path: root/tests/runtest.proj

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="src\dir.props" />
  <Import Project="$(ToolsDir)Build.Post.targets" Condition="Exists('$(ToolsDir)Build.Post.targets') AND '$(BuildWrappers)' == 'true'" /> 
  <Import Project="helixperftasks.targets" Condition="'$(Performance)'=='true'"/> 
  <PropertyGroup>
    <XunitTestBinBase Condition="'$(XunitTestBinBase)'==''" >$(BaseOutputPathWithConfig)</XunitTestBinBase>
    <XunitWrapperGeneratedCSDirBase>$(XunitTestBinBase)\TestWrappers\</XunitWrapperGeneratedCSDirBase>
    <XunitWrapperOutputIntermediatedDirBase>$(XunitTestBinBase)\Tests\</XunitWrapperOutputIntermediatedDirBase>
    <MSBuildEnableAllPropertyFunctions>1</MSBuildEnableAllPropertyFunctions>
  </PropertyGroup>

  <ItemGroup>
    <DisabledTestDir Include="Common" />
    <_SkipTestDir Include="@(DisabledTestDir)" />
  </ItemGroup>

  <Target Name="Rebuild" />

  <Target Name="FindCmdDirectories" DependsOnTargets="GetListOfTestCmds">

    <Error Condition="!Exists('$(XunitTestBinBase)')" 
           Text="$(XunitTestBinBase) does not exist. Please run buildtest.cmd from the (repo root)\tests at least once to get the tests built." />

    <ItemGroup>

      <AllTestDirsNonCanonicalPaths Include="$([System.IO.Directory]::GetDirectories(`$(XunitTestBinBase)`))" />
      <AllTestDirsPaths Include="@(AllTestDirsNonCanonicalPaths)" />
      <AllTestDirsPaths Include="@(AllTestDirsNonCanonicalPaths)" >
        <Path>$([System.IO.Path]::GetFullPath(%(Identity)))</Path>
      </AllTestDirsPaths>
      <NonExcludedTestDirectories Include="@(AllTestDirsPaths -> '%(Path)')" Exclude="@(_SkipTestDir -> '$(XunitTestBinBase)%(Identity)')" />
      <TopLevelDirectories Include="@(NonExcludedTestDirectories)" />
      <SecondLevel Include="$([System.IO.Directory]::GetDirectories(%(TopLevelDirectories.Identity)))" />
      <SecondLevelDirectories Include="@(SecondLevel)">
        <Path>$([System.IO.Path]::GetFullPath(%(AllRunnableTestPaths.Identity)))</Path>
      </SecondLevelDirectories>
      <TestDirectoriesWithDup Include="@(SecondLevelDirectories -> '%(Identity)')" Condition="$([System.String]::new('%(Path)').StartsWith('%(Identity)'))" />

    </ItemGroup>

    <RemoveDuplicates Inputs="@(TestDirectoriesWithDup)">
      <Output
          TaskParameter="Filtered"
          ItemName="TestDirectories"/>
    </RemoveDuplicates>

  </Target>

  <Import Project="$(__Exclude)" Condition="'$(__Exclude)' != '' AND '$(XunitTestBinBase)' != ''" /> 
  <PropertyGroup>
    <HaveExcludes>False</HaveExcludes>
    <HaveExcludes Condition="'$(__Exclude)' != ''">True</HaveExcludes>
  </PropertyGroup>

  <Target Name="CreateXunitWrapper" DependsOnTargets="CreateXunitFacts">

    <PropertyGroup>
      <_XunitWrapperGen >
        <![CDATA[
        
$(_XunitProlog)
@(AllXUnitFacts)
$(_XunitEpilog)

]]>
      </_XunitWrapperGen>
      <XunitWrapperGenCsProj>
        <![CDATA[
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    
  <Import Project="$(SourceDir)dir.props" />
  <PropertyGroup>
    <Configuration Condition=" '%24(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '%24(Platform)' == '' ">AnyCPU</Platform>
    <AssemblyName>$(XunitWrapper)</AssemblyName>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{95DFC527-4DC1-495E-97D7-E94EE1F7140D}</ProjectGuid>
    <OutputType>Library</OutputType>
    <TargetFrameworkIdentifier Condition ="'$(BuildTestsAgainstPackages)' != 'true'">.NETFramework</TargetFrameworkIdentifier>
    <TargetFrameworkVersion Condition ="'$(BuildTestsAgainstPackages)' != 'true'">v4.5</TargetFrameworkVersion>
    <IsXunitWrapperProject>true</IsXunitWrapperProject>
    <SkipSigning>true</SkipSigning>
    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
    <SolutionDir Condition="%24(SolutionDir) == '' Or %24(SolutionDir) == '*Undefined*'">..\..\</SolutionDir>
    <CLRTestKind>BuildOnly</CLRTestKind>
    <IsTestProject>true</IsTestProject>
    <ProjectJson Condition="'$(BuildTestsAgainstPackages)' != 'true'">%24(TestWrappersPackagesConfigFileDirectory)project.json</ProjectJson>
    <ProjectLockJson Condition="'$(BuildTestsAgainstPackages)' != 'true'">%24(TestWrappersPackagesConfigFileDirectory)project.lock.json</ProjectLockJson>
  </PropertyGroup>
  <!-- Default configurations to help VS understand the configurations -->
  <PropertyGroup Condition=" '%24(Configuration)|%24(Platform)' == 'Debug|AnyCPU' ">
  </PropertyGroup>
  <PropertyGroup Condition=" '%24(Configuration)|%24(Platform)' == 'Release|AnyCPU' ">
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="$(XunitWrapper).cs" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
   <ItemGroup>
    <ProjectReference Include="$(SourceDir)Common\Desktop.Coreclr.TestWrapper\Desktop.Coreclr.TestWrapper.csproj" Condition="'$(BuildTestsAgainstPackages)' != 'true'">
      <Project>{8ffe99c0-22f8-4462-b839-970eac1b3472}</Project>
      <Name>coreclr</Name>
    </ProjectReference>
    <ProjectReference Include="$(SourceDir)Common\Coreclr.TestWrapper\Coreclr.TestWrapper.csproj" Condition="'$(BuildTestsAgainstPackages)' == 'true'">
      <Project>{8ffe99c0-22f8-4462-b839-970eac1b3472}</Project>
      <Name>coreclr</Name>
    </ProjectReference>
  </ItemGroup>
 
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Runtime" />
    <Reference Include="mscorlib" />
  </ItemGroup>
  <Import Project="$(SourceDir)dir.targets" />
  <PropertyGroup>
     <OutDir>$(XunitTestBinBase)\$(CategoryWithSlash)\</OutDir>
  </PropertyGroup>
</Project>
        ]]>
      </XunitWrapperGenCsProj>

    </PropertyGroup>

    <!-- <Exec Command="md" -->
    <MakeDir  Directories="$(XunitWrapperGeneratedCSDirBase)$(Category)"/>

    <!-- Write the file -->
    <WriteLinesToFile
      File="$(XunitWrapperSrcDir)\$(XunitWrapper).cs"
      Lines="$(_XunitWrapperGen)"
      Overwrite="true" />

    <!-- Write the file -->
    <WriteLinesToFile
      File="$(XunitWrapperSrcDir)\$(XunitWrapper).csproj"
      Lines="$(XunitWrapperGenCsProj)"
      Overwrite="true" />
  </Target>
  
  <Target Name="BuildXunitWrapper">
    <MSBuild Projects="$(XunitWrapperSrcDir)\$(XunitWrapper).csproj"/>
  </Target>

  <Target Name="CreateXunitFacts">
    <!-- NOTE! semicolons must be escaped with %3B boooo -->

    <PropertyGroup>
      <_CMDDIR_Parent>$([System.IO.Path]::GetDirectoryName($(_CMDDIR)))</_CMDDIR_Parent>
      <_CMDDIR_Grandparent>$([System.IO.Path]::GetDirectoryName($(_CMDDIR_Parent)))</_CMDDIR_Grandparent>
      <CategoryWithSlash>$([System.String]::Copy('$(_CMDDIR)').Replace($(_CMDDIR_Grandparent)\,''))</CategoryWithSlash>
      <Category>$([System.String]::Copy('$(CategoryWithSlash)').Replace('\','.'))</Category>
      <XunitWrapper>$(Category).XUnitWrapper</XunitWrapper>
      <XunitWrapperSrcDir>$(XunitWrapperGeneratedCSDirBase)$(Category)</XunitWrapperSrcDir>
      <XunitWrapperOutputDir>$(XunitWrapperOutputIntermediatedDirBase)$(Category)</XunitWrapperOutputDir>
    </PropertyGroup>
    <PropertyGroup>
      <_XunitProlog Condition=" '$(_XunitProlog)'=='' ">
        <![CDATA[
using Xunit%3B
using System%3B
using System.Collections.Generic%3B
using System.Diagnostics%3B
using System.Reflection%3B
using CoreclrTestLib%3B

namespace $([System.String]::Copy($(Category)).Replace(".","_").Replace("\","").Replace("-","_"))
{
        internal class _Global
        {
            internal static bool runningInWindows%3B
            internal static string reportBase%3B
            internal static string testBinaryBase%3B
            internal static string coreRoot%3B

            static _Global()
            {
                reportBase = System.Environment.GetEnvironmentVariable(%22XunitTestReportDirBase%22)%3B
                testBinaryBase = System.IO.Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath)%3B
                coreRoot = System.IO.Path.GetFullPath(System.Environment.GetEnvironmentVariable(%22CORE_ROOT%22))%3B

                if (String.IsNullOrEmpty(reportBase)) {
                    reportBase = System.IO.Path.Combine(testBinaryBase, "Reports")%3B
                }
                else
                {
                    reportBase = System.IO.Path.GetFullPath(reportBase)%3B
                }

                if (String.IsNullOrEmpty(coreRoot)) {
                    throw new ArgumentException("Environment variable CORE_ROOT is not set")%3B
                }

                string operatingSystem = System.Environment.GetEnvironmentVariable("OS")%3B
                runningInWindows = (operatingSystem != null && operatingSystem.StartsWith("Windows"))%3B
            }
        }

]]>
      </_XunitProlog>

      <_XunitEpilog Condition=" '$(_XunitEpilog)'=='' ">
      <![CDATA[
}

]]>
      </_XunitEpilog>
    </PropertyGroup>

    <ItemGroup>
      <CanonicalExcludeList Include="%(ExcludeList.FullPath)" Condition="$(HaveExcludes)"/>
    </ItemGroup>

    <PropertyGroup>
      <TestExecutableReplacement Condition="'$(TargetsWindows)' != 'true' ">testExecutable = testExecutable.Replace("\\", "/")%3B</TestExecutableReplacement>
    </PropertyGroup>

    <ItemGroup>
      <AllCMDsPresent Include="$(_CMDDIR)\**\*.cmd" />
      <AllCMDExcludeFilter Include="@(CanonicalExcludeList)" Condition="$(HaveExcludes)"/>
      <AllCMDs Include="@(AllCMDsPresent)" Exclude="@(AllCMDExcludeFilter)"/>

      <AllCommands Include="@(AllCMDs)" >
        <_FactName>$([System.String]::Copy('%(AllCMDs.FullPath)').Replace("$(_CMDDIR)",'').Replace(".","_").Replace("\","_").Replace("-","_"))</_FactName>
        <_ClassName>$([System.String]::Copy('%(AllCMDs.FullPath)').Replace("$(_CMDDIR)",'').Replace("cmd","").Replace(".","_").Replace("\","_").Replace("-","_"))</_ClassName>

        <_XunitFact >
          <![CDATA[

        public class %(AllCommands._ClassName)
        {
            [Fact]
            public void %(AllCommands._FactName)()
            {
                int ret = -100%3B
                string outputFile = null%3B
                string errorFile = null%3B
                string testExecutable = null%3B
                Exception infraEx = null%3B

                try
                {
                  CoreclrTestWrapperLib wrapper = new CoreclrTestWrapperLib()%3B
                  string testSubfolder = @"\$(Category)\$([System.String]::Copy('%(AllCMDs.RelativeDir)').Replace("$(_CMDDIR)\",''))"%3B
                  outputFile = System.IO.Path.GetFullPath(_Global.reportBase + testSubfolder + @"%(AllCMDs.FileName).output.txt")%3B
                  errorFile = System.IO.Path.GetFullPath(_Global.reportBase + testSubfolder + @"%(AllCMDs.FileName).error.txt")%3B
                  testExecutable = System.IO.Path.GetFullPath(_Global.testBinaryBase + @"$([System.String]::Copy('%(AllCMDs.FullPath)').Replace("$(_CMDDIR)",''))")%3B
                  $(TestExecutableReplacement)

                  if (!_Global.runningInWindows) {
                      testExecutable = testExecutable.Replace(".cmd", ".sh")%3B
                  }

                  System.IO.Directory.CreateDirectory(_Global.reportBase + testSubfolder)%3B

                  ret = wrapper.RunTest(testExecutable, outputFile, errorFile)%3B
                }
                catch (Exception ex)
                {
                    infraEx = ex%3B
                }

                if (ret != CoreclrTestWrapperLib.EXIT_SUCCESS_CODE)
                {
                    string sErrorText = null%3B
                    try
                    {
                        sErrorText = System.IO.File.ReadAllText(errorFile)%3B
                    }
                    catch(Exception ex)
                    {
                      sErrorText = "Unable to read error file: " + errorFile%3B
                    }

                    string outputText = null%3B
                    try
                    {
                        System.IO.StreamReader outputReader = new System.IO.StreamReader(outputFile)%3B
                        outputText = outputReader.ReadToEnd()%3B
                        outputReader.Close()%3B
                    }
                    catch(Exception ex)
                    {
                        outputText = "Unable to read output file: " + outputFile%3B
                    }

                    string msg = infraEx != null ? "Test Infrastructure Failure: " + infraEx.Message
                                                 : sErrorText + "\n\n" +
                                                   "Return code:      " + ret + "\n" +
                                                   "Raw output file:      " + outputFile + "\n" +
                                                   "Raw output:\n" + outputText + "\n" +
                                                   "To run the test:\n" +
                                                   "> set CORE_ROOT=" + _Global.coreRoot + "\n" +
                                                   "> " + testExecutable + "\n"%3B

                    Assert.True(ret == CoreclrTestWrapperLib.EXIT_SUCCESS_CODE, msg)%3B
                }
            }
       }

        ]]>
        </_XunitFact>
      </AllCommands>
      <AllXUnitFacts Include= "%(AllCommands._XunitFact)" />
    </ItemGroup>

  </Target>

  <Target Name="CreateAllWrappers" DependsOnTargets="GetListOfTestCmds;FindCmdDirectories">
    <MSBuild Projects="$(MSBuildProjectFile)" Targets="CreateXunitWrapper;BuildXunitWrapper" Properties="_CMDDIR=%(TestDirectories.Identity)" />
  </Target>

  <Target Name="GetListOfTestCmds">
    <ItemGroup>
      <AllRunnableTestPaths Include="$(XunitTestBinBase)\**\*.cmd" />
    </ItemGroup>
  </Target> 

  <Import Project="tests.targets" />
  <Import Project="publishdependency.targets" />

  <PropertyGroup>
    <TargetRid Condition="'$(RuntimeId)' != ''">$(RuntimeId)</TargetRid>
    <TargetRid Condition="'$(RuntimeId)' == ''">$(TestNugetRuntimeId)</TargetRid>
  </PropertyGroup>

  <Target Name="CreateTestOverlay">
    <MSBuild Projects="$(MSBuildProjectFile)"
             Targets="CopyDependecyToCoreRoot"
             Properties="Language=C#;TargetRid=$(TargetRid)" />
  </Target>

  <Target Name="BinPlaceRef">
    <!-- Copy mscorlib.dll from TargetingPack to bin/Product/ref, if we're building against packages -->
    <MSBuild Projects="$(MSBuildProjectFile)"
             Targets="CopyDependencyToRef"
             Properties="Language=C#;TargetRid=$(TargetRid)"
             Condition=" '$(BuildTestsAgainstPackages)'=='true' " />
  </Target>

  <Target Name="BinPlaceProduct">
    <!-- Copy test dependencies to bin/Product, if we're building against packages -->
    <MSBuild Projects="$(MSBuildProjectFile)"
             Targets="CopyDependencyToProduct"
             Properties="Language=C#;TargetRid=$(TargetRid)"
             Condition=" '$(BuildTestsAgainstPackages)'=='true' " />
  </Target>

  <!-- All the test projects need to add dependency to currently built runtime as they require that to run. 
       In addition the version number of built runtime can change so all project.json needs to be dynamically generated.
       Instead the following task creates a project.json with dependencies like  Microsoft.netcore.runtime.coreclr ..etc.
        -->
  <Target Name="CreateTestRuntimeJsonFile">
    <ItemGroup>
      <CoreclrPackage Include="$(CORE_ROOT)\.nuget\**\Microsoft.NETCore.Runtime.CoreCLR.*.nupkg"/>
    </ItemGroup>
    <PropertyGroup>
      <CoreclrPackageFileName>%(CoreclrPackage.Filename)</CoreclrPackageFileName>
      <!-- Get package version number from nuget package filename at core_root -->
      <CoreClrPackageVersion Condition="'$(BuildTestsAgainstPackages)'!='true'">$([System.String]::Copy('$(CoreclrPackageFileName)').Replace('Microsoft.NETCore.Runtime.CoreCLR.',''))</CoreClrPackageVersion>
      <TestRuntimeJsonContents>
        <![CDATA[
{
  "dependencies": {
    "Microsoft.NETCore.Runtime.CoreCLR": "$(CoreClrPackageVersion)",
    "Microsoft.NETCore.TestHost": "1.0.0-rc3-24117-00"
  },
  "frameworks": {
    "dnxcore50": {}
  },
  "runtimes": {
    "$(TestNugetRuntimeId)":{}
  }
}

        ]]>
      </TestRuntimeJsonContents>
    </PropertyGroup>

    <MakeDir Directories="$(TestRuntimeProjectJsonDir)" Condition="!Exists('$(TestRuntimeProjectJsonDir)')" />

    <!-- Write the file -->
    <WriteLinesToFile
      File="$(TestRuntimeProjectJson)"
      Lines="$(TestRuntimeJsonContents)"
      Overwrite="true" />

  </Target>

  <Target Name="RunPerfTests" Condition="'$(Performance)'=='true'">  
    <Message Text="Executing steps for perf tests" Importance="High"/>  
    
    <!-- generate project.json for runtime dependency -->  
    <MSBuild Projects="$(MSBuildProjectFile)"  
             Targets="CreateTestRuntimeJsonFile"/>  
     
    <!-- generate project.lock.json file corresponding to above json file -->
    <MSBuild Projects="src\Common\test_dependencies\test_dependencies.csproj"/>
    
    <!-- Package each perf test, upload it and trigger event to execute the tests -->  
    <MSBuild Projects="$(MSBuildProjectFile)" Targets="UploadPerfAssemblies" />  
  </Target>  


  <Target Name="Build">

    <!-- generate project.json for runtime dependency -->
    <MSBuild Projects="$(MSBuildProjectFile)"
             Targets="CreateTestRuntimeJsonFile"
             Condition=" '$(BuildWrappers)'=='true' " />

    <!-- generate project.lock.json file corresponding to above json file -->
    <MSBuild Projects="src\Common\test_dependencies\test_dependencies.csproj"
             Condition=" '$(BuildWrappers)'=='true' " />

    <!-- Default for building -->
    <MSBuild Projects="$(MSBuildProjectFile)"
             Targets="CreateAllWrappers"
             Properties="_CMDDIR=%(TestDirectories.Identity)"
             Condition=" '$(BuildWrappers)'=='true' " />

    <!-- Execution -->

    <MSBuild Projects="$(MSBuildProjectFile)"
             Targets="CreateTestOverlay"
             Condition=" '$(GenerateRuntimeLayout)'=='true' "/>

    <MSBuild Projects="$(MSBuildProjectFile)" Targets="RunTests"
             Condition=" '$(RunTests)'=='true' "/>
  </Target>

  <Target Name="Clean">
    <RemoveDir Condition=" '$(BuildWrappers)'=='true'" Directories="$(XunitWrapperGeneratedCSDirBase);$(XunitWrapperOutputIntermediatedDirBase)" ContinueOnError="WarnAndContinue" /> 
  </Target>
</Project>