PHP behat_error函数代码示例

 /**
  * Ensures the behat dir exists in moodledata
  * @param int $runprocess run process for which behat dir is returned.
  * @return string Full path
  */
 public static function get_behat_dir($runprocess = 0)
 {
     global $CFG;
     // If not set then return empty string.
     if (!isset($CFG->behat_dataroot)) {
         return "";
     }
     if (empty($runprocess)) {
         $behatdir = $CFG->behat_dataroot . '/behat';
     } else {
         if (isset($CFG->behat_parallel_run[$runprocess - 1]['behat_dataroot'])) {
             $behatdir = $CFG->behat_parallel_run[$runprocess - 1]['behat_dataroot'] . '/behat';
         } else {
             $behatdir = $CFG->behat_dataroot . $runprocess . '/behat';
         }
     }
     if (!is_dir($behatdir)) {
         if (!mkdir($behatdir, $CFG->directorypermissions, true)) {
             behat_error(BEHAT_EXITCODE_PERMISSIONS, 'Directory ' . $behatdir . ' can not be created');
         }
     }
     if (!is_writable($behatdir)) {
         behat_error(BEHAT_EXITCODE_PERMISSIONS, 'Directory ' . $behatdir . ' is not writable');
     }
     return $behatdir;
 }

 /**
  * Ensures the behat dir exists in maharadata
  * @return string Full path
  */
 public static function get_behat_dir()
 {
     global $CFG;
     $behatdir = $CFG->behat_dataroot . '/behat';
     if (!is_dir($behatdir)) {
         if (!mkdir($behatdir, $CFG->directorypermissions, true)) {
             behat_error(BEHAT_EXITCODE_PERMISSIONS, 'Directory ' . $behatdir . ' can not be created');
         }
     }
     if (!is_writable($behatdir)) {
         behat_error(BEHAT_EXITCODE_PERMISSIONS, 'Directory ' . $behatdir . ' is not writable');
     }
     return $behatdir;
 }

         }
         closedir($dh);
         unset($dh);
         unset($file);
     }
     if (defined('BEHAT_UTIL')) {
         // Now we create dataroot directory structure for behat tests.
         testing_initdataroot($CFG->behat_dataroot, 'behat');
     } else {
         behat_error(BEHAT_EXITCODE_INSTALL);
     }
 }
 if (!defined('BEHAT_UTIL') and !defined('BEHAT_TEST')) {
     // Somebody tries to access test site directly, tell them if not enabled.
     if (!file_exists($CFG->behat_dataroot . '/behat/test_environment_enabled.txt')) {
         behat_error(BEHAT_EXITCODE_CONFIG, 'Behat is configured but not enabled on this test site.');
     }
 }
 // Constant used to inform that the behat test site is being used,
 // this includes all the processes executed by the behat CLI command like
 // the site reset, the steps executed by the browser drivers when simulating
 // a user session and a real session when browsing manually to $CFG->behat_wwwroot
 // like the browser driver does automatically.
 // Different from BEHAT_TEST as only this last one can perform CLI
 // actions like reset the site or use data generators.
 define('BEHAT_SITE_RUNNING', true);
 // Clean extra config.php settings.
 behat_clean_init_config();
 // Now we can begin switching $CFG->X for $CFG->behat_X.
 $CFG->wwwroot = $CFG->behat_wwwroot;
 $CFG->prefix = $CFG->behat_prefix;

 /**
  * Return blacklisted contexts or features for a theme, as defined in blacklist.json.
  *
  * @param string $theme themename
  * @param string $testtype test type (contexts|features)
  * @return array list of blacklisted contexts or features
  */
 protected function get_blacklisted_tests_for_theme($theme, $testtype)
 {
     global $CFG;
     $themetestpath = $CFG->dirroot . DIRECTORY_SEPARATOR . "theme" . DIRECTORY_SEPARATOR . $theme . self::get_behat_tests_path();
     if (file_exists($themetestpath . DIRECTORY_SEPARATOR . 'blacklist.json')) {
         // Blacklist file exist. Leave it for last to clear the feature and contexts.
         $blacklisttests = @json_decode(file_get_contents($themetestpath . DIRECTORY_SEPARATOR . 'blacklist.json'), true);
         if (empty($blacklisttests)) {
             behat_error(BEHAT_EXITCODE_REQUIREMENT, $themetestpath . DIRECTORY_SEPARATOR . 'blacklist.json is empty');
         }
         // If features or contexts not defined then no problem.
         if (!isset($blacklisttests[$testtype])) {
             $blacklisttests[$testtype] = array();
         }
         return $blacklisttests[$testtype];
     }
     return array();
 }

 /**
  * Disables test mode
  * @throws coding_exception
  * @return void
  */
 public static function stop_test_mode()
 {
     if (!defined('BEHAT_UTIL')) {
         throw new coding_exception('This method can be only used by Behat CLI tool');
     }
     $testenvfile = self::get_test_file_path();
     if (!self::is_test_mode_enabled()) {
         echo "Test environment was already disabled\n";
     } else {
         if (!unlink($testenvfile)) {
             behat_error(BEHAT_EXITCODE_PERMISSIONS, 'Can not delete test environment file');
         }
     }
 }

/**
 * Checks that the behat config vars are properly set.
 *
 * @return void Stops execution with error code if something goes wrong.
 */
function behat_check_config_vars()
{
    global $CFG;
    // Verify prefix value.
    if (empty($CFG->behat_dbprefix)) {
        behat_error(BEHAT_EXITCODE_CONFIG, 'Define $CFG->behat_dbprefix in config.php');
    }
    if (!empty($CFG->dbprefix) and $CFG->behat_dbprefix == $CFG->dbprefix) {
        behat_error(BEHAT_EXITCODE_CONFIG, '$CFG->behat_dbprefix in config.php must be different from $CFG->dbprefix');
    }
    if (!empty($CFG->phpunit_dbprefix) and $CFG->behat_dbprefix == $CFG->phpunit_dbprefix) {
        behat_error(BEHAT_EXITCODE_CONFIG, '$CFG->behat_dbprefix in config.php must be different from $CFG->phpunit_dbprefix');
    }
    // Verify behat wwwroot value.
    if (empty($CFG->behat_wwwroot)) {
        behat_error(BEHAT_EXITCODE_CONFIG, 'Define $CFG->behat_wwwroot in config.php');
    }
    if (!empty($CFG->wwwroot) and $CFG->behat_wwwroot == $CFG->wwwroot) {
        behat_error(BEHAT_EXITCODE_CONFIG, '$CFG->behat_wwwroot in config.php must be different from $CFG->wwwroot');
    }
    // Verify behat dataroot value.
    if (empty($CFG->behat_dataroot)) {
        behat_error(BEHAT_EXITCODE_CONFIG, 'Define $CFG->behat_dataroot in config.php');
    }
    if (!file_exists($CFG->behat_dataroot)) {
        $permissions = isset($CFG->directorypermissions) ? $CFG->directorypermissions : 02777;
        umask(0);
        if (!mkdir($CFG->behat_dataroot, $permissions, true)) {
            behat_error(BEHAT_EXITCODE_PERMISSIONS, '$CFG->behat_dataroot directory can not be created');
        }
    }
    $CFG->behat_dataroot = realpath($CFG->behat_dataroot);
    if (empty($CFG->behat_dataroot) or !is_dir($CFG->behat_dataroot) or !is_writable($CFG->behat_dataroot)) {
        behat_error(BEHAT_EXITCODE_CONFIG, '$CFG->behat_dataroot in config.php must point to an existing writable directory');
    }
    if (!empty($CFG->dataroot) and $CFG->behat_dataroot == realpath($CFG->dataroot)) {
        behat_error(BEHAT_EXITCODE_CONFIG, '$CFG->behat_dataroot in config.php must be different from $CFG->dataroot');
    }
    if (!empty($CFG->phpunit_dataroot) and $CFG->behat_dataroot == realpath($CFG->phpunit_dataroot)) {
        behat_error(BEHAT_EXITCODE_CONFIG, '$CFG->behat_dataroot in config.php must be different from $CFG->phpunit_dataroot');
    }
}

 /**
  * Updates a config file
  *
  * The tests runner and the steps definitions list uses different
  * config files to avoid problems with concurrent executions.
  *
  * The steps definitions list can be filtered by component so it's
  * behat.yml is different from the $CFG->dirroot one.
  *
  * @param  string $component Restricts the obtained steps definitions to the specified component
  * @param  string $testsrunner If the config file will be used to run tests
  * @return void
  */
 public static function update_config_file($component = '', $testsrunner = true)
 {
     global $CFG;
     // Behat must have a separate behat.yml to have access to the whole set of features and steps definitions.
     if ($testsrunner === true) {
         $configfilepath = behat_command::get_behat_dir() . '/behat.yml';
     } else {
         // Alternative for steps definitions filtering, one for each user.
         $configfilepath = self::get_steps_list_config_filepath();
     }
     // Gets all the components with features.
     $features = array();
     $components = tests_finder::get_components_with_tests('features');
     if ($components) {
         foreach ($components as $componentname => $path) {
             $path = self::clean_path($path) . self::get_behat_tests_path();
             if (empty($featurespaths[$path]) && file_exists($path)) {
                 // Standarizes separator (some dirs. comes with OS-dependant separator).
                 $uniquekey = str_replace('\\', '/', $path);
                 $featurespaths[$uniquekey] = $path;
             }
         }
         $features = array_values($featurespaths);
     }
     // Optionally include features from additional directories.
     if (!empty($CFG->behat_additionalfeatures)) {
         $features = array_merge($features, array_map("realpath", $CFG->behat_additionalfeatures));
     }
     // Gets all the components with steps definitions.
     $stepsdefinitions = array();
     $steps = self::get_components_steps_definitions();
     if ($steps) {
         foreach ($steps as $key => $filepath) {
             if ($component == '' || $component === $key) {
                 $stepsdefinitions[$key] = $filepath;
             }
         }
     }
     // We don't want the deprecated steps definitions here.
     if (!$testsrunner) {
         unset($stepsdefinitions['behat_deprecated']);
     }
     // Behat config file specifing the main context class,
     // the required Behat extensions and Moodle test wwwroot.
     $contents = self::get_config_file_contents($features, $stepsdefinitions);
     // Stores the file.
     if (!file_put_contents($configfilepath, $contents)) {
         behat_error(BEHAT_EXITCODE_PERMISSIONS, 'File ' . $configfilepath . ' can not be created');
     }
 }

if (!file_exists($CFG->behat_dataroot)) {
    if (!mkdir($CFG->behat_dataroot, $CFG->directorypermissions)) {
        behat_error(BEHAT_EXITCODE_PERMISSIONS, '$CFG->behat_dataroot directory can not be created');
    }
}
if (!is_dir($CFG->behat_dataroot) || !is_writable($CFG->behat_dataroot)) {
    behat_error(BEHAT_EXITCODE_PERMISSIONS, '$CFG->behat_dataroot directory has no permissions or is not a directory');
}
// Check that the directory does not contains other things.
if (!file_exists("{$CFG->behat_dataroot}/behattestdir.txt")) {
    if ($dh = opendir($CFG->behat_dataroot)) {
        while (($file = readdir($dh)) !== false) {
            if ($file === 'behat' or $file === '.' or $file === '..' or $file === '.DS_Store') {
                continue;
            }
            behat_error(BEHAT_EXITCODE_CONFIG, '$CFG->behat_dataroot directory is not empty, ensure this is the directory where you want to install behat test dataroot');
        }
        closedir($dh);
        unset($dh);
        unset($file);
    }
    // Now we create dataroot directory structure for behat tests.
    testing_initdataroot($CFG->behat_dataroot, 'behat');
}
// Overrides vars with behat-test ones.
$vars = array('wwwroot', 'prefix', 'dataroot');
foreach ($vars as $var) {
    $CFG->{$var} = $CFG->{'behat_' . $var};
}
// Clean $CFG extra values before performing any action.
behat_clean_init_config();

/**
 * Print update progress as dots for updating feature file step list.
 *
 * @param Process $process process executing update step command.
 * @param string $featurestepfile feature step file in which steps will be saved.
 * @return int exitcode.
 */
function print_update_step_output($process, $featurestepfile)
{
    $printedlength = 0;
    echo "Updating steps feature file for parallel behat runs" . PHP_EOL;
    // Show progress while running command.
    while ($process->isRunning()) {
        usleep(10000);
        $op = $process->getIncrementalOutput();
        if (trim($op)) {
            echo ".";
            $printedlength++;
            if ($printedlength > 70) {
                $printedlength = 0;
                echo PHP_EOL;
            }
        }
    }
    // If any error then exit.
    $exitcode = $process->getExitCode();
    // Output err.
    if ($exitcode != 0) {
        echo $process->getErrorOutput();
        exit($exitcode);
    }
    // Extract features with step info and save it in file.
    $featuresteps = $process->getOutput();
    $featuresteps = explode(PHP_EOL, $featuresteps);
    $realroot = realpath(__DIR__ . '/../../../../') . '/';
    foreach ($featuresteps as $featurestep) {
        if (trim($featurestep)) {
            $step = explode("::", $featurestep);
            $step[0] = str_replace($realroot, '', $step[0]);
            $steps[$step[0]] = $step[1];
        }
    }
    arsort($steps);
    if (!@file_put_contents($featurestepfile, json_encode($steps, JSON_PRETTY_PRINT))) {
        behat_error(BEHAT_EXITCODE_PERMISSIONS, 'File ' . $featurestepfile . ' can not be created');
        $exitcode = -1;
    }
    echo PHP_EOL . "Updated step count in " . $featurestepfile . PHP_EOL;
    return $exitcode;
}

/**
 * Checks that the behat config vars are properly set.
 *
 * @return void Stops execution with error code if something goes wrong.
 */
function behat_check_config_vars()
{
    global $CFG;
    // CFG->behat_prefix must be set and with value different than CFG->prefix and phpunit_prefix.
    if (empty($CFG->behat_prefix) || $CFG->behat_prefix == $CFG->prefix || !empty($CFG->phpunit_prefix) && $CFG->behat_prefix == $CFG->phpunit_prefix) {
        behat_error(BEHAT_EXITCODE_CONFIG, 'Define $CFG->behat_prefix in config.php with a value different than $CFG->prefix and $CFG->phpunit_prefix');
    }
    // $CFG->behat_wwwroot must be different than CFG->wwwroot if it is set, it may not be set as
    // it can take the default value and we should also consider that will have the same value than
    // $CFG->wwwroot if $CFG->behat_switchcompletely is set.
    if (!empty($CFG->behat_wwwroot) && $CFG->behat_wwwroot == $CFG->wwwroot && empty($CFG->behat_switchcompletely)) {
        behat_error(BEHAT_EXITCODE_CONFIG, 'Define $CFG->behat_wwwroot in config.php with a value different than $CFG->wwwroot');
    }
    // CFG->behat_dataroot must be set and with value different than CFG->dataroot and phpunit_dataroot.
    $CFG->dataroot = realpath($CFG->dataroot);
    if (!empty($CFG->behat_dataroot) && is_dir($CFG->behat_dataroot)) {
        $CFG->behat_dataroot = realpath($CFG->behat_dataroot);
    }
    if (empty($CFG->behat_dataroot) || $CFG->behat_dataroot == $CFG->dataroot || !empty($CFG->phpunit_dataroot) && is_dir($CFG->phpunit_dataroot) && $CFG->behat_dataroot == realpath($CFG->phpunit_dataroot)) {
        behat_error(BEHAT_EXITCODE_CONFIG, 'Define $CFG->behat_dataroot in config.php with a value different than $CFG->dataroot and $CFG->phpunit_dataroot');
    }
}

 /**
  * Checks if behat is set up and working
  *
  * Uses notice() instead of behat_error() because is
  * also called from web interface
  *
  * It checks behat dependencies have been installed and runs
  * the behat help command to ensure it works as expected
  *
  * @param  bool $checkphp Extra check for the PHP version
  * @return void
  */
 public static function check_behat_setup($checkphp = false)
 {
     global $CFG;
     // We don't check the PHP version if $CFG->behat_switchcompletely has been enabled.
     // Here we are in CLI.
     if (empty($CFG->behat_switchcompletely) && $checkphp && version_compare(PHP_VERSION, '5.4.0', '<')) {
         behat_error(BEHAT_EXITCODE_REQUIREMENT, 'PHP 5.4 is required. See config-dist.php for possible alternatives');
     }
     // Moodle setting.
     if (!self::are_behat_dependencies_installed()) {
         $msg = get_string('wrongbehatsetup', 'tool_behat');
         // With HTML.
         $docslink = self::DOCS_URL . '#Installation';
         if (!CLI_SCRIPT) {
             $docslink = html_writer::tag('a', $docslink, array('href' => $docslink, 'target' => '_blank'));
         }
         $msg .= '. ' . get_string('moreinfoin', 'tool_behat', $docslink);
         notice($msg);
     }
     // Behat test command.
     list($output, $code) = self::run(' --help');
     if ($code != 0) {
         notice(get_string('wrongbehatsetup', 'tool_behat'));
     }
     // Checking behat dataroot existence otherwise notice about admin/tool/behat/cli/util.php.
     if (empty($CFG->behat_dataroot) || !is_dir($CFG->behat_dataroot) || !is_writable($CFG->behat_dataroot)) {
         notice(get_string('runclitool', 'tool_behat', 'php admin/tool/behat/cli/util.php'));
     }
 }

 /**
  * Updates a config file
  *
  * The tests runner and the steps definitions list uses different
  * config files to avoid problems with concurrent executions.
  *
  * The steps definitions list can be filtered by component so it's
  * behat.yml is different from the $CFG->dirroot one.
  *
  * @param  string $component Restricts the obtained steps definitions to the specified component
  * @param  string $testsrunner If the config file will be used to run tests
  * @param  string $tags features files including tags.
  * @param  bool   $themesuitewithallfeatures if only theme specific features need to be included in the suite.
  * @param  int    $parallelruns number of parallel runs.
  * @param  int    $run current run for which config needs to be updated.
  * @return void
  */
 public static function update_config_file($component = '', $testsrunner = true, $tags = '', $themesuitewithallfeatures = false, $parallelruns = 0, $run = 0)
 {
     global $CFG;
     // Behat must have a separate behat.yml to have access to the whole set of features and steps definitions.
     if ($testsrunner === true) {
         $configfilepath = behat_command::get_behat_dir() . '/behat.yml';
     } else {
         // Alternative for steps definitions filtering, one for each user.
         $configfilepath = self::get_steps_list_config_filepath();
     }
     $behatconfigutil = self::get_behat_config_util();
     $behatconfigutil->set_theme_suite_to_include_core_features($themesuitewithallfeatures);
     $behatconfigutil->set_tag_for_feature_filter($tags);
     // Gets all the components with features, if running the tests otherwise not required.
     $features = array();
     if ($testsrunner) {
         $features = $behatconfigutil->get_components_features();
     }
     // Gets all the components with steps definitions.
     $stepsdefinitions = $behatconfigutil->get_components_contexts($component);
     // We don't want the deprecated steps definitions here.
     if (!$testsrunner) {
         unset($stepsdefinitions['behat_deprecated']);
     }
     // Get current run.
     if (empty($run) && $run !== false && !empty($CFG->behatrunprocess)) {
         $run = $CFG->behatrunprocess;
     }
     // Get number of parallel runs if not passed.
     if (empty($parallelruns) && $parallelruns !== false) {
         $parallelruns = self::get_parallel_test_runs();
     }
     // Behat config file specifing the main context class,
     // the required Behat extensions and Moodle test wwwroot.
     $contents = $behatconfigutil->get_config_file_contents($features, $stepsdefinitions, $tags, $parallelruns, $run);
     // Stores the file.
     if (!file_put_contents($configfilepath, $contents)) {
         behat_error(BEHAT_EXITCODE_PERMISSIONS, 'File ' . $configfilepath . ' can not be created');
     }
 }

 /**
  * Checks if behat is set up and working
  *
  * Uses notice() instead of behat_error() because is
  * also called from web interface
  *
  * It checks behat dependencies have been installed and runs
  * the behat help command to ensure it works as expected
  *
  * @param  bool $checkphp Extra check for the PHP version
  * @return int Error code or 0 if all ok
  */
 public static function behat_setup_problem($checkphp = false)
 {
     global $CFG;
     // We don't check the PHP version if $CFG->behat_switchcompletely has been enabled.
     // Here we are in CLI.
     if (empty($CFG->behat_switchcompletely) && $checkphp && version_compare(PHP_VERSION, '5.4.0', '<')) {
         behat_error(BEHAT_EXITCODE_REQUIREMENT, 'PHP 5.4 is required. See config-dist.php for possible alternatives');
     }
     $clibehaterrorstr = "Behat dependencies not installed. Ensure you ran the composer installer. " . self::DOCS_URL . "#Installation\n";
     // Moodle setting.
     if (!self::are_behat_dependencies_installed()) {
         // With HTML.
         if (!CLI_SCRIPT) {
             $msg = get_string('wrongbehatsetup', 'tool_behat');
             $docslink = self::DOCS_URL . '#Installation';
             $docslink = html_writer::tag('a', $docslink, array('href' => $docslink, 'target' => '_blank'));
             $msg .= get_string('moreinfoin', 'tool_behat', $docslink);
         } else {
             $msg = $clibehaterrorstr;
         }
         self::output_msg($msg);
         return BEHAT_EXITCODE_COMPOSER;
     }
     // Behat test command.
     list($output, $code) = self::run(' --help');
     if ($code != 0) {
         // Returning composer error code to avoid conflicts with behat and moodle error codes.
         if (!CLI_SCRIPT) {
             $msg = get_string('wrongbehatsetup', 'tool_behat');
         } else {
             $msg = $clibehaterrorstr;
         }
         self::output_msg($msg);
         return BEHAT_EXITCODE_COMPOSER;
     }
     // Checking behat dataroot existence otherwise echo about admin/tool/behat/cli/init.php.
     if (empty($CFG->behat_dataroot) || !is_dir($CFG->behat_dataroot) || !is_writable($CFG->behat_dataroot)) {
         self::output_msg(get_string('runclitool', 'tool_behat', 'php admin/tool/behat/cli/init.php'));
         return BEHAT_EXITCODE_CONFIG;
     }
     return 0;
 }

 /**
  * Updates a config file
  *
  * The tests runner and the steps definitions list uses different
  * config files to avoid problems with concurrent executions.
  *
  * The steps definitions list can be filtered by plugin so it's
  * behat.yml is different from the $CFG->docroot one.
  *
  * @param  string $plugin Restricts the obtained steps definitions to the specified plugin
  * @param  string $testsrunner If the config file will be used to run tests
  * @return void
  */
 public static function update_config_file($plugin = '', $testsrunner = true)
 {
     global $CFG;
     // Behat must have a separate behat.yml to have access to the whole set of features and steps definitions.
     if ($testsrunner === true) {
         $configfilepath = BehatCommand::get_behat_dir() . '/behat.yml';
     } else {
         // Alternative for steps definitions filtering, one for each user.
         $configfilepath = self::get_steps_list_config_filepath();
     }
     // Get core features
     $features = array(dirname(dirname(dirname(dirname(dirname(__DIR__))))) . '/test/behat/features');
     // Gets all the plugins with features.
     $plugins = TestsFinder::get_plugins_with_tests('features');
     if ($plugins) {
         foreach ($plugins as $pluginname => $path) {
             $path = self::clean_path($path) . self::get_behat_tests_path();
             if (empty($featurespaths[$path]) && file_exists($path)) {
                 // Standarizes separator (some dirs. comes with OS-dependant separator).
                 $uniquekey = str_replace('\\', '/', $path);
                 $featurespaths[$uniquekey] = $path;
             }
         }
         $features = array_merge($features, array_values($featurespaths));
     }
     // Optionally include features from additional directories.
     if (!empty($CFG->behat_additionalfeatures)) {
         $features = array_merge($features, array_map("realpath", $CFG->behat_additionalfeatures));
     }
     $stepsdefinitions = array();
     // Find step definitions from core. They must be in the folder $MAHARA_ROOT/test/behat/stepdefinitions
     // The file name must be /^Behat[A-z0-9_]+\.php$/
     $regite = new RegexIterator(new DirectoryIterator(get_mahararoot_dir() . '/test/behat/stepdefinitions'), '|^Behat[A-z0-9_\\-]+\\.php$|');
     foreach ($regite as $file) {
         $key = $file->getBasename('.php');
         $stepsdefinitions[$key] = $file->getPathname();
     }
     // Gets all the plugins with steps definitions.
     $steps = self::get_plugins_steps_definitions();
     if ($steps) {
         foreach ($steps as $key => $filepath) {
             if ($plugin === '' || $plugin === $key) {
                 $stepsdefinitions[$key] = $filepath;
             }
         }
     }
     // We don't want the deprecated steps definitions here.
     if (!$testsrunner) {
         unset($stepsdefinitions['behat_deprecated']);
     }
     // Behat config file specifing the main context class,
     // the required Behat extensions and Mahara test wwwroot.
     $contents = self::get_config_file_contents($features, $stepsdefinitions);
     // Stores the file.
     if (!file_put_contents($configfilepath, $contents)) {
         behat_error(BEHAT_EXITCODE_PERMISSIONS, 'File ' . $configfilepath . ' can not be created');
     }
 }