build.proj

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="Current" DefaultTargets="BuildAllConfigurations" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

  <Import Project="src/Directory.Build.props" />
  <Import Project="$(ToolsDir)targets\GenerateMdsPackage.targets" />
  <Import Project="$(ToolsDir)targets\add-ons\GenerateAkvPackage.targets" />
  <Import Project="$(ToolsDir)targets\CompareMdsRefAssemblies.targets" />

  <PropertyGroup>
    <!-- SourceLink variable-->
    <DisableSourceLink>false</DisableSourceLink>

    <Configuration Condition="'$(Configuration)' == ''">Debug</Configuration>
    <Platform Condition="'$(Platform)' == ''">AnyCPU</Platform>
    <!-- Flag to control whether or not to build Microsoft.DotNet.GenAPI project in tools -->
    <BuildTools Condition="'$(BuildTools)' == ''">true</BuildTools>
    <!-- Flag to control if Windows drivers should be built or not -->
    <IsEnabledWindows Condition="'$(IsEnabledWindows)' == '' AND '$(TargetsWindows)' == 'true'">true</IsEnabledWindows>
    <IsEnabledWindows Condition="'$(TargetsUnix)' == 'true'">false</IsEnabledWindows>
    <TestOS Condition="'$(TestTargetOS)' == '' AND '$(TargetsWindows)' == 'true'">Windows</TestOS>
    <TestOS Condition="'$(TestTargetOS)' == '' AND '$(TargetsUnix)' == 'true'">Unix</TestOS>
    <TF Condition="$(TF) == ''">net9.0</TF> <!-- Default Target Framework -->
    <TFGroup Condition="'$([MSBuild]::GetTargetFrameworkIdentifier($(TF)))' == '.NETFramework'">netfx</TFGroup>
    <TFGroup Condition="'$([MSBuild]::GetTargetFrameworkIdentifier($(TF)))' == '.NETCoreApp'">netcore</TFGroup>
    <TargetGroup Condition="'$(TFGroup)' == 'netfx'">netfx</TargetGroup>
    <TargetGroup Condition="'$(TFGroup)' == 'netcore'">netcoreapp</TargetGroup>
    <TargetNetCoreVersion Condition="$(TargetGroup) == 'netcoreapp' AND $(TargetNetCoreVersion) == ''">$(TF)</TargetNetCoreVersion>
    <TargetNetFxVersion Condition="$(TargetGroup) == 'netfx' AND $(TargetNetFxVersion) == ''">$(TF)</TargetNetFxVersion>
    <GenerateNuget Condition="'$(GenerateNuget)' == '' AND '$(IsEnabledWindows)' == 'true'">true</GenerateNuget>

    <CommonProperties>Configuration=$(Configuration);ReferenceType=$(ReferenceType);</CommonProperties>
    <ProjectProperties>$(CommonProperties);AssemblyFileVersion=$(AssemblyFileVersion);TargetsWindows=$(TargetsWindows);TargetsUnix=$(TargetsUnix);</ProjectProperties>
    <TestProjectProperties>$(ProjectProperties);BuildForRelease=false;TargetNetCoreVersion=$(TargetNetCoreVersion);TargetNetFxVersion=$(TargetNetFxVersion)</TestProjectProperties>
    <ResultsDirectory Condition="$(ResultsDirectory) == ''">TestResults</ResultsDirectory>
    <!--
      Path to a `dotnet` version like a x86 or any especific versions in addition to a default installed version.
      This property is empty by default to use the default path of the system's path variable.
      The provided path should be ended to a `\` character without white spaces: Ex. C:\x86\
    -->
    <DotnetPath></DotnetPath>
    <!-- Using these properties to compile and pack netfx dll fixes nuget package explorer error "Compiler flags: missing" -->
    <NugetPackProperties>DebugType=portable;DebugSymbols=true;IncludeSymbols=true;SymbolPackageFormat=snupkg;PublishRepositoryUrl=true;RepositoryUrl=https://github.com/dotnet/sqlclient;RepositoryType=git;EmbedUnTrackedSources=true;Deterministic=true;</NugetPackProperties>
    <!-- TF_BUILD is enabled only within AzureDevOps pipeline to support continuous integation build. -->
    <NugetPackProperties Condition="'$(TF_BUILD)' == 'true'">$(NugetPackProperties);ContinuousIntegrationBuild=true;</NugetPackProperties>
  </PropertyGroup>

  <!-- Test configuration properties -->
  <PropertyGroup>
    <!-- Set up default filters for tests to exclude failing and flaky tests -->
    <Filter Condition="'$(Filter)' == ''">category!=failing&amp;category!=flaky&amp;category!=interactive</Filter>
    <FilterArgument>--filter "$(Filter)"</FilterArgument>

    <!-- Collect code coverage unless explicitly disabled -->
    <CollectCodeCoverage Condition="'$(CollectCodeCoverage)' == ''">true</CollectCodeCoverage>
    <CodeCoverageRunSettings>$(TestsPath)/tools/Microsoft.Data.SqlClient.TestUtilities/CodeCoverage.runsettings</CodeCoverageRunSettings>
    <CollectArgument Condition="'$(CollectCodeCoverage)' == 'true'">--collect "Code coverage" --settings "$(CodeCoverageRunSettings)"</CollectArgument>

    <!-- Set up tests to fail after hangs and report via blame -->
    <BlameArgument>$(Blame)</BlameArgument>
    <BlameArgument Condition="'$(BlameArgument)' == ''">
      --blame-hang
      --blame-hang-dump-type full
      --blame-hang-timeout 10m
    </BlameArgument>
  </PropertyGroup>

  <!-- Release Build properties must be turned on for Release purposes, and turned off for Code Coverage calculations -->
  <PropertyGroup>
    <BuildForRelease Condition="$(BuildForRelease) == ''">true</BuildForRelease>
    <CI>ContinuousIntegrationBuild=$(BuildForRelease);EmbedUntrackedSources=$(BuildForRelease)</CI>
  </PropertyGroup>

  <!-- Populate all managed projects -->
  <ItemGroup>
    <Tools Include="tools/GenAPI/Microsoft.DotNet.GenAPI/Microsoft.DotNet.GenAPI.csproj" />
    <SqlServer Include="**/Microsoft.SqlServer.Server.csproj" />
    <Abstractions Include="src/Microsoft.Data.SqlClient.Extensions/Abstractions/src/Abstractions.csproj" />
    <Azure Include="src/Microsoft.Data.SqlClient.Extensions/Azure/src/Azure.csproj" />
    <Logging Include="src/Microsoft.Data.SqlClient.Extensions/Logging/src/Logging.csproj" />
    <NetFxDriver Include="**/netfx/**/Microsoft.Data.SqlClient*.csproj" Condition="'$(IsEnabledWindows)' == 'true'" />
    <NetCoreDriver Include="**/netcore/**/Microsoft.Data.SqlClient*.csproj" />
    <!-- Used to build .NET Standard DLL for lib folder from this project. -->
    <NetStandardDriver Include="**/netcore/ref/Microsoft.Data.SqlClient*.csproj" />
    <AKVProvider Include="**/add-ons/**/AzureKeyVaultProvider/*.csproj" />

    <UnitTests Include="**/UnitTests/Microsoft.Data.SqlClient.UnitTests.csproj" />
    <UnitTestsProj Include="**/UnitTests/Microsoft.Data.SqlClient.UnitTests.csproj" />

    <FunctionalTests Include="**/FunctionalTests/Microsoft.Data.SqlClient.FunctionalTests.csproj" />
    <FunctionalTestsProj Include="**/FunctionalTests/Microsoft.Data.SqlClient.FunctionalTests.csproj" />

    <ManualTests Include="**/ManualTests/Microsoft.Data.SqlClient.ManualTests.csproj" />
    <ManualTestsProj Include="**/ManualTests/Microsoft.Data.SqlClient.ManualTests.csproj" />
  </ItemGroup>

  <!-- Top Level Build targets -->
  <Target Name="Restore" DependsOnTargets="RestoreNetCore;RestoreNetFx" />
  <Target Name="BuildSqlClient" DependsOnTargets="BuildSqlServer;BuildLogging;BuildAbstractions;BuildNetFx;BuildNetCore;BuildNetStandard" />
  <!-- TODO: This doesn't really build everything; just the SqlClient driver and its NuGet package. -->
  <Target Name="BuildAllConfigurations" DependsOnTargets="Restore;BuildTools;BuildSqlServer;BuildLogging;BuildAbstractions;BuildNetFx;BuildNetCoreAllOS;BuildNetStandard;GenerateMdsPackage" />

  <!-- SqlServer Targets -->
  <PropertyGroup>
    <SqlServerProperties>$(CommonProperties)</SqlServerProperties>

    <SqlServerProperties
      Condition="'$(SqlServerPackageVersion)' != ''">
      $(SqlServerProperties);SqlServerPackageVersion=$(SqlServerPackageVersion)
    </SqlServerProperties>

    <SqlServerProperties
      Condition="'$(SqlServerAssemblyFileVersion)' != ''">
      $(SqlServerProperties);SqlServerAssemblyFileVersion=$(SqlServerAssemblyFileVersion)
    </SqlServerProperties>
  </PropertyGroup>

  <Target Name="RestoreSqlServer">
    <MSBuild Projects="@(SqlServer)" Targets="restore" Properties="$(SqlServerProperties)" />
  </Target>

  <Target Name="BuildSqlServer" DependsOnTargets="RestoreSqlServer">
    <MSBuild
      Projects="@(SqlServer)"
      Targets="Build"
      Properties="$(CI);$(SqlServerProperties)" />
  </Target>

  <Target Name="PackSqlServer">
    <MSBuild
      Projects="@(SqlServer)"
      Targets="Pack"
      Properties="$(SqlServerProperties);NoBuild=true" />
  </Target>

  <!-- Abstractions Targets -->
  <PropertyGroup>
    <AbstractionsProperties>$(CommonProperties)</AbstractionsProperties>

    <!--
      If the AbstractionsPackageVersion property was supplied on the
      command-line, then pass it along to the Abstractions build.  Otherwise,
      omit it entirely to avoid it expanding as empty here and thus overriding
      the default behaviour in the Abstractions project.  Command-line
      properties take precedence over project defaults, even if their value is
      empty.  For example:

        dotnet build -p:AbstractionsPackageVersion=

      That results in $(AbstractionsPackageVersion) being defined as empty,
      and cannot be overridden by the project.
    -->
    <AbstractionsProperties
      Condition="'$(AbstractionsPackageVersion)' != ''">
      $(AbstractionsProperties);AbstractionsPackageVersion=$(AbstractionsPackageVersion)
    </AbstractionsProperties>

    <!-- Do the same for the AbstractionsAssemblyFileVersion property. -->
    <AbstractionsProperties
      Condition="'$(AbstractionsAssemblyFileVersion)' != ''">
      $(AbstractionsProperties);AbstractionsAssemblyFileVersion=$(AbstractionsAssemblyFileVersion)
    </AbstractionsProperties>
  </PropertyGroup>

  <Target Name="RestoreAbstractions" DependsOnTargets="RestoreLogging">
    <MSBuild
      Projects="@(Abstractions)"
      Targets="Restore"
      Properties="$(AbstractionsProperties)" />
  </Target>

  <Target Name="BuildAbstractions" DependsOnTargets="RestoreAbstractions;BuildLogging">
    <MSBuild
      Projects="@(Abstractions)"
      Targets="Build"
      Properties="$(CI);$(AbstractionsProperties)" />
  </Target>

  <Target Name="PackAbstractions">
    <MSBuild
      Projects="@(Abstractions)"
      Targets="Pack"
      Properties="$(AbstractionsProperties);NoBuild=true" />
  </Target>

  <!-- Logging Targets -->
  <PropertyGroup>
    <LoggingProperties>$(CommonProperties)</LoggingProperties>

    <!--
      If the LoggingPackageVersion property was supplied on the command-line,
      then pass it along to the Logging build.  Otherwise, omit it entirely
      to avoid it expanding as empty here and thus overriding the default
      behaviour in the Logging project.
    -->
    <LoggingProperties
      Condition="'$(LoggingPackageVersion)' != ''">
      $(LoggingProperties);LoggingPackageVersion=$(LoggingPackageVersion)
    </LoggingProperties>

    <!-- Do the same for the LoggingAssemblyFileVersion property. -->
    <LoggingProperties
      Condition="'$(LoggingAssemblyFileVersion)' != ''">
      $(LoggingProperties);LoggingAssemblyFileVersion=$(LoggingAssemblyFileVersion)
    </LoggingProperties>
  </PropertyGroup>

  <Target Name="RestoreLogging">
    <MSBuild
      Projects="@(Logging)"
      Targets="Restore"
      Properties="$(LoggingProperties)" />
  </Target>

  <Target Name="BuildLogging" DependsOnTargets="RestoreLogging">
    <MSBuild
      Projects="@(Logging)"
      Targets="Build"
      Properties="$(CI);$(LoggingProperties)" />
  </Target>

  <Target Name="PackLogging">
    <MSBuild
      Projects="@(Logging)"
      Targets="Pack"
      Properties="$(LoggingProperties);NoBuild=true" />
  </Target>

  <!-- Azure Targets -->
  <PropertyGroup>
    <AzureProperties>$(CommonProperties)</AzureProperties>

    <!--
      If the AzurePackageVersion property was supplied on the command-line, then
      pass it along to the Azure build.  Otherwise, omit it entirely to avoid it
      expanding as empty here and thus overriding the default behaviour in the
      Azure project.  Command-line properties take precedence over project
      defaults, even if their value is empty.  For example:

        dotnet build -p:AzurePackageVersion=

      That results in $(AzurePackageVersion) being defined as empty, and cannot
      be overridden by the project.
    -->
    <AzureProperties
      Condition="'$(AzurePackageVersion)' != ''">
      $(AzureProperties);AzurePackageVersion=$(AzurePackageVersion)
    </AzureProperties>

    <!-- Do the same for the AzureAssemblyFileVersion property. -->
    <AzureProperties
      Condition="'$(AzureAssemblyFileVersion)' != ''">
      $(AzureProperties);AzureAssemblyFileVersion=$(AzureAssemblyFileVersion)
    </AzureProperties>
  </PropertyGroup>

  <Target Name="RestoreAzure">
    <MSBuild
      Projects="@(Azure)"
      Targets="Restore"
      Properties="$(AzureProperties)" />
  </Target>

  <Target Name="BuildAzure" DependsOnTargets="RestoreAzure">
    <MSBuild
      Projects="@(Azure)"
      Targets="Build"
      Properties="$(CI);$(AzureProperties)" />
  </Target>

  <Target Name="PackAzure">
    <MSBuild
      Projects="@(Azure)"
      Targets="Pack"
      Properties="$(AzureProperties);NoBuild=true" />
  </Target>

  <!-- Other Targets -->
  <Target Name="RestoreNetCore" DependsOnTargets="RestoreSqlServer;RestoreAbstractions;RestoreLogging">
    <MSBuild Projects="@(NetCoreDriver)" Targets="restore" Properties="$(ProjectProperties)" />
  </Target>

  <Target Name="RestoreNetFx" DependsOnTargets="RestoreSqlServer;RestoreAbstractions;RestoreLogging" Condition="'$(IsEnabledWindows)' == 'true'">
    <MSBuild Projects="@(NetFxDriver)" Targets="restore" Properties="$(ProjectProperties)" />
  </Target>

  <Target Name="RestoreTools" Condition="'$(BuildTools)' == 'true'">
    <MSBuild Projects="@(Tools)" Targets="restore" Properties="$(CommonProperties)" />
  </Target>

  <Target Name="BuildTools" DependsOnTargets="RestoreTools" Condition="'$(BuildTools)' == 'true'">
    <MSBuild Projects="@(Tools)" Properties="$(CommonProperties)" />
  </Target>

  <Target Name="BuildNetFx" DependsOnTargets="RestoreNetFx;BuildSqlServer;BuildAbstractions;BuildLogging" Condition="'$(IsEnabledWindows)' == 'true'">
    <MSBuild Projects="@(NetFxDriver)" Properties="$(CI);Platform=AnyCPU;$(ProjectProperties);$(NugetPackProperties);" />
  </Target>

  <Target Name="BuildNetCore" DependsOnTargets="RestoreNetCore;BuildSqlServer;BuildAbstractions;BuildLogging">
    <MSBuild Projects="@(NetCoreDriver)" Properties="$(CI);Platform=AnyCPU;$(ProjectProperties)" />
  </Target>

  <Target Name="BuildNetCoreAllOS" DependsOnTargets="RestoreNetCore;BuildSqlServer;BuildAbstractions;BuildLogging">
    <MSBuild Projects="@(NetCoreDriver)" Properties="$(CI);$(ProjectProperties);Platform=AnyCPU;OSGroup=Unix;" RemoveProperties="TargetsWindows;TargetsUnix;" />
    <MSBuild Projects="@(NetCoreDriver)" Properties="$(CI);$(ProjectProperties);Platform=AnyCPU;OSGroup=Windows_NT;" RemoveProperties="TargetsWindows;TargetsUnix;" Condition="'$(IsEnabledWindows)' == 'true'" />
    <MSBuild Projects="@(NetCoreDriver)" Properties="$(CI);$(ProjectProperties);Platform=AnyCPU;OSGroup=AnyOS;" RemoveProperties="TargetsWindows;TargetsUnix;" />
  </Target>

  <Target Name="BuildNetCoreUnix" DependsOnTargets="RestoreNetCore">
    <MSBuild Projects="@(NetCoreDriver)" Properties="$(CI);$(ProjectProperties);Platform=AnyCPU;OSGroup=Unix;"   RemoveProperties="TargetsWindows;TargetsUnix;" />
   </Target>

  <!-- Build .NET Standard target DLLs for Lib folder from here.
   This target enables BuildForLib for the NetCore ref project. -->
  <Target Name="BuildNetStandard">
    <MSBuild Projects="@(NetStandardDriver)" Properties="$(CI);$(ProjectProperties);Platform=AnyCPU;OSGroup=AnyOS;BuildForLib=True" RemoveProperties="TargetsWindows;TargetsUnix;" />
  </Target>

  <!-- Tests -->

  <!-- Run all tests applicable to the host OS. -->
  <Target Name="RunTests" DependsOnTargets="RunUnitTests;RunFunctionalTests;RunManualTests"/>

  <!-- Run all unit tests applicable to the host OS. -->
  <Target Name="RunUnitTests" DependsOnTargets="RunUnitTestsWindows;RunUnitTestsUnix" Condition="$(ReferenceType.Contains('Project'))"/>

  <!-- Run all unit tests applicable to Windows. -->
  <Target Name="RunUnitTestsWindows" Condition="'$(IsEnabledWindows)' == 'true' AND $(ReferenceType.Contains('Project'))">
    <PropertyGroup>
      <!--
        The UnitTests project exclusively uses Project references, which is the default applied by
        src/Directory.Build.props, so no need to specify the ReferenceType property here.
      -->
      <TestCommand>
        $(DotnetPath)dotnet test "@(UnitTestsProj)"
        -f $(TF)
        -p:Configuration=$(Configuration)
        $(FilterArgument)
        $(BlameArgument)
        $(CollectArgument)
        --results-directory $(ResultsDirectory)
        --logger:"trx;LogFilePrefix=Unit-Windows$(TargetGroup)-$(TestSet)"
      </TestCommand>
      <!-- Convert more than one whitespace character into one space -->
      <TestCommand>$([System.Text.RegularExpressions.Regex]::Replace($(TestCommand), "\s+", " "))</TestCommand>
    </PropertyGroup>
    <Message Text=">>> Running unit tests for Windows via command: $(TestCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(TestCommand)"/>
  </Target>

  <!-- Run all unit tests applicable to Unix. -->
  <Target Name="RunUnitTestsUnix" Condition="'$(IsEnabledWindows)' != 'true' AND $(ReferenceType.Contains('Project'))">
    <PropertyGroup>
      <TestCommand>
        $(DotnetPath)dotnet test "@(UnitTestsProj)"
        -f $(TF)
        -p:Configuration=$(Configuration)
        $(FilterArgument)
        $(BlameArgument)
        $(CollectArgument)
        --results-directory $(ResultsDirectory)
        --logger:"trx;LogFilePrefix=Unit-Unixnetcoreapp-$(TestSet)"
      </TestCommand>
      <!-- Convert more than one whitespace character into one space -->
      <TestCommand>$([System.Text.RegularExpressions.Regex]::Replace($(TestCommand), "\s+", " "))</TestCommand>
    </PropertyGroup>
    <Message Text=">>> Running unit tests for Unix via command: $(TestCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(TestCommand)"/>
  </Target>

  <!-- Run all Functional tests applicable to the host OS. -->
  <Target Name="RunFunctionalTests" DependsOnTargets="RunFunctionalTestsWindows;RunFunctionalTestsUnix" />

  <!-- Run all Functional tests applicable to Windows. -->
  <Target Name="RunFunctionalTestsWindows" Condition="'$(IsEnabledWindows)' == 'true'">
    <PropertyGroup>
      <TestCommand>
        $(DotnetPath)dotnet test "@(FunctionalTestsProj)"
        -f $(TF)
        -p:Configuration=$(Configuration)
        -p:ReferenceType=$(ReferenceType)
        -p:AbstractionsPackageVersion=$(AbstractionsPackageVersion)
        -p:MdsPackageVersion=$(MdsPackageVersion)
        $(FilterArgument)
        $(BlameArgument)
        $(CollectArgument)
        --results-directory $(ResultsDirectory)
        --logger:"trx;LogFilePrefix=Functional-Windows$(TargetGroup)-$(TestSet)"
      </TestCommand>
      <!-- Convert more than one whitespace character into one space -->
      <TestCommand>$([System.Text.RegularExpressions.Regex]::Replace($(TestCommand), "\s+", " "))</TestCommand>
    </PropertyGroup>
    <Message Text=">>> Running Functional test for Windows via command: $(TestCommand)" />
    <Exec ConsoleToMsBuild="true" Command="$(TestCommand)" />
  </Target>

  <!-- Run all Functional tests applicable to Unix. -->
  <Target Name="RunFunctionalTestsUnix" Condition="'$(IsEnabledWindows)' != 'true'">
    <PropertyGroup>
      <TestCommand>
        $(DotnetPath)dotnet test "@(FunctionalTestsProj)"
        -f $(TF)
        -p:Configuration=$(Configuration)
        -p:ReferenceType=$(ReferenceType)
        -p:AbstractionsPackageVersion=$(AbstractionsPackageVersion)
        -p:MdsPackageVersion=$(MdsPackageVersion)
        $(FilterArgument)
        $(BlameArgument)
        $(CollectArgument)
        --results-directory $(ResultsDirectory)
        --logger:"trx;LogFilePrefix=Functional-Unixnetcoreapp-$(TestSet)"
      </TestCommand>
      <!-- Convert more than one whitespace character into one space -->
      <TestCommand>$([System.Text.RegularExpressions.Regex]::Replace($(TestCommand), "\s+", " "))</TestCommand>
    </PropertyGroup>
    <Message Text=">>> Running Functional test for Unix via command: $(TestCommand)" />
    <Exec ConsoleToMsBuild="true" Command="$(TestCommand)" />
  </Target>

  <!-- Run all Manual tests applicable to the host OS. -->
  <Target Name="RunManualTests" DependsOnTargets="RunManualTestsWindows;RunManualTestsUnix" />

  <!-- Run all Manual tests applicable to Windows. -->
  <Target Name="RunManualTestsWindows" Condition="'$(IsEnabledWindows)' == 'true'">
    <PropertyGroup>
      <TestCommand>
        $(DotnetPath)dotnet test "@(ManualTestsProj)"
        -f $(TF)
        -p:Configuration=$(Configuration)
        -p:ReferenceType=$(ReferenceType)
        -p:AbstractionsPackageVersion=$(AbstractionsPackageVersion)
        -p:MdsPackageVersion=$(MdsPackageVersion)
        $(FilterArgument)
        $(BlameArgument)
        $(CollectArgument)
        --results-directory $(ResultsDirectory)
        --logger:"trx;LogFilePrefix=Manual-Windows$(TargetGroup)-$(TestSet)"
      </TestCommand>
      <!-- Add test set only if it was provided - otherwise it will be permanently set to '' -->
      <TestCommand Condition="'$(TestSet)' != ''">
        $(TestCommand)
        -p:TestSet=$(TestSet)
      </TestCommand>

      <!-- Convert more than one whitespace character into one space -->
      <TestCommand>$([System.Text.RegularExpressions.Regex]::Replace($(TestCommand), "\s+", " "))</TestCommand>
    </PropertyGroup>
    <Message Text=">>> Running Manual test for Windows via command: $(TestCommand)" />
    <Exec ConsoleToMsBuild="true" Command="$(TestCommand)" />
  </Target>

  <!-- Run all Manual tests applicable to Unix. -->
  <Target Name="RunManualTestsUnix" Condition="'$(IsEnabledWindows)' != 'true'">
    <PropertyGroup>
      <TestCommand>
        $(DotnetPath)dotnet test "@(ManualTestsProj)"
        -f $(TF)
        -p:Configuration=$(Configuration)
        -p:ReferenceType=$(ReferenceType)
        -p:AbstractionsPackageVersion=$(AbstractionsPackageVersion)
        -p:MdsPackageVersion=$(MdsPackageVersion)
        $(FilterArgument)
        $(BlameArgument)
        $(CollectArgument)
        --results-directory $(ResultsDirectory)
        --logger:"trx;LogFilePrefix=Manual-Unixnetcoreapp-$(TestSet)"
      </TestCommand>

      <!-- Add test set only if it was provided - otherwise it will be permanently set to '' -->
      <TestCommand Condition="'$(TestSet)' != ''">
        $(TestCommand)
        -p:TestSet=$(TestSet)
      </TestCommand>

      <!-- Convert more than one whitespace character into one space -->
      <TestCommand>$([System.Text.RegularExpressions.Regex]::Replace($(TestCommand), "\s+", " "))</TestCommand>
    </PropertyGroup>
    <Message Text=">>> Running Manual test for Unix via command: $(TestCommand)" />
    <Exec ConsoleToMsBuild="true" Command="$(TestCommand)" />
  </Target>

  <!-- Clean all build outputs. -->
  <Target Name="Clean">
    <RemoveDir Directories='$([System.IO.Directory]::GetDirectories(".", "artifacts", SearchOption.AllDirectories))' />
    <RemoveDir Directories='$([System.IO.Directory]::GetDirectories(".", "bin", SearchOption.AllDirectories))' />
    <RemoveDir Directories='$([System.IO.Directory]::GetDirectories(".", ".nuget", SearchOption.AllDirectories))' />
    <RemoveDir Directories='$([System.IO.Directory]::GetDirectories(".", "obj", SearchOption.AllDirectories))' />
    <!-- Remove generated .nupkg and .snupkg files from packages/ and output/. -->
    <ItemGroup>
      <PackagesToDelete Include="$(RepoRoot)/packages/*.nupkg" />
      <PackagesToDelete Include="$(RepoRoot)/packages/*.snupkg" />
      <PackagesToDelete Include="$(RepoRoot)/output/*.nupkg" />
      <PackagesToDelete Include="$(RepoRoot)/output/*.snupkg" />
    </ItemGroup>
    <Delete Files="@(PackagesToDelete)" />
  </Target>

  <!-- AKV Targets ========================================================= -->
  <Target Name="BuildAkv">
    <!-- @TODO: TestTargetOS for restore poisons the project.assets.json file... We should remove it. -->
    <!-- @TODO: TestTargetOS makes this far more complicated than it needs to be. We should remove it. -->
    <!-- @TODO: RemoveProperties shouldn't be necessary -->
    <Message Text=">>> Restoring AKV project" />
    <MSBuild Projects="@(AKVProvider)" Targets="Restore" Properties="$(CommonProperties)" />

    <PropertyGroup>
      <BuildAkvProperties>$(CI);TestTargetOS=$(TestOS)netfx;Platform=AnyCPU;$(ProjectProperties);$(NugetPackProperties)</BuildAkvProperties>
    </PropertyGroup>
    <Message Text=">>> Building AKV project for netfx [$(BuildAkvProperties)]" />
    <MSBuild Projects="@(AKVProvider)" Properties="$(BuildAkvProperties);" />

    <PropertyGroup>
      <BuildAkvProperties>$(CI);TestTargetOS=$(TestOS)netcoreapp;$(ProjectProperties);Platform=AnyCPU;OSGroup=Unix;</BuildAkvProperties>
    </PropertyGroup>
    <Message Text=">>> Building AKV project for netcore/unix [$(BuildAkvProperties)]" />
    <MSBuild Projects="@(AKVProvider)" Properties="$(BuildAkvProperties)" RemoveProperties="TargetsWindows;TargetsUnix;" />

    <PropertyGroup>
      <BuildAkvProperties>$(CI);TestTargetOS=$(TestOS)netcoreapp;$(ProjectProperties);Platform=AnyCPU;OSGroup=Windows_NT</BuildAkvProperties>
    </PropertyGroup>
    <Message Text=">>> Building AKV project for netcore/windows [$(BuildAkvProperties)]" />
    <MSBuild Projects="@(AKVProvider)" Properties="$(BuildAkvProperties);" RemoveProperties="TargetsWindows;TargetsUnix;" />

    <PropertyGroup>
      <BuildAkvProperties>$(CI);TestTargetOS=$(TestOS)netcoreapp;$(ProjectProperties);Platform=AnyCPU;OSGroup=AnyOS;</BuildAkvProperties>
    </PropertyGroup>
    <Message Text=">>> Building AKV project for netcore/anyos [$(BuildAkvProperties)]" />
    <MSBuild Projects="@(AKVProvider)" Properties="$(BuildAkvProperties)" RemoveProperties="TargetsWindows;TargetsUnix;" />
  </Target>

  <Target Name="BuildAKVNetFx" DependsOnTargets="BuildNetFx" Condition="'$(IsEnabledWindows)' == 'true'">
    <MSBuild Projects="@(AKVProvider)" Targets="restore" Properties="$(CommonProperties);TestTargetOS=$(TestOS)netfx" />
    <Message Text=">>> Building AKVNetFx [$(CI);TestTargetOS=$(TestOS)netfx;Platform=AnyCPU;$(TestProjectProperties)] ..." Condition="!$(ReferenceType.Contains('Package'))" />
    <MSBuild Projects="@(AKVProvider)" Properties="$(CI);TestTargetOS=$(TestOS)netfx;Platform=AnyCPU;$(TestProjectProperties);$(NugetPackProperties);" Condition="!$(ReferenceType.Contains('Package'))" />

    <!-- Only build platform specific builds for Package reference types -->
    <Message Text=">>> Building AKVNetFx [$(CI);TestTargetOS=$(TestOS)netfx;Platform=$(Platform);$(TestProjectProperties)] ..." Condition="$(ReferenceType.Contains('Package'))" />
    <MSBuild Projects="@(AKVProvider)" Properties="$(CI);TestTargetOS=$(TestOS)netfx;Platform=$(Platform);$(TestProjectProperties);$(NugetPackProperties);" Condition="$(ReferenceType.Contains('Package'))" />
  </Target>

  <Target Name="BuildAKVNetCore" DependsOnTargets="BuildNetCore">
    <MSBuild Projects="@(AKVProvider)" Targets="restore" Properties="$(CommonProperties);TestTargetOS=$(TestOS)netcoreapp" />
    <Message Text=">>> Building AKVNetCore [$(CI);TestTargetOS=$(TestOS)netcoreapp;$(ProjectProperties);Platform=AnyCPU;ReferenceType=$(ReferenceType);] ..." Condition="!$(ReferenceType.Contains('Package'))" />
    <MSBuild Projects="@(AKVProvider)" Properties="$(CI);TestTargetOS=$(TestOS)netcoreapp;$(ProjectProperties);Platform=AnyCPU;" Condition="!$(ReferenceType.Contains('Package'))" />

    <!-- Only build platform specific builds for Package reference types -->
    <Message Text=">>> Building AKVNetCore [$(CI);TestTargetOS=$(TestOS)netcoreapp;$(ProjectProperties);Platform=$(Platform);ReferenceType=$(ReferenceType);] ..." Condition="$(ReferenceType.Contains('Package'))" />
    <MSBuild Projects="@(AKVProvider)" Properties="$(CI);TestTargetOS=$(TestOS)netcoreapp;$(ProjectProperties);Platform=$(Platform);" Condition="$(ReferenceType.Contains('Package'))" />
  </Target>

  <Target Name="BuildAKVNetCoreAllOS" DependsOnTargets="BuildNetCore">
    <MSBuild Projects="@(AKVProvider)" Targets="restore" Properties="$(CommonProperties);TestTargetOS=$(TestOS)netcoreapp" />
    <MSBuild Projects="@(AKVProvider)" Properties="$(CI);TestTargetOS=$(TestOS)netcoreapp;$(ProjectProperties);Platform=AnyCPU;OSGroup=Unix;" RemoveProperties="TargetsWindows;TargetsUnix;" />
    <MSBuild Projects="@(AKVProvider)" Properties="$(CI);TestTargetOS=$(TestOS)netcoreapp;$(ProjectProperties);Platform=AnyCPU;OSGroup=Windows_NT;" RemoveProperties="TargetsWindows;TargetsUnix;" Condition="'$(IsEnabledWindows)' == 'true'" />
    <MSBuild Projects="@(AKVProvider)" Properties="$(CI);TestTargetOS=$(TestOS)netcoreapp;$(ProjectProperties);Platform=AnyCPU;OSGroup=AnyOS;" RemoveProperties="TargetsWindows;TargetsUnix;" />
  </Target>

</Project>