build.settings.props

<?xml version="1.0" encoding="utf-8"?>
<Project
    DefaultTargets="Run"
    ToolsVersion="14.0"
    xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <!-- Overrides for the build configuration -->
    <PropertyGroup>
        <!-- A flag that indicates whether or not the build output of the VS projects is redirected to the $(DirBuildBinPlatformConfig) directory. -->
        <!-- <RedirectBuildOutputToSingleFolder>false</RedirectBuildOutputToSingleFolder> -->

        <!-- The build configuration (debug / release / ...) that will be used to run all the unit tests and the static verification on -->
        <TestConfiguration>Release</TestConfiguration>

        <!-- The build configuration (debug / release / ..) that will be used to create the binaries that should be deployed -->
        <ProductionConfiguration>Release</ProductionConfiguration>

        <!-- The platform for which the binaries will be build -->
        <!-- <Platform>Any CPU</Platform> -->
        <!-- <PlatformWithoutSpaces>$(Platform.Replace(" ",""))</PlatformWithoutSpaces> -->
    </PropertyGroup>


    <!--
        **** PREPARE - WORKSPACE ****
    -->
    <!--
        The list of all files that should be deleted prior to starting the build process.

        If the deletion process fails the build will continue and a warning will be printed.
    -->
    <ItemGroup Condition=" '$(ShouldLoadFilesToDelete)' == 'true' ">
        <!--
        <FilesToDelete Include="" />
        -->
    </ItemGroup>

    <!--
        The list of all directories that should be deleted prior to starting the build process.
        Deleting the directories will also delete all the files contained in these directories.

        If the deletion process fails the build will continue and a warning will be printed.
    -->
    <ItemGroup Condition=" '$(ShouldLoadDirectoriesToDelete)' == 'true' ">
        <!--
        <DirectoriesToDelete Include="" />
        -->
    </ItemGroup>


    <!--
        **** PREPARE - COPY FILES ****
    -->
    <ItemGroup Condition=" '$(ShouldLoadNuGetFilesToCopy)' == 'true' ">
        <!--
        <NuGetFilesToCopy Include="My.Cool.NuGet.Package">
            <Include>**/*.*</Include>
            <Destinations>$(DirBuildTemp)</Destinations>
        </NuGetFilesToCopy>
        -->
    </ItemGroup>
    <ItemGroup Condition=" '$(ShouldLoadHttpFilesToCopy)' == 'true' AND '@(HttpFilesToCopy)' == '' ">
        <!--
        <HttpFilesToCopy Include="">
            <Destination></Destination>
            <GpgKey></GpgKey>
            <Hash></Hash>
            <HashAlgorithm></HashAlgorithm>
            <HashFile></HashFile>
            <Name></Name>
            <Password></Password>
            <SignatureFile></SignatureFile>
            <UseDefaultCredentials></UseDefaultCredentials>
            <UserName></UserName>
            <Unzip></Unzip>
        </HttpFilesToCopy>
        -->
    </ItemGroup>
    <ItemGroup Condition=" '$(ShouldLoadFilesToCopy)' == 'true' ">
        <!--
        <FilesToCopy Include="">
            <Destination></Destination>
        </FilesToCopy>
        -->
    </ItemGroup>
    <ItemGroup Condition=" '$(ShouldLoadArchiveFilesToCopy)' == 'true' ">
        <!--
        <ArchiveFilesToCopy Include="">
            <Destination></Destination>
            <GpgKey></GpgKey>
            <Hash></Hash>
            <HashAlgorithm></HashAlgorithm>
            <HashFile></HashFile>
            <SignatureFile></SignatureFile>
        </ArchiveFilesToCopy>
        -->
    </ItemGroup>


    <!--
        **** PREPARE - GENERATE FILES ****
    -->
    <!--
        The list of all files that should be generated and their template files.

        The template file may contain zero or more template parameters as indicated at the top of this
        file. By default template parameters must be enclosed in '${}'. By providing a value for
        'Expression' it is possible to use a custom regular expression to search for elements to replace,
        e.g. $TOKEN$. Note that elements in the regular expession might need to be converted in a suitable
        format because XML doesn't like < and > and MsBuild doesn't like $ (%24), * (%2A), ? (%3F).

        Only the 'Template' value is required.

        Additional parameters can be provided through the 'TemplateTokens' ItemGroup below.
    -->
    <ItemGroup Condition=" '$(ShouldLoadBuildFilesToGenerate)' == 'true' ">
        <BuildFilesToGenerate Include="$(DirDoc)\Nuclei.Nunit.Extensions.Documentation\docfx.json">
            <Template>$(DirDoc)\Nuclei.Nunit.Extensions.Documentation\template.docfx.json</Template>
            <Encoding>UTF-8</Encoding>
        </BuildFilesToGenerate>
    </ItemGroup>


    <!--
        **** VISUAL STUDIO BUILD ****
    -->
    <!--
        The item group defining the location of the Vistual Studio solutions that should be build.
        The solution path allows build templates, e.g. '$(DirSrc)\${CompanyName}\${ProductName}\MySolution.sln'
    -->
    <ItemGroup Condition=" '$(ShouldLoadSolutionsToBuild)' == 'true' ">
        <SolutionsToBuild Include="$(DirSrc)\*.sln"
                          Condition=" '$(TestConfiguration)' != '$(ProductionConfiguration)' " >
            <Configuration>$(TestConfiguration)</Configuration>
            <Platform>$(Platform)</Platform>
            <Targets>Rebuild</Targets>
            <Properties>
                ShouldPerformCodeAnalysis=false;
            </Properties>
        </SolutionsToBuild>
        <SolutionsToBuild Include="$(DirSrc)\*.sln">
            <Configuration>$(ProductionConfiguration)</Configuration>
            <Platform>$(Platform)</Platform>
            <Targets>Rebuild</Targets>
            <Properties>
                ShouldPerformCodeAnalysis=false;
            </Properties>
        </SolutionsToBuild>
    </ItemGroup>

    <PropertyGroup>
        <!--
            A flag that indicates whether an AssemblyInfo file with the company and copyright information should be generated.
            The file will be placed in the Properties directory of the Visual Studio project and will be named
            AssemblyInfo.Company.xx (cs/vb). This file will contain:
            - The AssemblyCompanyAttribute with the company name
            - The AssemblyCopyrightAttribute with the text provided by the ${CopyrightLong} template parameter.
        -->
        <ShouldGenerateAssemblyCompanyInfo>true</ShouldGenerateAssemblyCompanyInfo>

        <!--
            A flag that indicates whether an AssemblyInfo file with the version numbers should be generated. The file
            will be placed in the Properties directory of the Visual Studio project and will be named
            AssemblyInfo.Version.xx (cs/vb). This file will contain:
            - The AssemblyVersionAttribute with the version as provided by the ${VersionAssembly} template parameter.
            - The AssemblyFileVersionAttribute with the version as provided by the ${VersionAssemblyFile} template parameter.
            - The AssemblyInformationalVersionAttribute with the version as provided by the ${VersionProduct} template parameter.

            Also indicates that a VersionNumber.wxi should be generated. This file will be placed
            in the project folder of the Visual Studio project. This file will contain:
            - The ApplicationVersion property with the version as provided by the ${VersionProduct} template parameter.
            - The InstallVersion property with the version as provided by the ${VersionInstall} template parameter.
            - The ProductVersionFolder property with the version as provided by the ${VersionInstallFilePath} template parameter.
        -->
        <ShouldGenerateAssemblyVersionInfo>true</ShouldGenerateAssemblyVersionInfo>

        <!--
            A flag that indicates whether an AssemblyInfo file with the build information should be generated. The file
            will be placed in the Properties directory of the Visual Studio project and will be named
            AssemblyInfo.BuildInformation.xx (cs/vb). This file will contain
            - The AssemblyConfigurationAttribute containing the configuration of the build, e.g. Debug
            - The AssemblyBuildTimeAttribute containing the complete date and time that the file was generated (which
              should be close enough to the time the assembly was build).
            - The assemblyBuildInformationAttribute which contains the build number and VCS revision number.

            Note for this file to compile successfully a reference to the Nuclei.Build assembly needs to be added.
            This assembly can be found on NuGet.org (http://www.nuget.org/packages/Nuclei.Build/)
        -->
        <ShouldGenerateAssemblyBuildInfo>true</ShouldGenerateAssemblyBuildInfo>
    </PropertyGroup>

    <!--
        The ItemGroup defining the information for the generation of the InternalsVisibleAttribute.
        Three different ways of referencing the test projects public key are available. Test assemblies
        can be referenced by:
        - Providing the snk key that was / is used to sign the test assembly. This is mainly of use
          for test assemblies which are compiled at the same time as the target assemblies, i.e. test
          assemblies that are part of the same Visual Studio solution.
        - Providing the signed test assembly. This is mainly of use for test assemblies that have been
          compiled prior to compiling the target assemblies, e.g. third party test assemblies.
        - Providing the full public key for the assembly. This is mainly of use for assemblies that
          do not exists on disk, e.g. assemblies that are dynamically generated.

        Multiple projects can be referenced in the 'projects' section by separating them with a semi-colon (;). Whitespace
        can be added if required but it has no influence on the project list.

        If the assemblies are not signed it is possible to leave out the signing information, e.g. the 'KeyFile'
        property, the 'AssemblyFromPackage' property and the 'PublicKey' property.
    -->
    <PropertyGroup>
        <!--
            Defines the compiler constants for which the InternalsVisibleTo attributes should
            be generated.

            Separate multiple compiler constants with semi-colons.
        -->
        <!-- <InternalsVisibletoCompilerConstants>INTERNALS_VISIBLE_TO</InternalsVisibletoCompilerConstants> -->
    </PropertyGroup>
    <ItemGroup Condition=" '$(ShouldLoadInternalsVisibleTo)' == 'true' ">
        <!--
        <InternalsVisibleTo Include="MyTestProject">
            <Projects>
                MyProject1;
                MyProject2;
            </Projects>
            <KeyFile>$(MyKeyFileReference)</KeyFile>
        </InternalsVisibleTo>
        <InternalsVisibleTo Include="SomeExternalAssembly">
            <Projects>
                MyProject1;
                MyProject2;
            </Projects>
            <AssemblyFromPackage>SomeExternalAssembly.dll</AssemblyFromPackage>
        </InternalsVisibleTo>
        <InternalsVisibleTo Include="SomeOtherExternalAssemblyThatDoesNotExistOnDisk">
            <Projects>
                MyProject1;
                MyProject2;
            </Projects>
            <PublicKey>$(TheFullPublicKeyForTheExternalAssemblyThatDoesNotExistOnDisk)</PublicKey>
        </InternalsVisibleTo>
        -->
    </ItemGroup>

    <!-- Build configuration -->
    <PropertyGroup>
        <!--
            The version of the .NET framework at which the assemblies should be targeted. This value is set
            for all projects that include the MsBuild.Projects.XXXX NuGet package.
        -->
        <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    </PropertyGroup>


    <!--
        **** UNIT TESTS ****
    -->
    <PropertyGroup>
        <!--
            The assembly name prefix for the assemblies containing the unit tests. Allows build templates,
            e.g. '${CompanyName}.${ProductName}.Tests'.
        -->
        <!--<UnitTestAssemblyNamePrefix>Test.Unit</UnitTestAssemblyNamePrefix>-->

        <!--
            The full path to the location where the MsTest report file should be created. This path can include build templates,
            e.g. $(DirBuildLogs)\${CompanyName}\${ProductName}\mytest.trx.
        -->
        <!--<FileReportMsTest>$(DirBuildLogs)\mstest.trx</FileReportMsTest>-->

        <!--
            The full path to the directory where the VsTest report files should be created. This path can include build templates,
            e.g. $(DirBuildLogs)\${CompanyName}\${ProductName}.
        -->
        <!--<DirReportVsTest>$(DirBuildLogs)\vstest</DirReportVsTest>-->

        <!--
            The full path to the XML report file that is generated by OpenCover upon completion of the unit test execution.
            Allows build templates, e.g. $(DirBuildLogs)\${CompanyName}\${ProductName}\opencover.xml.
        -->
        <!--<FileReportOpenCoverXml>$(DirBuildLogs)\opencover.xml</FileReportOpenCoverXml>-->

        <!--
            The full path to the CSV report file that is generated by OpenCover upon completion of the unit test execution.
            Allows build templates. , e.g. $(DirBuildLogs)\${CompanyName}\${ProductName}\coverage.csv.
        -->
        <!--<FileReportOpenCoverCsv>$(DirBuildLogs)\coverage.csv</FileReportOpenCoverCsv>-->

        <!--
            The full path to the Cobertura report directory which will contain the cobertura report files which are generated
            by converting the OpenCover results to Cobertura.
            Allows build templates, e.g. $(DirBuildLogs)\${CompanyName}\${ProductName}
        -->
        <!-- <DirReportOpenCoverCobertura>$(DirBuildLogs)</DirReportOpenCoverCobertura> -->
    </PropertyGroup>
    <ItemGroup Condition=" '$(ShouldLoadUnitTestAssemblies)' == 'true' ">
        <!--
            The ItemGroup items that define which files contain the unit test cases. Paths can include build templates,
            e.g. $(DirBuildBinPlatformConfig)\${VersionMajor}.0\**\test*.dll
        -->
        <!--
        <UnitTestAssemblies
            Condition=" '$(DirSrc)' != '' "
            Include="$(DirSrc)\**\bin\$(Configuration)\**\$(UnitTestAssemblyNamePrefix)*.dll" />
        -->
    </ItemGroup>
    <ItemGroup Condition=" '$(ShouldLoadOpenCoverIgnoreAttributes)' == 'true' ">
        <!--
            The ItemGroup items that define the attributes that indicate code that should be ignored by OpenCover.
        -->
        <!--<OpenCoverIgnoreAttributes Include="System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute" />-->
        <!--<OpenCoverIgnoreAttributes Include="System.Runtime.CompilerServices.CompilerGeneratedAttribute" />-->
    </ItemGroup>
    <ItemGroup Condition=" '$(ShouldLoadOpenCoverFilters)' == 'true' ">
        <!--
            The ItemGroup items that define the filters used by OpenCover.
            NOTE: Use the hexadecimal value for * (%2A) to avoid MsBuild trying to make sense out of the text.
        -->
        <!--<OpenCoverFilters Include="+[$(ProductNamespace)]%2A" />-->
        <!--<OpenCoverFilters Include="+[$(ProductNamespace).%2A]%2A" />-->
        <!--<OpenCoverFilters Include="-[%2A$(UnitTestAssemblyNamePrefix)%2A]%2A" />-->
        <!--<OpenCoverFilters Include="-[NUnit]%2A" />-->
        <!--<OpenCoverFilters Include="-[NUnit.%2A]%2A" />-->
    </ItemGroup>


    <!--
        **** SOURCE ANALYSIS - XML ****
    -->
    <ItemGroup Condition=" '$(ShouldLoadXmlFilesToValidate)' == 'true' ">
        <!--
            The paths to the XML files that should be validated against the given schema.
        -->
        <!--
        <XmlFilesToValidate
            Condition=" '$(DirSrc)' != '' "
            Exclude="$(DirSrc)\**\ignore.xml"
            Include="$(DirSrc)\**\*.xml">
            <SchemaFile></SchemaFile>
            <TargetNamespace></TargetNamespace>
        </XmlFilesToValidate>
        -->
    </ItemGroup>


    <!--
        **** BINARY ANALYSIS - FXCOP ****
    -->
    <PropertyGroup>
        <!--
            The full path to the FxCop project file.
        -->
        <!--<FileProjectFxCop>UNDEFINED</FileProjectFxCop>-->
        <!--
            The full path to the FxCop output report. Allows build templates, e.g. $(DirBuildLogs)\${ProductName}_fxcop.xml.
        -->
        <!--<FileReportFxCop>$(DirBuildLogs)\fxcop.xml</FileReportFxCop>-->
        <!--
            The full path to the XML file that contains the custom dictionary for FxCop.
        -->
        <!--<FxCopCustomDictionary>$(DirWorkspace)\customdictionary.xml</FxCopCustomDictionary>-->
        <!--
            The culture that FxCop should use for the spelling rules.
        -->
        <!--<FxCopCulture>$(CodeAnalysisCulture)</FxCopCulture>-->
        <!--
            A flag that indicates whether any fxcop analysis errors should be marked as errors or as warnings. If FxCop analysis
            errors are marked as errors then any analysis error will stop the build.
        -->
        <!--<FxCopWarningsAsErrors>true</FxCopWarningsAsErrors>-->
    </PropertyGroup>
    <ItemGroup Condition=" '$(ShouldLoadFxCopFiles)' == 'true' ">
        <!--
            The locations of the files that should be analyzed by FxCop.
        -->
        <!--
        <FxCopFiles Include="$(DirSrc)\**\bin\$(Configuration)\**\$(ProductNamespace).dll"
                    Exclude="$(DirSrc)\**\bin\**\Test.*.dll">
            <TargetFramework>4.0</TargetFramework>
        </FxCopFiles>
        -->
    </ItemGroup>
    <ItemGroup Condition=" '$(ShouldLoadFxCopReferenceFiles)' == 'true' ">
        <!--
            The locations of the assemblies (not including the .NET framework assemblies) which FxCop should
            use as reference assemblies.
        -->
        <!--
        <FxCopReferenceFiles Include=""
                             Exclude="" />
        -->
    </ItemGroup>
    <ItemGroup Condition=" '$(ShouldLoadFxCopReferenceDirectories)' == 'true' ">
        <!--
            The directory locations that contain the assemblies (not including the .NET framework assemblies) which
            FxCop should use as reference assemblies
        -->
        <!--
        <FxCopReferenceDirectories Include=""
                                   Exclude="" />
        -->
    </ItemGroup>


    <!--
        **** PACK - NUGET ****
    -->
    <PropertyGroup>
        <!--
            Defines how the version range for a dependency is generated in a NuGet package. Options are:

                None   - The version range of the dependency is simply the version, e.g. 1.2.3
                Major  - The version range of the dependency is from the current version up to, but not including, the next major version,
                         e.g [1.2.3, 2)
                Minor  - The version range of the dependency is from the current version up to, but not including, the next minor version,
                         e.g [1.2.3, 1.3)
                Patch  - The version range of the dependency is from the current version up to, but not including, the next patch version,
                         e.g [1.2.3, 1.2.4)
        -->
        <!-- <NuGetDependencyVersionRangeStrategy>Major</NuGetDependencyVersionRangeStrategy> -->
    </PropertyGroup>

    <!--
        The item group defining the (partial) names of the NuGet packages that only contain design time element and should
        thus not be considered dependencies for the generated NuGet packages, even if they are included in the list
        of dependencies that should be included.

        By default nBuildkit and nUnit are ignored.
    -->
    <ItemGroup Condition=" '$(ShouldLoadDesignTimeDependencies)' == 'true' ">
        <DesignTimeDependencies Include="nBuildKit" />
        <DesignTimeDependencies Include="StyleCop.Analyzers" />
    </ItemGroup>


    <!--
        **** BUILD STEPS ****
    -->
    <PropertyGroup>
        <!-- Indicate if an error in the pre-step actions should fail the build -->
        <!-- <FailBuildOnPreStepFailure>false</FailBuildOnPreStepFailure> -->

        <!-- Indicate if an error in the post-step actions should fail the build -->
        <!-- <FailBuildOnPostStepFailure>false</FailBuildOnPostStepFailure> -->

        <!-- Indicate if an error in the pre-step actions should immediately stop the build -->
        <!-- <StopBuildOnPreStepFailure>false</StopBuildOnPreStepFailure> -->

        <!-- Indicate if an error in the post-step actions should immediately stop the build -->
        <!-- <StopBuildOnPostStepFailure>false</StopBuildOnPostStepFailure> -->
    </PropertyGroup>

    <!--
         A list of all additional scripts and their targets that should be executed before each of the selected build steps. Globally defined
         pre-steps will be executed prior to the presteps of the individual steps.

        The metadata to the script that is about to be executed is passed to each pre-step under the following properties:

        - StepDescription : The full description of the step to be executed.
        - StepId          : The ID of the step. In general the name of the property that references the step file.
        - StepName        : The name of the step.
        - StepPath        : The full path to the script file for the step.

        Additionally all the standard properties as seen below and the properties for the given build step are passed in.
    -->
    <ItemGroup Condition=" '$(ShouldLoadBuildPreStepsToExecute)' == 'true' ">
        <!--
        <BuildPreStepsToExecute Include="">
            <Properties>
            </Properties>
        </BuildPreStepsToExecute>
        -->
    </ItemGroup>

    <!--
        A list of all additional scripts and their targets that should be executed after each of the selected build steps. Globally defined
         post-steps will be executed after the poststeps of the individual steps.

        The metadata to the script that is about to be executed is passed to each pre-step under the following properties:

        - StepDescription : The full description of the step to be executed.
        - StepId          : The ID of the step. In general the name of the property that references the step file.
        - StepName        : The name of the step.
        - StepPath        : The full path to the script file for the step.

        Additionally all the standard properties as seen below and the properties for the given build step are passed in.
    -->
    <ItemGroup Condition=" '$(ShouldLoadBuildPostStepsToExecute)' == 'true' ">
        <!--
        <BuildPostStepsToExecute Include="">
            <Properties>
            </Properties>
        </BuildPostStepsToExecute>
        -->
    </ItemGroup>

    <!--
        The following ItemGroup defines which steps are taken during the build process. The order of the items in the item group
        determines in which order the build steps are executed.

        Each build step can define the following items:
        - Properties                                     - The semi-colon separated set of properties that should be passed to the script.
                                                           Properties are written as 'key=value'.
        - Groups                                         - All the groups that a given step belongs to. The user can elect to only run build steps for a given group.
        - PreSteps                                       - A semi-colon separated list of all additional scripts and their targets that should be executed before
                                                           the selected build step.
        - PostSteps                                      - A semi-colon separated list of all additional scripts and their targets that should be executed after
                                                           the selected build step.

        The metadata to the script that is about to be executed is passed to each pre-step under the following properties:

        - StepDescription : The full description of the step to be executed.
        - StepId          : The ID of the step. In general the name of the property that references the step file.
        - StepName        : The name of the step.
        - StepPath        : The full path to the script file for the step.

        Additional build steps can be defined by providing the path to the MsBuild script that should be executed
        for that step, e.g. adding a build step that points to the 'c:\stuff\MyCoolScript.msbuild' will execute
        that script.

        Any properties defined by the 'Properties' section are pushed up.

        Custom build steps may chose to add metadata to the 'AvailableStepMetadata' ItemGroup. This ItemGroup contains metadata describing
        all known steps.
    -->
    <ItemGroup Condition=" '$(ShouldLoadBuildStepsToExecute)' == 'true' ">
        <BuildStepsToExecute Include="$(BuildStepsPrepareWorkspace)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                clean;
                prepare;
                prepare.clean;
            </Groups>
            <Id>BuildStepsPrepareWorkspace</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <!--
        <BuildStepsToExecute Include="$(BuildStepsBuildTargetsAssembly)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.bootstrap;
            </Groups>
            <Id>BuildStepsBuildTargetsAssembly</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <BuildStepsToExecute Include="$(BuildStepsGenerateTargetsFile)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.bootstrap;
            </Groups>
            <Id>BuildStepsGenerateTargetsFile</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        -->

        <BuildStepsToExecute Include="$(BuildStepsPrepareRestoreNuGet)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.restore;
                prepare.restore.nuget;
            </Groups>
            <Id>BuildStepsPrepareRestoreNuGet</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <!--
            The following steps need to be executed on the original branch (i.e. the branch we are interested in
            building.
        -->
        <BuildStepsToExecute Include="$(BuildStepsPrepareVcsBranch)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.buildserver;
                prepare.buildserver.vcssetbranch;
                prepare.vcs;
                prepare.vcs.vcssetbranch;
            </Groups>
            <Id>BuildStepsPrepareVcsBranch</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsPrepareVcsInfo)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.get;
                prepare.get.vcsinfo;
            </Groups>
            <Id>BuildStepsPrepareVcsInfo</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsPrepareGetIssueIds)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.get;
                prepare.get.issueids;
            </Groups>
            <Id>BuildStepsPrepareGetIssueIds</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <!--
            This step potentially changes the local branch we are building. If one or more merge targets have been
            specified then this step will merge to all merge targets and leave the current branch as the last branch
            we merged to.
        -->
        <BuildStepsToExecute Include="$(BuildStepsPrepareVcsMerge)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.buildserver;
                prepare.buildserver.merge;
                prepare.vcs;
                prepare.vcs.merge;
            </Groups>
            <Id>BuildStepsPrepareVcsMerge</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <!--
            All steps from here on may be executed on a different branch than the orginal branch we we started the
            build on because we might have done some merging.
        -->
        <BuildStepsToExecute Include="$(BuildStepsPrepareGetVersion)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.get;
                prepare.get.version;
            </Groups>
            <Id>BuildStepsPrepareGetVersion</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute
            Condition=" '$(IsGitFlow)' == 'true' AND ('$(IsReleaseBranch)' == 'true' OR '$(IsHotfixBranch)' == 'true') "
            Include="$(BuildStepsPrepareTagVcs)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.buildserver;
                prepare.buildserver.tag;
                prepare.vcs;
                prepare.vcs.tag;
            </Groups>
            <Id>BuildStepsPrepareTagVcs</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <BuildStepsToExecute Include="$(BuildStepsPrepareReleaseNotes)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.get;
                prepare.get.releasenotes;
            </Groups>
            <Id>BuildStepsPrepareReleaseNotes</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <!--
        <BuildStepsToExecute Include="$(BuildStepsPrepareRestoreNpm)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.restore;
                prepare.restore.npm;
            </Groups>
            <Id>BuildStepsPrepareRestoreNpm</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsPrepareRestoreBower)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.restore;
                prepare.restore.bower;
            </Groups>
            <Id>BuildStepsPrepareRestoreBower</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        -->

        <BuildStepsToExecute Include="$(BuildStepsPrepareCopyNuGet)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.copy;
                prepare.copy.nuget;
            </Groups>
            <Id>BuildStepsPrepareCopyNuGet</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsPrepareCopyHttp)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.copy;
                prepare.copy.url;
            </Groups>
            <Id>BuildStepsPrepareCopyHttp</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsPrepareCopyFiles)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.copy;
                prepare.copy.files;
            </Groups>
            <Id>BuildStepsPrepareCopyFiles</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsPrepareCopyArchive)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.copy;
                prepare.copy.archive;
            </Groups>
            <Id>BuildStepsPrepareCopyArchive</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <BuildStepsToExecute Include="$(BuildStepsPrepareUpdateProjectInfo)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.generate;
                prepare.generate.assemblyinfo;
            </Groups>
            <Id>build.help</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <!--
        <BuildStepsToExecute Include="$(BuildStepsPrepareGenerateLicenses)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.generate;
                prepare.generate.licenses;
            </Groups>
            <Id>BuildStepsPrepareGenerateLicenses</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        -->
        <BuildStepsToExecute Include="$(BuildStepsPrepareGenerateFiles)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                prepare;
                prepare.generate;
                prepare.generate.files;
            </Groups>
            <Id>BuildStepsPrepareGenerateFiles</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <BuildStepsToExecute Include="$(BuildStepsBuildVisualStudioSolution)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                build;
                build.visualstudio;
            </Groups>
            <Id>BuildStepsBuildVisualStudioSolution</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <BuildStepsToExecute Include="$(BuildStepsUnitTestNUnit)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                test;
                test.unittest;
                test.unittest.nunit;
            </Groups>
            <Id>BuildStepsUnitTestNUnit</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
                Configuration=$(TestConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        <!--
        <BuildStepsToExecute Include="$(BuildStepsUnitTestMsTest)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                test;
                test.unittest;
                test.unittest.mstest;
            </Groups>
            <Id>BuildStepsUnitTestMsTest</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
                Configuration=$(TestConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsUnitTestVsTest)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                test;
                test.unittest;
                test.unittest.vstest;
            </Groups>
            <Id>BuildStepsUnitTestVsTest</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
                Configuration=$(TestConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        -->

        <!--
        <BuildStepsToExecute Include="$(BuildStepsAnalyzeXml)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                test;
                test.analyze;
                test.analyze.xml;
            </Groups>
            <Id>BuildStepsAnalyzeXml</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
                Configuration=$(TestConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        -->

        <!--
        <BuildStepsToExecute Include="$(BuildStepsAnalyzeBinariesFxCop)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                test;
                test.analyze;
                test.analyze.fxcop;
            </Groups>
            <Id>BuildStepsAnalyzeBinariesFxCop</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
                Configuration=$(TestConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        -->

        <!--
        <BuildStepsToExecute Include="$(BuildStepsBuildILMerge)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                build;
                build.ilmerge;
            </Groups>
            <Id>BuildStepsBuildILMerge</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        -->

        <!--
        <BuildStepsToExecute Include="$(BuildStepsBuildWyam)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                build;
                build.doc;
                build.doc.wyam;
            </Groups>
            <Id>BuildStepsBuildWyam</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        -->

        <BuildStepsToExecute Include="$(BuildStepsPackNuGet)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                package;
                package.nuget;
            </Groups>
            <Id>BuildStepsPackNuGet</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsPackZip)">
            <ExecuteAfter></ExecuteAfter>
            <ExecuteBefore></ExecuteBefore>
            <Groups>
                package;
                package.zip;
            </Groups>
            <Id>BuildStepsPackZip</Id>
            <PostSteps>
            </PostSteps>
            <PreSteps>
            </PreSteps>
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
    </ItemGroup>

    <!--
        Define the scripts that should be executed when any one of the build steps fails.

        Steps can be defined by providing the path to the MsBuild script that should be executed
        for that step, e.g. adding a build step that points to the 'c:\stuff\MyCoolScript.msbuild' will execute
        that script.

        Any properties defined by the 'Properties' section are pushed up.
    -->
    <ItemGroup Condition=" '$(ShouldLoadBuildFailureStepsToExecute)' == 'true' ">
        <!--
        <BuildFailureStepsToExecute Include="">
            <Properties>
            </Properties>
            <Groups>
            </Groups>
        </BuildFailureStepsToExecute>
        -->
    </ItemGroup>

    <!--
        The following item group stores metadata describing the custom build steps that are executed in the build process.
        By providing this metadata it is possible for pre- and post-step actions to more clearly determine which step
        they were attached to.
    -->
    <ItemGroup Condition=" '$(ShouldLoadAvailableStepMetadata)' == 'true' ">
        <!--
        <AvailableStepMetadata Include="$([System.IO.Path]::GetFileName('$(DirWorkspace)\my.build.step.msbuild'))">
            <Description>
                The description for my cool build step
            </Description>
            <Id></Id>
            <Name>My build step</Name>
            <Path>$(DirWorkspace)\my.build.step.msbuild</Path>
        </AvailableStepMetadata>
        -->
    </ItemGroup>





    <!--
        *************************************
        *                                   *
        *     SHARED TOOLS                  *
        *                                   *
        *************************************
    -->

    <!-- Overrides for the tools paths -->
    <PropertyGroup>
    </PropertyGroup>





    <!--
        *****************************************
        *                                       *
        *     NBUILDKIT SPECIFIC SETTINGS       *
        *                                       *
        *****************************************
    -->

    <PropertyGroup>
        <!-- Defines whether the current script file has been loaded / imported or not -->
        <ExistsBuildSettings>true</ExistsBuildSettings>

        <!-- Defines the version number of the configuration file -->
        <NBuildKitConfigurationVersion>1.1</NBuildKitConfigurationVersion>
    </PropertyGroup>
</Project>