// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml;
using Microsoft.Build.BackEnd;
using Microsoft.Build.Collections;
using Microsoft.Build.Construction;
using Microsoft.Build.Engine.UnitTests.Globbing;
using Microsoft.Build.Evaluation;
using Microsoft.Build.Execution;
using Microsoft.Build.Framework;
using Microsoft.Build.Shared;
using Shouldly;
using Xunit;
using InvalidProjectFileException = Microsoft.Build.Exceptions.InvalidProjectFileException;
using NodeLoggingContext = Microsoft.Build.BackEnd.Logging.NodeLoggingContext;

#nullable disable

namespace Microsoft.Build.UnitTests.BackEnd
{
    public class IntrinsicTask_Tests
    {
        [Fact]
        public void PropertyGroup()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup> 
                    <p1>v1</p1>
                    <p2>v2</p2>
                </PropertyGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
            ExecuteTask(task, LookupHelpers.CreateLookup(properties));

            Assert.Equal(2, properties.Count);
            Assert.Equal("v1", properties["p1"].EvaluatedValue);
            Assert.Equal("v2", properties["p2"].EvaluatedValue);
        }

        [Fact]
        public void PropertyGroupWithComments()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t' >
                <PropertyGroup><!-- c -->
                    <p1>v1</p1><!-- c -->
                </PropertyGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
            ExecuteTask(task, LookupHelpers.CreateLookup(properties));

            Assert.Single(properties);
            Assert.Equal("v1", properties["p1"].EvaluatedValue);
        }

        [Fact]
        public void PropertyGroupEmpty()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t' >
                <PropertyGroup/>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
            ExecuteTask(task, LookupHelpers.CreateLookup(properties));

            Assert.Empty(properties);
        }

        [Fact]
        public void PropertyGroupWithReservedProperty()
        {
            Assert.Throws<InvalidProjectFileException>(() =>
            {
                string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup>
                  <MSBuildProjectFile/>
                </PropertyGroup>
            </Target>
            </Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                ExecuteTask(task);
            });
        }

        [Fact]
        public void PropertyGroupWithInvalidPropertyName()
        {
            Assert.Throws<InvalidProjectFileException>(() =>
            {
                string content = ObjectModelHelpers.CleanupFileContents(
                @"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup>
                  <PropertyGroup/>
                </PropertyGroup>
            </Target>
            </Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                ExecuteTask(task);
            });
        }
        [Fact]
        public void BlankProperty()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup>
                  <p1></p1>
                </PropertyGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
            ExecuteTask(task, LookupHelpers.CreateLookup(properties));

            Assert.Single(properties);
            Assert.Equal("", properties["p1"].EvaluatedValue);
        }

        [Fact]
        public void PropertyGroupWithInvalidSyntax1()
        {
            Assert.Throws<InvalidProjectFileException>(() =>
            {
                string content = ObjectModelHelpers.CleanupFileContents(
                @"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup>x</PropertyGroup>
            </Target>
            </Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                ExecuteTask(task, null);
            });
        }

        [Fact]
        public void PropertyGroupWithInvalidSyntax2()
        {
            Assert.Throws<InvalidProjectFileException>(() =>
            {
                string content = ObjectModelHelpers.CleanupFileContents(
                @"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup>
                    <p Include='v0'/>
                </PropertyGroup>
            </Target>
            </Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                ExecuteTask(task, null);
            });
        }
        [Fact]
        public void PropertyGroupWithConditionOnGroup()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup Condition='false'> 
                    <p1>v1</p1>
                    <p2>v2</p2>
                </PropertyGroup>
                <Message Text='[$(P1)][$(P2)]'/>
            </Target>
            </Project>"))));

            p.Build(new string[] { "t" }, new ILogger[] { logger });
            logger.AssertLogDoesntContain("[v1][v2]");
            logger.ClearLog();

            p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup Condition='true'> 
                    <p1>v1</p1>
                    <p2>v2</p2>
                </PropertyGroup>
                <Message Text='[$(P1)][$(P2)]'/>
            </Target>
            </Project>"))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });
            logger.AssertLogContains("[v1][v2]");
        }

        [Fact]
        public void PropertyGroupWithConditionOnGroupUsingMetadataErrors()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
            @"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup Condition=""'%(i0.m)'=='m2'"">
                    <p1>@(i0)</p1>
                    <p2>%(i0.m)</p2>
                </PropertyGroup>
            </Target>
            </Project>"))));

            p.Build(new string[] { "t" }, new ILogger[] { logger });
            logger.AssertLogContains("MSB4191"); // Metadata not allowed
        }

        [Fact]
        public void ItemGroup()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'/>
                    <i2 Include='b1'/>
                </ItemGroup>
            </Target>
            </Project>");

            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
            ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
            Assert.Equal("a1", i1Group.First().EvaluatedInclude);
            Assert.Equal("b1", i2Group.First().EvaluatedInclude);
        }

        internal const string TargetitemwithIncludeAndExclude = @"
                    <Project>
                       <Target Name=`t`>
                          <ItemGroup>
                              <i Include='{0}' Exclude='{1}'/>
                          </ItemGroup>
                       </Target>
                    </Project>
                ";

        public static IEnumerable<object[]> IncludesAndExcludesWithWildcardsTestData => GlobbingTestData.IncludesAndExcludesWithWildcardsTestData;

        [Theory]
        [MemberData(nameof(IncludesAndExcludesWithWildcardsTestData))]
        public void ItemsWithWildcards(string includeString, string excludeString, string[] inputFiles, string[] expectedInclude, bool makeExpectedIncludeAbsolute)
        {
            var projectContents = string.Format(TargetitemwithIncludeAndExclude, includeString, excludeString).Cleanup();

            AssertItemEvaluationFromTarget(projectContents, "t", "i", inputFiles, expectedInclude, makeExpectedIncludeAbsolute, normalizeSlashes: true);
        }

        [Fact]
        public void ItemKeepDuplicatesEmptySameAsTrue()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'/>
                    <i1 Include='a1' KeepDuplicates='' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i1");
            Assert.Equal(2, group.Count);
        }

        [Fact]
        public void ItemKeepDuplicatesFalse()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'/>
                    <i1 Include='a1' KeepDuplicates='false' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i1");
            Assert.Single(group);
        }

        [Fact]
        public void ItemKeepDuplicatesAsCondition()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'/>
                    <i1 Include='a1' KeepDuplicates="" '$(Keep)' == 'true' "" />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i1");
            Assert.Single(group);
        }

        [Fact]
        public void ItemKeepDuplicatesFalseKeepsExistingDuplicates()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'/>
                    <i1 Include='a1'/>              
                    <i1 Include='a1' KeepDuplicates='false' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i1");
            Assert.Equal(2, group.Count);
        }

        [Fact]
        public void ItemKeepDuplicatesFalseDuringCopyEliminatesDuplicates()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'/>
                    <i1 Include='a1'/>              
                    <i2 Include='@(i1)' KeepDuplicates='false' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i1");
            Assert.Equal(2, group.Count);

            group = lookup.GetItems("i2");
            Assert.Single(group);
        }

        [Fact]
        public void ItemKeepDuplicatesFalseWithMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>              
                      <m1>m1</m1>
                    </i1>
                    <i1 Include='a2' KeepDuplicates='false' />
                    <i1 Include='a1' KeepDuplicates='false'>
                      <m1>m1</m1>
                    </i1>
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i1");
            Assert.Equal(2, group.Count);
        }

        [Fact]
        public void ItemKeepMetadataEmptySameAsKeepAll()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>              
                      <m1>m1</m1>
                    </i1>
                    <i2 Include='@(i1)' KeepMetadata='' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i2");
            Assert.Equal("m1", group.First().GetMetadataValue("m1"));
        }

        [Fact]
        public void ItemKeepMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>              
                      <m1>m1</m1>
                      <m2>m2</m2>
                      <m3>m3</m3>
                    </i1>
                    <i2 Include='@(i1)' KeepMetadata='m2' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i2");
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m1"));
            Assert.Equal("m2", group.First().GetMetadataValue("m2"));
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m3"));
        }


        [Fact]
        public void ItemKeepMetadataNotExistent()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>              
                      <m1>m1</m1>
                      <m2>m2</m2>
                      <m3>m3</m3>
                    </i1>
                    <i2 Include='@(i1)' KeepMetadata='NONEXISTENT' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i2");
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m1"));
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m2"));
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m3"));
        }

        [Fact]
        public void ItemKeepMetadataList()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>              
                      <m1>m1</m1>
                      <m2>m2</m2>
                      <m3>m3</m3>
                    </i1>
                    <i2 Include='@(i1)' KeepMetadata='m1;m2' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i2");
            Assert.Equal("m1", group.First().GetMetadataValue("m1"));
            Assert.Equal("m2", group.First().GetMetadataValue("m2"));
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m3"));
        }

        [Fact]
        public void ItemKeepMetadataListExpansion()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>              
                      <m1>m1</m1>
                      <m2>m2</m2>
                      <m3>m3</m3>
                    </i1>
                    <i2 Include='@(i1)' KeepMetadata='$(Keep)' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            var scope = lookup.EnterScope("test");
            lookup.SetProperty(ProjectPropertyInstance.Create("Keep", "m1;m2"));
            ExecuteTask(task, lookup);
            scope.LeaveScope();

            var group = lookup.GetItems("i2");
            Assert.Equal("m1", group.First().GetMetadataValue("m1"));
            Assert.Equal("m2", group.First().GetMetadataValue("m2"));
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m3"));
        }

        [Fact]
        public void ItemRemoveMetadataEmptySameAsKeepAll()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>              
                      <m1>m1</m1>
                    </i1>
                    <i2 Include='@(i1)' RemoveMetadata='' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i2");
            Assert.Equal("m1", group.First().GetMetadataValue("m1"));
        }

        [Fact]
        public void ItemRemoveMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>              
                      <m1>m1</m1>
                      <m2>m2</m2>
                      <m3>m3</m3>
                    </i1>
                    <i2 Include='@(i1)' RemoveMetadata='m2' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i2");
            Assert.Equal("m1", group.First().GetMetadataValue("m1"));
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m2"));
            Assert.Equal("m3", group.First().GetMetadataValue("m3"));
        }

        [Fact]
        public void ItemRemoveMetadataList()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>              
                      <m1>m1</m1>
                      <m2>m2</m2>
                      <m3>m3</m3>
                    </i1>
                    <i2 Include='@(i1)' RemoveMetadata='m1;m2' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var group = lookup.GetItems("i2");
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m1"));
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m2"));
            Assert.Equal("m3", group.First().GetMetadataValue("m3"));
        }

        [Fact]
        public void ItemRemoveMetadataListExpansion()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>              
                      <m1>m1</m1>
                      <m2>m2</m2>
                      <m3>m3</m3>
                    </i1>
                    <i2 Include='@(i1)' RemoveMetadata='$(Remove)' />
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            var scope = lookup.EnterScope("test");
            lookup.SetProperty(ProjectPropertyInstance.Create("Remove", "m1;m2"));
            ExecuteTask(task, lookup);
            scope.LeaveScope();

            var group = lookup.GetItems("i2");
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m1"));
            Assert.Equal(String.Empty, group.First().GetMetadataValue("m2"));
            Assert.Equal("m3", group.First().GetMetadataValue("m3"));
        }

        [Fact]
        public void ItemKeepMetadataAndRemoveMetadataMutuallyExclusive()
        {
            Assert.Throws<InvalidProjectFileException>(() =>
            {
                string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>              
                      <m1>m1</m1>
                      <m2>m2</m2>
                      <m3>m3</m3>
                    </i1>
                    <i2 Include='@(i1)' KeepMetadata='m1' RemoveMetadata='m2' />
                </ItemGroup>
            </Target>
            </Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                Lookup lookup = LookupHelpers.CreateEmptyLookup();
                ExecuteTask(task, lookup);
            });
        }
        /// <summary>
        /// Should not make items with an empty include.
        /// </summary>
        [Fact]
        public void ItemGroupWithPropertyExpandingToNothing()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='$(xxx)'/>
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
            Assert.Empty(i1Group);
        }

        [Fact]
        public void ItemGroupWithComments()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> <!-- c -->
                    <i1 Include='a1;a2'/> <!-- c -->
                    <ii Remove='a1'/> <!-- c -->
                    <i1> <!-- c -->
                        <m>m1</m> <!-- c -->
                    </i1> <!-- c -->
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
            Assert.Equal("a1", i1Group.First().EvaluatedInclude);
            Assert.Equal("m1", i1Group.First().GetMetadataValue("m"));
        }

        /// <summary>
        /// This is something that used to be done by CreateItem
        /// </summary>
        [Fact]
        public void ItemGroupTrims()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='  $(p0)  '/>
                    <i2 Include='b1'/>
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
            properties.Set(ProjectPropertyInstance.Create("p0", "    v0    "));
            Lookup lookup = LookupHelpers.CreateLookup(properties);
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
            Assert.Equal("v0", i1Group.First().EvaluatedInclude);
        }

        [Fact]
        public void ItemGroupWithInvalidSyntax1()
        {
            Assert.Throws<InvalidProjectFileException>(() =>
            {
                string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>x</ItemGroup>
            </Target>
            </Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                ExecuteTask(task, null);
            });
        }

        [Fact]
        public void ItemGroupWithInvalidSyntax2()
        {
            Assert.Throws<InvalidProjectFileException>(() =>
            {
                string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                  <i>x</i>
                </ItemGroup>
            </Target>
            </Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                ExecuteTask(task, null);
            });
        }

        [Fact]
        public void ItemGroupWithInvalidSyntax3()
        {
            Assert.Throws<InvalidProjectFileException>(() =>
            {
                string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                  <i Include='x' Exclude='y' Remove='z'/>
                </ItemGroup>
            </Target>
            </Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                ExecuteTask(task, null);
            });
        }
        [Fact]
        public void ItemGroupWithTransform()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a.cpp'/>
                    <i2 Include=""@(i1->'%(filename).obj')""/>
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
            ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
            Assert.Equal("a.cpp", i1Group.First().EvaluatedInclude);
            Assert.Equal("a.obj", i2Group.First().EvaluatedInclude);
        }

        [Fact]
        public void ItemGroupWithTransformInMetadataValue()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a.cpp'/>
                    <i2 Include='@(i1)'>
                       <m>@(i1->'%(filename).obj')</m>
                    </i2>
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
            Assert.Equal("a.cpp", i2Group.First().EvaluatedInclude);
            Assert.Equal("a.obj", i2Group.First().GetMetadataValue("m"));
        }

        [Fact]
        public void ItemGroupWithExclude()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'/>
                    <i2 Include='a1;@(i1);b1;b2' Exclude='@(i1);b1'/>
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
            ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
            Assert.Equal("a1", i1Group.First().EvaluatedInclude);
            Assert.Equal("b2", i2Group.First().EvaluatedInclude);
        }

        [Fact]
        public void ItemGroupWithMetadataInExclude()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>
                        <m>a1</m>
                    </i1>
                    <i2 Include='b1;@(i1)' Exclude='%(i1.m)'/>
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
            ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
            Assert.Single(i1Group);
            Assert.Single(i2Group);
            Assert.Equal("a1", i1Group.First().EvaluatedInclude);
            Assert.Equal("b1", i2Group.First().EvaluatedInclude);
        }

        [Fact]
        public void ItemGroupWithConditionOnGroup()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup Condition='false'> 
                    <i1 Include='a1'/>
                    <i2 Include='b1'/>
                </ItemGroup>
                <Message Text='[@(i1)][@(i2)]'/>
            </Target>
            </Project>"))));

            p.Build(new string[] { "t" }, new ILogger[] { logger });
            logger.AssertLogDoesntContain("[a1][b1]");
            logger.ClearLog();

            p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup Condition='true'> 
                    <i1 Include='a1'/>
                    <i2 Include='b1'/>
                </ItemGroup>
                <Message Text='[@(i1)][@(i2)]'/>
            </Target>
            </Project>"))));

            p.Build(new string[] { "t" }, new ILogger[] { logger });
            logger.AssertLogContains("[a1][b1]");
        }

        [Fact]
        public void ItemGroupWithConditionOnGroupUsingMetadataErrors()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup Condition=""'%(i0.m)'!='m1'"">
                    <i1 Include='a1'/>
                    <i2 Include='%(i0.m)'/>
                    <i3 Include='%(i0.identity)'/>
                    <i4 Include='@(i0)'/>
                </ItemGroup>
            </Target>
            </Project>"))));

            p.Build(new string[] { "t" }, new ILogger[] { logger });
            logger.AssertLogContains("MSB4191"); // Metadata not allowed
        }

        [Fact]
        public void PropertyGroupWithExternalPropertyReferences()
        {
            // <PropertyGroup>
            //     <p0>v0</p0>
            // </PropertyGroup>
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup> 
                    <p1>$(p0)</p1>
                </PropertyGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            PropertyDictionary<ProjectPropertyInstance> properties = GeneratePropertyGroup();
            ExecuteTask(task, LookupHelpers.CreateLookup(properties));

            Assert.Equal(2, properties.Count);
            Assert.Equal("v0", properties["p0"].EvaluatedValue);
            Assert.Equal("v0", properties["p1"].EvaluatedValue);
        }

        [Fact]
        public void ItemGroupWithPropertyReferences()
        {
            // <PropertyGroup>
            //     <p0>v0</p0>
            // </PropertyGroup>
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='$(p0)'/>
                    <i2 Include='a2'/>
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            PropertyDictionary<ProjectPropertyInstance> properties = GeneratePropertyGroup();
            Lookup lookup = LookupHelpers.CreateLookup(properties);
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
            ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");
            Assert.Equal("v0", i1Group.First().EvaluatedInclude);
            Assert.Equal("a2", i2Group.First().EvaluatedInclude);
        }

        [Fact]
        public void ItemGroupWithMetadataReferences()
        {
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>
                        <m>m1</m>
                    </i1>
                    <i1 Include='a2'>
                        <m>m2</m>
                    </i1>
                    <i2 Include='%(i1.m)'/>
                </ItemGroup>
            </Target>
            </Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
            ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");

            Assert.Equal("a1", i1Group.First().EvaluatedInclude);
            Assert.Equal("a2", i1Group.ElementAt(1).EvaluatedInclude);
            Assert.Equal("m1", i2Group.First().EvaluatedInclude);
            Assert.Equal("m2", i2Group.ElementAt(1).EvaluatedInclude);

            Assert.Equal("m1", i1Group.First().GetMetadataValue("m"));
            Assert.Equal("m2", i1Group.ElementAt(1).GetMetadataValue("m"));
        }

        [Fact]
        public void ItemGroupWithMetadataReferencesOnMetadataConditions()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='a1'>
                        <m>m1</m>
                    </i1>
                    <i1 Include='a2'>
                        <m>m2</m>
                    </i1>
                    <i2 Include='@(i1)'>
                        <n Condition=""'%(i1.m)'=='m1'"">n1</n>
                    </i2>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");

            Assert.Equal(2, i2Group.Count);
            Assert.Equal("a1", i2Group.First().EvaluatedInclude);
            Assert.Equal("a2", i2Group.ElementAt(1).EvaluatedInclude);

            Assert.Equal("n1", i2Group.First().GetMetadataValue("n"));
            Assert.Equal(String.Empty, i2Group.ElementAt(1).GetMetadataValue("n"));
        }

        [Fact]
        public void ItemGroupWithMetadataReferencesOnItemGroupAndItemConditionsErrors()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup Condition=""'%(i0.m)' != m1"" >
                    <i1 Include=""%(m)"" Condition=""'%(i0.m)' != m3""/>
                </ItemGroup>
            </Target></Project>"))));

            p.Build(new string[] { "t" }, new ILogger[] { logger });
            logger.AssertLogContains("MSB4191"); // Metadata not allowed
        }

        [Fact]
        public void ItemGroupWithExternalMetadataReferences()
        {
            // <ItemGroup>
            //    <i0 Include='a1'>
            //        <m>m1</m>
            //    </i0>
            //    <i0 Include='a2;a3'>
            //        <m>m2</m>
            //    </i0>
            //    <i0 Include='a4'>
            //        <m>m3</m>
            //    </i0>
            // </ItemGroup>
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include='b1'>
                        <m>%(i0.m)</m>
                    </i1>
                    <i2 Include='%(i1.m)'/>
                </ItemGroup>
            </Target></Project>");

            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = GenerateLookup(task.Project);
            ExecuteTask(task, lookup);

            ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");
            ICollection<ProjectItemInstance> i2Group = lookup.GetItems("i2");

            Assert.Equal("b1", i1Group.First().EvaluatedInclude);
            Assert.Equal("b1", i1Group.ElementAt(1).EvaluatedInclude);
            Assert.Equal("b1", i1Group.ElementAt(2).EvaluatedInclude);
            Assert.Equal("m1", i1Group.First().GetMetadataValue("m"));
            Assert.Equal("m2", i1Group.ElementAt(1).GetMetadataValue("m"));
            Assert.Equal("m3", i1Group.ElementAt(2).GetMetadataValue("m"));

            Assert.Equal("m1", i2Group.First().EvaluatedInclude);
            Assert.Equal("m2", i2Group.ElementAt(1).EvaluatedInclude);
            Assert.Equal("m3", i2Group.ElementAt(2).EvaluatedInclude);
        }

        [Fact]
        public void PropertyGroupWithCumulativePropertyReferences()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup> 
                    <p1>v1</p1>
                    <p2>#$(p1)#</p2>
                    <p1>v2</p1>
                </PropertyGroup>
            </Target></Project>");

            IntrinsicTask task = CreateIntrinsicTask(content);
            PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
            ExecuteTask(task, LookupHelpers.CreateLookup(properties));

            Assert.Equal(2, properties.Count);
            Assert.Equal("v2", properties["p1"].EvaluatedValue);
            Assert.Equal("#v1#", properties["p2"].EvaluatedValue);
        }

        [Fact]
        public void PropertyGroupWithMetadataReferencesOnGroupErrors()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup Condition=""'%(i0.m)' != m1"">
                    <p1>%(i0.m)</p1>
                </PropertyGroup>
            </Target></Project>"))));

            p.Build(new string[] { "t" }, new ILogger[] { logger });
            logger.AssertLogContains("MSB4191");
        }

        [Fact]
        public void PropertyGroupWithMetadataReferencesOnProperty()
        {
            // <ItemGroup>
            //    <i0 Include='a1'>
            //        <m>m1</m>
            //        <n>n1</n>
            //    </i0>
            //    <i0 Include='a2;a3'>
            //        <m>m2</m>
            //        <n>n2</n>
            //    </i0>
            //    <i0 Include='a4'>
            //        <m>m3</m>
            //        <n>n3</n>
            //    </i0>
            // </ItemGroup>
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup> 
                    <p1 Condition=""'%(i0.n)' != n3"">%(i0.n)</p1>
                </PropertyGroup>
            </Target></Project>");

            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = GenerateLookup(task.Project);
            ExecuteTask(task, lookup);

            Assert.Equal("n2", lookup.GetProperty("p1").EvaluatedValue);
        }

        [Fact]
        public void PropertiesCanReferenceItemsInSameTarget()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <Target Name='t'>
                    <ItemGroup>
                      <i1 Include='a1;a2'/>
                    </ItemGroup>
                    <PropertyGroup>
                      <p>@(i1->'#%(identity)#', '*')</p>
                    </PropertyGroup>
                    <Message Text='[$(p)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[#a1#*#a2#]");
        }

        [Fact]
        public void ItemsCanReferencePropertiesInSameTarget()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <Target Name='t'>
                    <PropertyGroup>
                        <p0>v0</p0>
                    </PropertyGroup>
                    <ItemGroup> 
                        <i1 Include='$(p0)'/>
                    </ItemGroup>
                    <Message Text='[@(i1)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[v0]");
        }

        [Fact]
        public void PropertyGroupInTargetCanOverwriteGlobalProperties()
        {
            MockLogger logger = new MockLogger();
            Dictionary<string, string> globalProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            globalProperties.Add("global", "v0");

            Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <PropertyGroup>
                    <global>v1</global>
                  </PropertyGroup>
                  <Target Name='t2' DependsOnTargets='t'>
                    <Message Text='final:[$(global)]'/>
                  </Target>
                  <Target Name='t'>
                    <Message Text='start:[$(global)]'/>
                    <PropertyGroup>
                      <global>v2</global>
                    </PropertyGroup>
                    <Message Text='end:[$(global)]'/>
                  </Target>
                </Project>
            "))), globalProperties, ObjectModelHelpers.MSBuildDefaultToolsVersion);

            ProjectInstance p = project.CreateProjectInstance();

            Assert.Equal("v0", p.GetProperty("global").EvaluatedValue);
            p.Build(new string[] { "t2" }, new ILogger[] { logger });

            // PropertyGroup outside of target can't overwrite global property,
            // but PropertyGroup inside of target can overwrite it
            logger.AssertLogContains("start:[v0]", "end:[v2]", "final:[v2]");
            Assert.Equal("v2", p.GetProperty("global").EvaluatedValue);

            // Resetting the project goes back to the old value
            p = project.CreateProjectInstance();
            Assert.Equal("v0", p.GetProperty("global").EvaluatedValue);
        }

        [Fact]
        public void PropertiesAreRevertedAfterBuild()
        {
            MockLogger logger = new MockLogger();
            Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <PropertyGroup>
                    <p>p0</p>
                  </PropertyGroup>
                  <Target Name='t'>
                    <PropertyGroup>
                      <p>p1</p>
                    </PropertyGroup>
                  </Target>
                </Project>
            "))));

            ProjectInstance p = project.CreateProjectInstance();
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            string value = p.GetProperty("p").EvaluatedValue;
            Assert.Equal("p1", value);

            p = project.CreateProjectInstance();

            value = p.GetProperty("p").EvaluatedValue;
            Assert.Equal("p0", value);
        }

        [Fact]
        public void PropertiesVisibleToSubsequentTask()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <Target Name='t'>
                    <PropertyGroup>
                      <p>p1</p>
                    </PropertyGroup>
                    <Message Text='[$(p)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[p1]");
        }

        [Fact]
        public void PropertiesVisibleToSubsequentTarget()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <Target Name='t2' DependsOnTargets='t'>
                    <Message Text='[$(p)]'/>                    
                  </Target>
                  <Target Name='t'>
                    <PropertyGroup>
                      <p>p1</p>
                    </PropertyGroup>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t2" }, new ILogger[] { logger });

            logger.AssertLogContains("[p1]");
        }

        [Fact]
        public void ItemsVisibleToSubsequentTask()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <Target Name='t'>
                    <ItemGroup>
                      <i Include='i1'/>
                    </ItemGroup>
                    <Message Text='[@(i)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[i1]");
        }

        [Fact]
        public void ItemsVisibleToSubsequentTarget()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <Target Name='t2' DependsOnTargets='t'>
                    <Message Text='[@(i)]'/>                    
                  </Target>
                  <Target Name='t'>
                    <ItemGroup>
                      <i Include='i1'/>
                    </ItemGroup>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t2" }, new ILogger[] { logger });

            logger.AssertLogContains("[i1]");
        }

        [Fact]
        public void ItemsNotVisibleToParallelTargetBatches()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i Include='1.in'><output>1.out</output></i>
                    <i Include='2.in'><output>2.out</output></i>
                  </ItemGroup> 
                  <Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
                    <Message Text='start:[@(i)]'/>
                    <ItemGroup>
                      <j Include='%(i.identity)'/>
                    </ItemGroup>
                    <Message Text='end:[@(j)]'/>                    
                </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "start:[1.in]", "end:[1.in]", "start:[2.in]", "end:[2.in]" });
        }

        [Fact]
        public void PropertiesNotVisibleToParallelTargetBatches()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i Include='1.in'><output>1.out</output></i>
                    <i Include='2.in'><output>2.out</output></i>
                  </ItemGroup>
                  <Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
                    <Message Text='start:[$(p)]'/>
                    <PropertyGroup>
                      <p>p1</p>
                    </PropertyGroup>
                    <Message Text='end:[$(p)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "start:[]", "end:[p1]", "start:[]", "end:[p1]" });
        }

        // One input is built, the other is inferred
        [Fact]
        public void ItemsInPartialBuild()
        {
            string[] oldFiles = null, newFiles = null;
            try
            {
                oldFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2005, 1, 1));
                newFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2006, 1, 1));

                MockLogger logger = new MockLogger();
                Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i Include='" + oldFiles.First() + "'><output>" + newFiles.First() + @"</output></i>
                    <i Include='" + newFiles.ElementAt(1) + "'><output>" + oldFiles.ElementAt(1) + @"</output></i>
                  </ItemGroup>
                  <Target Name='t2' DependsOnTargets='t'>
                    <Message Text='final:[@(j)]'/>
                  </Target>
                  <Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.Output)'>
                    <Message Text='start:[@(j)]'/>
                    <ItemGroup>
                      <j Include='%(i.identity)'/>
                    </ItemGroup>
                    <Message Text='end:[@(j)]'/>
                </Target>
                </Project>
            "))));
                p.Build(new string[] { "t2" }, new ILogger[] { logger });

                // We should only see messages for the out of date inputs, but the itemgroup should do its work for both inputs
                logger.AssertLogContains(new string[] { "start:[]", "end:[" + newFiles.ElementAt(1) + "]", "final:[" + oldFiles.First() + ";" + newFiles.ElementAt(1) + "]" });
            }
            finally
            {
                ObjectModelHelpers.DeleteTempFiles(oldFiles);
                ObjectModelHelpers.DeleteTempFiles(newFiles);
            }
        }

        // One input is built, the other input is inferred
        [Fact]
        public void PropertiesInPartialBuild()
        {
            string[] oldFiles = null, newFiles = null;
            try
            {
                oldFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2005, 1, 1));
                newFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2006, 1, 1));

                MockLogger logger = new MockLogger();
                Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i Include='" + oldFiles.First() + "'><output>" + newFiles.First() + @"</output></i>
                    <i Include='" + newFiles.ElementAt(1) + "'><output>" + oldFiles.ElementAt(1) + @"</output></i>
                  </ItemGroup>
                  <Target Name='t2' DependsOnTargets='t'>
                    <Message Text='final:[$(p)]'/>
                  </Target>
                  <Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.Output)'>
                    <Message Text='start:[$(p)]'/>
                    <PropertyGroup>
                      <p>@(i)</p>
                    </PropertyGroup>
                    <Message Text='end:[$(p)]'/>
                </Target>
                </Project>
            "))));
                p.Build(new string[] { "t2" }, new ILogger[] { logger });

                // We should only see messages for the out of date inputs, but the propertygroup should do its work for both inputs
                // Finally, execution wins over inferral, as the code chooses to do it that way
                logger.AssertLogContains(new string[] { "start:[]", "end:[" + newFiles.ElementAt(1) + "]", "final:[" + newFiles.ElementAt(1) + "]" });
            }
            finally
            {
                ObjectModelHelpers.DeleteTempFiles(oldFiles);
                ObjectModelHelpers.DeleteTempFiles(newFiles);
            }
        }

        // One input is built, the other is inferred
        [Fact]
        public void ItemsInPartialBuildVisibleToSubsequentlyInferringTasks()
        {
            string[] oldFiles = null, newFiles = null;
            try
            {
                oldFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2005, 1, 1));
                newFiles = ObjectModelHelpers.GetTempFiles(2, new DateTime(2006, 1, 1));
                string oldInput = oldFiles.First();
                string newInput = newFiles.ElementAt(1);
                string oldOutput = oldFiles.ElementAt(1);
                string newOutput = newFiles.First();

                MockLogger logger = new MockLogger();
                Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i Include='" + oldInput + "'><output>" + newOutput + @"</output></i>
                    <i Include='" + newInput + "'><output>" + oldOutput + @"</output></i>
                  </ItemGroup>
                  <Target Name='t2' DependsOnTargets='t'>
                    <Message Text='final:[@(i)]'/>
                  </Target>
                  <Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.Output)'>
                    <Message Text='start:[@(i)]'/>
                    <ItemGroup>
                      <j Include='%(i.identity)'/>
                    </ItemGroup>
                    <Message Text='middle:[@(i)][@(j)]'/>
                    <CreateItem Include='@(j)'>
                      <Output TaskParameter='Include' ItemName='i'/>
                    </CreateItem>
                    <Message Text='end:[@(i)]'/>
                </Target>
                </Project>
            "))));
                p.Build(new string[] { "t2" }, new ILogger[] { logger });

                // We should only see messages for the out of date inputs, but the itemgroup should do its work for both inputs;
                // The final result should include the out of date inputs (twice) and the up to date inputs (twice).
                // NOTE: outputs from regular tasks, like CreateItem, are gathered up and included in the project in the order (1) inferred (2) executed.
                // Intrinsic tasks, because they affect the project directly, don't do this. So the final order we see is
                // two inputs (old, new) from the ItemGroup; followed by the inferred CreateItem output, then the executed CreateItem output.
                // I suggest this ordering isn't important: it's a new feature, so nobody will get broken.
                logger.AssertLogContains(new string[] { "start:[" + newInput + "]",
                                                        "middle:[" + newInput + "][" + newInput + "]",
                                                        "end:["   + newInput + ";" + newInput + "]",
                                                        "final:[" + oldInput + ";" + newInput + ";" + oldInput + ";" + newInput + "]" });
            }
            finally
            {
                ObjectModelHelpers.DeleteTempFiles(oldFiles);
                ObjectModelHelpers.DeleteTempFiles(newFiles);
            }
        }

        [Fact]
        public void IncludeNoOp()
        {
            Assert.Throws<InvalidProjectFileException>(() =>
            {
                string content = ObjectModelHelpers.CleanupFileContents(
                @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Include=''/>
                </ItemGroup>
            </Target></Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                ExecuteTask(task, null);
            });
        }
        [Fact]
        public void RemoveNoOp()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1 Remove='a1'/>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            Assert.Empty(lookup.GetItems("i1"));
        }

        [Fact]
        public void RemoveItemInTarget()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i1 Include='a1'/> 
                    <i1 Remove='a1'/>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            Assert.Empty(lookup.GetItems("i1"));
        }

        /// <summary>
        /// Removes in one batch should never affect adds in a parallel batch, even if that
        /// parallel batch ran first.
        /// </summary>
        [Fact]
        public void RemoveOfItemAddedInTargetByParallelTargetBatchDoesNothing()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <!-- just to cause two target batches -->
                    <i Include='1.in'><output>1.out</output></i>
                    <i Include='2.in'><output>2.out</output></i>
                  </ItemGroup> 
                  <Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
                    <ItemGroup>
                      <j Include='a' Condition=""'%(i.Identity)'=='1.in'""/>
                      <j Remove='a' Condition=""'%(i.Identity)'=='2.in'""/>

                      <!-- and again in reversed batch order, in case the engine batches the other way around -->
                      <j Include='b' Condition=""'%(i.Identity)'=='2.in'""/>
                      <j Remove='b' Condition=""'%(i.Identity)'=='1.in'""/>

                      <!-- but obviously a remove in the same batch works -->
                      <j Include='c' Condition=""'%(i.Identity)'=='2.in'""/>
                      <j Remove='c' Condition=""'%(i.Identity)'=='2.in'""/>

                      <!-- unless it's before the add -->
                      <j Remove='d' Condition=""'%(i.Identity)'=='2.in'""/>
                      <j Include='d' Condition=""'%(i.Identity)'=='2.in'""/>
                  </ItemGroup>
                  </Target>
                  <Target Name='t2'>
                    <Message Text='final:[@(j)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t", "t2" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "final:[a;b;d]" });
        }

        [Fact]
        public void RemoveItemInTargetWithTransform()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i0 Include='a.cpp;b.cpp'/>
                    <i1 Include='a.obj;b.obj'/> 
                    <i1 Remove=""@(i0->'%(filename).obj')""/>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            Assert.Empty(lookup.GetItems("i1"));
        }

        [Fact]
        public void RemoveWithMultipleIncludes()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i1 Include='a1'/> 
                    <i1 Include='a2'/> 
                    <i1 Remove='a1;a2'/>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            Assert.Empty(lookup.GetItems("i1"));
        }

        [Fact]
        public void RemoveAllItemsInList()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i1 Include='a1'/> 
                    <i1 Include='a2'/> 
                    <i1 Remove='@(i1)'/>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            Assert.Empty(lookup.GetItems("i1"));
        }

        [Fact]
        public void RemoveWithItemReferenceOnMatchingMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
                @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                    <Target Name='t'>
                        <ItemGroup>
                            <I1 Include='a1' M1='1' M2='a'/>
                            <I1 Include='b1' M1='2' M2='x'/>
                            <I1 Include='c1' M1='3' M2='y'/>
                            <I1 Include='d1' M1='4' M2='b'/>

                            <I2 Include='a2' M1='x' m2='c'/>
                            <I2 Include='b2' M1='2' m2='x'/>
                            <I2 Include='c2' M1='3' m2='Y'/>
                            <I2 Include='d2' M1='y' m2='d'/>

                            <I2 Remove='@(I1)' MatchOnMetadata='m1' />
                        </ItemGroup>
                    </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var items = lookup.GetItems("I2");

            items.Select(i => i.EvaluatedInclude).ShouldBe(new[] { "a2", "d2" });

            items.ElementAt(0).GetMetadataValue("M1").ShouldBe("x");
            items.ElementAt(0).GetMetadataValue("M2").ShouldBe("c");
            items.ElementAt(1).GetMetadataValue("M1").ShouldBe("y");
            items.ElementAt(1).GetMetadataValue("M2").ShouldBe("d");
        }

        [Fact]
        public void RemoveWithItemReferenceOnCaseInsensitiveMatchingMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
                @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                    <Target Name='t'>
                        <ItemGroup>
                            <I1 Include='a1' M1='1' M2='a'/>
                            <I1 Include='b1' M1='2' M2='x'/>
                            <I1 Include='c1' M1='3' M2='y'/>
                            <I1 Include='d1' M1='4' M2='b'/>

                            <I2 Include='a2' M1='x' m2='c'/>
                            <I2 Include='b2' M1='2' m2='x'/>
                            <I2 Include='c2' M1='3' m2='Y'/>
                            <I2 Include='d2' M1='y' m2='d'/>

                            <I2 Remove='@(I1)' MatchOnMetadata='m2' MatchOnMetadataOptions='CaseInsensitive' />
                        </ItemGroup>
                    </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var items = lookup.GetItems("I2");

            items.Select(i => i.EvaluatedInclude).ShouldBe(new[] { "a2", "d2" });

            items.ElementAt(0).GetMetadataValue("M1").ShouldBe("x");
            items.ElementAt(0).GetMetadataValue("M2").ShouldBe("c");
            items.ElementAt(1).GetMetadataValue("M1").ShouldBe("y");
            items.ElementAt(1).GetMetadataValue("M2").ShouldBe("d");
        }

        [Fact]
        public void RemoveWithItemReferenceOnFilePathMatchingMetadata()
        {
            using (var env = TestEnvironment.Create())
            {
                env.SetCurrentDirectory(Environment.CurrentDirectory);
                string content = ObjectModelHelpers.CleanupFileContents(
                    $@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                    <Target Name='t'>
                        <ItemGroup>
                            <I1 Include='a1' M1='foo.txt\' M2='a'/>
                            <I1 Include='b1' M1='foo/bar.cs' M2='x'/>
                            <I1 Include='c1' M1='foo/bar.vb' M2='y'/>
                            <I1 Include='d1' M1='foo\foo\foo' M2='b'/>
                            <I1 Include='e1' M1='a/b/../c/./d' M2='1'/>
                            <I1 Include='f1' M1='{Environment.CurrentDirectory}\b\c' M2='6'/>

                            <I2 Include='a2' M1='FOO.TXT' m2='c'/>
                            <I2 Include='b2' M1='foo/bar.txt' m2='x'/>
                            <I2 Include='c2' M1='/foo/BAR.vb\\/' m2='Y'/>
                            <I2 Include='d2' M1='foo/foo/foo/' m2='d'/>
                            <I2 Include='e2' M1='foo/foo/foo/' m2='c'/>
                            <I2 Include='f2' M1='b\c' m2='e'/>
                            <I2 Include='g2' M1='b\d\c' m2='f'/>

                            <I2 Remove='@(I1)' MatchOnMetadata='m1' MatchOnMetadataOptions='PathLike' />
                        </ItemGroup>
                    </Target></Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                Lookup lookup = LookupHelpers.CreateEmptyLookup();
                ExecuteTask(task, lookup);

                var items = lookup.GetItems("I2");

                if (FileUtilities.GetIsFileSystemCaseSensitive())
                {
                    items.Select(i => i.EvaluatedInclude).ShouldBe(new[] { "a2", "b2", "c2", "g2" });

                    items.ElementAt(0).GetMetadataValue("M1").ShouldBe(@"FOO.TXT");
                    items.ElementAt(0).GetMetadataValue("M2").ShouldBe("c");
                    items.ElementAt(1).GetMetadataValue("M1").ShouldBe("foo/bar.txt");
                    items.ElementAt(1).GetMetadataValue("M2").ShouldBe("x");
                    items.ElementAt(2).GetMetadataValue("M1").ShouldBe(@"/foo/BAR.vb\\/");
                    items.ElementAt(2).GetMetadataValue("M2").ShouldBe("Y");
                    items.ElementAt(3).GetMetadataValue("M1").ShouldBe(@"b\d\c");
                    items.ElementAt(3).GetMetadataValue("M2").ShouldBe("f");
                }
                else
                {
                    items.Select(i => i.EvaluatedInclude).ShouldBe(new[] { "b2", "c2", "g2" });

                    items.ElementAt(0).GetMetadataValue("M1").ShouldBe("foo/bar.txt");
                    items.ElementAt(0).GetMetadataValue("M2").ShouldBe("x");
                    items.ElementAt(1).GetMetadataValue("M1").ShouldBe(@"/foo/BAR.vb\\/");
                    items.ElementAt(1).GetMetadataValue("M2").ShouldBe("Y");
                    items.ElementAt(2).GetMetadataValue("M1").ShouldBe(@"b\d\c");
                    items.ElementAt(2).GetMetadataValue("M2").ShouldBe("f");
                }
            }
        }

        [Fact]
        public void RemoveWithItemReferenceOnIntrinsicMatchingMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
                $@"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                    <Target Name='t'>
                        <ItemGroup>
                            <I1 Include='foo.txt' />
                            <I1 Include='bar.cs' />
                            <I1 Include='../bar.cs' />
                            <I1 Include='/foo/../bar.txt' />

                            <I2 Include='foo.txt' />
                            <I2 Include='../foo.txt' />
                            <I2 Include='/bar.txt' />
                            <I2 Include='/foo/bar.txt' />

                            <I2 Remove='@(I1)' MatchOnMetadata='FullPath' MatchOnMetadataOptions='PathLike' />
                        </ItemGroup>
                    </Target></Project> ");

            IntrinsicTask task = CreateIntrinsicTask(content);
            PropertyDictionary<ProjectPropertyInstance> properties = GeneratePropertyGroup();
            Lookup lookup = LookupHelpers.CreateLookup(properties);
            ExecuteTask(task, lookup);

            var items = lookup.GetItems("I2");

            items.Select(i => i.EvaluatedInclude).ShouldBe(new[] { "../foo.txt", "/foo/bar.txt" });
        }

        [Fact]
        public void RemoveWithPropertyReferenceInMatchOnMetadata()
        {
            // <PropertyGroup>
            //     <p0>v0</p0>
            // </PropertyGroup>
            string content = ObjectModelHelpers.CleanupFileContents(
                @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                    <Target Name='t'>
                        <ItemGroup>
                            <I1 Include='a1' v0='1' M2='a'/>
                            <I1 Include='b1' v0='2' M2='x'/>
                            <I1 Include='c1' v0='3' M2='y'/>
                            <I1 Include='d1' v0='4' M2='b'/>

                            <I2 Include='a2' v0='x' m2='c'/>
                            <I2 Include='b2' v0='2' m2='x'/>
                            <I2 Include='c2' v0='3' m2='Y'/>
                            <I2 Include='d2' v0='y' m2='d'/>

                            <I2 Remove='@(I1)' MatchOnMetadata='$(p0)' />
                        </ItemGroup>
                    </Target></Project>");

            IntrinsicTask task = CreateIntrinsicTask(content);
            PropertyDictionary<ProjectPropertyInstance> properties = GeneratePropertyGroup();
            Lookup lookup = LookupHelpers.CreateLookup(properties);
            ExecuteTask(task, lookup);

            var items = lookup.GetItems("I2");

            items.Select(i => i.EvaluatedInclude).ShouldBe(new[] { "a2", "d2" });

            items.ElementAt(0).GetMetadataValue("v0").ShouldBe("x");
            items.ElementAt(0).GetMetadataValue("M2").ShouldBe("c");
            items.ElementAt(1).GetMetadataValue("v0").ShouldBe("y");
            items.ElementAt(1).GetMetadataValue("M2").ShouldBe("d");
        }

        [Fact]
        public void RemoveWithItemReferenceInMatchOnMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
                @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                    <Target Name='t'>
                        <ItemGroup>
                            <Meta2 Include='M2'/>

                            <I1 Include='a1' v0='1' M2='a'/>
                            <I1 Include='b1' v0='2' M2='x'/>
                            <I1 Include='c1' v0='3' M2='y'/>
                            <I1 Include='d1' v0='4' M2='b'/>

                            <I2 Include='a2' v0='x' m2='c'/>
                            <I2 Include='b2' v0='2' m2='x'/>
                            <I2 Include='c2' v0='3' m2='Y'/>
                            <I2 Include='d2' v0='y' m2='d'/>

                            <I2 Remove='@(I1)' MatchOnMetadata='@(Meta2)' />
                        </ItemGroup>
                    </Target></Project>");

            IntrinsicTask task = CreateIntrinsicTask(content);
            PropertyDictionary<ProjectPropertyInstance> properties = GeneratePropertyGroup();
            Lookup lookup = LookupHelpers.CreateLookup(properties);
            ExecuteTask(task, lookup);

            var items = lookup.GetItems("I2");

            items.Select(i => i.EvaluatedInclude).ShouldBe(new[] { "a2", "c2", "d2" });

            items.ElementAt(0).GetMetadataValue("v0").ShouldBe("x");
            items.ElementAt(0).GetMetadataValue("M2").ShouldBe("c");
            items.ElementAt(1).GetMetadataValue("v0").ShouldBe("3");
            items.ElementAt(1).GetMetadataValue("M2").ShouldBe("Y");
            items.ElementAt(2).GetMetadataValue("v0").ShouldBe("y");
            items.ElementAt(2).GetMetadataValue("M2").ShouldBe("d");
        }

        [Fact]
        public void KeepWithItemReferenceOnNonmatchingMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
                @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                    <Target Name='t'>
                        <ItemGroup>
                            <I1 Include='a1' a='1' b='a'/>
                            <I1 Include='b1' a='2' b='x'/>
                            <I1 Include='c1' a='3' b='y'/>
                            <I1 Include='d1' a='4' b='b'/>

                            <I2 Include='a2' c='x' d='c'/>
                            <I2 Include='b2' c='2' d='x'/>
                            <I2 Include='c2' c='3' d='Y'/>
                            <I2 Include='d2' c='y' d='d'/>

                            <I2 Remove='@(I1)' MatchOnMetadata='e' />
                        </ItemGroup>
                    </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            var items = lookup.GetItems("I2");

            items.Select(i => i.EvaluatedInclude).ShouldBe(new[] { "a2", "b2", "c2", "d2" });

            items.ElementAt(0).GetMetadataValue("c").ShouldBe("x");
            items.ElementAt(1).GetMetadataValue("c").ShouldBe("2");
            items.ElementAt(2).GetMetadataValue("c").ShouldBe("3");
            items.ElementAt(3).GetMetadataValue("c").ShouldBe("y");
            items.ElementAt(0).GetMetadataValue("d").ShouldBe("c");
            items.ElementAt(1).GetMetadataValue("d").ShouldBe("x");
            items.ElementAt(2).GetMetadataValue("d").ShouldBe("Y");
            items.ElementAt(3).GetMetadataValue("d").ShouldBe("d");
        }

        [Fact]
        public void RemoveWithMatchingMultipleMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
                @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                    <Target Name='t'>
                        <ItemGroup>
                            <I1 Include='a1' M1='1' M2='a'/>
                            <I1 Include='b1' M1='2' M2='x'/>
                            <I1 Include='c1' M1='3' M2='y'/>
                            <I1 Include='d1' M1='4' M2='b'/>

                            <I2 Include='a2' M1='x' m2='c'/>
                            <I2 Include='b2' M1='2' m2='x'/>
                            <I2 Include='c2' M1='3' m2='Y'/>
                            <I2 Include='d2' M1='y' m2='d'/>

                            <I2 Remove='@(I1)' MatchOnMetadata='M1;M2' />
                        </ItemGroup>
                    </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);
            ICollection<ProjectItemInstance> items = lookup.GetItems("I2");
            items.Count.ShouldBe(3);
            items.ElementAt(0).EvaluatedInclude.ShouldBe("a2");
            items.ElementAt(1).EvaluatedInclude.ShouldBe("c2");
            items.ElementAt(2).EvaluatedInclude.ShouldBe("d2");
        }

        [Fact]
        public void RemoveWithMultipleItemReferenceOnMatchingMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
                @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                    <Target Name='t'>
                        <ItemGroup>
                            <I1 Include='a1' M1='1' M2='a'/>
                            <I1 Include='b1' M1='2' M2='x'/>
                            <I1 Include='c1' M1='3' M2='y'/>
                            <I1 Include='d1' M1='4' M2='b'/>

                            <I2 Include='a2' M1='x' m2='c'/>
                            <I2 Include='b2' M1='2' m2='x'/>
                            <I2 Include='c2' M1='3' m2='Y'/>
                            <I2 Include='d2' M1='y' m2='d'/>

                            <I3 Include='a3' M1='1' m2='b'/>
                            <I3 Include='b3' M1='x' m2='a'/>
                            <I3 Include='c3' M1='3' m2='2'/>
                            <I3 Include='d3' M1='y' m2='d'/>

                            <I3 Remove='@(I1);@(I2)' MatchOnMetadata='M1' />
                        </ItemGroup>
                    </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);
            ICollection<ProjectItemInstance> items = lookup.GetItems("I3");
            items.ShouldBeEmpty();
        }

        [Fact]
        public void FailWithMetadataItemReferenceOnMatchingMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
                @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                    <Target Name='t'>
                        <ItemGroup>
                            <I1 Include='a1' M1='1' M2='a'/>
                            <I1 Include='b1' M1='2' M2='x'/>
                            <I1 Include='c1' M1='3' M2='y'/>
                            <I1 Include='d1' M1='4' M2='b'/>

                            <I2 Include='a2' M1='x' m2='c'/>
                            <I2 Include='b2' M1='2' m2='x'/>
                            <I2 Include='c2' M1='3' m2='Y'/>
                            <I2 Include='d2' M1='y' m2='d'/>

                            <I2 Remove='%(I1.M1)' MatchOnMetadata='M1' />
                        </ItemGroup>
                    </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            Assert.ThrowsAny<InvalidProjectFileException>(() => ExecuteTask(task, lookup))
                .HelpKeyword.ShouldBe("MSBuild.OM_MatchOnMetadataIsRestrictedToReferencedItems");
        }

        [Fact]
        public void RemoveItemOutsideTarget()
        {
            // <ItemGroup>
            //    <i0 Include='a1'>
            //        <m>m1</m>
            //        <n>n1</n>
            //    </i0>
            //    <i0 Include='a2;a3'>
            //        <m>m2</m>
            //        <n>n2</n>
            //    </i0>
            //    <i0 Include='a4'>
            //        <m>m3</m>
            //        <n>n3</n>
            //    </i0>
            // </ItemGroup>
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i0 Remove='a2'/>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = GenerateLookup(task.Project);

            task.ExecuteTask(lookup);

            ICollection<ProjectItemInstance> i0Group = lookup.GetItems("i0");

            Assert.Equal(3, i0Group.Count);
            Assert.Equal("a1", i0Group.First().EvaluatedInclude);
            Assert.Equal("a3", i0Group.ElementAt(1).EvaluatedInclude);
            Assert.Equal("a4", i0Group.ElementAt(2).EvaluatedInclude);
        }

        /// <summary>
        /// Bare (batchable) metadata is prohibited on IG/PG conditions -- all other expressions
        /// should be allowed
        /// </summary>
        [Fact]
        public void ConditionOnPropertyGroupUsingPropertiesAndItemListsAndTransforms()
        {
            // <ItemGroup>
            //    <i0 Include='a1'>
            //        <m>m1</m>
            //    </i0>
            //    <i0 Include='a2;a3'>
            //        <m>m2</m>
            //    </i0>
            //    <i0 Include='a4'>
            //        <m>m3</m>
            //    </i0>
            // </ItemGroup>
            // <PropertyGroup>
            //     <p0>v0</p0>
            // </PropertyGroup>
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <PropertyGroup Condition=""'$(p0)'=='v0' and '@(i0)'=='a1;a2;a3;a4' and '@(i0->'%(identity).x','|')'=='a1.x|a2.x|a3.x|a4.x'"">
                  <p1>v1</p1>
                </PropertyGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);

            Lookup lookup = GenerateLookupWithItemsAndProperties(task.Project);

            task.ExecuteTask(lookup);

            string p1 = lookup.GetProperty("p1").EvaluatedValue;

            Assert.Equal("v1", p1);
        }

        /// <summary>
        /// Bare (batchable) metadata is prohibited on IG/PG conditions -- all other expressions
        /// should be allowed
        /// </summary>
        [Fact]
        public void ConditionOnItemGroupUsingPropertiesAndItemListsAndTransforms()
        {
            // <ItemGroup>
            //    <i0 Include='a1'>
            //        <m>m1</m>
            //    </i0>
            //    <i0 Include='a2;a3'>
            //        <m>m2</m>
            //    </i0>
            //    <i0 Include='a4'>
            //        <m>m3</m>
            //    </i0>
            // </ItemGroup>
            // <PropertyGroup>
            //     <p0>v0</p0>
            // </PropertyGroup>
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup Condition=""'$(p0)'=='v0' and '@(i0)'=='a1;a2;a3;a4' and '@(i0->'%(identity).x','|')'=='a1.x|a2.x|a3.x|a4.x'"">
                  <i1 Include='x'/>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);

            Lookup lookup = GenerateLookupWithItemsAndProperties(task.Project);

            task.ExecuteTask(lookup);

            ICollection<ProjectItemInstance> i1Group = lookup.GetItems("i1");

            Assert.Single(i1Group);
            Assert.Equal("x", i1Group.First().EvaluatedInclude);
        }

        /// <summary>
        /// This bug was caused by batching over the ItemGroup as well as over each child.
        /// If the condition on a child did not exclude it, an unwitting child could be included multiple times,
        /// once for each outer batch. The fix was to abandon the idea of outer batching and just
        /// prohibit batchable expressions on the ItemGroup conditions. It's just too hard to write such expressions
        /// in a comprehensible way.
        /// </summary>
        [Fact]
        public void RegressPCHBug()
        {
            // <ItemGroup>
            //    <i0 Include='a1'>
            //        <m>m1</m>
            //    </i0>
            //    <i0 Include='a2;a3'>
            //        <m>m2</m>
            //    </i0>
            //    <i0 Include='a4'>
            //        <m>m3</m>
            //    </i0>
            // </ItemGroup>
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                  <!-- squint and pretend i0 is 'CppCompile' and 'm' is 'ObjectFile' -->
                  <Link Include=""A_PCH""/>
                  <Link Include=""@(i0->'%(m).obj')"" Condition=""'%(i0.m)' == 'm1'""/>
                  <Link Include=""@(i0->'%(m)')"" Condition=""'%(i0.m)' == 'm2'""/>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);

            Lookup lookup = GenerateLookup(task.Project);

            task.ExecuteTask(lookup);

            ICollection<ProjectItemInstance> linkGroup = lookup.GetItems("link");

            Assert.Equal(4, linkGroup.Count);
            Assert.Equal("A_PCH", linkGroup.First().EvaluatedInclude);
            Assert.Equal("m1.obj", linkGroup.ElementAt(1).EvaluatedInclude);
            Assert.Equal("m2", linkGroup.ElementAt(2).EvaluatedInclude);
            Assert.Equal("m2", linkGroup.ElementAt(3).EvaluatedInclude);
        }

        [Fact]
        public void RemovesOfPersistedItemsAreReversed()
        {
            MockLogger logger = new MockLogger();
            Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i0 Include='a1'/>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <i0 Remove='a1'/>
                    </ItemGroup>
                    <Message Text='[@(i0)]'/>
                  </Target>
                </Project>
            "))));

            ProjectInstance p = project.CreateProjectInstance();
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            // The item was removed during the build
            logger.AssertLogContains("[]");
            Assert.Empty(p.ItemsToBuildWith["i0"]);
            Assert.Empty(p.ItemsToBuildWith.ItemTypes);

            p = project.CreateProjectInstance();
            // We should still have the item left
            Assert.Single(p.ItemsToBuildWith["i0"]);
            Assert.Single(p.ItemsToBuildWith.ItemTypes);
        }

        [Fact]
        public void RemovesOfPersistedItemsAreReversed1()
        {
            MockLogger logger = new MockLogger();
            Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i0 Include='a1'/>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <i0 Include='a1'/>
                      <i0 Remove='a1'/>
                    </ItemGroup>
                    <Message Text='[@(i0)]'/>
                  </Target>
                </Project>
            "))));

            ProjectInstance p = project.CreateProjectInstance();
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[]");
            Assert.Empty(p.ItemsToBuildWith["i0"]);
            Assert.Empty(p.ItemsToBuildWith.ItemTypes);

            p = project.CreateProjectInstance();
            // We should still have the item left
            Assert.Single(p.ItemsToBuildWith["i0"]);
            Assert.Single(p.ItemsToBuildWith.ItemTypes);
        }

        [Fact]
        public void RemovesOfPersistedItemsAreReversed2()
        {
            MockLogger logger = new MockLogger();
            Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i0 Include='a1'/>
                    <i0 Include='a2'/>
                    <i1 Include='b1'/>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <i0 Include='a1'/>
                      <i0 Remove='a1'/>
                      <i0 Include='a1'/>
                      <i0 Include='a3'/>
                    </ItemGroup>
                    <Message Text='[@(i0)][@(i1)]'/>
                  </Target>
                </Project>
            "))));

            ProjectInstance p = project.CreateProjectInstance();
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[a2;a1;a3][b1]");
            Assert.Equal(3, p.ItemsToBuildWith["i0"].Count);
            Assert.Single(p.ItemsToBuildWith["i1"]);
            Assert.Equal(2, p.ItemsToBuildWith.ItemTypes.Count);

            p = project.CreateProjectInstance();
            Assert.Equal(2, p.ItemsToBuildWith["i0"].Count);
            Assert.Single(p.ItemsToBuildWith["i1"]);
            Assert.Equal(2, p.ItemsToBuildWith.ItemTypes.Count);
        }

        [Fact]
        public void RemovesOfPersistedItemsAreReversed3()
        {
            MockLogger logger = new MockLogger();
            Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i0 Include='a1'>
                      <m>m1</m>
                    </i0> 
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <i0 Include='a1'>
                        <m>m2</m>
                      </i0> 
                      <i0 Remove='a1'/>
                    </ItemGroup>
                    <Message Text='[%(i0.m)]'/>
                  </Target>
                </Project>
            "))));
            ProjectInstance p = project.CreateProjectInstance();
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[]");
            Assert.Empty(p.ItemsToBuildWith["i0"]);
            Assert.Empty(p.ItemsToBuildWith.ItemTypes);

            p = project.CreateProjectInstance();
            Assert.Single(p.ItemsToBuildWith["i0"]);
            Assert.Equal("m1", p.ItemsToBuildWith["i0"].First().GetMetadataValue("m"));
            Assert.Single(p.ItemsToBuildWith.ItemTypes);
        }

        /// <summary>
        /// Persisted item is copied into another item list by an ItemGroup -- the copy
        /// should be reversed
        /// </summary>
        [Fact]
        public void RemovesOfPersistedItemsAreReversed4()
        {
            MockLogger logger = new MockLogger();
            Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i0 Include='a1'/>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <i0 Include='@(i0)'/>
                      <i1 Include='@(i0)'/> <!-- for good measure, into another list as well -->
                    </ItemGroup>
                    <Message Text='[@(i0)][@(i1)]'/>
                  </Target>
                </Project>
            "))));

            ProjectInstance p = project.CreateProjectInstance();
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[a1;a1][a1;a1]");
            Assert.Equal(2, p.ItemsToBuildWith["i0"].Count);
            Assert.Equal(2, p.ItemsToBuildWith["i1"].Count);
            Assert.Equal(2, p.ItemsToBuildWith.ItemTypes.Count);

            p = project.CreateProjectInstance();
            Assert.Single(p.ItemsToBuildWith["i0"]);
            Assert.Equal("a1", p.ItemsToBuildWith["i0"].First().EvaluatedInclude);
            Assert.Empty(p.ItemsToBuildWith["i1"]);
            Assert.Single(p.ItemsToBuildWith.ItemTypes);
        }

        [Fact]
        public void RemovesOfItemsOnlyWithMetadataValue()
        {
            MockLogger logger = new MockLogger();
            Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i0 Include='a1'>
                      <m>m1</m>
                    </i0> 
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <i0 Include='a1'>
                        <m>m2</m>
                      </i0> 
                      <i0 Remove='a1' Condition=""'%(i0.m)' == 'm1'""/>
                    </ItemGroup>
                    <Message Text='[%(i0.m)]'/>
                  </Target>
                </Project>
            "))));
            ProjectInstance p = project.CreateProjectInstance();
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[m2]");
            Assert.Single(p.ItemsToBuildWith["i0"]);
        }

        [Fact]
        public void RemoveBatchingOnRemoveValue()
        {
            MockLogger logger = new MockLogger();
            Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i0 Include='m1;m2;m3'/>
                    <i1 Include='a1'>
                      <m>m1</m>
                    </i1>
                    <i1 Include='a2'>
                      <m>m2</m>
                    </i1>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <i0 Remove='%(i1.m)'/>
                    </ItemGroup>
                    <Message Text='[@(i0)]'/>
                  </Target>
                </Project>
            "))));
            ProjectInstance p = project.CreateProjectInstance();
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[m3]");
            Assert.Single(p.ItemsToBuildWith["i0"]);
        }

        [Fact]
        public void RemoveWithWildcards()
        {
            using (var env = TestEnvironment.Create())
            {
                var projectDirectory = env.CreateFolder();
                env.SetCurrentDirectory(projectDirectory.Path);

                var file1 = env.CreateFile(projectDirectory).Path;
                var file2 = env.CreateFile(projectDirectory).Path;

                string content = ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                <Target Name='t'>
                    <ItemGroup>
                        <i1 Include='" + file1 + ";" + file2 + @";other'/>
                        <i1 Remove='" + projectDirectory.Path + Path.DirectorySeparatorChar + @"*.tmp'/>
                    </ItemGroup>
                </Target></Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
                Lookup lookup = LookupHelpers.CreateLookup(properties);
                ExecuteTask(task, lookup);

                Assert.Single(lookup.GetItems("i1"));
                Assert.Equal("other", lookup.GetItems("i1").First().EvaluatedInclude);
            }
        }

        [Fact]
        public void RemovesNotVisibleToParallelTargetBatches()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i Include='1.in'><output>1.out</output></i>
                    <i Include='2.in'><output>2.out</output></i>
                  </ItemGroup> 
                  <Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
                    <Message Text='start:[@(i)]'/>
                    <ItemGroup>
                      <i Remove='1.in;2.in'/>
                    </ItemGroup>
                    <Message Text='end:[@(i)]'/>                    
                </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "start:[1.in]", "end:[]", "start:[2.in]", "end:[]" });
        }

        [Fact]
        public void RemovesNotVisibleToParallelTargetBatches2()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i Include='1.in'><output>1.out</output></i>
                    <i Include='2.in'><output>2.out</output></i>
                    <j Include='j1'/>
                  </ItemGroup> 
                  <Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
                    <Message Text='start:[@(j)]'/>
                    <ItemGroup>
                      <j Remove='@(j)'/>
                    </ItemGroup>
                    <Message Text='end:[@(j)]'/>                    
                </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "start:[j1]", "end:[]", "start:[j1]", "end:[]" });
        }

        /// <summary>
        /// Whidbey behavior was that items/properties emitted by a target being called, were
        /// not visible to subsequent tasks in the calling target. (That was because the project
        /// items and properties had been cloned for the target batches.) We must match that behavior.
        /// </summary>
        [Fact]
        public void CalledTargetItemsAreNotVisibleToCallerTarget()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i Include='a'/>
                  </ItemGroup>
                  <PropertyGroup>
                    <p>a</p>
                  </PropertyGroup>
                  <Target Name='t3' DependsOnTargets='t' >
                    <Message Text='after target:[$(p)][@(i)]'/>
                  </Target>
                  <Target Name='t' >
                    <CallTarget Targets='t2'/>
                    <Message Text='in target:[$(p)][@(i)]'/>
                  </Target>
                  <Target Name='t2' >
                    <CreateItem Include='b'>
                      <Output TaskParameter='include' ItemName='i'/>
                      <Output TaskParameter='include' PropertyName='q'/>
                    </CreateItem>
                    <ItemGroup>
                      <i Include='c'/>
                    </ItemGroup>
                    <PropertyGroup>
                      <p>$(p);$(q);c</p>
                    </PropertyGroup>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t3" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "in target:[a][a]", "after target:[a;b;c][a;b;c]" });
        }

        /// <summary>
        /// Items and properties should be visible within a CallTarget, even if the CallTargets are separate tasks
        /// </summary>
        [Fact]
        public void CalledTargetItemsAreVisibleWhenTargetsRunFromSeperateTasks()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
    <Target Name='Build' DependsOnTargets='t'>
        <Message Text='Props During Build:[$(SomeProperty)]'/>
        <Message Text='Items During Build:[@(SomeItem)]'/>
    </Target>

    <Target Name='t'>
        <CallTarget Targets='t1'/>
        <CallTarget Targets='t2'/>
        <Message Text='Props After t1;t2:[$(SomeProperty)]'/>
        <Message Text='Items After t1;t2:[@(SomeItem)]'/>
    </Target>
    <Target Name='t1'>
        <PropertyGroup>
            <SomeProperty>prop</SomeProperty>
        </PropertyGroup>
        <ItemGroup>
            <SomeItem Include='item'/>
        </ItemGroup>
        <Message Text='Props During t1:[$(SomeProperty)]'/>
        <Message Text='Items During t1:[@(SomeItem)]'/>
    </Target>

    <Target Name='t2'>
        <Message Text='Props During t2:[$(SomeProperty)]'/>
        <Message Text='Items During t2:[@(SomeItem)]'/>
    </Target>
</Project>
            "))));
            p.Build(new string[] { "Build" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "Props During t1:[prop]", "Props During t2:[prop]", "Props After t1;t2:[]", "Props During Build:[prop]" });
            logger.AssertLogContains(new string[] { "Items During t1:[item]", "Items During t2:[item]", "Items After t1;t2:[]", "Items During Build:[item]" });
        }

        /// <summary>
        /// Items and properties should be visible within a CallTarget, even if the targets
        /// are Run Separately
        /// </summary>
        [Fact]
        public void CalledTargetItemsAreVisibleWhenTargetsRunSeperately()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
    <Target Name='Build' DependsOnTargets='t'>
        <Message Text='Props During Build:[$(SomeProperty)]'/>
        <Message Text='Items During Build:[@(SomeItem)]'/>
    </Target>

    <Target Name='t'>
        <CallTarget Targets='t1;t2' RunEachTargetSeparately='true'/>
        <Message Text='Props After t1;t2:[$(SomeProperty)]'/>
        <Message Text='Items After t1;t2:[@(SomeItem)]'/>
    </Target>
    <Target Name='t1'>
        <PropertyGroup>
            <SomeProperty>prop</SomeProperty>
        </PropertyGroup>
        <ItemGroup>
            <SomeItem Include='item'/>
        </ItemGroup>
        <Message Text='Props During t1:[$(SomeProperty)]'/>
        <Message Text='Items During t1:[@(SomeItem)]'/>
    </Target>

    <Target Name='t2'>
        <Message Text='Props During t2:[$(SomeProperty)]'/>
        <Message Text='Items During t2:[@(SomeItem)]'/>
    </Target>
</Project>
            "))));
            p.Build(new string[] { "Build" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "Props During t1:[prop]", "Props During t2:[prop]", "Props After t1;t2:[]", "Props During Build:[prop]" });
            logger.AssertLogContains(new string[] { "Items During t1:[item]", "Items During t2:[item]", "Items After t1;t2:[]", "Items During Build:[item]" });
        }

        /// <summary>
        /// Items and properties should be visible within a CallTarget, even if the targets
        /// are Run Together
        /// </summary>
        [Fact]
        public void CalledTargetItemsAreVisibleWhenTargetsRunTogether()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
    <Target Name='Build' DependsOnTargets='t'>
        <Message Text='Props During Build:[$(SomeProperty)]'/>
        <Message Text='Items During Build:[@(SomeItem)]'/>
    </Target>

    <Target Name='t'>
        <CallTarget Targets='t1;t2' RunEachTargetSeparately='false'/>
        <Message Text='Props After t1;t2:[$(SomeProperty)]'/>
        <Message Text='Items After t1;t2:[@(SomeItem)]'/>
    </Target>
    <Target Name='t1'>
        <PropertyGroup>
            <SomeProperty>prop</SomeProperty>
        </PropertyGroup>
        <ItemGroup>
            <SomeItem Include='item'/>
        </ItemGroup>
        <Message Text='Props During t1:[$(SomeProperty)]'/>
        <Message Text='Items During t1:[@(SomeItem)]'/>
    </Target>

    <Target Name='t2'>
        <Message Text='Props During t2:[$(SomeProperty)]'/>
        <Message Text='Items During t2:[@(SomeItem)]'/>
    </Target>
</Project>
            "))));
            p.Build(new string[] { "Build" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "Props During t1:[prop]", "Props During t2:[prop]", "Props After t1;t2:[]", "Props During Build:[prop]" });
            logger.AssertLogContains(new string[] { "Items During t1:[item]", "Items During t2:[item]", "Items After t1;t2:[]", "Items During Build:[item]" });
        }

        /// <summary>
        /// Whidbey behavior was that items/properties emitted by a target calling another target, were
        /// not visible to the calling target. (That was because the project items and properties had been cloned for the target batches.)
        /// We must match that behavior. (For now)
        /// </summary>
        [Fact]
        public void CallerTargetItemsAreNotVisibleToCalledTarget()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i Include='a'/>
                  </ItemGroup>
                  <PropertyGroup>
                    <p>a</p>
                  </PropertyGroup>
                  <Target Name='t3' DependsOnTargets='t' >
                    <Message Text='after target:[$(p)][@(i)]'/>
                  </Target>
                  <Target Name='t' >
                    <CreateItem Include='b'>
                      <Output TaskParameter='include' ItemName='i'/>
                      <Output TaskParameter='include' PropertyName='q'/>
                    </CreateItem>
                    <ItemGroup>
                      <i Include='c'/>
                    </ItemGroup>
                    <PropertyGroup>
                      <p>$(p);$(q);c</p>
                    </PropertyGroup>
                    <CallTarget Targets='t2'/>
                  </Target>
                  <Target Name='t2' >
                    <Message Text='in target:[$(p)][@(i)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t3" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "in target:[a][a]", "after target:[a;b;c][a;b;c]" });
        }

        [Fact]
        public void ModifyNoOp()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup> 
                    <i1/>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            Assert.Empty(lookup.GetItems("i1"));
        }

        [Fact]
        public void ModifyItemInTarget()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i1 Include='a1'> 
                      <m>m1</m>
                    </i1>
                    <i1>
                      <m>m2</m>
                    </i1>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ProjectItemInstance item = lookup.GetItems("i1").First();
            Assert.Equal("m2", item.GetMetadataValue("m"));
        }

        [Fact]
        public void ModifyItemInTargetComplex()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
              <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                <PropertyGroup>
                  <p1>true</p1>
                  <p2>v3</p2>
                </PropertyGroup>

                <ItemGroup>
                   <i Include='item1'/>
                </ItemGroup>

                <Target Name='t'>
                    <ItemGroup>
                      <i>
                        <m1 Condition=""'$(p1)' == 'true'"">v1</m1>
                        <m2>v2</m2>
                        <m3>$(p2)</m3>
                      </i>
                    </ItemGroup>
                    <Message Text='[%(i.identity)|%(i.m1)|%(i.m2)|%(i.m3)]'/>
                </Target>
              </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains(@"[item1|v1|v2|v3]");
        }

        [Fact]
        public void ModifyItemInTargetLastMetadataWins()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i1 Include='a1'> 
                      <m>m1</m>
                    </i1>
                    <i1>
                      <m>m2</m>
                      <m>m3</m>
                      <m Condition='false'>m4</m>
                    </i1>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ProjectItemInstance item = lookup.GetItems("i1").First();
            Assert.Equal("m3", item.GetMetadataValue("m"));
        }

        [Fact]
        public void ModifyItemEmittedByTask()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <Target Name='t'>
                    <CreateItem Include='a1' AdditionalMetadata='m=m1;n=n1'>
                      <Output TaskParameter='include' ItemName='i1'/>
                    </CreateItem>
                    <ItemGroup>
                      <i1>
                        <m>m2</m>
                      </i1>
                    </ItemGroup>
                    <Message Text='[%(i1.m)][%(i1.n)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "[m2][n1]" });
        }

        [Fact]
        public void ModifyItemInTargetWithCondition()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i1 Include='a1'> 
                      <m>m1</m>
                    </i1>
                    <i1 Include='a2'> 
                      <m>m2</m>
                    </i1>
                    <i1 Condition=""'%(i1.m)'=='m2'"">
                      <m>m3</m>
                    </i1>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ProjectItemInstance item1 = lookup.GetItems("i1").First();
            ProjectItemInstance item2 = lookup.GetItems("i1").ElementAt(1);
            Assert.Equal("a1", item1.EvaluatedInclude);
            Assert.Equal("a2", item2.EvaluatedInclude);
            Assert.Equal("m1", item1.GetMetadataValue("m"));
            Assert.Equal("m3", item2.GetMetadataValue("m"));
        }

        [Fact]
        public void ModifyItemInTargetWithConditionOnMetadata()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i1 Include='a1'> 
                      <m>m1</m>
                    </i1>
                    <i1 Include='a2'> 
                      <m>m2</m>
                    </i1>
                    <i1>
                      <m Condition=""'%(i1.m)'=='m2'"">m3</m>
                    </i1>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ProjectItemInstance item1 = lookup.GetItems("i1").First();
            ProjectItemInstance item2 = lookup.GetItems("i1").ElementAt(1);
            Assert.Equal("a1", item1.EvaluatedInclude);
            Assert.Equal("a2", item2.EvaluatedInclude);
            Assert.Equal("m1", item1.GetMetadataValue("m"));
            Assert.Equal("m3", item2.GetMetadataValue("m"));
        }

        [Fact]
        public void ModifyItemWithUnqualifiedMetadataError()
        {
            Assert.Throws<InvalidProjectFileException>(() =>
            {
                string content = ObjectModelHelpers.CleanupFileContents(
                @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i1 Include='a1'/>
                    <i1>
                      <m Condition=""'%(undefined_on_a1)'=='1'"">2</m>
                    </i1>
                </ItemGroup>
            </Target></Project>");
                IntrinsicTask task = CreateIntrinsicTask(content);
                ExecuteTask(task, null);
            });
        }
        [Fact]
        public void ModifyItemInTargetWithConditionWithoutItemTypeOnMetadataInCondition()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i1 Include='a1'> 
                      <m>m1</m>
                    </i1>
                    <i1 Include='a2'> 
                      <m>m2</m>
                    </i1>
                    <i1 Condition=""'%(m)'=='m2'"">
                      <m>m3</m>
                    </i1>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ProjectItemInstance item1 = lookup.GetItems("i1").First();
            ProjectItemInstance item2 = lookup.GetItems("i1").ElementAt(1);
            Assert.Equal("a1", item1.EvaluatedInclude);
            Assert.Equal("a2", item2.EvaluatedInclude);
            Assert.Equal("m1", item1.GetMetadataValue("m"));
            Assert.Equal("m3", item2.GetMetadataValue("m"));
        }


        [Fact]
        public void ModifyItemInTargetWithConditionOnMetadataWithoutItemTypeOnMetadataInCondition()
        {
            string content = ObjectModelHelpers.CleanupFileContents(
            @"<Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i1 Include='a1'> 
                      <m>m1</m>
                    </i1>
                    <i1 Include='a2'> 
                      <m>m2</m>
                    </i1>
                    <i1>
                      <m Condition=""'%(m)'=='m2'"">m3</m>
                    </i1>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);
            Lookup lookup = LookupHelpers.CreateEmptyLookup();
            ExecuteTask(task, lookup);

            ProjectItemInstance item1 = lookup.GetItems("i1").First();
            ProjectItemInstance item2 = lookup.GetItems("i1").ElementAt(1);
            Assert.Equal("a1", item1.EvaluatedInclude);
            Assert.Equal("a2", item2.EvaluatedInclude);
            Assert.Equal("m1", item1.GetMetadataValue("m"));
            Assert.Equal("m3", item2.GetMetadataValue("m"));
        }

        [Fact]
        public void ModifyItemOutsideTarget()
        {
            // <ItemGroup>
            //    <i0 Include='a1'>
            //        <m>m1</m>
            //        <n>n1</n>
            //    </i0>
            //    <i0 Include='a2;a3'>
            //        <m>m2</m>
            //        <n>n2</n>
            //    </i0>
            //    <i0 Include='a4'>
            //        <m>m3</m>
            //        <n>n3</n>
            //    </i0>
            // </ItemGroup>
            string content = ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
            <Target Name='t'>
                <ItemGroup>
                    <i0>
                      <m>m4</m>
                    </i0>
                </ItemGroup>
            </Target></Project>");
            IntrinsicTask task = CreateIntrinsicTask(content);

            Lookup lookup = GenerateLookup(task.Project);

            task.ExecuteTask(lookup);

            ICollection<ProjectItemInstance> i0Group = lookup.GetItems("i0");

            Assert.Equal(4, i0Group.Count);
            foreach (ProjectItemInstance item in i0Group)
            {
                Assert.Equal("m4", item.GetMetadataValue("m"));
            }
        }

        [Fact]
        public void RemoveComplexMidlExample()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
  <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
    <PropertyGroup>
      <UseIdlBasedDllData>true</UseIdlBasedDllData>
      <MidlDllDataFileName>dlldata.c</MidlDllDataFileName>
      <MidlDllDataDir>dlldatadir</MidlDllDataDir>
      <MidlHeaderDir>headerdir</MidlHeaderDir>
      <MidlTlbDir>tlbdir</MidlTlbDir>
      <MidlProxyDir>proxydir</MidlProxyDir>
      <MidlInterfaceDir>interfacedir</MidlInterfaceDir>
    </PropertyGroup>

    <ItemGroup>
       <Idl Include='a.idl'/>
       <Idl Include='b.idl'>
          <DllDataFileName>mydlldata.c</DllDataFileName>
       </Idl>
       <Idl Include='c.idl'>
          <HeaderFileName>myheader.h</HeaderFileName>
       </Idl>
    </ItemGroup>

    <Target Name='MIDL'>
        <Message Text='Before: [%(idl.identity)|%(Idl.m1)]'/>
        <ItemGroup>
          <Idl>
            <DllDataFileName Condition=""'$(UseIdlBasedDllData)' == 'true' and '%(Idl.DllDataFileName)' == ''"">$(MidlDllDataDir)\%(Filename)_dlldata.c</DllDataFileName>
            <DllDataFileName Condition=""'$(UseIdlBasedDllData)' != 'true' and '%(Idl.DllDataFileName)' == ''"">$(MidlDllDataFileName)</DllDataFileName>
            <HeaderFileName Condition=""'%(Idl.HeaderFileName)' == ''"">$(MidlHeaderDir)\%(Idl.Filename).h</HeaderFileName>
            <TypeLibraryName Condition=""'%(Idl.TypeLibraryName)' == ''"">$(MidlTlbDir)\%(Filename).tlb</TypeLibraryName>
            <ProxyFileName Condition=""'%(Idl.ProxyFileName)' == ''"">$(MidlProxyDir)\%(Filename)_p.c</ProxyFileName>
            <InterfaceIdentifierFileName Condition=""'%(Idl.InterfaceIdentifierFileName)' == ''"">$(MidlInterfaceDir)\%(Filename)_i.c</InterfaceIdentifierFileName>
          </Idl>
        </ItemGroup>

        <Message Text='[%(idl.identity)|%(idl.dlldatafilename)|%(idl.headerfilename)|%(idl.TypeLibraryName)|%(idl.ProxyFileName)|%(idl.InterfaceIdentifierFileName)]'/>
    </Target>
  </Project>
            "))));
            p.Build(new string[] { "MIDL" }, new ILogger[] { logger });

            logger.AssertLogContains(@"[a.idl|dlldatadir\a_dlldata.c|headerdir\a.h|tlbdir\a.tlb|proxydir\a_p.c|interfacedir\a_i.c]",
                                     @"[b.idl|mydlldata.c|headerdir\b.h|tlbdir\b.tlb|proxydir\b_p.c|interfacedir\b_i.c]",
                                     @"[c.idl|dlldatadir\c_dlldata.c|myheader.h|tlbdir\c.tlb|proxydir\c_p.c|interfacedir\c_i.c]");
        }

        [Fact]
        public void ModifiesOfPersistedItemsAreReversed1()
        {
            MockLogger logger = new MockLogger();
            Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i0 Include='i1'>
                      <m>m0</m>
                    </i0>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <i0>
                        <m>m1</m>
                      </i0> 
                    </ItemGroup>
                  </Target>
                  <Target Name='t2'>
                    <Message Text='[%(i0.m)]'/>
                  </Target>
                </Project>
            "))));

            ProjectInstance p = project.CreateProjectInstance();
            p.Build(new string[] { "t", "t2" }, new ILogger[] { logger });

            logger.AssertLogContains("[m1]");

            ProjectItemInstance item = p.ItemsToBuildWith["i0"].First();
            Assert.Equal("m1", item.GetMetadataValue("m"));

            p = project.CreateProjectInstance();
            item = p.ItemsToBuildWith["i0"].First();
            Assert.Equal("m0", item.GetMetadataValue("m"));
        }

        /// <summary>
        /// Modify of an item copied during the build
        /// </summary>
        [Fact]
        public void ModifiesOfPersistedItemsAreReversed2()
        {
            MockLogger logger = new MockLogger();
            Project project = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i0 Include='i1'>
                      <m>m0</m>
                      <n>n0</n>
                    </i0>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <i1 Include='@(i0)'>
                        <m>m1</m>
                      </i1>
                      <i1>
                        <n>n1</n>
                      </i1> 
                    </ItemGroup>
                  </Target>
                  <Target Name='t2'>
                    <Message Text='[%(i0.m)][%(i0.n)]'/>
                    <Message Text='[%(i1.m)][%(i1.n)]'/>
                  </Target>
                </Project>
            "))));

            ProjectInstance p = project.CreateProjectInstance();
            p.Build(new string[] { "t", "t2" }, new ILogger[] { logger });

            logger.AssertLogContains("[m0][n0]", "[m1][n1]");

            Assert.Single(p.ItemsToBuildWith["i0"]);
            Assert.Single(p.ItemsToBuildWith["i1"]);
            Assert.Equal("m0", p.ItemsToBuildWith["i0"].First().GetMetadataValue("m"));
            Assert.Equal("n0", p.ItemsToBuildWith["i0"].First().GetMetadataValue("n"));
            Assert.Equal("m1", p.ItemsToBuildWith["i1"].First().GetMetadataValue("m"));
            Assert.Equal("n1", p.ItemsToBuildWith["i1"].First().GetMetadataValue("n"));

            p = project.CreateProjectInstance();
            Assert.Single(p.ItemsToBuildWith["i0"]);
            Assert.Empty(p.ItemsToBuildWith["i1"]);
            Assert.Equal("m0", p.ItemsToBuildWith["i0"].First().GetMetadataValue("m"));
            Assert.Equal("n0", p.ItemsToBuildWith["i0"].First().GetMetadataValue("n"));
        }


        /// <summary>
        /// The case is where a transform is done on an item to generate a pdb file name when the extension of an item is dll
        /// the resulting items is expected to have an extension metadata of pdb but instead has an extension of dll
        /// </summary>
        [Fact]
        public void IncludeCheckOnMetadata()
        {
            MockLogger logger = new MockLogger();

            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project xmlns='msbuildnamespace'>
                   <Target Name='a'>
                     <ItemGroup>
                       <Content Include='a.dll' />
                       <Content Include=""@(Content->'%(FileName).pdb')"" Condition=""'%(Content.Extension)' == '.dll'""/>
                      </ItemGroup>

                      <Message Text='[%(Content.Identity)]->[%(Content.Extension)]' Importance='High'/>
                   </Target>
                </Project> "))));
            bool success = p.Build(new string[] { "a" }, new ILogger[] { logger });
            Assert.True(success);
            logger.AssertLogContains("[a.dll]->[.dll]");
            logger.AssertLogContains("[a.pdb]->[.pdb]");
        }

        /// <summary>
        /// The case is where a transform is done on an item to generate a pdb file name the batching is done on the identity.
        /// If the identity was also copied over then we would only get one bucket instead of two buckets
        /// </summary>
        [Fact]
        public void IncludeCheckOnMetadata2()
        {
            MockLogger logger = new MockLogger();

            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project xmlns='msbuildnamespace'>
                   <Target Name='a'>
                     <ItemGroup>
                       <Content Include='a.dll' />
                       <Content Include=""@(Content->'%(FileName)%(Extension).pdb')""/>
                       <Content Include=""@(Content->'%(FileName)%(Extension).pdb')"" Condition=""'%(Content.Identity)' != ''""/>
                      </ItemGroup>

                      <Message Text='[%(Content.Identity)]->[%(Content.Extension)]' Importance='High'/>
                   </Target>
                </Project> "))));
            bool success = p.Build(new string[] { "a" }, new ILogger[] { logger });
            Assert.True(success);
            logger.AssertLogContains("[a.dll]->[.dll]");
            logger.AssertLogContains("[a.dll.pdb]->[.pdb]");
            logger.AssertLogContains("[a.dll.pdb.pdb]->[.pdb]");
        }

        /// <summary>
        /// Make sure that recursive dir still gets the right file
        ///
        /// </summary>
        [Fact]
        [Trait("Category", "netcore-osx-failing")]
        [Trait("Category", "netcore-linux-failing")]
        public void IncludeCheckOnMetadata_3()
        {
            MockLogger logger = new MockLogger();

            string tempPath = Path.GetTempPath();
            string directoryForTest = Path.Combine(tempPath, "IncludeCheckOnMetadata_3\\Test");
            string fileForTest = Path.Combine(directoryForTest, "a.dll");

            try
            {
                if (Directory.Exists(directoryForTest))
                {
                    FileUtilities.DeleteWithoutTrailingBackslash(directoryForTest, true);
                }
                else
                {
                    Directory.CreateDirectory(directoryForTest);
                }

                File.WriteAllText(fileForTest, fileForTest);

                Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project xmlns='msbuildnamespace'>
                   <Target Name='a'>
                     <ItemGroup>
                        <Content Include='a.dll' />
                        <Content Include='" + Path.Combine(directoryForTest, "..", "**") + @"'  Condition=""'%(Content.Extension)' == '.dll'""/>
                    </ItemGroup>
                         <Message Text='[%(Content.Identity)]->[%(Content.Extension)]->[%(Content.RecursiveDir)]' Importance='High'/>
                     </Target>
                </Project> "))));
                bool success = p.Build(new string[] { "a" }, new ILogger[] { logger });
                Assert.True(success);
                logger.AssertLogContains("[a.dll]->[.dll]->[]");
                logger.AssertLogContains(
                    "[" + Path.Combine(directoryForTest, "..", "Test", "a.dll") + @"]->[.dll]->[Test"
                    + Path.DirectorySeparatorChar + "]");
            }
            finally
            {
                if (Directory.Exists(directoryForTest))
                {
                    FileUtilities.DeleteWithoutTrailingBackslash(directoryForTest, true);
                }
            }
        }

        [Fact]
        public void RemoveItemInImportedFile()
        {
            MockLogger logger = new MockLogger();
            string importedFile = null;

            try
            {
                importedFile = FileUtilities.GetTemporaryFileName();
                File.WriteAllText(importedFile, ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i1 Include='imported'/>
                  </ItemGroup>
                </Project>
            "));
                Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                    <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                      <Import Project='" + importedFile + @"'/>
                      <Target Name='t'>
                        <Message Text='[@(i1)]'/>
                        <ItemGroup>
                          <i1 Remove='imported'/>
                        </ItemGroup>
                        <Message Text='[@(i1)]'/>
                      </Target>
                    </Project>
                "))));
                p.Build(new string[] { "t" }, new ILogger[] { logger });

                logger.AssertLogContains("[imported]", "[]");
            }
            finally
            {
                ObjectModelHelpers.DeleteTempFiles(new string[] { importedFile });
            }
        }

        [Fact]
        public void ModifyItemInImportedFile()
        {
            MockLogger logger = new MockLogger();
            string importedFile = null;

            try
            {
                importedFile = FileUtilities.GetTemporaryFileName();
                File.WriteAllText(importedFile, ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i1 Include='imported'/>
                  </ItemGroup>
                </Project>
            "));
                Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                    <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                      <Import Project='" + importedFile + @"'/>
                      <Target Name='t'>
                        <ItemGroup>
                          <i1>
                            <m>m1</m>
                          </i1>
                        </ItemGroup>
                        <Message Text='[%(i1.m)]'/>
                      </Target>
                    </Project>
                "))));
                p.Build(new string[] { "t" }, new ILogger[] { logger });

                logger.AssertLogContains("[m1]");
            }
            finally
            {
                ObjectModelHelpers.DeleteTempFiles(new string[] { importedFile });
            }
        }

        /// <summary>
        /// Properties produced in one target batch are not visible to another
        /// </summary>
        [Fact]
        public void OutputPropertiesInTargetBatchesCreateItem()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <!-- just to cause two target batches -->
                    <i Include='1.in'><output>1.out</output></i>
                    <i Include='2.in'><output>2.out</output></i>
                  </ItemGroup> 
                  <Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.output)'>
                    <Message Text='start:[$(p)]'/>
                    <CreateProperty Value='$(p)--%(i.Identity)'>
                      <Output TaskParameter='Value' PropertyName='p'/>
                    </CreateProperty>
                    <Message Text='end:[$(p)]'/>
                  </Target>
                  <Target Name='t2'>
                    <Message Text='final:[$(p)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t", "t2" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "start:[]", "end:[--1.in]", "start:[]", "end:[--2.in]", "final:[--2.in]" });
        }

        /// <summary>
        /// Properties produced in one task batch are not visible to another
        /// </summary>
        [Fact]
        public void OutputPropertiesInTaskBatchesCreateItem()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <Target Name='t'>
                    <ItemGroup>
                      <i Include='1.in;2.in'/>
                    </ItemGroup>
                    <CreateProperty Value='$(p)--%(i.Identity)'>
                      <Output TaskParameter='Value' PropertyName='p'/>
                    </CreateProperty>
                    <Message Text='end:[$(p)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains(new string[] { "end:[--2.in]" });
        }

        /// <summary>
        /// In this case gen.cpp was getting ObjectFile of def.obj.
        /// </summary>
        [Fact]
        public void PhoenixBatchingIssue()
        {
            ProjectRootElement xml = ProjectRootElement.Create(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
            <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                <ItemGroup>
                    <CppCompile Include='gen.cpp'/>
                    <CppCompile Include='def.cpp'>
                        <ObjectFile>def.obj</ObjectFile>
                    </CppCompile>
                </ItemGroup>
                
                <Target Name='t'>
                    <ItemGroup>
                        <CppCompile>
                            <IncludeInLib Condition=""'%(CppCompile.IncludeInLib)' == ''"">true</IncludeInLib>
                        </CppCompile>
                        <CppCompile>
                            <ObjectFile>%(Filename).obj</ObjectFile>
                        </CppCompile>
                    </ItemGroup>
                </Target>
            </Project>
            "))));
            ProjectInstance instance = new ProjectInstance(xml);
            instance.Build();

            Assert.Equal(2, instance.Items.Count);
            Assert.Equal("gen.obj", instance.GetItems("CppCompile").First().GetMetadataValue("ObjectFile"));
            Assert.Equal("def.obj", instance.GetItems("CppCompile").Last().GetMetadataValue("ObjectFile"));
        }

        [Fact]
        public void PropertiesInInferredBuildCreateProperty()
        {
            string[] files = null;
            try
            {
                files = ObjectModelHelpers.GetTempFiles(2, new DateTime(2005, 1, 1));

                MockLogger logger = new MockLogger();
                Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <i Include='" + files.First() + "'><output>" + files.ElementAt(1) + @"</output></i>
                  </ItemGroup>
                  <Target Name='t2' DependsOnTargets='t'>
                    <Message Text='final:[$(p)]'/>
                  </Target>
                  <Target Name='t' Inputs='%(i.Identity)' Outputs='%(i.Output)'>
                    <Message Text='start:[$(p)]'/>
                    <CreateProperty Value='@(i)'>
                      <Output TaskParameter='Value' PropertyName='p'/>
                    </CreateProperty>
                    <Message Text='end:[$(p)]'/>
                </Target>
                </Project>
            "))));
                p.Build(new string[] { "t2" }, new ILogger[] { logger });

                // We should only see messages from the second target, as the first is only inferred
                logger.AssertLogDoesntContain("start:");
                logger.AssertLogDoesntContain("end:");
                logger.AssertLogContains(new string[] { "final:[" + files.First() + "]" });
            }
            finally
            {
                ObjectModelHelpers.DeleteTempFiles(files);
            }
        }

        [Fact]
        public void ModifyItemPreviouslyModified()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <x Include='a'/>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <x>
                        <m1>1</m1>
                      </x>
                      <x>
                        <m1>2</m1>
                      </x>  
                    </ItemGroup>
                    <Message Text='[%(x.m1)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogDoesntContain("[1]");
            logger.AssertLogContains("[2]");
        }

        [Fact]
        public void ModifyItemPreviouslyModified2()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <x Include='a'/>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <x>
                        <m1>1</m1>
                      </x>
                    </ItemGroup>
                    <ItemGroup>
                      <x>
                        <m1>2</m1>
                      </x>  
                    </ItemGroup>
                    <Message Text='[%(x.m1)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogDoesntContain("[1]");
            logger.AssertLogContains("[2]");
        }

        [Fact]
        public void RemoveItemPreviouslyModified()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <x Include='a'/>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <x>
                        <m1>1</m1>
                      </x>
                      <x Remove='@(x)'/>
                    </ItemGroup>
                    <Message Text='[%(x.m1)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogDoesntContain("[1]");
            logger.AssertLogDoesntContain("[2]");
        }

        [Fact]
        public void RemoveItemPreviouslyModified2()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <x Include='a'/>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <x>
                        <m1>1</m1>
                      </x>
                    </ItemGroup>
                    <ItemGroup>
                      <x Remove='@(x)'/>
                    </ItemGroup>
                    <Message Text='[%(x.m1)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogDoesntContain("[1]");
            logger.AssertLogDoesntContain("[2]");
        }

        [Fact]
        public void FilterItemPreviouslyModified()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <x Include='a'/>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <x>
                        <m1>1</m1>
                      </x>
                      <x Condition=""'%(x.m1)'=='1'"">
                        <m1>2</m1>
                      </x>
                    </ItemGroup>
                    <Message Text='[%(x.m1)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogDoesntContain("[1]");
            logger.AssertLogContains("[2]");
        }

        [Fact]
        public void FilterItemPreviouslyModified2()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                  <ItemGroup>
                    <x Include='a'/>
                  </ItemGroup>
                  <Target Name='t'>
                    <ItemGroup>
                      <x>
                        <m1>1</m1>
                      </x>
                      <x>
                        <m1 Condition=""'%(x.m1)'=='1'"">2</m1>
                      </x>
                    </ItemGroup>
                    <Message Text='[%(x.m1)]'/>
                  </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogDoesntContain("[1]");
            logger.AssertLogContains("[2]");
        }

        [Fact]
        public void FilterItemPreviouslyModified3()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                   <ItemGroup>
                       <A Include='a;b;c'>
                           <m>m1</m>
                       </A>
                   </ItemGroup>
                   <Target Name='t'>
                       <ItemGroup>
                           <A Condition=""'%(m)' == 'm1'"">
                               <m>m2</m>
                           </A>
                       </ItemGroup>
                       <ItemGroup>
                           <A Condition=""'%(m)' == 'm2'"">
                               <m>m3</m>
                           </A>
                       </ItemGroup>
                       <ItemGroup>
                           <A Condition=""'%(m)' == 'm3'"">
                               <m>m4</m>
                           </A>
                       </ItemGroup>
                       <Message Text='[@(A) = %(A.m)]'/>
                   </Target>
                </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[a;b;c = m4]");
        }

        [Fact]
        public void FilterItemPreviouslyModified4()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                   <Target Name='t'>
                       <ItemGroup>
                           <A Include='a;b;c'>
                               <m>m1</m>
                           </A>
                           <A Condition=""'%(Identity)' == 'a' or '%(Identity)' == 'c'"">
                               <m>m2</m>
                           </A>
                           <A Condition=""'%(Identity)' == 'a' or '%(Identity)' == 'c'"">
                               <m>m3</m>
                           </A>
                       </ItemGroup>
                       <Message Text='[@(A) = %(A.m)]'/>
                   </Target>
               </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[b = m1]");
            logger.AssertLogContains("[a;c = m3]");
        }

        [Fact]
        public void FilterItemPreviouslyModified5()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                   <Target Name='t'>
                       <ItemGroup>
                           <A Include='a;b;c'>
                               <m>m1</m>
                           </A>
                           <A Condition=""'%(Identity)' == 'a' or '%(Identity)' == 'c'"">
                               <m>m2</m>
                           </A>
                           <A Condition=""'%(Identity)' == 'a'"">
                               <m>m3</m>
                           </A>
                       </ItemGroup>
                       <Message Text='[@(A) = %(A.m)]'/>
                   </Target>
               </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[a = m3]");
            logger.AssertLogContains("[b = m1]");
            logger.AssertLogContains("[c = m2]");
        }

        [Fact]
        public void FilterItemPreviouslyModified6()
        {
            MockLogger logger = new MockLogger();
            Project p = new Project(XmlReader.Create(new StringReader(ObjectModelHelpers.CleanupFileContents(@"
                <Project ToolsVersion='msbuilddefaulttoolsversion' xmlns='msbuildnamespace'>
                    <ItemGroup>
                        <A Include='a;b;c'>
                            <m>m1</m>
                        </A>
                    </ItemGroup>
                    <Target Name='t'>
                        <ItemGroup>
                            <A Condition=""'%(m)' == 'm1'"">
                                <m>m2</m>
                            </A>
                        </ItemGroup>
                        <ItemGroup>
                            <A Condition=""'%(m)' == 'm2'"">
                                <m></m>
                            </A>
                        </ItemGroup>
                        <ItemGroup>
                            <A Condition=""'%(m)' == 'm3'"">
                                <m>m3</m>
                            </A>
                        </ItemGroup>
                        <Message Text='[@(A)=%(A.m)]'/>
                    </Target>
               </Project>
            "))));
            p.Build(new string[] { "t" }, new ILogger[] { logger });

            logger.AssertLogContains("[a;b;c=]");
        }
        //////////////////////////////////////////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region Helpers

        private static PropertyDictionary<ProjectPropertyInstance> GeneratePropertyGroup()
        {
            PropertyDictionary<ProjectPropertyInstance> properties = new PropertyDictionary<ProjectPropertyInstance>();
            properties.Set(ProjectPropertyInstance.Create("p0", "v0"));
            return properties;
        }

        private static Lookup GenerateLookupWithItemsAndProperties(ProjectInstance project)
        {
            PropertyDictionary<ProjectPropertyInstance> pg = new PropertyDictionary<ProjectPropertyInstance>();
            pg.Set(ProjectPropertyInstance.Create("p0", "v0"));

            Lookup lookup = GenerateLookup(project, pg);
            return lookup;
        }

        private static Lookup GenerateLookup(ProjectInstance project)
        {
            return GenerateLookup(project, new PropertyDictionary<ProjectPropertyInstance>());
        }

        private static Lookup GenerateLookup(ProjectInstance project, PropertyDictionary<ProjectPropertyInstance> properties)
        {
            List<ProjectItemInstance> items = new List<ProjectItemInstance>();
            ProjectItemInstance item1 = new ProjectItemInstance(project, "i0", "a1", project.FullPath);
            ProjectItemInstance item2 = new ProjectItemInstance(project, "i0", "a2", project.FullPath);
            ProjectItemInstance item3 = new ProjectItemInstance(project, "i0", "a3", project.FullPath);
            ProjectItemInstance item4 = new ProjectItemInstance(project, "i0", "a4", project.FullPath);
            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.Add(item1);
            items.Add(item2);
            items.Add(item3);
            items.Add(item4);
            ItemDictionary<ProjectItemInstance> itemsByName = new ItemDictionary<ProjectItemInstance>();
            itemsByName.ImportItems(items);

            Lookup lookup = LookupHelpers.CreateLookup(properties, itemsByName);

            return lookup;
        }

        private static IntrinsicTask CreateIntrinsicTask(string content)
        {
            Project project = new Project(XmlReader.Create(new StringReader(content)));
            ProjectInstance projectInstance = project.CreateProjectInstance();
            ProjectTargetInstanceChild targetChild = projectInstance.Targets["t"].Children.First();

            NodeLoggingContext nodeContext = new NodeLoggingContext(new MockLoggingService(), 1, false);
            BuildRequestEntry entry = new BuildRequestEntry(new BuildRequest(1 /* submissionId */, 0, 1, new string[] { "t" }, null, BuildEventContext.Invalid, null), new BuildRequestConfiguration(1, new BuildRequestData("projectFile", new Dictionary<string, string>(), "3.5", Array.Empty<string>(), null), "2.0"));
            entry.RequestConfiguration.Project = projectInstance;
            IntrinsicTask task = IntrinsicTask.InstantiateTask(
                targetChild,
                nodeContext.LogProjectStarted(entry).LogTargetBatchStarted(projectInstance.FullPath, projectInstance.Targets["t"], null, TargetBuiltReason.None),
                projectInstance,
                false);

            return task;
        }

        private void ExecuteTask(IntrinsicTask task)
        {
            ExecuteTask(task, null);
        }

        private void ExecuteTask(IntrinsicTask task, Lookup lookup)
        {
            if (lookup == null)
            {
                lookup = LookupHelpers.CreateEmptyLookup();
            }

            task.ExecuteTask(lookup);
        }

        internal static void AssertItemEvaluationFromTarget(string projectContents, string targetName, string itemType, string[] inputFiles, string[] expectedInclude, bool makeExpectedIncludeAbsolute = false, Dictionary<string, string>[] expectedMetadataPerItem = null, bool normalizeSlashes = false)
        {
            ObjectModelHelpers.AssertItemEvaluationFromGenericItemEvaluator((p, c) =>
                {
                    var project = new Project(p, new Dictionary<string, string>(), MSBuildConstants.CurrentToolsVersion, c);
                    var projectInstance = project.CreateProjectInstance();
                    var targetChild = projectInstance.Targets["t"].Children.First();

                    var nodeContext = new NodeLoggingContext(new MockLoggingService(), 1, false);
                    var entry = new BuildRequestEntry(new BuildRequest(1 /* submissionId */, 0, 1, new string[] { targetName }, null, BuildEventContext.Invalid, null), new BuildRequestConfiguration(1, new BuildRequestData("projectFile", new Dictionary<string, string>(), "3.5", Array.Empty<string>(), null), "2.0"));
                    entry.RequestConfiguration.Project = projectInstance;
                    var task = IntrinsicTask.InstantiateTask(
                        targetChild,
                        nodeContext.LogProjectStarted(entry).LogTargetBatchStarted(projectInstance.FullPath, projectInstance.Targets["t"], null, TargetBuiltReason.None),
                        projectInstance,
                        false);

                    var lookup = new Lookup(new ItemDictionary<ProjectItemInstance>(), new PropertyDictionary<ProjectPropertyInstance>());
                    task.ExecuteTask(lookup);

                    return lookup.GetItems(itemType).Select(i => (ObjectModelHelpers.ITestItem)new ObjectModelHelpers.ProjectItemInstanceTestItemAdapter(i)).ToList();
                },
                projectContents,
                inputFiles,
                expectedInclude,
                makeExpectedIncludeAbsolute,
                expectedMetadataPerItem,
                normalizeSlashes);
        }
        #endregion
    }
}
