build.proj

<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="BuildAll" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <!-- Imports ========================================================= -->
  <Import Project="src/Directory.Build.props" />

  <!-- Build Parameters ================================================ -->
  <!-- @TODO: Add a Help target that lists targets and these descriptions of the parameters -->
  <PropertyGroup>
    <!--
      BuildNumber
      Applies to:     Build*, Pack*
      Description:    Number that identifies the build.

                      For local developer builds, this does not need to be used. The developer
                      should either specify an entire package version override (via
                      PackageVersion*, et. al.) or by omitting the package version.

                      For automated builds, this should always be specified instead of
                      a package version. Thus, the version base is controlled via source and the
                      build number is simply appended as a revision number.
      Default value:  [blank]
      Example:        1234
    -->
    <!-- @TODO: Currently this is defaulted to 0 by Directory.Build.props, which is the same default used later on anyhow. -->
    <BuildNumber Condition="'$(BuildNumber)' == ''" />
    <BuildNumberArgument Condition="'$(BuildNumber)' != ''">
      -p:BuildNumber=$(BuildNumber)
    </BuildNumberArgument>

    <!--
      BuildSuffix
      Aplies to:      Build*, Pack*
      Description:    Suffix to add at the end of the package version to indicate the generated
                      version is a pre-release.

                      For local developer builds, this does not need to be set. If a specific
                      package version is needed, specify PackageVersionMds. Otherwise, the
                      generated package version will eg, 1.2.3.dev.

                      For automated builds, this should only be specified on pre-release builds, ie
                      PR/CI pipeline runs. For official, production-ready builds, omit this field
                      and include a BuildNumber.
      Default value:  [blank]
      Example:        prbuild
    -->
    <BuildSuffix Condition="'$(BuildSuffix)' == ''" />
    <BuildSuffixArgument Condition="'$(BuildSuffix)' != ''">
      -p:BuildSuffix=$(BuildSuffix)
    </BuildSuffixArgument>

    <!--
      Configuration
      Applies to:     All targets
      Description:    Which build configuration to build
      Default value:  Debug
      Allowed values: Debug, Release
    -->
    <Configuration Condition="'$(Configuration)' == ''">Debug</Configuration>

    <!--
      DotnetPath
      Applies to:    All targets
      Description:   Path to folder containing the `dotnet` binary. Override this if a specific
                     version (eg, x86) is required. Otherwise, this defaults to using the dotnet
                     binary in the PATH variable. The provided path should end with a `\` (or `/`)
                     character.
      Default value: [blank]
      Example:       C:\x86\
    -->
    <DotnetPath Condition="'$(DotnetPath)' == ''" />

    <!--
      PackBuild
      Applies to:     Pack*
      Description:    Whether the Pack* targets should build the project before packaging. If
                      true, the project will be built as part of packaging. If false, it will not.

                      For most developers, building immediately before packing is the norm, and
                      this functionality is added for convenience. However, for official builds,
                      binaries are signed between building and packing, so building immediately
                      before packing would clobber the signed binaries.
      Default value:  true
      Allowed values: (true|false)
    -->
    <PackBuild Condition="'$(PackBuild)' == ''">true</PackBuild>
    <PackBuildArgument Condition="'$(PackBuild.ToLower())' != 'true'">
      --no-build
    </PackBuildArgument>

    <!--
      SqlClient family package versions
      =================================
      The Internal.Logging, Extensions.Abstractions, Extensions.Azure, and
      AlwaysEncrypted.AzureKeyVaultProvider packages are all part of the SqlClient family and share
      the SqlClient version.  There are no longer separate per-package version parameters for these
      packages — use PackageVersionSqlClient (below) to set the version for the entire family.
    -->

    <!--
      PackageVersionSqlClient
      Applies to:
        Build:        BuildSqlClient*, BuildLogging, BuildAbstractions, BuildAzure, BuildAkvProvider
        Pack:         PackSqlClient, PackLogging, PackAbstractions, PackAzure, PackAkvProvider
        Test:         TestSqlClient, TestSqlClientFunctional, TestSqlClientManual, TestAzure
                      (Package reference mode only)
      Description:    Specifies the version of the SqlClient *family*.  All family packages
                      (Microsoft.Data.SqlClient, Internal.Logging, Extensions.Abstractions,
                      Extensions.Azure, and the AlwaysEncrypted.AzureKeyVaultProvider) share this
                      single version, which is used both as the assigned package/assembly version
                      when building/packing a family package and as the dependency version when a
                      family package references another. Build and Pack targets use it in both
                      reference modes; Test targets consume it only in Package reference mode. If
                      omitted, the version defaults to the value calculated by Versions.props.

      Default value:  [blank]
      Example:        7.0.0-preview4
    -->
    <PackageVersionSqlClient Condition="'$(PackageVersionSqlClient)' == ''" />
    <PackageVersionSqlClientArgument Condition="'$(PackageVersionSqlClient)' != ''">
      -p:SqlClientPackageVersion=$(PackageVersionSqlClient)
    </PackageVersionSqlClientArgument>

    <!--
      PackageVersionSqlServer
      Applies to:
        Build:        BuildSqlServer and BuildSqlClient* in Package reference mode
        Pack:         PackSqlServer and PackSqlClient in Package reference mode
        Test:         TestSqlClientUnit and TestSqlClientManual in Package reference mode
      Description:    Specifies the package version to use for Microsoft.SqlServer.Server. If this
                      is specified, it will be used preferentially: assembly version and file
                      version will be derived from the specified package version.
      Default value:  [blank]
      Example:        1.0.0-dev2345
    -->
    <PackageVersionSqlServer Condition="'$(PackageVersionSqlServer)' == ''" />
    <PackageVersionSqlServerArgument Condition="'$(PackageVersionSqlServer)' != ''">
      -p:SqlServerPackageVersion=$(PackageVersionSqlServer)
    </PackageVersionSqlServerArgument>

    <!--
      ReferenceType
      Applies to:     BuildSqlClient, BuildSqlClientUnix, BuildSqlClientWindows
      Description:    Determines how to build SqlClient. If set to "Project", any cross-project
                      references (eg, Abstractions from SqlClient) will be made as project
                      references. If set to "Package", package references will be made instead. When
                      running in package mode, target versions can be specified via PackageVersion*
                      build parameters. If these are not provided, the central feed version will be
                      used instead (see Directory.Packages.props). In package mode, all Pack*
                      targets also mirror their .nupkg/.snupkg output into the local NuGet feed
                      directory (packages/) so that downstream builds in the same invocation can
                      restore them without a separate feed publish step. When running in project
                      mode, the dependencies will be built automatically.

      Applies to:     TestSqlClientFunctional, TestSqlClientManual
      Description:    Determines whether to test against a project reference or a package version
                      of the test targets. Same description above applies.

      Default value:  Project
      Allowed values: (Package|Project)
    -->
    <ReferenceType Condition="'$(ReferenceType)' == ''">Project</ReferenceType>
    <ReferenceTypeArgument Condition="'$(ReferenceType.ToLower())' == 'package'">
      -p:ReferenceType=Package
    </ReferenceTypeArgument>

    <!--
      SkipDependencyPack
      Applies to:     Build* targets in Package mode
      Description:    When true, suppresses the automatic DependsOnTargets that pack sibling
                      packages before building a downstream package. This is intended for CI
                      systems (e.g. OneBranch) that build each package in a separate job and
                      supply pre-built dependency packages externally. Without this flag,
                      Build targets in Package mode will first run Pack targets for their
                      dependencies to populate the local NuGet feed.
      Default value:  false
    -->
    <SkipDependencyPack Condition="'$(SkipDependencyPack)' == ''">false</SkipDependencyPack>

    <!--
      SigningKeyPath
      Applies to:     Build*, Pack* (driver targets only)
      Description:    Path to the key to use to strong name sign binaries. If omitted, binaries
                      will not be strong name signed.
                      For Pack* targets, this only applies to a build - ie, if PackBuild is set to
                      false, SigningKeyPath will have no effect.
      Default value:  [blank]
      Example:        C:\path\to\my\signing\key.snk
    -->
    <SigningKeyPath Condition="'$(SigningKeyPath)' == ''" />
    <SigningKeyPathArgument Condition="'$(SigningKeyPath)' != ''">
      -p:SigningKeyPath="$(SigningKeyPath)"
    </SigningKeyPathArgument>

    <!--
      TestSigningKeyPath
      Applies to:     TestSqlClientUnit
      Description:    Path to the key used to sign test assemblies. Required in Package mode when
                      SigningKeyPath is set so that InternalsVisibleTo grants from signed driver
                      assemblies can be fulfilled.
      Default value:  [blank]
      Example:        C:\path\to\sqlclient-test-key.snk
    -->
    <TestSigningKeyPath Condition="'$(TestSigningKeyPath)' == ''" />
    <TestSigningKeyPathArgument Condition="'$(TestSigningKeyPath)' != ''">
      -p:TestSigningKeyPath="$(TestSigningKeyPath)"
    </TestSigningKeyPathArgument>

    <!--
      TestBlameTimeout
      Applies to:     Test* targets
      Description:    How long to wait on a test before timing it out. This will be fed to the
                      dotnet blame-hang-timeout argument. If 0 is specified, hang timeout will be
                      disabled. For more details and supported suffixes see:
                      https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-test-vstest#options
      Default value:  10m
      Allowed values: (time_expression|0)
    -->
    <TestBlameTimeout Condition="'$(TestBlameTimeout)' == ''">10m</TestBlameTimeout>
    <TestBlameArgument Condition="'$(TestBlameTimeout)' != '0'">
      --blame-hang
      --blame-hang-dump-type full
      --blame-hang-timeout $(TestBlameTimeout)
    </TestBlameArgument>

    <!--
      TestCodeCoverage
      Applies to:     Test* targets
      Description:    Whether code coverage data should be collected during test target execution.
      Default value:  true
      Allowed value:  (true|false)
    -->
    <TestCodeCoverage Condition="'$(TestCodeCoverage)' == ''">true</TestCodeCoverage>
    <TestCodeCoverageArgument Condition="'$(TestCodeCoverage.ToLower())' == 'true'">
      --collect "Code coverage"
      --settings "$(RepoRoot)src/Microsoft.Data.SqlClient/tests/tools/Microsoft.Data.SqlClient.TestUtilities/CodeCoverage.runsettings"
    </TestCodeCoverageArgument>

    <!--
      TestFilters
      Applies to:     Test* targets
      Description:    Filter to use to include or exclude any tests. If not specified, this defaults
                      to including all tests that are not in the category "failing", "flaky", or
                      "interactive". Use "none" to disable filtering and run all tests in the
                      target. For more information see:
                      https://learn.microsoft.com/en-us/dotnet/core/testing/selective-unit-tests
      Default value:  category!=failing&category!=flaky&category!=interactive
      Allowed values: (category_expression|none)
    -->
    <TestFilters Condition="'$(TestFilters)' == ''">category!=failing&amp;category!=flaky&amp;category!=interactive</TestFilters>
    <TestFilters Condition="'$(TestFilters.ToLower())' == 'none'" />
    <!--
      Exclude tests in the "signed" category when building unsigned assemblies.  We have some tests
      that require signed assemblies, and they would fail with strong name validation exceptions on
      .NET Framework.
    -->
    <TestFilters Condition="'$(TestFilters)' != '' AND '$(SigningKeyPath)' == ''">$(TestFilters)&amp;category!=signed</TestFilters>
    <TestFiltersArgument Condition="'$(TestFilters)' != ''">
      --filter "$(TestFilters)"
    </TestFiltersArgument>

    <!--
      TestFramework
      Applies to:    Test* targets
      Description:   Target framework moniker for the version of .NET to use to execute the
                     specified test target. If not specified, this defaults to running tests for
                     *all* framework versions supported for the project.
      Default value: [blank]
      Example:       net462
    -->
    <TestFramework Condition="'$(TestFramework)' == ''" />
    <TestFrameworkArgument Condition="'$(TestFramework)' != ''">-f $(TestFramework)</TestFrameworkArgument>

    <!--
      TestResultsFolderPath
      Applies to:    Test* targets
      Description:   Absolute path to directory where any test results should be dumped. If not
                     specified, this path will default to test_results in the root of the
                     repository.
      Default value: $(RepoRoot)\test_results
      Example:       C:\my_test_results\my_extra_special_test_run_folder\
    -->
    <TestResultsFolderPath Condition="'$(TestResultsFolderPath)' == ''">$(RepoRoot)test_results</TestResultsFolderPath>

    <!--
      TestSet
      Applies to:     TestSqlClientManual
      Description:    Used to select a set of tests to run from the SqlClient manual tests project. If not
                      specified, all manual tests will be executed. In the manual test target, this
                      value is converted into a Set trait filter and combined with any TestFilters.
      Default value:  [blank]
      Allowed values: ([1][2][3][AE])
      Examples:       "1", "12", "AE", "12AE"
    -->
    <TestSet Condition="'$(TestSet)' == ''" />
  </PropertyGroup>

  <!-- ================================================================= -->
  <!-- Top Level/Miscellaneous Targets -->

  <!--
    BuildAll: Build all projects in the repo, for all supported OS and TargetFramework combinations.
    This is the default target.
  -->
  <Target Name="BuildAll" DependsOnTargets="BuildDriver;BuildTests;BuildSamples;BuildTools" />

  <!--
    BuildDriver: Builds all driver projects.
    Note: These have been ordered in a vague attempt to minimize multiple rebuilds of dependencies.
  -->
  <Target Name="BuildDriver" DependsOnTargets="BuildLogging;BuildAbstractions;BuildSqlClient;BuildAzure;BuildAkvProvider;BuildSqlServer" />

  <!-- Clean: Convenience target to remove build/test output -->
  <Target Name="Clean">
    <!-- Remove known build output paths -->
    <RemoveDir Directories="$([System.IO.Directory]::GetDirectories('.', 'artifacts', SearchOption.AllDirectories))" />
    <RemoveDir Directories="$([System.IO.Directory]::GetDirectories('.', 'test_results', SearchOption.AllDirectories))" />

    <!-- Remove remaining bin/intermediate paths, eg test binaries -->
    <RemoveDir Directories="$([System.IO.Directory]::GetDirectories('.', 'bin', SearchOption.AllDirectories))" />
    <RemoveDir Directories="$([System.IO.Directory]::GetDirectories('.', 'obj', SearchOption.AllDirectories))" />
  </Target>

  <!--
    Pack: Packages all driver projects.
    Note: These have been ordered in a vague attempt to minimize multiple rebuilds of dependencies.
  -->
  <Target Name="Pack" DependsOnTargets="PackLogging;PackAbstractions;PackSqlClient;PackAzure;PackAkvProvider;PackSqlServer" />

  <!-- ================================================================= -->
  <!-- Version Extraction Targets
       =========================
       The SqlClient family shares one version, so there are two extraction targets:

         GetVersionsSqlClient  — the SqlClient family version (Internal.Logging,
                                 Extensions.Abstractions, Microsoft.Data.SqlClient,
                                 Extensions.Azure, and the AKV Provider all share this).
         GetVersionsSqlServer  — the independently-versioned Microsoft.SqlServer.Server.

       Each emits labeled messages at High importance that pipelines capture by grepping stdout:
         PackageVersion: <value>
         FileVersion: <value>
       GetVersionsSqlServer additionally emits its last-shipped version:
         PublishedVersion: <value>

       Usage:
         dotnet build build.proj -t:GetVersionsSqlClient -v:m -nologo -p:BuildNumber=1234
         # stdout contains:
         #   PackageVersion: 7.1.0-preview1
         #   FileVersion: 7.1.0.1234
  -->

  <Target Name="GetVersionsSqlClient">
    <PropertyGroup>
      <_Cmd>"$(DotnetPath)dotnet" build "$(SqlClientProjectPath)" -getProperty:SqlClientPackageVersion $(BuildNumberArgument) $(BuildSuffixArgument)</_Cmd>
      <_Cmd>$([System.Text.RegularExpressions.Regex]::Replace($(_Cmd), "\s+", " "))</_Cmd>
    </PropertyGroup>
    <Exec Command="$(_Cmd)" ConsoleToMsBuild="true" StandardOutputImportance="High">
      <Output TaskParameter="ConsoleOutput" PropertyName="_PackageVersion" />
    </Exec>
    <PropertyGroup>
      <_Cmd>"$(DotnetPath)dotnet" build "$(SqlClientProjectPath)" -getProperty:SqlClientFileVersion $(BuildNumberArgument) $(BuildSuffixArgument)</_Cmd>
      <_Cmd>$([System.Text.RegularExpressions.Regex]::Replace($(_Cmd), "\s+", " "))</_Cmd>
    </PropertyGroup>
    <Exec Command="$(_Cmd)" ConsoleToMsBuild="true" StandardOutputImportance="High">
      <Output TaskParameter="ConsoleOutput" PropertyName="_FileVersion" />
    </Exec>
    <Message Text="PackageVersion: $(_PackageVersion)" Importance="High" />
    <Message Text="FileVersion: $(_FileVersion)" Importance="High" />
  </Target>

  <Target Name="GetVersionsSqlServer">
    <PropertyGroup>
      <_Cmd>"$(DotnetPath)dotnet" build "$(SqlServerProjectPath)" -getProperty:SqlServerPackageVersion $(BuildNumberArgument) $(BuildSuffixArgument)</_Cmd>
      <_Cmd>$([System.Text.RegularExpressions.Regex]::Replace($(_Cmd), "\s+", " "))</_Cmd>
    </PropertyGroup>
    <Exec Command="$(_Cmd)" ConsoleToMsBuild="true" StandardOutputImportance="High">
      <Output TaskParameter="ConsoleOutput" PropertyName="_PackageVersion" />
    </Exec>
    <Exec Command="&quot;$(DotnetPath)dotnet&quot; build &quot;$(SqlServerProjectPath)&quot; -getProperty:SqlServerPublishedVersion" ConsoleToMsBuild="true" StandardOutputImportance="High">
      <Output TaskParameter="ConsoleOutput" PropertyName="_PublishedVersion" />
    </Exec>
    <PropertyGroup>
      <_Cmd>"$(DotnetPath)dotnet" build "$(SqlServerProjectPath)" -getProperty:SqlServerFileVersion $(BuildNumberArgument) $(BuildSuffixArgument)</_Cmd>
      <_Cmd>$([System.Text.RegularExpressions.Regex]::Replace($(_Cmd), "\s+", " "))</_Cmd>
    </PropertyGroup>
    <Exec Command="$(_Cmd)" ConsoleToMsBuild="true" StandardOutputImportance="High">
      <Output TaskParameter="ConsoleOutput" PropertyName="_FileVersion" />
    </Exec>
    <Message Text="PackageVersion: $(_PackageVersion)" Importance="High" />
    <Message Text="PublishedVersion: $(_PublishedVersion)" Importance="High" />
    <Message Text="FileVersion: $(_FileVersion)" Importance="High" />
  </Target>

  <!--
    Test: Run all test targets for all driver projects.

    Note: This requires local and remote SQL Server setups with corresponding JSON configuration
    files. It will run for a *very* long time and it is not recommended, even in automated test
    environments. Please consider running project specific test targets or specific test sets within
    the project.
  -->
  <Target Name="Test" DependsOnTargets="TestAbstractions;TestAzure;TestSqlClient" />

  <!-- ================================================================= -->
  <!-- Microsoft.Data.SqlClient Targets -->
  <PropertyGroup>
    <!-- Root for SqlClient projects -->
    <SqlClientSrcRoot>$(RepoRoot)src/Microsoft.Data.SqlClient/</SqlClientSrcRoot>
    <SqlClientArtifactRoot>$(RepoRoot)artifacts/Microsoft.Data.SqlClient/</SqlClientArtifactRoot>

    <!-- Project Path -->
    <SqlClientProjectPath>$(SqlClientSrcRoot)src/Microsoft.Data.SqlClient.csproj</SqlClientProjectPath>
    <SqlClientRefProjectPath>$(SqlClientSrcRoot)ref/Microsoft.Data.SqlClient.csproj</SqlClientRefProjectPath>
    <SqlClientNotSupportedProjectPath>$(SqlClientSrcRoot)notsupported/Microsoft.Data.SqlClient.csproj</SqlClientNotSupportedProjectPath>
    <SqlClientPackageArtifactRoot>$(SqlClientArtifactRoot)$(ReferenceType)-$(Configuration)/</SqlClientPackageArtifactRoot>

    <!-- Test Project Paths -->
    <SqlClientFunctionalTestProjectPath>$(SqlClientSrcRoot)tests/FunctionalTests/Microsoft.Data.SqlClient.FunctionalTests.csproj</SqlClientFunctionalTestProjectPath>
    <SqlClientManualTestProjectPath>$(SqlClientSrcRoot)tests/ManualTests/Microsoft.Data.SqlClient.ManualTests.csproj</SqlClientManualTestProjectPath>
    <SqlClientUnitTestProjectPath>$(SqlClientSrcRoot)tests/UnitTests/Microsoft.Data.SqlClient.UnitTests.csproj</SqlClientUnitTestProjectPath>

    <!-- Tools/Specs Paths -->
    <GenApiPath>$(RepoRoot)tools/GenAPI/Microsoft.DotNet.GenAPI/</GenApiPath>
    <GenApiProjectPath>$(GenApiPath)Microsoft.DotNet.GenAPI.csproj</GenApiProjectPath>
  </PropertyGroup>

  <!-- Build SqlClient Targets =============================================== -->
  <!-- BuildSqlClient: Builds all binaries for SqlClient -->
  <Target Name="BuildSqlClient" DependsOnTargets="BuildSqlClientUnix;BuildSqlClientWindows;BuildSqlClientRef;BuildSqlClientNotSupported" />

  <!--
    BuildSqlClientNotSupported: Builds a version of the SqlClient assemblies that always throws
    PlatformNotSupportedException. It generates the source for this using GenAPI which is built as
    the first step of this target.
  -->
  <PropertyGroup>
    <BuildSqlClientNotSupportedDependsOn Condition="'$(ReferenceType.ToLower())' == 'package' AND '$(SkipDependencyPack)' != 'true'">PackLogging;PackAbstractions;PackSqlServer</BuildSqlClientNotSupportedDependsOn>
  </PropertyGroup>
  <Target Name="BuildSqlClientNotSupported" DependsOnTargets="$(BuildSqlClientNotSupportedDependsOn)">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(GenApiProjectPath)"
        -p:Configuration=$(Configuration)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Building GenAPI project"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />

    <!-- Get the path to the GenAPI artifact -->
    <ItemGroup>
      <GenApiArtifactPath Include="$(GenApiPath)bin/$(Configuration)/**/Microsoft.DotNet.GenAPI.dll" />
    </ItemGroup>

    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SqlClientNotSupportedProjectPath)"
        -p:Configuration=$(Configuration)
        -p:GenApiPath="@(GenApiArtifactPath->'%(FullPath)')"
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Building not supported binaries project"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildSqlClientRef: Builds the ref binaries project for SqlClient, which is OS-agnostic -->
  <PropertyGroup>
    <BuildSqlClientRefDependsOn Condition="'$(ReferenceType.ToLower())' == 'package' AND '$(SkipDependencyPack)' != 'true'">PackLogging;PackAbstractions;PackSqlServer</BuildSqlClientRefDependsOn>
  </PropertyGroup>
  <Target Name="BuildSqlClientRef" DependsOnTargets="$(BuildSqlClientRefDependsOn)">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build $(SqlClientRefProjectPath)
        -p:Configuration=$(Configuration)
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)

        <!-- Reference type arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Building SqlClient ref binaries"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildSqlClientUnix: Builds all unix-specific SqlClient binaries -->
  <PropertyGroup>
    <BuildSqlClientUnixDependsOn Condition="'$(ReferenceType.ToLower())' == 'package' AND '$(SkipDependencyPack)' != 'true'">PackLogging;PackAbstractions;PackSqlServer</BuildSqlClientUnixDependsOn>
  </PropertyGroup>
  <Target Name="BuildSqlClientUnix" DependsOnTargets="$(BuildSqlClientUnixDependsOn)">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build $(SqlClientProjectPath)
        -p:Configuration=$(Configuration)
        -p:TargetOs=Unix
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Building SqlClient for Unix"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildSqlClientWindows: Builds all windows-specific SqlClient binaries -->
  <PropertyGroup>
    <BuildSqlClientWindowsDependsOn Condition="'$(ReferenceType.ToLower())' == 'package' AND '$(SkipDependencyPack)' != 'true'">PackLogging;PackAbstractions;PackSqlServer</BuildSqlClientWindowsDependsOn>
  </PropertyGroup>
  <Target Name="BuildSqlClientWindows" DependsOnTargets="$(BuildSqlClientWindowsDependsOn)">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build $(SqlClientProjectPath)
        -p:Configuration=$(Configuration)
        -p:TargetOs=Windows_NT
        $(SigningKeyPathArgument)

        <!-- Versioning Arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building SqlClient for Windows"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- Pack SqlClient Target ===================================================== -->
  <!--
    SqlClient packaging uses the output from multiple projects, so we cannot simply ask dotnet
    pack to package the SqlClient project alone.  We must ensure that all of the satellite
    projects are built as well.  To achieve this, when PackBuild is true, we add the compound
    BuildSqlClient target as a dependency of PackSqlClient.  This ensures all SqlClient targets are
    built before packing.
  -->
  <PropertyGroup>
    <PackSqlClientDependsOn Condition="'$(PackBuild.ToLower())' == 'true'">BuildSqlClient</PackSqlClientDependsOn>
  </PropertyGroup>

  <!--
    PackSqlClient: Packages SqlClient binaries with dotnet pack.
    The package layout is defined by a nuspec file because we package the artifacts from multiple
    projects into a single .nupkg file.
  -->
  <Target Name="PackSqlClient" DependsOnTargets="$(PackSqlClientDependsOn)">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" pack "$(SqlClientProjectPath)"
        -p:Configuration=$(Configuration)
        $(PackBuildArgument)
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlServerArgument)

        <!-- Pack settings are defined in Microsoft.Data.SqlClient.csproj -->
        -p:PackageOutputPath="$(SqlClientPackageArtifactRoot)"
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Packing SqlClient"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />

    <!-- In Package mode, mirror produced packages into local feed (packages/) for downstream restore. -->
    <ItemGroup Condition="'$(ReferenceType.ToLower())' == 'package'">
      <SqlClientPackedArtifacts Include="$(SqlClientPackageArtifactRoot)*.nupkg" />
      <SqlClientPackedArtifacts Include="$(SqlClientPackageArtifactRoot)*.snupkg" />
    </ItemGroup>
    <Copy
      Condition="'$(ReferenceType.ToLower())' == 'package'"
      SourceFiles="@(SqlClientPackedArtifacts)"
      DestinationFolder="$(PackagesDir)"
      SkipUnchangedFiles="true" />
  </Target>

  <!-- Test SqlClient Targets ==================================================== -->
  <!-- TestSqlClient: Runs all test projects for SqlClient -->
  <Target Name="TestSqlClient" DependsOnTargets="TestSqlClientFunctional;TestSqlClientManual;TestSqlClientUnit" />

  <!-- TestSqlClientFunctional: Runs functional tests for SqlClient -->
  <Target Name="TestSqlClientFunctional">
    <!-- @TODO: Prevent from running in non-admin user mode -->
    <PropertyGroup>
      <LogFilePrefix>SqlClientFunctional-$(OS)</LogFilePrefix>
      <LogFilePrefix Condition="'$(TestFramework)' != ''">$(LogFilePrefix)-$(TestFramework)</LogFilePrefix>

      <DotnetCommand>
        "$(DotnetPath)dotnet" test "$(SqlClientFunctionalTestProjectPath)"
        -p:Configuration=$(Configuration)
        $(TestBlameArgument)
        $(TestCodeCoverageArgument)
        $(TestFiltersArgument)
        $(TestFrameworkArgument)
        --results-directory "$(TestResultsFolderPath)"
        --logger:"trx;LogFilePrefix=$(LogFilePrefix)"

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlClientArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Running functional tests for SqlClient"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- TestSqlClientManual: Runs manual tests for SqlClient -->
  <Target Name="TestSqlClientManual">
    <PropertyGroup>
      <LogFilePrefix>SqlClientManual-$(OS)</LogFilePrefix>
      <LogFilePrefix Condition="'$(TestFramework)' != ''">$(LogFilePrefix)-$(TestFramework)</LogFilePrefix>
      <LogFilePrefix Condition="'$(TestSet)' != ''">$(LogFilePrefix)-$(TestSet)</LogFilePrefix>

      <!-- Join test sets together, if any were selected -->
      <NormalizedTestSet>$(TestSet.ToUpper())</NormalizedTestSet>
      <TestSetFilter Condition="$(NormalizedTestSet.Contains('1'))">Set=1</TestSetFilter>
      <TestSetFilter Condition="$(NormalizedTestSet.Contains('2'))">$(TestSetFilter)|Set=2</TestSetFilter>
      <TestSetFilter Condition="$(NormalizedTestSet.Contains('3'))">$(TestSetFilter)|Set=3</TestSetFilter>
      <TestSetFilter Condition="$(NormalizedTestSet.Contains('AE'))">$(TestSetFilter)|Set=AE</TestSetFilter>
      <TestSetFilter>$(TestSetFilter.Trim('|'))</TestSetFilter>

      <!-- Combine existing filters with test set filters -->
      <ManualTestFilters Condition="'$(TestSetFilter)' != '' and '$(TestFilters)' != ''">$(TestFilters)&amp;($(TestSetFilter))</ManualTestFilters>
      <ManualTestFilters Condition="'$(TestSetFilter)' == ''">$(TestFilters)</ManualTestFilters>
      <ManualTestFilters Condition="'$(TestFilters)' == ''">$(TestSetFilter)</ManualTestFilters>
      <ManualTestFiltersArgument Condition="'$(ManualTestFilters)' != ''">--filter "$(ManualTestFilters)"</ManualTestFiltersArgument>

      <DotnetCommand>
        "$(DotnetPath)dotnet" test "$(SqlClientManualTestProjectPath)"
        -p:Configuration=$(Configuration)
        $(TestBlameArgument)
        $(TestCodeCoverageArgument)
        $(ManualTestFiltersArgument)
        $(TestFrameworkArgument)
        --results-directory "$(TestResultsFolderPath)"
        --logger:"trx;LogFilePrefix=$(LogFilePrefix)"

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlClientArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Running manual tests for SqlClient"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- TestSqlClientUnit: Runs unit tests for SqlClient -->
  <Target Name="TestSqlClientUnit">
    <PropertyGroup>
      <LogFilePrefix>SqlClientUnit-$(OS)</LogFilePrefix>
      <LogFilePrefix Condition="'$(TestFramework)' != ''">$(LogFilePrefix)-$(TestFramework)</LogFilePrefix>

      <DotnetCommand>
        "$(DotnetPath)dotnet" test "$(SqlClientUnitTestProjectPath)"
        -p:Configuration=$(Configuration)
        $(TestBlameArgument)
        $(TestCodeCoverageArgument)
        $(TestFiltersArgument)
        $(TestFrameworkArgument)
        $(ReferenceTypeArgument)
        $(TestSigningKeyPathArgument)
        $(PackageVersionSqlClientArgument)
        $(PackageVersionSqlServerArgument)
        --results-directory "$(TestResultsFolderPath)"
        --logger:"trx;LogFilePrefix=$(LogFilePrefix)"
      </DotnetCommand>

      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Running unit tests for SqlClient"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- ================================================================= -->
  <!-- Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider Targets -->
  <PropertyGroup>
    <AkvProviderSrcRoot>$(RepoRoot)src/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider/</AkvProviderSrcRoot>
    <AkvProviderProjectPath>$(AkvProviderSrcRoot)src/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider.csproj</AkvProviderProjectPath>
    <AkvProviderArtifactRoot>$(RepoRoot)artifacts/Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider/$(Configuration)/</AkvProviderArtifactRoot>
  </PropertyGroup>

  <!-- BuildAkvProvider: Builds Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider -->
  <PropertyGroup>
    <BuildAkvProviderDependsOn Condition="'$(ReferenceType.ToLower())' == 'package' AND '$(SkipDependencyPack)' != 'true'">PackSqlClient;PackLogging</BuildAkvProviderDependsOn>
  </PropertyGroup>
  <Target Name="BuildAkvProvider" DependsOnTargets="$(BuildAkvProviderDependsOn)">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(AkvProviderProjectPath)"
        -p:Configuration=$(Configuration)
        $(SigningKeyPathArgument)

        <!--Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)

        <!-- Reference type arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Building AKV Provider"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- PackAkvProvider: Packages Microsoft.Data.SqlClient.AlwaysEncrypted.AzureKeyVaultProvider -->
  <Target Name="PackAkvProvider">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" pack "$(AkvProviderProjectPath)"
        -p:Configuration=$(Configuration)
        $(PackBuildArgument)
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Packaging AKV Provider"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />

    <!-- In Package mode, mirror produced packages into local feed (packages/) for downstream restore. -->
    <ItemGroup Condition="'$(ReferenceType.ToLower())' == 'package'">
      <AkvProviderPackedArtifacts Include="$(AkvProviderArtifactRoot)*.nupkg" />
      <AkvProviderPackedArtifacts Include="$(AkvProviderArtifactRoot)*.snupkg" />
    </ItemGroup>
    <Copy
      Condition="'$(ReferenceType.ToLower())' == 'package'"
      SourceFiles="@(AkvProviderPackedArtifacts)"
      DestinationFolder="$(PackagesDir)"
      SkipUnchangedFiles="true" />
  </Target>

  <!-- ================================================================= -->
  <!-- Microsoft.Data.SqlClient.Extensions.Abstractions Targets -->

  <PropertyGroup>
    <AbstractionsSrcRoot>$(RepoRoot)src/Microsoft.Data.SqlClient.Extensions/Abstractions/</AbstractionsSrcRoot>
    <AbstractionsProjectPath>$(AbstractionsSrcRoot)src/Abstractions.csproj</AbstractionsProjectPath>
    <AbstractionsTestProjectPath>$(AbstractionsSrcRoot)test/Abstractions.Test.csproj</AbstractionsTestProjectPath>
    <AbstractionsArtifactRoot>$(RepoRoot)artifacts/Microsoft.Data.SqlClient.Extensions.Abstractions/$(Configuration)/</AbstractionsArtifactRoot>
  </PropertyGroup>

  <!-- BuildAbstractions: Builds Microsoft.Data.SqlClient.Extensions.Abstractions -->
  <PropertyGroup>
    <BuildAbstractionsDependsOn Condition="'$(ReferenceType.ToLower())' == 'package' AND '$(SkipDependencyPack)' != 'true'">PackLogging</BuildAbstractionsDependsOn>
  </PropertyGroup>
  <Target Name="BuildAbstractions" DependsOnTargets="$(BuildAbstractionsDependsOn)">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(AbstractionsProjectPath)"
        -p:Configuration=$(Configuration)
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Building Abstractions"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- PackAbstractions: Packages Microsoft.Data.SqlClient.Extensions.Abstractions -->
  <Target Name="PackAbstractions">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" pack "$(AbstractionsProjectPath)"
        -p:Configuration=$(Configuration)
        $(PackBuildArgument)
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Packaging Abstractions"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />

    <!-- In Package mode, mirror produced packages into local feed (packages/) for downstream restore. -->
    <ItemGroup Condition="'$(ReferenceType.ToLower())' == 'package'">
      <AbstractionsPackedArtifacts Include="$(AbstractionsArtifactRoot)*.nupkg" />
      <AbstractionsPackedArtifacts Include="$(AbstractionsArtifactRoot)*.snupkg" />
    </ItemGroup>
    <Copy
      Condition="'$(ReferenceType.ToLower())' == 'package'"
      SourceFiles="@(AbstractionsPackedArtifacts)"
      DestinationFolder="$(PackagesDir)"
      SkipUnchangedFiles="true" />
  </Target>

  <!-- TestAbstractions: Runs Microsoft.Data.SqlClient.Extensions.Abstractions.Tests -->
  <Target Name="TestAbstractions">
    <PropertyGroup>
      <LogFilePrefix>AbstractionsTests-$(OS)</LogFilePrefix>
      <LogFilePrefix Condition="'$(TestFramework)' != ''">$(LogFilePrefix)-$(TestFramework)</LogFilePrefix>

      <DotnetCommand>
        "$(DotnetPath)dotnet" test "$(AbstractionsTestProjectPath)"

        <!-- Build arguments -->
        -p:Configuration=$(Configuration)
        $(SigningKeyPathArgument)
        $(TestSigningKeyPathArgument)

        <!-- Test arguments -->
        $(TestBlameArgument)
        $(TestCodeCoverageArgument)
        $(TestFiltersArgument)
        $(TestFrameworkArgument)
        --results-directory "$(TestResultsFolderPath)"
        --logger:"trx;LogFilePrefix=$(LogFilePrefix)"

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlClientArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Running tests for Abstractions"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- ================================================================= -->
  <!-- Microsoft.Data.SqlClient.Extensions.Azure Targets -->
  <PropertyGroup>
    <AzureSrcRoot>$(RepoRoot)src/Microsoft.Data.SqlClient.Extensions/Azure/</AzureSrcRoot>
    <AzureProjectPath>$(AzureSrcRoot)src/Azure.csproj</AzureProjectPath>
    <AzureTestProjectPath>$(AzureSrcRoot)test/Azure.Test.csproj</AzureTestProjectPath>
    <AzureArtifactRoot>$(RepoRoot)artifacts/Microsoft.Data.SqlClient.Extensions.Azure/$(Configuration)/</AzureArtifactRoot>
  </PropertyGroup>

  <!-- BuildAzure: Builds Microsoft.Data.SqlClient.Extensions.Azure -->
  <PropertyGroup>
    <BuildAzureDependsOn Condition="'$(ReferenceType.ToLower())' == 'package' AND '$(SkipDependencyPack)' != 'true'">PackLogging;PackAbstractions</BuildAzureDependsOn>
  </PropertyGroup>
  <Target Name="BuildAzure" DependsOnTargets="$(BuildAzureDependsOn)">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(AzureProjectPath)"
        -p:Configuration=$(Configuration)
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)

        <!-- Reference type arguments -->
        $(ReferenceTypeArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Building Azure"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- PackAzure: Packages Microsoft.Data.SqlClient.Extensions.Azure -->
  <Target Name="PackAzure">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" pack "$(AzureProjectPath)"
        -p:Configuration=$(Configuration)
        $(PackBuildArgument)
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Packaging Azure"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />

    <!-- In Package mode, mirror produced packages into local feed (packages/) for downstream restore. -->
    <ItemGroup Condition="'$(ReferenceType.ToLower())' == 'package'">
      <AzurePackedArtifacts Include="$(AzureArtifactRoot)*.nupkg" />
      <AzurePackedArtifacts Include="$(AzureArtifactRoot)*.snupkg" />
    </ItemGroup>
    <Copy
      Condition="'$(ReferenceType.ToLower())' == 'package'"
      SourceFiles="@(AzurePackedArtifacts)"
      DestinationFolder="$(PackagesDir)"
      SkipUnchangedFiles="true" />
  </Target>

  <!-- TestAzure: Runs Microsoft.Data.SqlClient.Extensions.Azure.Tests -->
  <Target Name="TestAzure">
    <PropertyGroup>
      <LogFilePrefix>AzureTests-$(OS)</LogFilePrefix>
      <LogFilePrefix Condition="'$(TestFramework)' != ''">$(LogFilePrefix)-$(TestFramework)</LogFilePrefix>

      <DotnetCommand>
        "$(DotnetPath)dotnet" test "$(AzureTestProjectPath)"
        -p:Configuration=$(Configuration)
        $(TestBlameArgument)
        $(TestCodeCoverageArgument)
        $(TestFiltersArgument)
        $(TestFrameworkArgument)
        --results-directory "$(TestResultsFolderPath)"
        --logger:"trx;LogFilePrefix=$(LogFilePrefix)"

        <!-- Reference type arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlClientArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Running tests for Azure"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- ================================================================= -->
  <!-- Microsoft.Data.SqlClient.Internal.Logging Targets -->
  <PropertyGroup>
    <LoggingSrcRoot>$(RepoRoot)src/Microsoft.Data.SqlClient.Internal/Logging/src/</LoggingSrcRoot>
    <LoggingProjectPath>$(LoggingSrcRoot)Logging.csproj</LoggingProjectPath>
    <LoggingArtifactRoot>$(RepoRoot)artifacts/Microsoft.Data.SqlClient.Internal.Logging/$(Configuration)/</LoggingArtifactRoot>
  </PropertyGroup>

  <!-- BuildLogging: Builds Microsoft.Data.SqlClient.Internal.Logging -->
  <Target Name="BuildLogging">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build $(LoggingProjectPath)
        -p:Configuration=$(Configuration)
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Building Logging"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- PackLogging: Packages Microsoft.Data.SqlClient.Internal.Logging -->
  <Target Name="PackLogging">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" pack $(LoggingProjectPath)
        -p:Configuration=$(Configuration)
        $(PackBuildArgument)
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlClientArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Packaging Logging"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />

    <!-- In Package mode, mirror produced packages into local feed (packages/) for downstream restore. -->
    <ItemGroup Condition="'$(ReferenceType.ToLower())' == 'package'">
      <LoggingPackedArtifacts Include="$(LoggingArtifactRoot)*.nupkg" />
      <LoggingPackedArtifacts Include="$(LoggingArtifactRoot)*.snupkg" />
    </ItemGroup>
    <Copy
      Condition="'$(ReferenceType.ToLower())' == 'package'"
      SourceFiles="@(LoggingPackedArtifacts)"
      DestinationFolder="$(PackagesDir)"
      SkipUnchangedFiles="true" />
  </Target>

  <!-- ================================================================= -->
  <!-- Microsoft.SqlServer.Server Targets -->
  <PropertyGroup>
    <SqlServerSrcRoot>$(RepoRoot)src/Microsoft.SqlServer.Server/</SqlServerSrcRoot>
    <SqlServerProjectPath>$(SqlServerSrcRoot)Microsoft.SqlServer.Server.csproj</SqlServerProjectPath>
    <SqlServerArtifactRoot>$(RepoRoot)artifacts/Microsoft.SqlServer.Server/$(Configuration)/</SqlServerArtifactRoot>
  </PropertyGroup>

  <!-- BuildSqlServer: Builds the Microsoft.SqlServer.Server project -->
  <Target Name="BuildSqlServer">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build $(SqlServerProjectPath)
        -p:Configuration=$(Configuration)
        $(SigningKeyPathArgument)

        <!--Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Building SqlServer"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- PackSqlServer: Packages the Microsoft.SqlServer.Server project -->
  <Target Name="PackSqlServer">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" pack $(SqlServerProjectPath)
        -p:Configuration=$(Configuration)
        $(PackBuildArgument)
        $(SigningKeyPathArgument)

        <!-- Versioning arguments -->
        $(BuildNumberArgument)
        $(BuildSuffixArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <!-- Convert more than one whitespace character into one space -->
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>

    <Message Importance="High" Text=">>> Packaging SqlServer"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />

    <!-- In Package mode, mirror produced packages into local feed (packages/) for downstream restore. -->
    <ItemGroup Condition="'$(ReferenceType.ToLower())' == 'package'">
      <SqlServerPackedArtifacts Include="$(SqlServerArtifactRoot)*.nupkg" />
      <SqlServerPackedArtifacts Include="$(SqlServerArtifactRoot)*.snupkg" />
    </ItemGroup>
    <Copy
      Condition="'$(ReferenceType.ToLower())' == 'package'"
      SourceFiles="@(SqlServerPackedArtifacts)"
      DestinationFolder="$(PackagesDir)"
      SkipUnchangedFiles="true" />
  </Target>

  <!-- ================================================================= -->
  <!-- Build Test Targets -->

  <PropertyGroup>
    <SqlClientPerformanceTestProjectPath>$(SqlClientSrcRoot)tests/PerformanceTests/Microsoft.Data.SqlClient.PerformanceTests.csproj</SqlClientPerformanceTestProjectPath>
    <SqlClientStressTestProjectPath>$(SqlClientSrcRoot)tests/StressTests/SqlClient.Stress.Runner/SqlClient.Stress.Runner.csproj</SqlClientStressTestProjectPath>
    <SamplesProjectPath>$(RepoRoot)doc/samples/Microsoft.Data.SqlClient.Samples.csproj</SamplesProjectPath>
  </PropertyGroup>

  <!-- BuildTests: Builds all test projects for all supported OS combinations. -->
  <Target Name="BuildTests" DependsOnTargets="BuildAbstractionsTests;BuildSqlClientTestsUnit;BuildSqlClientTestsFunctional;BuildSqlClientTestsManual;BuildSqlClientTestsPerformance;BuildSqlClientTestsStress;BuildAzureTests" />

  <!-- BuildAbstractionsTests: Builds the Abstractions test project (OS-agnostic). -->
  <Target Name="BuildAbstractionsTests">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(AbstractionsTestProjectPath)"
        -p:Configuration=$(Configuration)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building Abstractions Tests"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildSqlClientTestsUnit ================================================= -->
  <Target Name="BuildSqlClientTestsUnit" DependsOnTargets="BuildSqlClientTestsUnitUnix;BuildSqlClientTestsUnitWindows" />

  <Target Name="BuildSqlClientTestsUnitUnix">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SqlClientUnitTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Unix

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(TestSigningKeyPathArgument)
        $(PackageVersionSqlClientArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building SqlClient Unit Tests for Unix"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <Target Name="BuildSqlClientTestsUnitWindows">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SqlClientUnitTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Windows_NT

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(TestSigningKeyPathArgument)
        $(PackageVersionSqlClientArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building SqlClient Unit Tests for Windows"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildSqlClientTestsFunctional =========================================== -->
  <Target Name="BuildSqlClientTestsFunctional" DependsOnTargets="BuildSqlClientTestsFunctionalUnix;BuildSqlClientTestsFunctionalWindows" />

  <Target Name="BuildSqlClientTestsFunctionalUnix">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SqlClientFunctionalTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Unix

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionAbstractionsArgument)
        $(PackageVersionLoggingArgument)
        $(PackageVersionSqlClientArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building SqlClient Functional Tests for Unix"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <Target Name="BuildSqlClientTestsFunctionalWindows">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SqlClientFunctionalTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Windows_NT

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionAbstractionsArgument)
        $(PackageVersionLoggingArgument)
        $(PackageVersionSqlClientArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building SqlClient Functional Tests for Windows"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildSqlClientTestsManual =============================================== -->
  <Target Name="BuildSqlClientTestsManual" DependsOnTargets="BuildSqlClientTestsManualUnix;BuildSqlClientTestsManualWindows" />

  <Target Name="BuildSqlClientTestsManualUnix">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SqlClientManualTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Unix

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionAbstractionsArgument)
        $(PackageVersionLoggingArgument)
        $(PackageVersionSqlClientArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building SqlClient Manual Tests for Unix"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <Target Name="BuildSqlClientTestsManualWindows">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SqlClientManualTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Windows_NT

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionAbstractionsArgument)
        $(PackageVersionLoggingArgument)
        $(PackageVersionSqlClientArgument)
        $(PackageVersionSqlServerArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building SqlClient Manual Tests for Windows"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildSqlClientTestsPerformance ========================================== -->
  <Target Name="BuildSqlClientTestsPerformance" DependsOnTargets="BuildSqlClientTestsPerformanceUnix;BuildSqlClientTestsPerformanceWindows" />

  <Target Name="BuildSqlClientTestsPerformanceUnix">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SqlClientPerformanceTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Unix

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionAbstractionsArgument)
        $(PackageVersionLoggingArgument)
        $(PackageVersionSqlClientArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building SqlClient Performance Tests for Unix"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <Target Name="BuildSqlClientTestsPerformanceWindows">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SqlClientPerformanceTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Windows_NT

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionAbstractionsArgument)
        $(PackageVersionLoggingArgument)
        $(PackageVersionSqlClientArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building SqlClient Performance Tests for Windows"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildSqlClientTestsStress =============================================== -->
  <Target Name="BuildSqlClientTestsStress" DependsOnTargets="BuildSqlClientTestsStressUnix;BuildSqlClientTestsStressWindows" />

  <Target Name="BuildSqlClientTestsStressUnix">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SqlClientStressTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Unix

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionAbstractionsArgument)
        $(PackageVersionLoggingArgument)
        $(PackageVersionSqlClientArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building SqlClient Stress Tests for Unix"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <Target Name="BuildSqlClientTestsStressWindows">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SqlClientStressTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Windows_NT

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionAbstractionsArgument)
        $(PackageVersionLoggingArgument)
        $(PackageVersionSqlClientArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building SqlClient Stress Tests for Windows"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildAzureTests ========================================================= -->
  <Target Name="BuildAzureTests" DependsOnTargets="BuildAzureTestsUnix;BuildAzureTestsWindows" />

  <Target Name="BuildAzureTestsUnix">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(AzureTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Unix

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlClientArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building Azure Tests for Unix"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <Target Name="BuildAzureTestsWindows">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(AzureTestProjectPath)"
        -p:Configuration=$(Configuration)
        -p:TargetOs=Windows_NT

        <!-- Reference Type Arguments -->
        $(ReferenceTypeArgument)
        $(PackageVersionSqlClientArgument)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building Azure Tests for Windows"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- ================================================================= -->
  <!-- Build Samples Target -->

  <!-- Build all sample projects. -->
  <Target Name="BuildSamples">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(SamplesProjectPath)"
        -p:Configuration=$(Configuration)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building Samples"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- ================================================================= -->
  <!-- Build Tools Target -->

  <PropertyGroup>
    <AzureSqlConnectorProjectPath>$(RepoRoot)doc/apps/AzureSqlConnector/AzureSqlConnector.csproj</AzureSqlConnectorProjectPath>
    <PackageCompatibilityProjectPath>$(RepoRoot)tools/PackageCompatibility/src/PackageCompatibility.csproj</PackageCompatibilityProjectPath>
    <PackageCompatibilityTestProjectPath>$(RepoRoot)tools/PackageCompatibility/test/PackageCompatibility.Test.csproj</PackageCompatibilityTestProjectPath>
    <PackageCompatibilityDir>$(RepoRoot)tools/PackageCompatibility</PackageCompatibilityDir>
    <PackageValidatorProjectPath>$(RepoRoot)tools/PackageValidator/src/PackageValidator.csproj</PackageValidatorProjectPath>
    <PackageValidatorTestProjectPath>$(RepoRoot)tools/PackageValidator/test/PackageValidator.Test.csproj</PackageValidatorTestProjectPath>
    <PackageValidatorDir>$(RepoRoot)tools/PackageValidator</PackageValidatorDir>
  </PropertyGroup>

  <!-- BuildTools: Builds auxiliary tool/app projects (including their test projects). -->
  <Target Name="BuildTools" DependsOnTargets="BuildAzureSqlConnector;BuildPackageCompatibility;BuildPackageCompatibilityTest;BuildPackageValidator;BuildPackageValidatorTest" />

  <!-- BuildAzureSqlConnector: Builds the AzureSqlConnector sample app. -->
  <Target Name="BuildAzureSqlConnector">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(AzureSqlConnectorProjectPath)"
        -p:Configuration=$(Configuration)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building AzureSqlConnector"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildPackageCompatibility: Builds the PackageCompatibility tool. -->
  <Target Name="BuildPackageCompatibility">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(PackageCompatibilityProjectPath)"
        -p:Configuration=$(Configuration)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building PackageCompatibility"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildPackageValidator: Builds the PackageValidator tool. -->
  <Target Name="BuildPackageValidator">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(PackageValidatorProjectPath)"
        -p:Configuration=$(Configuration)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building PackageValidator"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildPackageCompatibilityTest: Builds the PackageCompatibility test project. -->
  <Target Name="BuildPackageCompatibilityTest">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(PackageCompatibilityTestProjectPath)"
        -p:Configuration=$(Configuration)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building PackageCompatibility tests"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!-- BuildPackageValidatorTest: Builds the PackageValidator test project. -->
  <Target Name="BuildPackageValidatorTest">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" build "$(PackageValidatorTestProjectPath)"
        -p:Configuration=$(Configuration)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Building PackageValidator tests"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" />
  </Target>

  <!--
    TestPackageCompatibility: Runs the PackageCompatibility tests.

    The Exec runs from the tool directory so the tool's global.json (which opts the xUnit v3
    test project into the Microsoft.Testing.Platform runner) is discovered.
  -->
  <Target Name="TestPackageCompatibility">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" test "$(PackageCompatibilityTestProjectPath)"
        -p:Configuration=$(Configuration)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Testing PackageCompatibility"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" WorkingDirectory="$(PackageCompatibilityDir)" />
  </Target>

  <!--
    TestPackageValidator: Runs the PackageValidator tests.

    The Exec runs from the tool directory so the tool's global.json (which opts the xUnit v3
    test project into the Microsoft.Testing.Platform runner) is discovered.
  -->
  <Target Name="TestPackageValidator">
    <PropertyGroup>
      <DotnetCommand>
        "$(DotnetPath)dotnet" test "$(PackageValidatorTestProjectPath)"
        -p:Configuration=$(Configuration)
      </DotnetCommand>
      <DotnetCommand>$([System.Text.RegularExpressions.Regex]::Replace($(DotnetCommand), "\s+", " "))</DotnetCommand>
    </PropertyGroup>
    <Message Importance="High" Text=">>> Testing PackageValidator"/>
    <Message Text="    Command: $(DotnetCommand)"/>
    <Exec ConsoleToMsBuild="true" Command="$(DotnetCommand)" WorkingDirectory="$(PackageValidatorDir)" />
  </Target>

</Project>