�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2F'>rocksdb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2F'>rocksdb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2Fbuild_tools%2F'>build_tools</a>/</p><hr><h3>✏️ Editing: run_ci_db_test.ps1</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'># Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
# This script enables you running RocksDB tests by running
# All the tests concurrently and utilizing all the cores
Param(
  [switch]$EnableJE = $false,  # Look for and use test executable, append _je to listed exclusions
  [switch]$RunAll = $false,    # Will attempt discover all *_test[_je].exe binaries and run all
                               # of them as Google suites. I.e. It will run test cases concurrently
                               # except those mentioned as $Run, those will run as individual test cases
                               # And any execlued with $ExcludeExes or $ExcludeCases
                               # It will also not run any individual test cases
                               # excluded but $ExcludeCasese
  [switch]$RunAllExe = $false, # Look for and use test exdcutables, append _je to exclusions automatically
                               # It will attempt to run them in parallel w/o breaking them up on individual
                               # test cases. Those listed with $ExcludeExes will be excluded
  [string]$SuiteRun = &quot;&quot;,      # Split test suites in test cases and run in parallel, not compatible with $RunAll
  [string]$Run = &quot;&quot;,           # Run specified executables in parallel but do not split to test cases
  [string]$ExcludeCases = &quot;&quot;,  # Exclude test cases, expects a comma separated list, no spaces
                               # Takes effect when $RunAll or $SuiteRun is specified. Must have full
                               # Test cases name including a group and a parameter if any
  [string]$ExcludeExes = &quot;&quot;,   # Exclude exes from consideration, expects a comma separated list,
                               # no spaces. Takes effect only when $RunAll is specified
  [string]$WorkFolder = &quot;&quot;,    # Direct tests to use that folder. SSD or Ram drive are better options.
   # Number of async tasks that would run concurrently. Recommend a number below 64.
   # However, CPU utlization really depends on the storage media. Recommend ram based disk.
   # a value of 1 will run everything serially
  [int]$Concurrency = 8,
  [int]$Limit = -1 # -1 means do not limit for test purposes
)

# Folders and commands must be fullpath to run assuming
# the current folder is at the root of the git enlistment
$StartDate = (Get-Date)
$StartDate


$DebugPreference = &quot;Continue&quot;

# These tests are not google test suites and we should guard
# Against running them as suites
$RunOnly = New-Object System.Collections.Generic.HashSet[string]
$RunOnly.Add(&quot;c_test&quot;) | Out-Null
$RunOnly.Add(&quot;compact_on_deletion_collector_test&quot;) | Out-Null
$RunOnly.Add(&quot;merge_test&quot;) | Out-Null
$RunOnly.Add(&quot;stringappend_test&quot;) | Out-Null # Apparently incorrectly written
$RunOnly.Add(&quot;backupable_db_test&quot;) | Out-Null # Disabled
$RunOnly.Add(&quot;timer_queue_test&quot;) | Out-Null # Not a gtest

if($RunAll -and $SuiteRun -ne &quot;&quot;) {
    Write-Error &quot;$RunAll and $SuiteRun are not compatible&quot;
    exit 1
}

if($RunAllExe -and $Run -ne &quot;&quot;) {
    Write-Error &quot;$RunAllExe and $Run are not compatible&quot;
    exit 1
}

# If running under Appveyor assume that root
[string]$Appveyor = $Env:APPVEYOR_BUILD_FOLDER
if($Appveyor -ne &quot;&quot;) {
    $RootFolder = $Appveyor
} else {
    $RootFolder = $PSScriptRoot -replace &#039;\\build_tools&#039;, &#039;&#039;
}

$LogFolder = -Join($RootFolder, &quot;\db_logs\&quot;)
$BinariesFolder = -Join($RootFolder, &quot;\build\Debug\&quot;)

if($WorkFolder -eq &quot;&quot;) {

    # If TEST_TMPDIR is set use it    
    [string]$var = $Env:TEST_TMPDIR
    if($var -eq &quot;&quot;) {
        $WorkFolder = -Join($RootFolder, &quot;\db_tests\&quot;)
        $Env:TEST_TMPDIR = $WorkFolder
    } else {
        $WorkFolder = $var
    }
} else {
# Override from a command line
  $Env:TEST_TMPDIR = $WorkFolder
}

Write-Output &quot;Root: $RootFolder, WorkFolder: $WorkFolder&quot;
Write-Output &quot;BinariesFolder: $BinariesFolder, LogFolder: $LogFolder&quot;

# Create test directories in the current folder
md -Path $WorkFolder -ErrorAction Ignore | Out-Null
md -Path $LogFolder -ErrorAction Ignore | Out-Null


$ExcludeCasesSet = New-Object System.Collections.Generic.HashSet[string]
if($ExcludeCases -ne &quot;&quot;) {
    Write-Host &quot;ExcludeCases: $ExcludeCases&quot;
    $l = $ExcludeCases -split &#039; &#039;
    ForEach($t in $l) { 
      $ExcludeCasesSet.Add($t) | Out-Null
    }
}

$ExcludeExesSet = New-Object System.Collections.Generic.HashSet[string]
if($ExcludeExes -ne &quot;&quot;) {
    Write-Host &quot;ExcludeExe: $ExcludeExes&quot;
    $l = $ExcludeExes -split &#039; &#039;
    ForEach($t in $l) { 
      $ExcludeExesSet.Add($t) | Out-Null
    }
}


# Extract the names of its tests by running db_test with --gtest_list_tests.
# This filter removes the &quot;#&quot;-introduced comments, and expands to
# fully-qualified names by changing input like this:
#
#   DBTest.
#     Empty
#     WriteEmptyBatch
#   MultiThreaded/MultiThreadedDBTest.
#     MultiThreaded/0  # GetParam() = 0
#     MultiThreaded/1  # GetParam() = 1
#
# into this:
#
#   DBTest.Empty
#   DBTest.WriteEmptyBatch
#   MultiThreaded/MultiThreadedDBTest.MultiThreaded/0
#   MultiThreaded/MultiThreadedDBTest.MultiThreaded/1
#
# Output into the parameter in a form TestName -&gt; Log File Name
function ExtractTestCases([string]$GTestExe, $HashTable) {

    $Tests = @()
# Run db_test to get a list of tests and store it into $a array
    &amp;$GTestExe --gtest_list_tests | tee -Variable Tests | Out-Null

    # Current group
    $Group=&quot;&quot;

    ForEach( $l in $Tests) {

      # Leading whitespace is fine
      $l = $l -replace &#039;^\s+&#039;,&#039;&#039;
      # Trailing dot is a test group but no whitespace
      if ($l -match &quot;\.$&quot; -and $l -notmatch &quot;\s+&quot;) {
        $Group = $l
      }  else {
        # Otherwise it is a test name, remove leading space
        $test = $l
        # remove trailing comment if any and create a log name
        $test = $test -replace &#039;\s+\#.*&#039;,&#039;&#039;
        $test = &quot;$Group$test&quot;

        if($ExcludeCasesSet.Contains($test)) {
            Write-Warning &quot;$test case is excluded&quot;
            continue
        }

        $test_log = $test -replace &#039;[\./]&#039;,&#039;_&#039;
        $test_log += &quot;.log&quot;
        $log_path = -join ($LogFolder, $test_log)

        # Add to a hashtable
        $HashTable.Add($test, $log_path);
      }
    }
}

# The function removes trailing .exe siffix if any,
# creates a name for the log file
# Then adds the test name if it was not excluded into
# a HashTable in a form of test_name -&gt; log_path
function MakeAndAdd([string]$token, $HashTable) {

    $test_name = $token -replace &#039;.exe$&#039;, &#039;&#039;
    $log_name =  -join ($test_name, &quot;.log&quot;)
    $log_path = -join ($LogFolder, $log_name)
    $HashTable.Add($test_name, $log_path)
}

# This function takes a list of Suites to run
# Lists all the test cases in each of the suite
# and populates HashOfHashes
# Ordered by suite(exe) @{ Exe = @{ TestCase = LogName }}
function ProcessSuites($ListOfSuites, $HashOfHashes) {

  $suite_list = $ListOfSuites
  # Problem: if you run --gtest_list_tests on
  # a non Google Test executable then it will start executing
  # and we will get nowhere
  ForEach($suite in $suite_list) {

    if($RunOnly.Contains($suite)) {
      Write-Warning &quot;$suite is excluded from running as Google test suite&quot;
      continue
    }

    if($EnableJE) {
      $suite += &quot;_je&quot;
    }

    $Cases = [ordered]@{}
    $Cases.Clear()
    $suite_exe = -Join ($BinariesFolder, $suite)
    ExtractTestCases -GTestExe $suite_exe -HashTable $Cases
    if($Cases.Count -gt 0) {
      $HashOfHashes.Add($suite, $Cases);
    }
  }

  # Make logs and run
  if($CasesToRun.Count -lt 1) {
     Write-Error &quot;Failed to extract tests from $SuiteRun&quot;
     exit 1
  }

}

# This will contain all test executables to run

# Hash table that contains all non suite
# Test executable to run
$TestExes = [ordered]@{}

# Check for test exe that are not
# Google Test Suites
# Since this is explicitely mentioned it is not subject
# for exclusions
if($Run -ne &quot;&quot;) {

  $test_list = $Run -split &#039; &#039;
  ForEach($t in $test_list) {

    if($EnableJE) {
      $t += &quot;_je&quot;
    }
    MakeAndAdd -token $t -HashTable $TestExes
  }

  if($TestExes.Count -lt 1) {
     Write-Error &quot;Failed to extract tests from $Run&quot;
     exit 1
  }
} elseif($RunAllExe) {
  # Discover all the test binaries
  if($EnableJE) {
    $pattern = &quot;*_test_je.exe&quot;
  } else {
    $pattern = &quot;*_test.exe&quot;
  }

  $search_path = -join ($BinariesFolder, $pattern)
  Write-Host &quot;Binaries Search Path: $search_path&quot;

  $DiscoveredExe = @()
  dir -Path $search_path | ForEach-Object {
     $DiscoveredExe += ($_.Name)     
  }

  # Remove exclusions
  ForEach($e in $DiscoveredExe) {
    $e = $e -replace &#039;.exe$&#039;, &#039;&#039;
    $bare_name = $e -replace &#039;_je$&#039;, &#039;&#039;

    if($ExcludeExesSet.Contains($bare_name)) {
      Write-Warning &quot;Test $e is excluded&quot;
      continue
    }
    MakeAndAdd -token $e -HashTable $TestExes
  }

  if($TestExes.Count -lt 1) {
     Write-Error &quot;Failed to discover test executables&quot;
     exit 1
  }
}

# Ordered by exe @{ Exe = @{ TestCase = LogName }}
$CasesToRun = [ordered]@{}

if($SuiteRun -ne &quot;&quot;) {
  $suite_list = $SuiteRun -split &#039; &#039;
  ProcessSuites -ListOfSuites $suite_list -HashOfHashes $CasesToRun
} elseif ($RunAll) {
# Discover all the test binaries
  if($EnableJE) {
    $pattern = &quot;*_test_je.exe&quot;
  } else {
    $pattern = &quot;*_test.exe&quot;
  }

  $search_path = -join ($BinariesFolder, $pattern)
  Write-Host &quot;Binaries Search Path: $search_path&quot;

  $ListOfExe = @()
  dir -Path $search_path | ForEach-Object {
     $ListOfExe += ($_.Name)     
  }

  # Exclude those in RunOnly from running as suites
  $ListOfSuites = @()
  ForEach($e in $ListOfExe) {

    $e = $e -replace &#039;.exe$&#039;, &#039;&#039;
    $bare_name = $e -replace &#039;_je$&#039;, &#039;&#039;

    if($ExcludeExesSet.Contains($bare_name)) {
      Write-Warning &quot;Test $e is excluded&quot;
      continue
    }

    if($RunOnly.Contains($bare_name)) {
      MakeAndAdd -token $e -HashTable $TestExes
    } else {
      $ListOfSuites += $bare_name
    }
  }

  ProcessSuites -ListOfSuites $ListOfSuites -HashOfHashes $CasesToRun
}


# Invoke a test with a filter and redirect all output
$InvokeTestCase = {
    param($exe, $test, $log);
    &amp;$exe --gtest_filter=$test &gt; $log 2&gt;&amp;1
}

# Invoke all tests and redirect output
$InvokeTestAsync = {
    param($exe, $log)
    &amp;$exe &gt; $log 2&gt;&amp;1
}

# Hash that contains tests to rerun if any failed
# Those tests will be rerun sequentially
# $Rerun = [ordered]@{}
# Test limiting factor here
[int]$count = 0
# Overall status
[bool]$script:success = $true;

function RunJobs($Suites, $TestCmds, [int]$ConcurrencyVal)
{
    # Array to wait for any of the running jobs
    $jobs = @()
    # Hash JobToLog
    $JobToLog = @{}

    # Wait for all to finish and get the results
    while(($JobToLog.Count -gt 0) -or
          ($TestCmds.Count -gt 0) -or 
           ($Suites.Count -gt 0)) {

        # Make sure we have maximum concurrent jobs running if anything
        # and the $Limit either not set or allows to proceed
        while(($JobToLog.Count -lt $ConcurrencyVal) -and
              ((($TestCmds.Count -gt 0) -or ($Suites.Count -gt 0)) -and
              (($Limit -lt 0) -or ($count -lt $Limit)))) {

            # We always favore suites to run if available
            [string]$exe_name = &quot;&quot;
            [string]$log_path = &quot;&quot;
            $Cases = @{}

            if($Suites.Count -gt 0) {
              # Will the first one
              ForEach($e in $Suites.Keys) {
                $exe_name = $e
                $Cases = $Suites[$e]
                break
              }
              [string]$test_case = &quot;&quot;
              [string]$log_path = &quot;&quot;
              ForEach($c in $Cases.Keys) {
                 $test_case = $c
                 $log_path = $Cases[$c]
                 break
              }

              Write-Host &quot;Starting $exe_name::$test_case&quot;
              [string]$Exe =  -Join ($BinariesFolder, $exe_name)
              $job = Start-Job -Name &quot;$exe_name::$test_case&quot; -ArgumentList @($Exe,$test_case,$log_path) -ScriptBlock $InvokeTestCase
              $JobToLog.Add($job, $log_path)

              $Cases.Remove($test_case)
              if($Cases.Count -lt 1) {
                $Suites.Remove($exe_name)
              }

            } elseif ($TestCmds.Count -gt 0) {

               ForEach($e in $TestCmds.Keys) {
                 $exe_name = $e
                 $log_path = $TestCmds[$e]
                 break
               }

              Write-Host &quot;Starting $exe_name&quot;
              [string]$Exe =  -Join ($BinariesFolder, $exe_name)
              $job = Start-Job -Name $exe_name -ScriptBlock $InvokeTestAsync -ArgumentList @($Exe,$log_path)
              $JobToLog.Add($job, $log_path)

              $TestCmds.Remove($exe_name)

            } else {
                Write-Error &quot;In the job loop but nothing to run&quot;
                exit 1
            }

            ++$count
        } # End of Job starting loop

        if($JobToLog.Count -lt 1) {
          break
        }

        $jobs = @()
        foreach($k in $JobToLog.Keys) { $jobs += $k }

        $completed = Wait-Job -Job $jobs -Any
        $log = $JobToLog[$completed]
        $JobToLog.Remove($completed)

        $message = -join @($completed.Name, &quot; State: &quot;, ($completed.State))

        $log_content = @(Get-Content $log)

        if($completed.State -ne &quot;Completed&quot;) {
            $script:success = $false
            Write-Warning $message
            $log_content | Write-Warning
        } else {
            # Scan the log. If we find PASSED and no occurrence of FAILED
            # then it is a success
            [bool]$pass_found = $false
            ForEach($l in $log_content) {

                if(($l -match &quot;^\[\s+FAILED&quot;) -or
                   ($l -match &quot;Assertion failed:&quot;)) {
                    $pass_found = $false
                    break
                }

                if(($l -match &quot;^\[\s+PASSED&quot;) -or
                   ($l -match &quot; : PASSED$&quot;) -or
                    ($l -match &quot;^PASS$&quot;) -or   # Special c_test case
                    ($l -match &quot;Passed all tests!&quot;) ) {
                    $pass_found = $true
                }
            }

            if(!$pass_found) {
                $script:success = $false;
                Write-Warning $message
                $log_content | Write-Warning
            } else {
                Write-Host $message
            }
        }

        # Remove cached job info from the system
        # Should be no output
        Receive-Job -Job $completed | Out-Null
    }
}

RunJobs -Suites $CasesToRun -TestCmds $TestExes -ConcurrencyVal $Concurrency

$EndDate = (Get-Date)

New-TimeSpan -Start $StartDate -End $EndDate | 
  ForEach-Object { 
    &quot;Elapsed time: {0:g}&quot; -f $_
  }


if(!$script:success) {
# This does not succeed killing off jobs quick
# So we simply exit
#    Remove-Job -Job $jobs -Force
# indicate failure using this exit code
    exit 1
 }

 exit 0

 
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2Fbuild_tools'>🔙 Back</a></p>