Win2D/Win2D.proj

<?xml version="1.0" encoding="utf-8"?>

<!--
    Master script for building all permutations of project * platform * configuration.

    For best performance, enable parallel builds:

        msbuild Win2D.proj /maxcpucount
-->

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0" DefaultTargets="Build">

  <!-- Parameters that can be configured by the caller, eg. "msbuild Win2D.proj /p:BuildPhone=false" -->
  <PropertyGroup>
    <BuildPlatforms>Win32;x64;ARM;AnyCPU</BuildPlatforms>
    <BuildConfigurations>Debug;Release</BuildConfigurations>
    <BuildWindows>true</BuildWindows>
    <BuildPhone>true</BuildPhone>
    <BuildTests>true</BuildTests>
    <BuildTools>true</BuildTools>
    <BuildDocs>true</BuildDocs>
    <RunTests>true</RunTests>
  </PropertyGroup>


  <!-- Set default platforms for each project type -->
  <ItemDefinitionGroup>
    <WindowsProject>
      <Platforms>Win32;x64;ARM</Platforms>
    </WindowsProject>
    <PhoneProject>
      <Platforms>Win32;ARM</Platforms>
    </PhoneProject>
    <AnyCPUProject>
      <Platforms>AnyCPU</Platforms>
    </AnyCPUProject>
  </ItemDefinitionGroup>


  <!-- Windows projects implementing the Canvas API -->
  <ItemGroup Condition="$(BuildWindows)">
    <WindowsProject Include="winrt\lib\winrt.lib.Windows.vcxproj" />
    <WindowsProject Include="winrt\dll\winrt.dll.Windows.vcxproj" />
    <WindowsProject Include="numerics\DotNet\DotNetNumerics.Windows.csproj" />
  </ItemGroup>

  <!-- Windows Phone projects implementing the Canvas API -->
  <ItemGroup Condition="$(BuildPhone)">
    <PhoneProject Include="winrt\lib\winrt.lib.WindowsPhone.vcxproj" />
    <PhoneProject Include="winrt\dll\winrt.dll.WindowsPhone.vcxproj" />
    <PhoneProject Include="numerics\DotNet\DotNetNumerics.WindowsPhone.csproj" />
  </ItemGroup>

  <!-- Windows test projects -->
  <ItemGroup Condition="$(BuildWindows) and $(BuildTests)">
    <WindowsProject Include="winrt\test.internal\winrt.test.internal.vcxproj">
      <Platforms>Win32;x64</Platforms>
      <AutomatedTests>desktop</AutomatedTests>
    </WindowsProject>
    <WindowsProject Include="winrt\test.external\winrt.test.external.Windows.vcxproj">
      <AutomatedTests>store</AutomatedTests>
    </WindowsProject>
    <WindowsProject Include="winrt\test.nativecomponent\winrt.test.nativecomponent.Windows.vcxproj" />
    <WindowsProject Include="winrt\test.managed\Windows\winrt.test.managed.Windows.csproj">
      <AutomatedTests>store</AutomatedTests>
    </WindowsProject>
    <WindowsProject Include="tests\CsConsumer\Windows\CsConsumer.Windows.csproj" />
    <WindowsProject Include="tests\ExampleGallery\Windows\ExampleGallery.Windows.csproj" />
    <WindowsProject Include="numerics\Cpp\tests\CppNumericsTests.Windows.vcxproj">
      <AutomatedTests>store</AutomatedTests>
    </WindowsProject>
    <WindowsProject Include="numerics\DotNet\tests\Windows\DotNetNumericsTests.Windows.csproj">
      <AutomatedTests>store</AutomatedTests>
    </WindowsProject>
  </ItemGroup>

  <!-- Windows Phone test projects -->
  <ItemGroup Condition="$(BuildPhone) and $(BuildTests)">
    <PhoneProject Include="winrt\test.external\winrt.test.external.WindowsPhone.vcxproj" />
    <PhoneProject Include="winrt\test.nativecomponent\winrt.test.nativecomponent.WindowsPhone.vcxproj" />
    <PhoneProject Include="winrt\test.managed\WindowsPhone\winrt.test.managed.WindowsPhone.csproj" />
    <PhoneProject Include="tests\CsConsumer\WindowsPhone\CsConsumer.WindowsPhone.csproj" />
    <PhoneProject Include="tests\ExampleGallery\WindowsPhone\ExampleGallery.WindowsPhone.csproj"/>
    <PhoneProject Include="numerics\Cpp\tests\CppNumericsTests.WindowsPhone.vcxproj" />
    <PhoneProject Include="numerics\DotNet\tests\WindowsPhone\DotNetNumericsTests.WindowsPhone.csproj" />
  </ItemGroup>

  <!-- Tools projects -->
  <ItemGroup Condition="$(BuildTools)">
    <AnyCPUProject Include="tools\copyright\copyright.csproj" />
    <AnyCPUProject Include="tools\codegen\exe\codegen.exe.csproj" />
    <AnyCPUProject Include="tools\codegen\test\codegen.test.csproj" Condition="$(BuildTests)">
      <AutomatedTests>desktop</AutomatedTests>
    </AnyCPUProject>
    <AnyCPUProject Include="tools\docs\DocDiff\DocDiff.csproj" />
    <AnyCPUProject Include="tools\docs\ExtractAPISurface\ExtractAPISurface.csproj" />
    <AnyCPUProject Include="tools\docs\MergeIntellisense\MergeIntellisense.csproj" />
  </ItemGroup>


  <!-- Master target just chains to a bunch of workers -->
  <Target Name="Build"
          DependsOnTargets="BuildProjects; CheckCopyrightBanners; BuildDocs; RunTests" />


  <!-- Use batching to build each project in turn -->
  <Target Name="BuildProjects"
          DependsOnTargets="PrepareVersionInfo; ChooseProjectsToBuild"
          Inputs="@(ProjectsToBuild)"
          Outputs="%(PlatformIndependentName)">

    <Message Importance="High" Text="Building all variants of project %(ProjectsToBuild.PlatformIndependentName):" />
    <Message Importance="High" Text="  %(ProjectsToBuild.Filename) (%(ProjectsToBuild.Configuration)|%(ProjectsToBuild.Platform))" />

    <!-- All the variants (platform and configuration) of a project can be built in parallel -->
    <MSBuild Projects="@(ProjectsToBuild)" BuildInParallel="true" Properties="IncludeVersionInfo=true" />
  </Target>


  <Target Name="ChooseProjectsToBuild">
    <ItemGroup>
      <!-- Expand parameter properties into item groups, so we can batch over them -->
      <BuildPlatform Include="$(BuildPlatforms)" />
      <BuildConfiguration Include="$(BuildConfigurations)" />

      <!-- Generate the cartesian product of all projects * all platforms we are building -->
      <CandidateProjects Include="@(WindowsProject);@(PhoneProject);@(AnyCPUProject)">
        <Platform>%(BuildPlatform.Identity)</Platform>
      </CandidateProjects>

      <!-- Filter the list to include only project/platform pairs where the project actually supports that platform -->
      <FilteredProjects Include="@(CandidateProjects)" Condition="$([System.String]::new('%(CandidateProjects.Platforms)').Contains('%(CandidateProjects.Platform)'))" />

      <!-- Generate the cartesian product of our filtered project list * the configurations we are building -->
      <ProjectsPerConfig Include="@(FilteredProjects)">
        <Configuration>%(BuildConfiguration.Identity)</Configuration>
      </ProjectsPerConfig>

      <!-- Move platform and configuration into the AdditionalProperties metadata, and generate a
           platform independent name that will be the same for Windows and Phone project variants -->
      <ProjectsToBuild Include="@(ProjectsPerConfig)">
        <AdditionalProperties>Platform=%(ProjectsPerConfig.Platform);Configuration=%(ProjectsPerConfig.Configuration)</AdditionalProperties>
        <PlatformIndependentName>$([System.String]::new('%(ProjectsPerConfig.Filename)').Replace('Windows', '').Replace('Phone', '').TrimEnd('.'))</PlatformIndependentName>
      </ProjectsToBuild>
    </ItemGroup>
  </Target>


  <Target Name="PrepareVersionInfo">
    <MakeDir Directories="obj" />

    <!-- Read the current Win2D version number -->
    <ReadLinesFromFile File="build\nuget\VERSION">
      <Output TaskParameter="Lines" PropertyName="Win2DVersion" />
    </ReadLinesFromFile>

    <!-- Read the SHA-1 hash for git HEAD, so we can later identify exactly what code went into this build -->
    <Exec Command="git rev-parse --verify HEAD &gt; obj\Win2D.githash.txt" IgnoreExitCode="true">
      <Output TaskParameter="ExitCode" PropertyName="GitExitCode" />
    </Exec>

    <WriteLinesToFile Condition="$(GitExitCode) != 0" File ="obj\Win2D.githash.txt" Lines="unknown git hash" />

    <ReadLinesFromFile File="obj\Win2D.githash.txt">
      <Output TaskParameter="Lines" PropertyName="GitHash" />
    </ReadLinesFromFile>

    <!-- Generate AssemblyVersion.cs, which adds the latest version info to managed assembly outputs -->
    <ItemGroup>
      <AssemblyVersionCode Include="[assembly: System.Reflection.AssemblyVersion(&quot;$(Win2DVersion)&quot;)]" />
      <AssemblyVersionCode Include="[assembly: System.Reflection.AssemblyFileVersion(&quot;$(Win2DVersion)&quot;)]" />
      <AssemblyVersionCode Include="[assembly: System.Reflection.AssemblyInformationalVersionAttribute(&quot;$(Win2DVersion) ($(GitHash))&quot;)]" />
    </ItemGroup>

    <ReadLinesFromFile File="obj\AssemblyVersion.cs">
      <Output TaskParameter="Lines" ItemName="ExistingAssemblyVersion" />
    </ReadLinesFromFile>

    <WriteLinesToFile Condition="@(AssemblyVersionCode) != @(ExistingAssemblyVersion)" File="obj\AssemblyVersion.cs" Lines="@(AssemblyVersionCode)" Overwrite="true" />

    <!-- Also generate DllVersion.h, which adds version info to native DLLs -->
    <ItemGroup>
      <DllVersionCode Include="#define DLL_VERSION $(Win2DVersion.Replace('.', ','))" />
      <DllVersionCode Include="#define DLL_VERSION_STRING &quot;$(Win2DVersion)&quot;" />
      <DllVersionCode Include="#define DLL_VERSION_STRING_LONG &quot;$(Win2DVersion) ($(GitHash))&quot;" />
    </ItemGroup>

    <ReadLinesFromFile File="obj\DllVersion.h">
      <Output TaskParameter="Lines" ItemName="ExistingDllVersion" />
    </ReadLinesFromFile>

    <WriteLinesToFile Condition="@(DllVersionCode) != @(ExistingDllVersion)" File="obj\DllVersion.h" Lines="@(DllVersionCode)" Overwrite="true" />
  </Target>


  <!-- Make sure all our source files have the right copyright -->
  <Target Name="CheckCopyrightBanners"
          Condition="$(BuildTools) and $(BuildPlatforms.Contains('AnyCPU')) and $(BuildConfigurations.Contains('Release'))">

    <Message Importance="High" Text="Checking copyright banners" />

    <MSBuild Projects="tools\copyright\CheckCopyrightBanners.proj" />
  </Target>


  <!-- Build the reference documentation -->
  <Target Name="BuildDocs"
          Condition="$(BuildDocs) and
                     $(BuildTools) and
                     $(BuildWindows) and
                     $(BuildPlatforms.Contains('AnyCPU')) and
                     $(BuildPlatforms.Contains('Win32')) and
                     $(BuildConfigurations.Contains('Release'))">

    <Message Importance="High" Text="Building documentation" />

    <MSBuild Projects="tools\docs\BuildDocs.proj" />
  </Target>


  <!-- Run the automated tests -->
  <Target Name="RunTests"
          Condition="$(BuildTests) and $(RunTests)"
          DependsOnTargets="ChooseProjectsToBuild; ChooseTestsToRun"
          Inputs="@(TestProjects)"
          Outputs="%(TestProjects.TestAppX)">

    <Message Importance="High" Text="Running tests: %(TestProjects.Filename) (%(TestProjects.Configuration)|%(TestProjects.Platform))" />

    <Exec Command="vstest.console %(TestProjects.TestBinary)%(TestProjects.TestArgs)" ContinueOnError="ErrorAndContinue" IgnoreStandardErrorWarningFormat="true" />
  </Target>


  <Target Name="ChooseTestsToRun">
    <ItemGroup>
      <TestProjects Include="@(ProjectsToBuild)" Condition="%(ProjectsToBuild.AutomatedTests) != '' and %(ProjectsToBuild.Platform) != ARM">
        <!-- Remap Win32 to x86 -->
        <TestPlatform Condition="%(ProjectsToBuild.Platform) == Win32">x86</TestPlatform>
        <TestPlatform Condition="%(ProjectsToBuild.Platform) != Win32">%(ProjectsToBuild.Platform)</TestPlatform>

        <!-- Work out where the test binaries are located -->
        <TestPath>bin\Windows%(TestProjects.TestPlatform)\%(ProjectsToBuild.Configuration)</TestPath>

        <TestAppX Condition="%(ProjectsToBuild.Configuration) == Release">%(ProjectsToBuild.Filename)_1.0.0.0_%(ProjectsToBuild.Platform)</TestAppX>
        <TestAppX Condition="%(ProjectsToBuild.Configuration) != Release">%(ProjectsToBuild.Filename)_1.0.0.0_%(ProjectsToBuild.Platform)_%(ProjectsToBuild.Configuration)</TestAppX>

        <!-- Binaries can be either a .dll for desktop tests, or .appx for store app tests -->
        <TestBinary Condition="%(ProjectsToBuild.AutomatedTests) == desktop">%(TestProjects.TestPath)\%(ProjectsToBuild.Filename)\%(ProjectsToBuild.Filename).dll</TestBinary>
        <TestBinary Condition="%(ProjectsToBuild.AutomatedTests) == store">%(TestProjects.TestPath)\%(ProjectsToBuild.Filename)\AppPackages\%(TestProjects.TestAppX)_Test\%(TestProjects.TestAppX).appx</TestBinary>

        <!-- Do we need the /Platform or /InIsolation arguments for this test project? -->
        <TestArgs Condition="%(ProjectsToBuild.Platform) == x64">%(TestProjects.TestArgs) /Platform:x64</TestArgs>
        <TestArgs Condition="%(ProjectsToBuild.Platform) == x64 or %(ProjectsToBuild.AutomatedTests) == store">%(TestProjects.TestArgs) /InIsolation</TestArgs>
      </TestProjects>
    </ItemGroup>
  </Target>

</Project>