settings.props

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0"
         DefaultTargets="Run"
         xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <!--
        Certain properties and items in this settings file allow replacement of the following templates:
        ${VersionMajor}           - The major version number
        ${VersionMinor}           - The minor version number
        ${VersionPatch}           - The patch version number
        ${VersionBuild}           - The build number of the version
        ${VersionPreRelease}      - The pre-release code, e.g. 'unstable'
        ${VersionSemantic}        - The semantic version, e.g. 1.2.3
        ${VersionSemanticFull}    - The full semantic version, e.g. 1.2.3-unstable.1+001
        ${VersionSEmanticNuGet}   - The full semantic version as used by nuget, e.g. 1.2.3-unstable0001

        ${Configuration}          - The configuration, e.g. Release
        ${Platform}               - The platform name, e.g. Any CPU
        ${PlatformWithoutSpaces}  - The platform name without spaces in it, e.g. AnyCPU

        ${VcsRevision}            - The current VCS revision 'number'
        ${VcsBranch}              - The name of the current VCS branch

        ${ReleaseNotesShort}      - The contents of the short release notes
        ${ReleaseNotesFull}       - The contents of the full release notes

        ${Now}                    - The current date and time in round trip format, e.g. 2015-05-15T19:31:45.1234567+12:00
        ${Date}                   - The current date in the format year-month-dayofmonth, e.g. 2015-05-15
        ${DayOfMonth}             - The current day of the month, e.g. 15
        ${Month}                  - The current month, e.g. 05
        ${Year}                   - The current year, e.g. 2015

        ${ProductName}            - The name of the product
        ${ProductNameInFilePath}  - The product name written in a way that it can be used in the file path
        ${ProductDescription}     - The (short) description of the product
        ${ProductNamespace}       - The namespace in which all the code for the product is placed
        ${ProductStartingYear}    - The year the current product was created / released.

        ${CompanyName}            - The name of the company
        ${CompanyNameInFilePath}  - The name of the company written in a way that it can be used in the file path
        ${CompanyUrl}             - The URL of the company website

        ${CopyrightShort}         - The short form of the copyright
        ${CopyrightLong}          - The long form of the copyright

        ${FileReleaseNotesShort}  - The file containing the short release notes
        ${FileReleaseNotesFull}   - The file containing the full release notes

        ${DirWorkspace}           - The full path to the directory that contains forms the base of the workspace for the project, e.g. c:\myproject
        ${DirBin}                 - The full path to the directory that contains the binaries, e.g. c:\myproject\build\bin\anycpu\release
        ${DirDeploy}              - The full path to the directory that contains the artifacts, e.g. c:\myproject\build\deploy
        ${DirLogs}                - The full path to the directory that contain the build logs, e.g. c:\myproject\build\logs
        ${DirSrc}                 - The full path to the directory that contains the source files, e.g. c:\myproject\src
        ${DirTemp}                - The full path to the directory that contains the temporary build files, e.g c:\myproject\build\temp

        ${DirNBuildKit}           - The full path to the directory that contains the nBuildKit scripts, e.g. c:\myproject\packages\nbuildkit.msbuild.0.1.0\build
        ${DirNBuildKitExtensions} - The full path to the directory that contains the nBuildKit extension scripts, e.g. c:\myproject\packages\nbuildkit.msbuild.0.1.0\build\extensions
        ${DirNBuildKitTemplates}  - The full path to the directory that contains the nBuildKit template files, e.g. c:\myproject\packages\nbuildkit.msbuild.0.1.0\build\templates

        ${VersionNBuildKit}       - The semantic version of nBuildKit that was used for the current build


        Special template parameters exists for additional version numbers. These are defined in the TemplateVersion ItemGroup
        as defined below.
    -->
    <!-- Overrides for the project specific properties -->
    <PropertyGroup>
        <!--
            The name of the product. This is for instance used for:
            * Copyrights
            * API documentation
        -->
        <ProductName Condition=" '$(ProductName)' == '' ">Ops.Resource.Core</ProductName>

        <!--
            The name of the product that can be used as part of a file path. This is for instance used for:
            * CCM
            * SourceMonitor
            * Deployment directory naming
        -->
        <ProductNameInFilePath Condition=" '$(ProductNameInFilePath)' == '' ">OpsResourceCore</ProductNameInFilePath>

        <!--
            The description of the product. This is for instance used for:
            * Installer information
        -->
        <ProductDescription>
            The NuGet packages that contain the core initialization scripts for resources.
        </ProductDescription>

        <!--
            The namespace in which all the code for the product is placed. This is for instance used for:
            * Finding the correct assemblies and namespaces for unit testing and coverage reporting
            * Generated code files that contain namespaces
        -->
        <ProductNamespace Condition=" '$(ProductNamespace)' == '' ">Ops.Resource.Core</ProductNamespace>

        <!--
            The first year the product was available / created. This is for instance used for:
            * Copyrights
        -->
        <ProductStartingYear Condition=" '$(ProductStartingYear)' == '' ">2015</ProductStartingYear>

        <!--
            The name of the company. This is for instance used for:
            * Copyrights
            * API documentation
        -->
        <CompanyName Condition=" '$(CompanyName)' == '' ">P van der Velde</CompanyName>

        <!--
            The name of the company that can be used as a part of a file path. This is for instance used for:
            * Installer file paths
        -->
        <CompanyNameInFilePath Condition=" '$(CompanyNameInFilePath)' == '' ">pvandervelde</CompanyNameInFilePath>

        <!--
            The URL of the company website. This is for instance used for:
            * nuspec files
        -->
        <CompanyUrl Condition=" '$(CompanyUrl)' == '' ">https://github.com/$(GitHubUserName)/ops-resource-core</CompanyUrl>

        <!--
            The email address that is specified in the documentation. This is for instance used for:
            * API documentation
        -->
        <EmailDocumentation Condition=" '$(EmailDocumentation)' == '' ">UNDEFINED</EmailDocumentation>

        <!--
            The short form of the  copyright text. This is for instance used for:
            * Documentation copyrights
            * Generated file copyrights
        -->
        <CopyrightShort>Copyright (c) - $(CompanyName). All rights reserved.</CopyrightShort>

        <!--
            The long form of the  copyright text. This is for instance used for:
            * Assembly copyrights
        -->
        <CopyrightLong>Copyright (c) - $(CompanyName) $(ProductStartingYear) - $([System.DateTime]::Now.ToString("yyyy")). All rights reserved.</CopyrightLong>
    </PropertyGroup>

    <!--
        Overrides for the VCS specific properties
    -->
    <PropertyGroup>
        <!-- The user name of the user who owns the repository on GitHub -->
        <GitHubUserName Condition=" '$(GitHubUserName)' == '' ">pvandervelde</GitHubUserName>

        <!--
            The github repository that contains the source code for the current product. Used when getting the release notes
            from the github issues. The correct format is <USERNAME>/<REPOSITORYNAME>
        -->
        <GitHubRepositoryName Condition=" '$(GitHubRepositoryName)' == '' ">$(GitHubUserName)\ops-resource-core</GitHubRepositoryName>

        <!--
            The full URL to the GIT repository. Can include the '%GitHubToken%' environment variable for authenticated
            connection to the repository, e.g. https://%GitHubToken%:@github.com/MyUser/MyProject.git
        -->
        <GitRemoteRepository Condition=" '$(GitRemoteRepository)' == '' ">https://%GitHubToken%:@github.com/$(GitHubUserName)/ops-resource-core.git</GitRemoteRepository>

        <!--
            A flag indicating whether or not the workspace is a GIT workspace or not. If no value is provided then
            any workspace that contains a .git folder will be assumed to be a GIT workspace.
        -->
        <IsGitWorkspace Condition=" '$(IsGitWorkspace)' == '' AND !Exists('$(DirWorkspace)\.git')">false</IsGitWorkspace>
        <IsGitWorkspace Condition=" '$(IsGitWorkspace)' == '' AND Exists('$(DirWorkspace)\.git')">true</IsGitWorkspace>

        <!--
            A flag that indicates whether or not the workspace is a TFS workspace. Defaults to false.
        -->
        <IsTfsWorkspace Condition=" '$(IsTfsWorkspace)' == '' ">false</IsTfsWorkspace>
    </PropertyGroup>

    <!--
        Defines the custom version numbers that should be available for template replacement.
        The template consists of a name and a version number string. The name will be used as the
        name of the template, i.e. 'VersionAssembly' will be available in the collection of template
        parameters available for replacement.

        Each version number may consist of zero or more template parameters. Template parameters
        must be enclosed in '${}', e.g. ${VersionMajor} will be replaced by the major version number
        as indicated at the top of the file.

        Note that custom version number templates may not reference other custom version number templates.
    -->
    <ItemGroup>
        <!--
            The template for the version number that will be used in the 'AssemblyVersionAttribute' in the
            'AssemblyInfo.VersionNumber.xx' file which can be generated if the 'ShouldGenerateAssemblyVersionInfo'
            property is set to 'true'
        -->
        <TemplateVersion Include="VersionAssembly">
            <Template>${VersionMajor}.${VersionMinor}.0.0</Template>
        </TemplateVersion>
        <!--
            The template for the version number that will be used in the 'AssemblyFileVersionAttribute' in the
            'AssemblyInfo.VersionNumber.xx' file which can be generated if the 'ShouldGenerateAssemblyVersionInfo'
            property is set to 'true'
        -->
        <TemplateVersion Include="VersionAssemblyFile">
            <Template>${VersionMajor}.${VersionMinor}.${VersionPatch}.${VersionBuild}</Template>
        </TemplateVersion>
        <!--
            The template for the version number that will be used in the 'AssemblyInformationalVersionAttribute' in the
            'AssemblyInfo.VersionNumber.xx' file which can be generated if the 'ShouldGenerateAssemblyVersionInfo'
            property is set to 'true'

            Also used as the 'ApplicationVersion' in the 'VersionNumber.wxi' file.
        -->
        <TemplateVersion Include="VersionProduct">
            <Template>${VersionSemanticFull}</Template>
        </TemplateVersion>
        <!--
            The template for the version number that will be used as the 'InstallVersion' in the
            'VersionNumber.wxi' file which can be generated if the 'ShouldGenerateAssemblyVersionInfo'
            property is set to 'true'
        -->
        <TemplateVersion Include="VersionInstall">
            <Template>${VersionMajor}.${VersionMinor}.${VersionPatch}</Template>
        </TemplateVersion>
        <!--
            The template for the version number that will be used as the 'ProductVersionFolder' in the
            'VersionNumber.wxi' file which can be generated if the 'ShouldGenerateAssemblyVersionInfo'
            property is set to 'true'
        -->
        <TemplateVersion Include="VersionInstallFilePath">
            <Template>${VersionMajor}.${VersionMinor}</Template>
        </TemplateVersion>
    </ItemGroup>

    <!--
        Directories
    -->
    <PropertyGroup>
        <!--
            NOTE: The 'DirWorkspace' property is always set prior to loading the current file. The variable is set
            to the directory which contains the current file.
        -->

        <!-- The directory that will contain all the files generated during the build process -->
        <DirBuild Condition=" '$(DirBuild)' == '' ">$(DirWorkspace)\build</DirBuild>

        <!--
            The directory that will contain all the binaries generated during the build process.
            Note that there may be configuration and platform specific sub-directories.
        -->
        <DirBuildBin Condition=" '$(DirBuildBin)' == '' ">$(DirBuild)\bin</DirBuildBin>

        <!--
            The directory where the current binaries are placed after being generated.
            Note that $(Platform) and $(Configuration) do not have to be defined in this settings file. They may be provided
            externally as long as they are provided before the settings file is loaded!
        -->
        <DirBuildBinPlatformConfig Condition=" '$(DirBuildBinPlatformConfig)' == '' ">$([System.IO.Path]::GetFullPath('$(DirBuildBin)\$(PlatformWithoutSpaces)\$(Configuration)\'))</DirBuildBinPlatformConfig>

        <!-- The directory that will contain all the generated artifacts during the build process -->
        <DirBuildDeploy Condition=" '$(DirBuildDeploy)' == '' ">$(DirBuild)\deploy</DirBuildDeploy>

        <!-- The directory that will contain all the documentation files which are generated during the build process -->
        <DirBuildDoc Condition=" '$(DirBuildDoc)' == '' ">$(DirBuildDeploy)\doc</DirBuildDoc>

        <!-- The directory that will contain all the generated build logs during the build process -->
        <DirBuildLogs Condition=" '$(DirBuildLogs)' == '' ">$(DirBuild)\logs</DirBuildLogs>

        <!-- The directory that will contain the reports generated by OpenCover and ReportGenerator describing the coverage of the unit tests. -->
        <DirReportGeneratorOutput Condition=" '$(DirReportGeneratorOutput)' == '' ">$(DirBuildLogs)\coverage</DirReportGeneratorOutput>

        <!-- The directory that contains the report files generated by MoMA -->
        <DirReportMoma Condition=" '$(DirReportMoma)' == '' ">$(DirBuildLogs)\moma</DirReportMoma>

        <!-- The directory that will contain all the temporary files needed during the build process -->
        <DirBuildTemp Condition=" '$(DirBuildTemp)' == '' ">$(DirBuild)\temp</DirBuildTemp>
        <DirBuildTempCore>$(DirBuildTemp)\core</DirBuildTempCore>
        <DirBuildTempCoreScripts>$(DirBuildTempCore)\scripts</DirBuildTempCoreScripts>
        <DirBuildTempCoreTemplates>$(DirBuildTempCore)\templates</DirBuildTempCoreTemplates>
        <DirBuildTempCoreCookbooks>$(DirBuildTempCore)\cookbooks</DirBuildTempCoreCookbooks>
        <DirBuildTempCoreCookbooksResourceCoreMeta>$(DirBuildTempCoreCookbooks)\ops_resource_core_meta</DirBuildTempCoreCookbooksResourceCoreMeta>
        <DirBuildTempCoreCookbooksResourceCoreConsul>$(DirBuildTempCoreCookbooks)\ops_resource_core_consul</DirBuildTempCoreCookbooksResourceCoreConsul>
        <DirBuildTempCoreCookbooksResourceCoreProvisioning>$(DirBuildTempCoreCookbooks)\ops_resource_core_provisioning</DirBuildTempCoreCookbooksResourceCoreProvisioning>
        <DirBuildTempCoreTests>$(DirBuildTempCore)\tests</DirBuildTempCoreTests>
        <DirBuildTempCoreTools>$(DirBuildTempCore)\tools</DirBuildTempCoreTools>
        <DirBuildTempCoreToolsPester>$(DirBuildTempCoreTools)\pester</DirBuildTempCoreToolsPester>

        <!-- The directory that will contain all the test files generated during the test process -->
        <DirBuildTest Condition=" '$(DirBuildTest)' == '' ">$(DirBuild)\tests</DirBuildTest>

        <!-- The directory that contains the Chef cookbooks -->
        <DirCookbooks Condition=" '$(DirCookbooks)' == '' ">$(DirWorkspace)\cookbooks</DirCookbooks>
        <DirCookbooksResourceCoreMeta>$(DirCookbooks)\ops_resource_core_meta</DirCookbooksResourceCoreMeta>
        <DirCookbooksResourceCoreConsul>$(DirCookbooks)\ops_resource_core_consul</DirCookbooksResourceCoreConsul>
        <DirCookbooksResourceCoreProvisioning>$(DirCookbooks)\ops_resource_core_provisioning</DirCookbooksResourceCoreProvisioning>

        <!-- The directory that contains all the NuGet packages for the project -->
        <DirPackages Condition=" '$(DirPackages)' == '' ">$(DirWorkspace)\packages</DirPackages>

        <!-- The directory that contains all the scripts for the project -->
        <DirScripts Condition=" '$(DirScripts)' == '' ">$(DirWorkspace)\scripts</DirScripts>

        <!-- The directory that contains the source files for the project -->
        <DirSrc Condition=" '$(DirSrc)' == '' ">$(DirWorkspace)\src</DirSrc>

        <!-- The directory that contains the template files for the project -->
        <DirTemplates Condition=" '$(DirTemplates)' == '' ">$(DirWorkspace)\templates</DirTemplates>
        <DirTemplatesHost Condition=" '$(DirTemplatesHost)' == '' ">$(DirTemplates)\host</DirTemplatesHost>
        <DirTemplatesHostLAN Condition=" '$(DirTemplatesHostLAN)' == '' ">$(DirTemplatesHost)\lan</DirTemplatesHostLAN>
        <DirTemplatesHostLANWindows Condition=" '$(DirTemplatesHostLANWindows)' == '' ">$(DirTemplatesHostLAN)\windows</DirTemplatesHostLANWindows>

        <!-- The directory that contains all the test files for the project -->
        <DirTest Condition=" '$(DirTest)' == '' ">$(DirWorkspace)\tests</DirTest>
    </PropertyGroup>


    <!--
        **** PREPARE - VERSIONING ****
    -->
    <PropertyGroup>
        <!--
            The full path to the file that contains the current version of the project in MsBuild format.  The file is expected
            to have the following structure:

            <?xml version="1.0" encoding="utf-8"?>
            <Project ToolsVersion="3.5"
                     DefaultTargets="Build"
                     xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
                <PropertyGroup>
                    <BuildNumber>$(BUILD_NUMBER)</BuildNumber>
                    <BuildNumber Condition=" '$(BuildNumber)' == '' ">0</BuildNumber>

                    <VersionMajor>1</VersionMajor>
                    <VersionMinor>2</VersionMinor>
                    <VersionPatch>3</VersionPatch>
                    <VersionBuild>$(BuildNumber)</VersionBuild>
                    <VersionPreRelease></VersionPreRelease>
                </PropertyGroup>
            </Project>
        -->
        <FileVersionMsBuild Condition=" '$(FileVersionMsBuild)' == '' ">$(DirWorkspace)\version.xml</FileVersionMsBuild>

        <!--
            The full path to the file that is used to store the version information during the build.
        -->
        <FileSemanticVersion Condition=" '$(FileSemanticVersion)' == '' ">$(DirBuildTemp)\semantic_version.json</FileSemanticVersion>

        <!--
            When using GitVersion with a git repository that needs authentication the following properties
            have to be defined on via an environment variable (either local to the process that executes the build,
            or global to the user):
              GitPassword - The user token that provides access to GitHub

            The following properties can be defined on the command line or via the current script:
              GitUserName - The user name of the user who owns the Git repository

            Note that if no authentication is required, e.g. the repository allows anonymous access or
            the authentication is done through the user account, i.e. via Active Directory, then
            the user name should be left empty.
        -->
        <GitUserName Condition=" '$(GitUserName)' == '' "></GitUserName>

        <!--
            The full directory path to the script that handles custom generation of the version numbers.

            The script is expected be a custom implementation of the CalculateCustomVersion.msbuild script.
            The script file can be called anything as long as it contains an inline task
            called CalculateCustomVersion that takes no parameters and returns the version number parts as follows:
                VersionMajor         - The major component of the version number, e.g. 1.
                VersionMinor         - The minor component of the version number, e.g. 2.
                VersionPatch         - The patch component of the version number, e.g. 3.
                VersionBuild         - The build component of the version number, e.g. 4.
                VersionPreRelease    - The pre-release section of the version number, e.g. 'unstable'
                VersionSemantic      - The short semantic version, normally made up of
                                       <MAJOR>.<MINOR>.<PATCH>, e.g. 1.2.3
                VersionSemanticFull  - The full semantic version, normally made up of
                                       <MAJOR>.<MINOR>.<PATCH>-<METADATA>+<BUILD>, e.g. 1.2.3-unstable+4
                VersionSemanticNuget - The NuGet compatible semantic version, normally made up of
                                       <MAJOR>.<MINOR>.<PATCH>-<PRERELEASE><BUILD>, e.g. 1.2.3-unstable4
        -->
        <VersionScriptPath Condition=" '$(VersionScriptPath)' == '' ">UNDEFINED</VersionScriptPath>
    </PropertyGroup>


    <!--
        **** PREPARE - RELEASE NOTES ****
    -->
    <PropertyGroup>
        <!-- The full path to the file that is used to store the release notes for the current release during the build. -->
        <FileReleaseNotesShort Condition=" '$(FileReleaseNotesShort)' == '' ">$(DirBuildTemp)\releasenotes_short.md</FileReleaseNotesShort>

        <!-- The full path to the file that is used to store the release notes for all the releases during the build. -->
        <FileReleaseNotesFull Condition=" '$(FileReleaseNotesFull)' == '' ">$(DirBuildTemp)\releasenotes_full.md</FileReleaseNotesFull>

        <!--
            The following properties have to be defined on via an environment variable (either local to the process that
            executes the build, or global to the user):
            - Always
              GitHubToken - The user token that provides access to GitHub

            - When using YouTrack
              IssueTrackerPassword - The password for the issue tracker user
        -->

        <!-- The user name of the user who owns the GitHub repository -->
        <GitHubUserName Condition=" '$(GitHubUserName)' == '' ">UNDEFINED</GitHubUserName>

        <!--- The URL of the YouTrack server, e.g. http://myuser.myjetbrains.com/youtrack -->
        <YouTrackServer Condition=" '$(YouTrackServer)' == '' ">UNDEFINED</YouTrackServer>

        <!-- The user name for YouTrack -->
        <IssueTrackerUserName Condition=" '$(IssueTrackerUserName)' == '' ">UNDEFINED</IssueTrackerUserName>

        <!-- The project ID that is used to identify the product in the issue tracker -->
        <IssueTrackerProjectId Condition=" '$(IssueTrackerProjectId)' == '' ">UNDEFINED</IssueTrackerProjectId>

        <!-- The filter for getting issues from YouTrack -->
        <IssueFilter Condition=" '$(IssueFilter)' == '' ">UNDEFINED</IssueFilter>
    </PropertyGroup>


    <!--
        **** PREPARE - VCS INFO ****
    -->
    <PropertyGroup>
        <!-- The full path to the file that contains the information about the current VCS workspace. -->
        <FileVcsInfo Condition=" '$(FileVcsInfo)' == '' ">$(DirBuildTemp)\vcs.info.json</FileVcsInfo>
    </PropertyGroup>


    <!--
        **** PREPARE - GENERATE FILES ****
    -->
    <!--
        Additional items that should be available for the template replacement.
        The default template parameters, as indicated at the top of this file, are always available.
    -->
    <ItemGroup>
        <TemplateTokens Include="DirOutput">
            <ReplacementValue>$(DirBuildTempCore)</ReplacementValue>
        </TemplateTokens>
    </ItemGroup>





    <!--
        *************************************
        *                                   *
        *     BUILD SETTINGS                *
        *                                   *
        *************************************
    -->

    <!-- Overrides for the global properties -->
    <PropertyGroup>
        <!-- A flag indicating whether or not to display debug log information, usually at the start of the script execution. -->
        <ShouldDisplayDebugLog Condition=" '$(ShouldDisplayDebugLog)' == '' ">true</ShouldDisplayDebugLog>

        <!--
            A flag that indicates whether or not the workspace should be cleaned before the build is started. If set to
            true then the 'DirBuild' directory will be removed as well as all known generated files.
        -->
        <ShouldClean Condition=" '$(ShouldClean)' == ''">true</ShouldClean>

        <!--
            Indicates that the execution of the build script runs through the steps but does not actually execute them.
        -->
        <ShouldExecute Condition=" '$(ShouldExecute)' == '' ">true</ShouldExecute>
    </PropertyGroup>

    <!-- Overrides for the build configuration -->
    <PropertyGroup>
        <!-- The build configuration (debug / release / ...) that will be used to run all the unit tests and the static verification on -->
        <TestConfiguration Condition=" '$(TestConfiguration)' == '' ">release</TestConfiguration>

        <!-- The build configuration (debug / release / ..) that will be used to create the binaries that should be deployed -->
        <ProductionConfiguration Condition=" '$(ProductionConfiguration)' == '' ">deploy</ProductionConfiguration>

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


    <!--
        **** BUILD STEPS ****
    -->
    <!--
        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.

        The following build steps are by default provided through the given properties:
        $(BuildStepsPrepareWorkspace)                    - Deletes the existing build artifacts and creates the required directories.
        $(BuildStepsPrepareRestoreNuGet)                 - Restores the NuGet packages for the project.
        $(BuildStepsPrepareGetVersion)                   - Gathers version information and stores it in a temporary file for use by the rest of the build process.
                                                           Currently supported methods of gathering version information are using (in order):
                                                           - The version defined by a custom MsBuild task which is defined in a file of which the path is stored
                                                             in the 'VersionScriptPath' property. The task should output:
                                                             - VersionMajor
                                                             - VersionMinor
                                                             - VersionPatch
                                                             - VersionBuild
                                                             - VersionPreRelease
                                                             - VersionSemantic
                                                             - VersionSemanticFull
                                                             - VersionSemanticNuget
                                                           - The version stored in an 'version.xml' file which contains an MsBuild property group with
                                                             the properties:
                                                             - BuildNumber
                                                             - VersionMajor
                                                             - VersionMinor
                                                             - VersionPatch
                                                             - VersionBuild
                                                             - VersionPreRelease
                                                           - The GitVersion tool (https://github.com/ParticularLabs/GitVersion)
                                                           - The GitHubFlowVersion tool (https://github.com/JakeGinnivan/GitHubFlowVersion)
        $(BuildStepsPrepareReleaseNotes)                 - Gathers the release notes and stores them for later use during the build process. Release notes
                                                           are retrieved with the GitReleaseNotes tool (https://github.com/GitTools/GitReleaseNotes) which
                                                           currently allows gathering release notes from GitHub, Jira and YouTrack
        $(BuildStepsPrepareVcsInfo)                      - Stores the Version Control System (VCS) information in a file for later use.
                                                           Currently supported version control systems is GIT
        $(BuildStepsPrepareGenerateFiles)                - Generates one or more files from a set of template files.
        $(BuildStepsAnalyzeSourceCcm)                    - Analyzes the source code files with CCM.
        $(BuildStepsAnalyzeSourceSouceMonitor)           - Analyzes the source code files with SourceMonitor.
        $(BuildStepsBuildVisualStudioSolution)           - Builds the binaries from a given Visual Studio solution.
        $(BuildStepsUnitTestNUnit)                       - Executes the unit tests with NUnit and measures code coverage with OpenCover.
        $(BuildStepsUnitTestMsTest)                      - Executes the unit tests with MsTest and measures code coverage with OpenCover.
        $(BuildStepsAnalyzeBinariesMoma)                 - Analyzes the binary files with Moma (Mono Migration Analyzer).
        $(BuildStepsAnalyzeBinariesFxCop)                - Analyzes the binary files with FxCop.
        $(BuildStepsBuildApiDocumentationWithSandcastle) - Builds the API documentation with SandCastle from the inline XML documentation comments.
        $(BuildStepsPackNuGet)                           - Generates the NuGet packages.
        $(BuildStepsPackZip)                             - Generates one or more ZIP archives.

        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.

        Each script has the following properties passed to it:
        $(BuildPropertyFile)                             - The full path to the settings.props file (i.e. this file).
        $(ShouldDisplayDebugLog)                         - A flag indicating whether or not to display debug log information, usually at the start of the script execution.
        $(NBuildKitVersion)                              - The full version of the nBuildKit library that is executing the build.
        $(DirNBuildKitMsBuild)                           - The full path to the directory that contains the nBuildKit scripts.
        $(DirNBuildKitMsBuildExtensions)                 - The full path to the directory that contains the nBuildKit extension scripts.
        $(DirNBuildKitMsBuildTemplates)                  - The full path to the directory that contains the nBuildKit templates.

        Additionally any properties defined by the 'Properties' section are also pushed up.
    -->
    <ItemGroup>
        <BuildStepsToExecute Include="$(BuildStepsPrepareWorkspace)">
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsPrepareRestoreNuGet)">
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsPrepareGetVersion)">
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <!--
        <BuildStepsToExecute Include="$(BuildStepsPrepareReleaseNotes)">
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        -->

        <BuildStepsToExecute Include="$(BuildStepsPrepareVcsInfo)">
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <!--
        <BuildStepsToExecute Include="$(BuildStepsPrepareGenerateFiles)">
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        -->
        <BuildStepsToExecute Include="$(DirWorkspace)\build.prepare.core.msbuild">
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <!--
        <BuildStepsToExecute Include="$(BuildStepsAnalyzeSourceCcm)">
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsAnalyzeSourceSouceMonitor)">
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        -->
        <BuildStepsToExecute Include="$(DirWorkspace)\analyze.rubocop.msbuild">
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(DirWorkspace)\analyze.foodcritic.msbuild">
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <!--
        <BuildStepsToExecute Include="$(BuildStepsBuildVisualStudioSolution)">
            <Properties>
            </Properties>
        </BuildStepsToExecute>

        <BuildStepsToExecute Include="$(BuildStepsUnitTestNUnit)">
            <Properties>
                Configuration=$(TestConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsUnitTestMsTest)">
            <Properties>
                Configuration=$(TestConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        -->

        <BuildStepsToExecute Include="$(DirWorkspace)\test.unit.chefspec.msbuild">
            <Properties>
                Configuration=$(TestConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>

        <!--
        <BuildStepsToExecute Include="$(BuildStepsAnalyzeBinariesMoma)">
            <Properties>
                Configuration=$(TestConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        <BuildStepsToExecute Include="$(BuildStepsAnalyzeBinariesFxCop)">
            <Properties>
                Configuration=$(TestConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>

        <BuildStepsToExecute Include="$(BuildStepsBuildApiDocumentationWithSandcastle)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform)
            </Properties>
        </BuildStepsToExecute>
        -->

        <BuildStepsToExecute Include="$(BuildStepsPackNuGet)">
            <Properties>
            </Properties>
        </BuildStepsToExecute>
        <!--
        <BuildStepsToExecute Include="$(BuildStepsPackZip)">
            <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.

        Each script has the following properties passed to it:
        $(BuildPropertyFile)             - The full path to the settings.props file (i.e. this file).
        $(ShouldDisplayDebugLog)         - A flag indicating whether or not to display debug log information, usually at the start of the script execution.
        $(NBuildKitVersion)              - The full version of the nBuildKit library that is executing the build.
        $(DirNBuildKitMsBuild)           - The full path to the directory that contains the nBuildKit scripts.
        $(DirNBuildKitMsBuildExtensions) - The full path to the directory that contains the nBuildKit extension scripts.
        $(DirNBuildKitMsBuildTemplates)  - The full path to the directory that contains the nBuildKit templates.

        Additionally any properties defined by the 'Properties' section are also pushed up.
    -->
    <ItemGroup>
        <!--
        <BuildFailureStepsToExecute Include="">
            <Properties>
            </Properties>
        </BuildFailureStepsToExecute>
        -->
    </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. Template parameters must be enclosed in '${}'.

        Additional parameters can be provided through the 'TemplateTokens' ItemGroup below.
    -->
    <ItemGroup>
        <BuildFilesToGenerate Include="$(DirBuildTemp)\MyFile.txt">
            <Template>$(DirTemplates)\MyTemplatefile.txt</Template>
        </BuildFilesToGenerate>
        <BuildFilesToGenerate Include="$(DirBuildTemp)\MyOtherFile.txt">
            <Template>$(DirTemplates)\MyOtherTemplatefile.txt</Template>
            <Token>MyAdditionalTemplateParameter</Token>
            <ReplacementValue>MyAdditionalTemplateValue</ReplacementValue>
        </BuildFilesToGenerate>
    </ItemGroup>


    <!--
        **** SOURCE ANALYSIS - CCM ****
    -->
    <PropertyGroup>
        <!--
            The full path to the template file that is used to provide the project information for CCM. Defaults
            to the template file included with nBuildKit.
        -->
        <FileTemplateCcm Condition=" '$(FileTemplateCcm)' == '' ">$(DirNBuildKitMsBuildTemplates)\ccm.xml</FileTemplateCcm>

        <!--
            The full path to the report file generated by CCM. Allows build templates. Allows build templates,
            e.g. $(DirBuildLogs)\${ProductName}_ccm.xml.
        -->
        <FileReportCcm Condition=" '$(FileReportCcm)' == '' ">$(DirBuildLogs)\ccm.xml</FileReportCcm>
    </PropertyGroup>


    <!--
        **** SOURCE ANALYSIS - SOURCEMONITOR ****
    -->
    <PropertyGroup>
        <!--
            The full path to the template file that is used to provide the project information for SourceMonitor. Defaults
            to the template file included with nBuildKit.
        -->
        <FileTemplateSourceMonitor Condition=" '$(FileTemplateSourceMonitor)' == '' ">$(DirNBuildKitMsBuildTemplates)\sourcemonitor.xml</FileTemplateSourceMonitor>

        <!--
            The full path to the report file generated by SourceMonitor. Allows build templates. Allows build templates,
            e.g. $(DirBuildLogs)\${ProductName}_sourcemonitor.xml
        -->
        <FileReportSourceMonitor Condition=" '$(FileReportSourceMonitor)' == '' ">$(DirBuildLogs)\sourcemonitor.xml</FileReportSourceMonitor>
    </PropertyGroup>


    <!--
        **** 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>
        <SolutionsToBuild Include="$(DirSrc)\myproject.sln">
            <Configuration>$(TestConfiguration)</Configuration>
            <Platform>$(Platform)</Platform>
            <Targets>Rebuild</Targets>
            <Properties></Properties>
        </SolutionsToBuild>
        <SolutionsToBuild Include="$(DirSrc)\myproject.sln">
            <Configuration>$(ProductionConfiguration)</Configuration>
            <Platform>$(Platform)</Platform>
            <Targets>Rebuild</Targets>
            <Properties></Properties>
        </SolutionsToBuild>
    </ItemGroup>

    <PropertyGroup>
        <!--
            A flag that indicates whether the source files with the company and product information should be generated.
            The files will be placed in the source directory (i.e. DirSrc) and will be called CompanyInformation.xx
            (cs/vb/wxi) and ProductInformation.xx (cs/vc/wxi).

            The CompanyInformation file will contain the Company website URL, the company name and the company name as used
            in file paths.

            The ProductInformation file will contain the product name, the product description and the product name as used
            in file paths.

            Any namespaces will be created as <ProductNamespace>.Internals where 'ProductNamespace' is defined
            in the current file at the top.
        -->
        <ShouldGenerateCompanyAndProductInfo>false</ShouldGenerateCompanyAndProductInfo>

        <!--
            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>false</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>false</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>false</ShouldGenerateAssemblyBuildInfo>

        <!--
            A flag that indicates whether an application manifest file should be generated for executables. The
            manifest file is placed in the same directory as the Visual Studio project and will be named
            <ProjectOutputName>.manifest, e.g. MyCoolApp.exe.manifest.
        -->
        <ShouldGenerateApplicationManifest>false</ShouldGenerateApplicationManifest>

        <!--
            A flag that indicates whether the current project is a Test project. The value will be set in the Visual
            Studio project files based on whether the project is a test project (as determined by the ProjectType GUID).

            This value is defined here just so that there is a value when no other value is specified. Do not comment this
            value out unless you know what you are doing!
        -->
        <IsTest Condition=" '$(IsTest)' == '' ">false</IsTest>
    </PropertyGroup>

    <!-- Build configuration -->
    <PropertyGroup>
        <!--
            A flag indicating whether warnings should be treated as errors by the compiler. This value is set
            for all projects that include the MsBuild.Projects.XXXX NuGet package.
        -->
        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
        <!--
            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.5</TargetFrameworkVersion>

        <!--
            The platform against which the code should be compiled. Note that the target should not have space in it,
            i.e. AnyCPU, x86, x64 etc.
        -->
        <PlatformTarget>$(PlatformWithoutSpaces)</PlatformTarget>
    </PropertyGroup>

    <!-- Execute code analysis after the build -->
    <PropertyGroup>
        <!--
            A flag that indicates whether or not the code analysis should be executed immediately after the compilation
            process is complete.
        -->
        <ShouldPerformCodeAnalysis Condition=" '$(ShouldPerformCodeAnalysis)' == '' ">true</ShouldPerformCodeAnalysis>
        <!--
            The code analysis rule set that should be used for non-test assemblies.
        -->
        <CodeAnalysisRuleSet Condition="$(ShouldPerformCodeAnalysis) AND !$(IsTest)">$(SolutionDir)\codeanalysis.base.ruleset</CodeAnalysisRuleSet>
        <!--
            The code analysis rule set that should be used for test assemblies. If no code analysis should be executed on test
            assemblies then it can be turned off in the settings for the different build configurations below.
        -->
        <CodeAnalysisRuleSet Condition="$(ShouldPerformCodeAnalysis) AND $(IsTest)">$(SolutionDir)\codeanalysis.test.ruleset</CodeAnalysisRuleSet>
        <!--
            The culture which will be used by the code analysis when searching for spelling errors. The culture name should
            be formatted using the .NET culture format.
        -->
        <CodeAnalysisCulture Condition="$(ShouldPerformCodeAnalysis)">en-US</CodeAnalysisCulture>
    </PropertyGroup>

    <!-- Generate the XML documentation file -->
    <PropertyGroup>
        <!--
            A flag indicating whether or not the XML documentation file should be generated during the compilation process.
            Note that if 'WarningsAsErrors' is enabled then missing documentation will generate errors that stop the
            build process.

            If documentation should only be generated for non-test assemblies then add the '!$(IsTest)' condition
            to the property.
        -->
        <GenerateDocumentation>true</GenerateDocumentation>
        <!--
            The full file path where the XML documentation file should be created.
        -->
        <DocumentationFile Condition="$(GenerateDocumentation) AND !$(IsTest)">$(OutputPath)\$(AssemblyName).XML</DocumentationFile>
    </PropertyGroup>

    <!-- Strong name the binaries -->
    <PropertyGroup>
        <!--
            A flag that indicates whether or not the assemblies should be strong named during the compilation process.
        -->
        <ShouldSign Condition=" '$(ShouldSign)' == '' ">true</ShouldSign>
        <SignAssembly Condition="$(ShouldSign)">true</SignAssembly>
        <DelaySign Condition="$(ShouldSign)">false</DelaySign>
        <!--
            The full path of the key file that will be used to sign the assemblies during the compilation process.
        -->
        <AssemblyOriginatorKeyFile Condition="$(ShouldSign)">$(SOFTWARE_SIGNING_KEY_PATH)</AssemblyOriginatorKeyFile>
    </PropertyGroup>

    <!--
        Debug configuration
    -->
    <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
        <DebugSymbols>true</DebugSymbols>
        <DebugType>full</DebugType>
        <DefineDebug>true</DefineDebug>
        <DefineTrace>true</DefineTrace>
        <Optimize>false</Optimize>
        <RunCodeAnalysis>$(ShouldPerformCodeAnalysis)</RunCodeAnalysis>
    </PropertyGroup>

    <!--
        Release configuration
    -->
    <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
        <DebugSymbols>false</DebugSymbols>
        <DebugType>pdbonly</DebugType>
        <DefineDebug>false</DefineDebug>
        <DefineTrace>true</DefineTrace>
        <Optimize>true</Optimize>
        <RunCodeAnalysis>$(ShouldPerformCodeAnalysis)</RunCodeAnalysis>
    </PropertyGroup>

    <!-- Compiler specific configurations -->
    <PropertyGroup>
        <!--
            Indicates what the warning level is for the C# compiler.
        -->
        <CSharpWarningLevel>4</CSharpWarningLevel>
        <!--
            Define any additional constants for the C# compiler. Multiple constants should be
            separated by a semi-colon (;).
        -->
        <CSharpConstants>TRACE</CSharpConstants>
        <!--
            The name of the directory that contains the VB.NET AssemblyInfo and resoure files.
        -->
        <VbNetAppDesignerFolder>My Project</VbNetAppDesignerFolder>
        <!--
            Indicates if the VB.NET Option Explicit is 'on' or 'off'
        -->
        <VbNetOptionExplicit>On</VbNetOptionExplicit>
        <!--
            Indicates if the VB.NET Option strict is 'on' or 'off'
        -->
        <VbNetOptionStrict>On</VbNetOptionStrict>
    </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.
    -->
    <ItemGroup>
        <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>

    <!--
        Define additional scripts that need to be executed prior to the start of the Visual Studio clean process and the
        start of the Visual Studio build process.

        Scripts are defined by providing the path to the MsBuild script that should be executed,
        e.g. 'c:\stuff\MyCoolScript.msbuild'.

        Each script has the following properties passed to it:
        $(BuildPropertyFile)             - The full path to the settings.props file (i.e. this file).
        $(Configuration)                 - The configuratino for the compilation process.
        $(Platform)                      - The platform for the compilation process.
        $(ShouldDisplayDebugLog)         - A flag indicating whether or not to display debug log information, usually at the start of the script execution.
        $(NBuildKitVersion)              - The full version of the nBuildKit library that is executing the build.
        $(DirNBuildKitMsBuild)           - The full path to the directory that contains the nBuildKit scripts.
        $(DirNBuildKitMsBuildExtensions) - The full path to the directory that contains the nBuildKit extension scripts.
        $(DirNBuildKitMsBuildTemplates)  - The full path to the directory that contains the nBuildKit templates.

        Additionally any properties defined by the 'Properties' section are also pushed up.
    -->
    <ItemGroup>
        <!--
        <PreCleanScripts Include="">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform)
            </Properties>
        </PreCleanScripts>
        <PreCompilationScripts Include="">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform)
            </Properties>
        </PreCompilationScripts>
        -->
    </ItemGroup>


    <!--
        **** UNIT TESTS ****
    -->
    <PropertyGroup>
        <!--
            The assembly name prefix for the assemblies containing the unit tests. Allows build templates,
            e.g. '${CompanyName}.${ProductName}.Tests'.
        -->
        <UnitTestAssemblyNamePrefix Condition=" '$(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 Condition=" '$(FileReportMsTest)' == '' ">$(DirBuildLogs)\mstest.trx</FileReportMsTest>

        <!--
            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 Condition=" '$(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 Condition=" '$(FileReportOpenCoverCsv)' == '' ">$(DirBuildLogs)\coverage.csv</FileReportOpenCoverCsv>
    </PropertyGroup>
    <ItemGroup>
        <!--
            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 Include="$(DirBuildBinPlatformConfig)\**\$(UnitTestAssemblyNamePrefix)*.dll" />

        <!--
            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" />

        <!--
            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>


    <!--
        **** BINARY ANALYSIS - MOMA ****
    -->
    <PropertyGroup>
        <!--
            The HTML report that is generated by MoMA. Allows build templates, e.g. $(DirReportMoma)\${ProductName}_moma.html.
        -->
        <FileReportMoma Condition=" '$(FileReportMoma)' == '' ">$(DirReportMoma)\moma.html</FileReportMoma>
    </PropertyGroup>
    <ItemGroup>
        <!--
            The locations of the files that should be analyzed by MoMA (Mono Migration Analyzer).
        -->
        <MomaInputFiles Include="$(DirBuildBinPlatformConfig)\*.dll"
                        Exclude="$(DirBuildBinPlatformConfig)\Test.*.dll" />
        <MomaInputFiles Include="$(DirBuildBinPlatformConfig)\*.exe"/>
    </ItemGroup>


    <!--
        **** BINARY ANALYSIS - FXCOP ****
    -->
    <PropertyGroup>
        <!--
            The full path to the FxCop project file.
        -->
        <FileProjectFxCop Condition=" '$(FileProjectFxCop)' == '' ">UNDEFINED</FileProjectFxCop>

        <!--
            The full path to the FxCop output report. Allows build templates, e.g. $(DirBuildLogs)\${ProductName}_fxcop.xml.
        -->
        <FileReportFxCop Condition=" '$(FileReportFxCop)' == '' ">$(DirBuildLogs)\fxcop.xml</FileReportFxCop>

        <!--
            The full path to the rules file that indicates which rules FxCop should use to analyse the binaries.
        -->
        <FileFxCopRuleSet Condition=" '$(FileFxCopRuleSet)' == '' ">$(DirSrc)\codeanalysis.base.ruleset</FileFxCopRuleSet>

        <!--
            The full path to the XML file that contains the custom dictionary for FxCop.
        -->
        <FxCopCustomDictionary Condition=" '$(FxCopCustomDictionary)' == '' ">$(DirWorkspace)\customdictionary.xml</FxCopCustomDictionary>

        <!--
            The culture that FxCop should use for the spelling rules.
        -->
        <FxCopCulture Condition=" '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 Condition=" '$(FxCopWarningsAsErrors)' == '' ">false</FxCopWarningsAsErrors>
    </PropertyGroup>
    <ItemGroup>
        <!--
            The locations of the files that should be analyzed by FxCop.
        -->
        <FxCopFiles Include="$(DirBuildBinPlatformConfig)\*.dll"
                    Exclude="$(DirBuildBinPlatformConfig)\Test.*.dll">
            <TargetFramework>4.5</TargetFramework>
        </FxCopFiles>
        <FxCopFiles Include="$(DirBuildBinPlatformConfig)\*.exe">
            <TargetFramework>2.0</TargetFramework>
        </FxCopFiles>

        <!--
            The locations of the assemblies (not including the .NET framework assemblies) which FxCop should
            use as reference assemblies.
        -->
        <!--
        <FxCopReferenceFiles Include=""
                             Exclude="" />
        -->

        <!--
            The directory locations that contain the assemblies (not including the .NET framework assemblies) which
            FxCop should use as reference assemblies
        -->
        <!--
        <FxCopReferenceDirectories Include=""
                                   Exclude="" />
        -->
    </ItemGroup>


    <!--
        **** BUILD API DOCUMENATION - SANDCASTLE ****
    -->
    <PropertyGroup>
        <!--
            The full path to the template file that is used to provide the project information for sandcastle. Defaults to
            the template file included with nBuildKit.
        -->
        <FileTemplateSandcastle Condition=" '$(FileTemplateSandcastle)' == '' ">$(DirNBuildKitMsBuildTemplates)\sandcastle.shfbproj</FileTemplateSandcastle>
    </PropertyGroup>


    <!--
        **** PACK - NUGET ****
    -->
    <!--
        The item group defining the location and contents of the NuGet packages that are generated during the build.

        The IncludedDependencies and the ExcludedDependencies are lists of packages.config files that
        should be included (or excluded) in the list of dependencies. Each entry is separated by a semi-colon(;).
        If there is a 'packages.config' file in the same directory as the nuspec file then it is assumed that
        all references in the 'packages.config' file should be added as dependencies.

        All file paths allow build templates, e.g. $(DirSrc)\${ProductName}\myproject.nuspec.
    -->
    <ItemGroup>
        <NuGetPackageSpecs Include="$(DirTemplates)\*.nuspec">
            <ShouldBuildSymbols>false</ShouldBuildSymbols>
            <IncludedDependencies>
                $(DirWorkspace)\packages.config
            </IncludedDependencies>
            <ExcludedDependencies>
            </ExcludedDependencies>
        </NuGetPackageSpecs>
    </ItemGroup>

    <!--
        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.
    -->
    <ItemGroup>
        <DesignTimeDependencies Include="nBuildKit" />
        <DesignTimeDependencies Include="nUnit" />
        <DesignTimeDependencies Include="GitReleaseNotes" />
        <DesignTimeDependencies Include="GitVersion" />
    </ItemGroup>


    <!--
        **** PACK - ZIP ARCHIVE ****
    -->
    <!--
        The item group defining the location and contents of the archive files that are generated during the build

        The IncludedFiles and the ExcludedFiles are actually lists of packages.config files that
        should be included (or excluded) in the list of dependencies. Each entry is separated by a semi-colon(;).

        All file paths allow build templates, e.g. $(DirBuildDeploy)\myarchive-${VersionSemantic}.zip.
    -->
    <ItemGroup>
        <ArchivePackageSpecs Include="$(DirTemplate)\myarchive.zipspec" />
    </ItemGroup>





    <!--
        *************************************
        *                                   *
        *     Test SETTINGS                 *
        *                                   *
        *************************************
    -->

    <!--
        **** Test STEPS ****
    -->
    <!--
        The following ItemGroup defines which steps are taken during the test process. The order of the items in the item group
        determines in which order the test steps are executed.

        The following test steps are by default provided through the given properties:
        $(TestStepsPrepareWorkspace)     - Deletes the existing test files and logs and creates the required directories for the test to execute.
        $(TestStepsPrepareRestoreNuGet)  - Restores the NuGet packages for the project.
        $(TestStepsPrepareGetVersion)    - Gathers version information and stores it in a temporary file for use by the rest of the test process.
                                           Currently supported methods of gathering version information are using (in order):
                                           - The version defined by a custom MsBuild task which is defined in a file of which the path is stored
                                             in the 'VersionScriptPath' property. The task should output:
                                             - VersionMajor
                                             - VersionMinor
                                             - VersionPatch
                                             - VersionBuild
                                             - VersionPreRelease
                                             - VersionSemantic
                                             - VersionSemanticFull
                                             - VersionSemanticNuget
                                           - The version stored in an 'version.xml' file which contains an MsBuild property group with
                                             the properties:
                                             - BuildNumber
                                             - VersionMajor
                                             - VersionMinor
                                             - VersionPatch
                                             - VersionBuild
                                             - VersionPreRelease
                                             - The GitVersion tool (https://github.com/ParticularLabs/GitVersion)
                                             - The GitHubFlowVersion tool (https://github.com/JakeGinnivan/GitHubFlowVersion)
        $(TestStepsPrepareReleaseNotes)  - Gathers the release notes and stores them for later use during the test process. Release notes
                                           are retrieved with the GitReleaseNotes tool (https://github.com/GitTools/GitReleaseNotes) which
                                           currently allows gathering release notes from GitHub, Jira and YouTrack
        $(TestStepsPrepareVcsInfo)       - Stores the Version Control System (VCS) information in a file for later use.
                                           Currently supported version control systems is GIT
        $(TestStepsPrepareGenerateFiles) - Generates one or more files from a set of template files.

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

        Each script has the following properties passed to it:
        $(BuildPropertyFile)              - The full path to the settings.props file (i.e. this file).
        $(ShouldDisplayDebugLog)          - A flag indicating whether or not to display debug log information, usually at the start of the script execution.
        $(NBuildKitVersion)               - The full version of the nBuildKit library that is executing the build.
        $(DirNBuildKitMsBuild)            - The full path to the directory that contains the nBuildKit scripts.
        $(DirNBuildKitMsBuildExtensions)  - The full path to the directory that contains the nBuildKit extension scripts.
        $(DirNBuildKitMsBuildTemplates)   - The full path to the directory that contains the nBuildKit templates.
    -->
    <ItemGroup>
        <TestStepsToExecute Include="$(TestStepsPrepareWorkspace)">
            <Properties>
            </Properties>
        </TestStepsToExecute>
        <TestStepsToExecute Include="$(TestStepsPrepareRestoreNuGet)">
            <Properties>
            </Properties>
        </TestStepsToExecute>
        <TestStepsToExecute Include="$(TestStepsPrepareGetVersion)">
            <Properties>
            </Properties>
        </TestStepsToExecute>
        <TestStepsToExecute Include="$(TestStepsPrepareReleaseNotes)">
            <Properties>
            </Properties>
        </TestStepsToExecute>
        <TestStepsToExecute Include="$(TestStepsPrepareVcsInfo)">
            <Properties>
            </Properties>
        </TestStepsToExecute>
        <TestStepsToExecute Include="$(TestStepsPrepareGenerateFiles)">
            <Properties>
            </Properties>
        </TestStepsToExecute>
    </ItemGroup>

    <!--
        Define the scripts that should be executed when any one of the test 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 test step that points to the 'c:\stuff\MyCoolScript.msbuild' will execute
        that script.

        Each script has the following properties passed to it:
        $(BuildPropertyFile)             - The full path to the settings.props file (i.e. this file).
        $(ShouldDisplayDebugLog)         - A flag indicating whether or not to display debug log information, usually at the start of the script execution.
        $(NBuildKitVersion)              - The full version of the nBuildKit library that is executing the build.
        $(DirNBuildKitMsBuild)           - The full path to the directory that contains the nBuildKit scripts.
        $(DirNBuildKitMsBuildExtensions) - The full path to the directory that contains the nBuildKit extension scripts.
        $(DirNBuildKitMsBuildTemplates)  - The full path to the directory that contains the nBuildKit templates.

        Additionally any properties defined by the 'Properties' section are also pushed up.
    -->
    <ItemGroup>
        <!--
        <TestFailureStepsToExecute Include="">
            <Properties>
            </Properties>
        </TestFailureStepsToExecute>
        -->
    </ItemGroup>


    <!--
        **** PREPARE - WORKSPACE ****
    -->
    <ItemGroup>
        <TestFilesToCopy Include="$(DirTest)\**\*.*">
            <TargetDirectory>$(DirBuildTest)</TargetDirectory>
        </TestFilesToCopy>
    </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. Template parameters must be enclosed in '${}'.

        Additional parameters can be provided through the 'TemplateTokens' ItemGroup below.
    -->
    <ItemGroup>
        <TestFilesToGenerate Include="$(DirBuildTemp)\MyFile.txt">
            <Template>$(DirTemplates)\MyTemplatefile.txt</Template>
        </TestFilesToGenerate>
        <TestFilesToGenerate Include="$(DirBuildTemp)\MyOtherFile.txt">
            <Template>$(DirTemplates)\MyOtherTemplatefile.txt</Template>
            <Token>MyAdditionalTemplateParameter</Token>
            <ReplacementValue>MyAdditionalTemplateValue</ReplacementValue>
        </TestFilesToGenerate>
    </ItemGroup>





    <!--
        *************************************
        *                                   *
        *     DEPLOYMENT SETTINGS           *
        *                                   *
        *************************************
    -->

    <!--
        **** DEPLOY STEPS ****
    -->
    <!--
        The following ItemGroup defines which steps are taken during the deploy process. The order of the items in the item group
        determines in which order the deploy steps are executed.

        The following deploy steps are by default provided through the given properties:
        $(DeployStepsTagVcs)              - Tags the current commit with the version number. Currentlyl supported version control systems are TFS and GIT.
        $(DeployStepsPushToNuget)         - Pushes one or more artifacts to a NuGet feed
        $(DeployStepsPushToDirectory)     - Pushes one or more artifacts to a directory
        $(DeployStepsPushToSymbolServer)  - Pushes one or more NuGet symbol packages to a local symbol server on a UNC path
        $(DeployStepsPushToGitHubRelease) - Pushes zero or more files to a GitHub release

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

        Each script has the following properties passed to it:
        $(BuildPropertyFile)              - The full path to the settings.props file (i.e. this file).
        $(ShouldDisplayDebugLog)          - A flag indicating whether or not to display debug log information, usually at the start of the script execution.
        $(NBuildKitVersion)               - The full version of the nBuildKit library that is executing the build.
        $(DirNBuildKitMsBuild)            - The full path to the directory that contains the nBuildKit scripts.
        $(DirNBuildKitMsBuildExtensions)  - The full path to the directory that contains the nBuildKit extension scripts.
        $(DirNBuildKitMsBuildTemplates)   - The full path to the directory that contains the nBuildKit templates.
    -->
    <ItemGroup>
        <DeployStepsToExecute Include="$(DeployStepTagVcs)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
        </DeployStepsToExecute>
        <DeployStepsToExecute Include="$(DeployStepsPushToNuget)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
        </DeployStepsToExecute>
        <DeployStepsToExecute Include="$(DeployStepsPushToDirectory)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
        </DeployStepsToExecute>
        <DeployStepsToExecute Include="$(DeployStepsPushToSymbolServer)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
        </DeployStepsToExecute>
        <DeployStepsToExecute Include="$(DeployStepsPushToGitHubRelease)">
            <Properties>
                Configuration=$(ProductionConfiguration);
                Platform=$(Platform);
            </Properties>
        </DeployStepsToExecute>
    </ItemGroup>

    <!--
        Define the scripts that should be executed when any one of the deploy 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 deploy step that points to the 'c:\stuff\MyCoolScript.msbuild' will execute
        that script.

        Each script has the following properties passed to it:
        $(BuildPropertyFile)             - The full path to the settings.props file (i.e. this file).
        $(ShouldDisplayDebugLog)         - A flag indicating whether or not to display debug log information, usually at the start of the script execution.
        $(NBuildKitVersion)              - The full version of the nBuildKit library that is executing the build.
        $(DirNBuildKitMsBuild)           - The full path to the directory that contains the nBuildKit scripts.
        $(DirNBuildKitMsBuildExtensions) - The full path to the directory that contains the nBuildKit extension scripts.
        $(DirNBuildKitMsBuildTemplates)  - The full path to the directory that contains the nBuildKit templates.

        Additionally any properties defined by the 'Properties' section are also pushed up.
    -->
    <ItemGroup>
        <!--
        <DeployFailureStepsToExecute Include="">
            <Properties>
            </Properties>
        </DeployFailureStepsToExecute>
        -->
    </ItemGroup>


    <!--
        **** PUSHTO - DIRECTORY / FILESERVER ****
    -->
    <!--
        The ItemGroup defining the files that should be pushed to a given deployment directory.

        The IncludedFiles and the ExcludedFiles are lists of files that
        should be included (or excluded) in the list of files to deploy. Each entry is separated by a semi-colon(;).

        The PushToDirectorySpecs, IncludedFiles and ExcludedFiles all allow the insertion of build templates,
        e.g. \\MyServer\${ProductNameInFilePath}\${VersionSemantic}
    -->
    <ItemGroup>
        <PushToDirectorySpecs Include="\\MyServer\${ProductNameInFilePath}\${VersionSemantic}">
            <IncludedFiles>
                $(DirBuildDeploy)\myfile.zip
            </IncludedFiles>
            <ExcludedFiles>
            </ExcludedFiles>
        </PushToDirectorySpecs>
    </ItemGroup>


    <!--
        **** PUSHTO - NUGET ****
    -->
    <PropertyGroup>
        <!--
            The URL to which all NuGet packages should be pushed. By default it pushes to nuget.org.
            If the repository needs authentication then the API key should be defined via an environment variable:
            NuGetApiKey - The NuGet API key for the NuGet feed
        -->
        <NuGetSourceUrl Condition=" '$(NuGetSourceUrl)' == '' ">UNDEFINED</NuGetSourceUrl>
    </PropertyGroup>
    <!--
        The ItemGroup defining which packages should be pushed up to the NuGet package source.
        Allows build templates, e.g. $(DirBuildDeploy)\${VersionSemantic}\*.nupkg.
    -->
    <ItemGroup>
        <NuGetPackagesToPush Include="$(DirBuildDeploy)\*.nupkg"
                             Exclude="$(DirBuildDeploy)\*.symbols.nupkg" />
    </ItemGroup>


    <!--
        **** PUSHTO - SYMBOL SERVER ****
    -->
    <!--
        The ItemGroup defining which symbol packages should be pushed up to the symbol server.
        Allows build templates, e.g. $(DirBuildDeploy)\${VersionSemantic}\*.symbols.nupkg.
    -->
    <PropertyGroup>
        <!--
            The URL to which all NuGet symbol packages should be pushed. If the repository needs authentication then
            the API key should be defined via an environment variable:
            NuGetApiKey - The NuGet API key for the NuGet feed
        -->
        <NuGetSymbolSourceUrl Condition=" '$(NuGetSymbolSourceUrl)' == '' ">UNDEFINED</NuGetSymbolSourceUrl>

        <!--
            The URL / UNC path to which all the symbol packages should be pushed.
        -->
        <SymbolServerUncPath Condition=" '$(SymbolServerUncPath)' == '' ">UNDEFINED</SymbolServerUncPath>
    </PropertyGroup>
    <ItemGroup>
        <SymbolPackagesToPush Include="$(DirBuildDeploy)\*.symbols.nupkg" />
    </ItemGroup>


    <!--
        **** PUSHTO - GITHUB RELEASE ****
    -->
    <!--
        The ItemGroup defining the files that should be pushed to a GitHub release. All properties
        except for the Repository allow the use of build templates, e.g. $(DirBuildDeploy)\myarchive-${VersionSemantic}.zip
    -->
    <ItemGroup>
        <PushToGitHubReleaseSpecs Include="${VersionSemantic} - My release">
             <Repository>MyCoolProject</Repository>
             <Description>${ReleaseNotesShort}</Description>
             <IncludedFiles>
                $(DirBuildDeploy)\myarchive-${VersionSemantic}.zip
             </IncludedFiles>
             <ExcludedFiles>
             </ExcludedFiles>
        </PushToGitHubReleaseSpecs>
    </ItemGroup>





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

    <!-- Overrides for the tools paths -->
    <PropertyGroup>
        <!--
            The full path to the CCM command line executable. If not defined the packages directory is searched.
        -->
        <ToolsExternalCcmPath Condition=" '$(ToolsExternalCcmPath)' == '' ">UNDEFINED</ToolsExternalCcmPath>

        <!--
            The full path to the directory that contains the FxCop command line executable
        -->
        <ToolsExternalFxCopDir Condition=" '$(ToolsExternalFxCopDir)' == '' AND Exists('C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop')">C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop</ToolsExternalFxCopDir>
        <ToolsExternalFxCopDir Condition=" '$(ToolsExternalFxCopDir)' == '' AND Exists('C:\Program Files (x86)\Microsoft Visual Studio 11.0\Team Tools\Static Analysis Tools\FxCop')">C:\Program Files (x86)\Microsoft Visual Studio 11.0\Team Tools\Static Analysis Tools\FxCop</ToolsExternalFxCopDir>
        <ToolsExternalFxCopDir Condition=" '$(ToolsExternalFxCopDir)' == '' AND Exists('C:\Program Files (x86)\Microsoft Visual Studio 12.0\Team Tools\Static Analysis Tools\FxCop')">C:\Program Files (x86)\Microsoft Visual Studio 12.0\Team Tools\Static Analysis Tools\FxCop</ToolsExternalFxCopDir>
        <ToolsExternalFxCopDir Condition=" '$(ToolsExternalFxCopDir)' == '' ">UNDEFINED</ToolsExternalFxCopDir>

        <!--
            The full path to the GitHubFlowVersion command line executable. If not defined the packages directory is searched.
        -->
        <ToolsExternalGitHubFlowVersionPath Condition=" '$(ToolsExternalGitHubFlowVersionPath)' == '' ">UNDEFINED</ToolsExternalGitHubFlowVersionPath>

        <!--
            The full path to the github-release command line executable.
        -->
        <ToolsExternalGitHubReleasePath Condition=" '$(ToolsExternalGitHubReleasePath)' == '' ">github-release.exe</ToolsExternalGitHubReleasePath>

        <!--
            The full path to the GIT command line executable. Normally expected to be found via the PATH environment variable.
        -->
        <ToolsExternalGitPath Condition=" '$(ToolsExternalGitPath)' == '' ">git.exe</ToolsExternalGitPath>

        <!--
            The full path to the GitReleaseNotes command line executable. If not defined the packages directory is searched.
        -->
        <ToolsExternalGitReleaseNotesPath Condition=" '$(ToolsExternalGitReleaseNotesPath)' == '' ">UNDEFINED</ToolsExternalGitReleaseNotesPath>

        <!--
            The full path to the GitVersion command line executable. If not defined the packages directory is searched.
        -->
        <ToolsExternalGitVersionPath Condition=" '$(ToolsExternalGitVersionPath)' == '' ">UNDEFINED</ToolsExternalGitVersionPath>

        <!--
            The full path to the MoMA command line executable. If not defined the packages directory is searched.
        -->
        <ToolsExternalMomaPath Condition=" '$(ToolsExternalMomaPath)' == '' ">UNDEFINED</ToolsExternalMomaPath>

        <!--
            The full path to the MsTest command line executable.
        -->
        <ToolsExternalMsTestPath Condition=" '$(ToolsExternalMsTestPath)' == '' AND Exists('C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\MsTest.exe')">C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\MsTest.exe</ToolsExternalMsTestPath>
        <ToolsExternalMsTestPath Condition=" '$(ToolsExternalMsTestPath)' == '' AND Exists('C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\IDE\MsTest.exe')">C:\Program Files (x86)\Microsoft Visual Studio 11.0\Common7\IDE\MsTest.exe</ToolsExternalMsTestPath>
        <ToolsExternalMsTestPath Condition=" '$(ToolsExternalMsTestPath)' == '' AND Exists('C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\MsTest.exe')">C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\IDE\MsTest.exe</ToolsExternalMsTestPath>
        <ToolsExternalMsTestPath Condition=" '$(ToolsExternalMsTestPath)' == '' ">UNDEFINED</ToolsExternalMsTestPath>

        <!--
            The full path to the NuGet command line executable. If not defined the packages directory is searched.
        -->
        <ToolsExternalNuGetPath Condition=" '$(ToolsExternalNuGetPath)' == '' ">nuget.exe</ToolsExternalNuGetPath>

        <!--
            The full path to the nUnit command line executable. If not defined the packages directory is searched.
        -->
        <ToolsExternalNUnitConsolePath Condition=" '$(ToolsExternalNUnitConsolePath)' == '' ">UNDEFINED</ToolsExternalNUnitConsolePath>

        <!--
            The full path to the OpenCover command line executable. If not defined the packages directory is searched.
        -->
        <ToolsExternalOpenCoverPath Condition=" '$(ToolsExternalOpenCoverPath)' == '' ">UNDEFINED</ToolsExternalOpenCoverPath>

        <!--
            The full path to the ReportGenerator command line executable. If not defined the packages directory is searched.
        -->
        <ToolsExternalReportGeneratorPath Condition=" '$(ToolsExternalReportGeneratorPath)' == '' ">UNDEFINED</ToolsExternalReportGeneratorPath>

        <!--
            The full path to the sn.exe command line executable.
        -->
        <ToolsExternalSnPath Condition=" '$(ToolsExternalSnPath)' == '' ">UNDEFINED</ToolsExternalSnPath>

        <!--
            The full path to the SourceMonitor command line executable. If not defined the packages directory is searched.
        -->
        <ToolsExternalSourceMonitorPath Condition=" '$(ToolsExternalSourceMonitorPath)' == '' ">UNDEFINED</ToolsExternalSourceMonitorPath>

        <!--
            The full path to the TFS command line executable. Normally expected to be found via the PATH environment variable.
        -->
        <ToolsExternalTfsPath Condition=" '$(ToolsExternalTfsPath)' == '' ">tf.exe</ToolsExternalTfsPath>
    </PropertyGroup>





    <!--
        *************************************
        *                                   *
        *     BUILD SPECIFIC SETTINGS       *
        *                                   *
        *************************************
    -->

    <!-- Build specific settings -->
    <PropertyGroup>
        <!-- Defines whether the current script file has been loaded / imported or not -->
        <ExistsSettings>true</ExistsSettings>
    </PropertyGroup>
</Project>