cmake-presets: Add build and test presets

Fixes: #21391

9 files changed, 1868 insertions, 343 deletions

diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx
index 2f41f70..f593f83 100644
--- a/Source/QtDialog/QCMake.cxx
+++ b/Source/QtDialog/QCMake.cxx
@@ -68,9 +68,9 @@ QCMake::QCMake(QObject* p)
   connect(&this->LoadPresetsTimer, &QTimer::timeout, this, [this]() {
     this->loadPresets();
     if (!this->PresetName.isEmpty() &&
-        this->CMakePresetsFile.Presets.find(
+        this->CMakePresetsFile.ConfigurePresets.find(
           std::string(this->PresetName.toLocal8Bit())) ==
-          this->CMakePresetsFile.Presets.end()) {
+          this->CMakePresetsFile.ConfigurePresets.end()) {
       this->setPreset(QString{});
     }
   });
@@ -158,7 +158,7 @@ void QCMake::setPreset(const QString& name, bool setBinary)
     if (!name.isNull()) {
       std::string presetName(name.toLocal8Bit());
       auto const& expandedPreset =
-        this->CMakePresetsFile.Presets[presetName].Expanded;
+        this->CMakePresetsFile.ConfigurePresets[presetName].Expanded;
       if (expandedPreset) {
         if (setBinary) {
           QString binaryDir =
@@ -420,7 +420,8 @@ QCMakePropertyList QCMake::properties() const
 
   if (!this->PresetName.isNull()) {
     std::string presetName(this->PresetName.toLocal8Bit());
-    auto const& p = this->CMakePresetsFile.Presets.at(presetName).Expanded;
+    auto const& p =
+      this->CMakePresetsFile.ConfigurePresets.at(presetName).Expanded;
     if (p) {
       for (auto const& v : p->CacheVariables) {
         if (!v.second) {
@@ -535,8 +536,8 @@ void QCMake::loadPresets()
   this->LastLoadPresetsResult = result;
 
   QVector<QCMakePreset> presets;
-  for (auto const& name : this->CMakePresetsFile.PresetOrder) {
-    auto const& it = this->CMakePresetsFile.Presets[name];
+  for (auto const& name : this->CMakePresetsFile.ConfigurePresetOrder) {
+    auto const& it = this->CMakePresetsFile.ConfigurePresets[name];
     auto const& p = it.Unexpanded;
     if (p.Hidden) {
       continue;
diff --git a/Source/cmCMakePresetsFile.cxx b/Source/cmCMakePresetsFile.cxx
index 8762158..e5557e6 100644
--- a/Source/cmCMakePresetsFile.cxx
+++ b/Source/cmCMakePresetsFile.cxx
@@ -5,6 +5,7 @@
 #include <algorithm>
 #include <cstdlib>
 #include <functional>
+#include <iostream>
 #include <iterator>
 #include <utility>
 
@@ -20,6 +21,26 @@
 #include "cmSystemTools.h"
 #include "cmVersion.h"
 
+#define CHECK_OK(expr)                                                        \
+  {                                                                           \
+    auto _result = expr;                                                      \
+    if (_result != ReadFileResult::READ_OK)                                   \
+      return _result;                                                         \
+  }
+
+#define CHECK_EXPAND(out, field, expanders)                                   \
+  {                                                                           \
+    switch (ExpandMacros(field, expanders)) {                                 \
+      case ExpandMacroResult::Error:                                          \
+        return false;                                                         \
+      case ExpandMacroResult::Ignore:                                         \
+        out.reset();                                                          \
+        return true;                                                          \
+      case ExpandMacroResult::Ok:                                             \
+        break;                                                                \
+    }                                                                         \
+  }
+
 namespace {
 enum class CycleStatus
 {
@@ -30,12 +51,13 @@ enum class CycleStatus
 
 using ReadFileResult = cmCMakePresetsFile::ReadFileResult;
 using CacheVariable = cmCMakePresetsFile::CacheVariable;
-using UnexpandedPreset = cmCMakePresetsFile::UnexpandedPreset;
-using ExpandedPreset = cmCMakePresetsFile::ExpandedPreset;
+using ConfigurePreset = cmCMakePresetsFile::ConfigurePreset;
+using BuildPreset = cmCMakePresetsFile::BuildPreset;
+using TestPreset = cmCMakePresetsFile::TestPreset;
 using ArchToolsetStrategy = cmCMakePresetsFile::ArchToolsetStrategy;
 
 constexpr int MIN_VERSION = 1;
-constexpr int MAX_VERSION = 1;
+constexpr int MAX_VERSION = 2;
 
 struct CMakeVersion
 {
@@ -47,7 +69,9 @@ struct CMakeVersion
 struct RootPresets
 {
   CMakeVersion CMakeMinimumRequired;
-  std::vector<cmCMakePresetsFile::UnexpandedPreset> Presets;
+  std::vector<cmCMakePresetsFile::ConfigurePreset> ConfigurePresets;
+  std::vector<cmCMakePresetsFile::BuildPreset> BuildPresets;
+  std::vector<cmCMakePresetsFile::TestPreset> TestPresets;
 };
 
 cmJSONHelper<std::nullptr_t, ReadFileResult> VendorHelper(ReadFileResult error)
@@ -183,35 +207,43 @@ auto const PresetOptionalBoolHelper =
   cmJSONOptionalHelper<bool, ReadFileResult>(ReadFileResult::READ_OK,
                                              PresetBoolHelper);
 
+auto const PresetIntHelper = cmJSONIntHelper<ReadFileResult>(
+  ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET);
+
+auto const PresetOptionalIntHelper = cmJSONOptionalHelper<int, ReadFileResult>(
+  ReadFileResult::READ_OK, PresetIntHelper);
+
+auto const PresetVectorIntHelper = cmJSONVectorHelper<int, ReadFileResult>(
+  ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, PresetIntHelper);
+
 auto const PresetWarningsHelper =
-  cmJSONObjectHelper<UnexpandedPreset, ReadFileResult>(
+  cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
     ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
-    .Bind("dev"_s, &UnexpandedPreset::WarnDev, PresetOptionalBoolHelper, false)
-    .Bind("deprecated"_s, &UnexpandedPreset::WarnDeprecated,
+    .Bind("dev"_s, &ConfigurePreset::WarnDev, PresetOptionalBoolHelper, false)
+    .Bind("deprecated"_s, &ConfigurePreset::WarnDeprecated,
           PresetOptionalBoolHelper, false)
-    .Bind("uninitialized"_s, &UnexpandedPreset::WarnUninitialized,
+    .Bind("uninitialized"_s, &ConfigurePreset::WarnUninitialized,
           PresetOptionalBoolHelper, false)
-    .Bind("unusedCli"_s, &UnexpandedPreset::WarnUnusedCli,
+    .Bind("unusedCli"_s, &ConfigurePreset::WarnUnusedCli,
           PresetOptionalBoolHelper, false)
-    .Bind("systemVars"_s, &UnexpandedPreset::WarnSystemVars,
+    .Bind("systemVars"_s, &ConfigurePreset::WarnSystemVars,
           PresetOptionalBoolHelper, false);
 
 auto const PresetErrorsHelper =
-  cmJSONObjectHelper<UnexpandedPreset, ReadFileResult>(
+  cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
     ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
-    .Bind("dev"_s, &UnexpandedPreset::ErrorDev, PresetOptionalBoolHelper,
-          false)
-    .Bind("deprecated"_s, &UnexpandedPreset::ErrorDeprecated,
+    .Bind("dev"_s, &ConfigurePreset::ErrorDev, PresetOptionalBoolHelper, false)
+    .Bind("deprecated"_s, &ConfigurePreset::ErrorDeprecated,
           PresetOptionalBoolHelper, false);
 
 auto const PresetDebugHelper =
-  cmJSONObjectHelper<UnexpandedPreset, ReadFileResult>(
+  cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
     ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
-    .Bind("output"_s, &UnexpandedPreset::DebugOutput, PresetOptionalBoolHelper,
+    .Bind("output"_s, &ConfigurePreset::DebugOutput, PresetOptionalBoolHelper,
           false)
-    .Bind("tryCompile"_s, &UnexpandedPreset::DebugTryCompile,
+    .Bind("tryCompile"_s, &ConfigurePreset::DebugTryCompile,
           PresetOptionalBoolHelper, false)
-    .Bind("find"_s, &UnexpandedPreset::DebugFind, PresetOptionalBoolHelper,
+    .Bind("find"_s, &ConfigurePreset::DebugFind, PresetOptionalBoolHelper,
           false);
 
 ReadFileResult ArchToolsetStrategyHelper(
@@ -239,18 +271,18 @@ ReadFileResult ArchToolsetStrategyHelper(
   return ReadFileResult::INVALID_PRESET;
 }
 
-std::function<ReadFileResult(UnexpandedPreset&, const Json::Value*)>
+std::function<ReadFileResult(ConfigurePreset&, const Json::Value*)>
 ArchToolsetHelper(
-  std::string UnexpandedPreset::*valueField,
-  cm::optional<ArchToolsetStrategy> UnexpandedPreset::*strategyField)
+  std::string ConfigurePreset::*valueField,
+  cm::optional<ArchToolsetStrategy> ConfigurePreset::*strategyField)
 {
   auto const objectHelper =
-    cmJSONObjectHelper<UnexpandedPreset, ReadFileResult>(
+    cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
       ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
       .Bind("value", valueField, PresetStringHelper, false)
       .Bind("strategy", strategyField, ArchToolsetStrategyHelper, false);
   return [valueField, strategyField, objectHelper](
-           UnexpandedPreset& out, const Json::Value* value) -> ReadFileResult {
+           ConfigurePreset& out, const Json::Value* value) -> ReadFileResult {
     if (!value) {
       (out.*valueField).clear();
       out.*strategyField = cm::nullopt;
@@ -272,41 +304,397 @@ ArchToolsetHelper(
 }
 
 auto const ArchitectureHelper = ArchToolsetHelper(
-  &UnexpandedPreset::Architecture, &UnexpandedPreset::ArchitectureStrategy);
+  &ConfigurePreset::Architecture, &ConfigurePreset::ArchitectureStrategy);
 auto const ToolsetHelper = ArchToolsetHelper(
-  &UnexpandedPreset::Toolset, &UnexpandedPreset::ToolsetStrategy);
+  &ConfigurePreset::Toolset, &ConfigurePreset::ToolsetStrategy);
 
-auto const PresetHelper =
-  cmJSONObjectHelper<UnexpandedPreset, ReadFileResult>(
+auto const ConfigurePresetHelper =
+  cmJSONObjectHelper<ConfigurePreset, ReadFileResult>(
     ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
-    .Bind("name"_s, &UnexpandedPreset::Name, PresetStringHelper)
-    .Bind("inherits"_s, &UnexpandedPreset::Inherits, PresetInheritsHelper,
+    .Bind("name"_s, &ConfigurePreset::Name, PresetStringHelper)
+    .Bind("inherits"_s, &ConfigurePreset::Inherits, PresetInheritsHelper,
           false)
-    .Bind("hidden"_s, &UnexpandedPreset::Hidden, PresetBoolHelper, false)
+    .Bind("hidden"_s, &ConfigurePreset::Hidden, PresetBoolHelper, false)
     .Bind<std::nullptr_t>("vendor"_s, nullptr,
                           VendorHelper(ReadFileResult::INVALID_PRESET), false)
-    .Bind("displayName"_s, &UnexpandedPreset::DisplayName, PresetStringHelper,
+    .Bind("displayName"_s, &ConfigurePreset::DisplayName, PresetStringHelper,
           false)
-    .Bind("description"_s, &UnexpandedPreset::Description, PresetStringHelper,
+    .Bind("description"_s, &ConfigurePreset::Description, PresetStringHelper,
           false)
-    .Bind("generator"_s, &UnexpandedPreset::Generator, PresetStringHelper,
+    .Bind("generator"_s, &ConfigurePreset::Generator, PresetStringHelper,
           false)
     .Bind("architecture"_s, ArchitectureHelper, false)
     .Bind("toolset"_s, ToolsetHelper, false)
-    .Bind("binaryDir"_s, &UnexpandedPreset::BinaryDir, PresetStringHelper,
+    .Bind("binaryDir"_s, &ConfigurePreset::BinaryDir, PresetStringHelper,
           false)
     .Bind<std::string>("cmakeExecutable"_s, nullptr, PresetStringHelper, false)
-    .Bind("cacheVariables"_s, &UnexpandedPreset::CacheVariables,
+    .Bind("cacheVariables"_s, &ConfigurePreset::CacheVariables,
           VariablesHelper, false)
-    .Bind("environment"_s, &UnexpandedPreset::Environment,
-          EnvironmentMapHelper, false)
+    .Bind("environment"_s, &ConfigurePreset::Environment, EnvironmentMapHelper,
+          false)
     .Bind("warnings"_s, PresetWarningsHelper, false)
     .Bind("errors"_s, PresetErrorsHelper, false)
     .Bind("debug"_s, PresetDebugHelper, false);
 
-auto const PresetsHelper =
-  cmJSONVectorHelper<UnexpandedPreset, ReadFileResult>(
-    ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESETS, PresetHelper);
+auto const BuildPresetHelper =
+  cmJSONObjectHelper<BuildPreset, ReadFileResult>(
+    ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
+    .Bind("name"_s, &BuildPreset::Name, PresetStringHelper)
+    .Bind("inherits"_s, &BuildPreset::Inherits, PresetInheritsHelper, false)
+    .Bind("hidden"_s, &BuildPreset::Hidden, PresetBoolHelper, false)
+    .Bind<std::nullptr_t>("vendor"_s, nullptr,
+                          VendorHelper(ReadFileResult::INVALID_PRESET), false)
+    .Bind("displayName"_s, &BuildPreset::DisplayName, PresetStringHelper,
+          false)
+    .Bind("description"_s, &BuildPreset::Description, PresetStringHelper,
+          false)
+    .Bind("environment"_s, &BuildPreset::Environment, EnvironmentMapHelper,
+          false)
+    .Bind("configurePreset"_s, &BuildPreset::ConfigurePreset,
+          PresetStringHelper, false)
+    .Bind("inheritConfigureEnvironment"_s,
+          &BuildPreset::InheritConfigureEnvironment, PresetOptionalBoolHelper,
+          false)
+    .Bind("jobs"_s, &BuildPreset::Jobs, PresetOptionalIntHelper, false)
+    .Bind("targets"_s, &BuildPreset::Targets, PresetVectorStringHelper, false)
+    .Bind("configuration"_s, &BuildPreset::Configuration, PresetStringHelper,
+          false)
+    .Bind("cleanFirst"_s, &BuildPreset::CleanFirst, PresetOptionalBoolHelper,
+          false)
+    .Bind("verbose"_s, &BuildPreset::Verbose, PresetOptionalBoolHelper, false)
+    .Bind("nativeToolOptions"_s, &BuildPreset::NativeToolOptions,
+          PresetVectorStringHelper, false);
+
+ReadFileResult TestPresetOutputVerbosityHelper(
+  TestPreset::OutputOptions::VerbosityEnum& out, const Json::Value* value)
+{
+  if (!value) {
+    out = TestPreset::OutputOptions::VerbosityEnum::Default;
+    return ReadFileResult::READ_OK;
+  }
+
+  if (!value->isString()) {
+    return ReadFileResult::INVALID_PRESET;
+  }
+
+  if (value->asString() == "default") {
+    out = TestPreset::OutputOptions::VerbosityEnum::Default;
+    return ReadFileResult::READ_OK;
+  }
+
+  if (value->asString() == "verbose") {
+    out = TestPreset::OutputOptions::VerbosityEnum::Verbose;
+    return ReadFileResult::READ_OK;
+  }
+
+  if (value->asString() == "extra") {
+    out = TestPreset::OutputOptions::VerbosityEnum::Extra;
+    return ReadFileResult::READ_OK;
+  }
+
+  return ReadFileResult::INVALID_PRESET;
+}
+
+auto const TestPresetOptionalOutputVerbosityHelper =
+  cmJSONOptionalHelper<TestPreset::OutputOptions::VerbosityEnum,
+                       ReadFileResult>(ReadFileResult::READ_OK,
+                                       TestPresetOutputVerbosityHelper);
+
+auto const TestPresetOptionalOutputHelper =
+  cmJSONOptionalHelper<TestPreset::OutputOptions, ReadFileResult>(
+    ReadFileResult::READ_OK,
+    cmJSONObjectHelper<TestPreset::OutputOptions, ReadFileResult>(
+      ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
+      .Bind("shortProgress"_s, &TestPreset::OutputOptions::ShortProgress,
+            PresetOptionalBoolHelper, false)
+      .Bind("verbosity"_s, &TestPreset::OutputOptions::Verbosity,
+            TestPresetOptionalOutputVerbosityHelper, false)
+      .Bind("debug"_s, &TestPreset::OutputOptions::Debug,
+            PresetOptionalBoolHelper, false)
+      .Bind("outputOnFailure"_s, &TestPreset::OutputOptions::OutputOnFailure,
+            PresetOptionalBoolHelper, false)
+      .Bind("quiet"_s, &TestPreset::OutputOptions::Quiet,
+            PresetOptionalBoolHelper, false)
+      .Bind("outputLogFile"_s, &TestPreset::OutputOptions::OutputLogFile,
+            PresetStringHelper, false)
+      .Bind("labelSummary"_s, &TestPreset::OutputOptions::LabelSummary,
+            PresetOptionalBoolHelper, false)
+      .Bind("subprojectSummary"_s,
+            &TestPreset::OutputOptions::SubprojectSummary,
+            PresetOptionalBoolHelper, false)
+      .Bind("maxPassedTestOutputSize"_s,
+            &TestPreset::OutputOptions::MaxPassedTestOutputSize,
+            PresetOptionalIntHelper, false)
+      .Bind("maxFailedTestOutputSize"_s,
+            &TestPreset::OutputOptions::MaxFailedTestOutputSize,
+            PresetOptionalIntHelper, false)
+      .Bind("maxTestNameWidth"_s, &TestPreset::OutputOptions::MaxTestNameWidth,
+            PresetOptionalIntHelper, false));
+
+auto const TestPresetOptionalFilterIncludeIndexObjectHelper =
+  cmJSONOptionalHelper<TestPreset::IncludeOptions::IndexOptions,
+                       ReadFileResult>(
+    ReadFileResult::READ_OK,
+    cmJSONObjectHelper<TestPreset::IncludeOptions::IndexOptions,
+                       ReadFileResult>(ReadFileResult::READ_OK,
+                                       ReadFileResult::INVALID_PRESET)
+      .Bind("start"_s, &TestPreset::IncludeOptions::IndexOptions::Start,
+            PresetOptionalIntHelper, false)
+      .Bind("end"_s, &TestPreset::IncludeOptions::IndexOptions::End,
+            PresetOptionalIntHelper, false)
+      .Bind("stride"_s, &TestPreset::IncludeOptions::IndexOptions::Stride,
+            PresetOptionalIntHelper, false)
+      .Bind("specificTests"_s,
+            &TestPreset::IncludeOptions::IndexOptions::SpecificTests,
+            PresetVectorIntHelper, false));
+
+ReadFileResult TestPresetOptionalFilterIncludeIndexHelper(
+  cm::optional<TestPreset::IncludeOptions::IndexOptions>& out,
+  const Json::Value* value)
+{
+  if (!value) {
+    out = cm::nullopt;
+    return ReadFileResult::READ_OK;
+  }
+
+  if (value->isString()) {
+    out.emplace();
+    out->IndexFile = value->asString();
+    return ReadFileResult::READ_OK;
+  }
+
+  if (value->isObject()) {
+    return TestPresetOptionalFilterIncludeIndexObjectHelper(out, value);
+  }
+
+  return ReadFileResult::INVALID_PRESET;
+}
+
+auto const TestPresetOptionalFilterIncludeHelper =
+  cmJSONOptionalHelper<TestPreset::IncludeOptions, ReadFileResult>(
+    ReadFileResult::READ_OK,
+    cmJSONObjectHelper<TestPreset::IncludeOptions, ReadFileResult>(
+      ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET)
+      .Bind("name"_s, &TestPreset::IncludeOptions::Name, PresetStringHelper,
+            false)
+      .Bind("label"_s, &TestPreset::IncludeOptions::Label, PresetStringHelper,
+            false)
+      .Bind("index"_s, &TestPreset::IncludeOptions::Index,
+            TestPresetOptionalFilterIncludeIndexHelper, false)
+      .Bind("useUnion"_s, &TestPreset::IncludeOptions::UseUnion,
+            PresetOptionalBoolHelper, false));
+
+auto const TestPresetOptionalFilterExcludeFixturesHelper =
+  cmJSONOptionalHelper<TestPreset::ExcludeOptions::FixturesOptions,
+                       ReadFileResult>(
+    ReadFileResult::READ_OK,
+    cmJSONObjectHelper<TestPreset::ExcludeOptions::FixturesOptions,
+                       ReadFileResult>(ReadFileResult::READ_OK,
+                                       ReadFileResult::INVALID_PRESET)
+      .Bind("any"_s, &TestPreset::ExcludeOptions::FixturesOptions::Any,
+            PresetStringHelper, false)
+      .Bind("setup"_s, &TestPreset::ExcludeOptions::FixturesOptions::Setup,
+            PresetStringHelper, false)
+      .Bind("cleanup"_s, &TestPreset::ExcludeOptions::FixturesOptions::Cleanup,
+            PresetStringHelper, false));
+
+auto const TestPresetOptionalFilterExcludeHelper =
+  cmJSONOptionalHelper<TestPreset::ExcludeOptions, ReadFileResult>(
+    ReadFileResult::READ_OK,
+    cmJSONObjectHelper<TestPreset::ExcludeOptions, ReadFileResult>(
+      ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET)
+      .Bind("name"_s, &TestPreset::ExcludeOptions::Name, PresetStringHelper,
+            false)
+      .Bind("label"_s, &TestPreset::ExcludeOptions::Label, PresetStringHelper,
+            false)
+      .Bind("fixtures"_s, &TestPreset::ExcludeOptions::Fixtures,
+            TestPresetOptionalFilterExcludeFixturesHelper, false));
+
+ReadFileResult TestPresetExecutionShowOnlyHelper(
+  TestPreset::ExecutionOptions::ShowOnlyEnum& out, const Json::Value* value)
+{
+  if (!value || !value->isString()) {
+    return ReadFileResult::INVALID_PRESET;
+  }
+
+  if (value->asString() == "human") {
+    out = TestPreset::ExecutionOptions::ShowOnlyEnum::Human;
+    return ReadFileResult::READ_OK;
+  }
+
+  if (value->asString() == "json-v1") {
+    out = TestPreset::ExecutionOptions::ShowOnlyEnum::JsonV1;
+    return ReadFileResult::READ_OK;
+  }
+
+  return ReadFileResult::INVALID_PRESET;
+}
+
+auto const TestPresetOptionalExecutionShowOnlyHelper =
+  cmJSONOptionalHelper<TestPreset::ExecutionOptions::ShowOnlyEnum,
+                       ReadFileResult>(ReadFileResult::READ_OK,
+                                       TestPresetExecutionShowOnlyHelper);
+
+ReadFileResult TestPresetExecutionModeHelper(
+  TestPreset::ExecutionOptions::RepeatOptions::ModeEnum& out,
+  const Json::Value* value)
+{
+  if (!value) {
+    return ReadFileResult::READ_OK;
+  }
+
+  if (!value->isString()) {
+    return ReadFileResult::INVALID_PRESET;
+  }
+
+  if (value->asString() == "until-fail") {
+    out = TestPreset::ExecutionOptions::RepeatOptions::ModeEnum::UntilFail;
+    return ReadFileResult::READ_OK;
+  }
+
+  if (value->asString() == "until-pass") {
+    out = TestPreset::ExecutionOptions::RepeatOptions::ModeEnum::UntilPass;
+    return ReadFileResult::READ_OK;
+  }
+
+  if (value->asString() == "after-timeout") {
+    out = TestPreset::ExecutionOptions::RepeatOptions::ModeEnum::AfterTimeout;
+    return ReadFileResult::READ_OK;
+  }
+
+  return ReadFileResult::INVALID_PRESET;
+}
+
+auto const TestPresetOptionalExecutionRepeatHelper =
+  cmJSONOptionalHelper<TestPreset::ExecutionOptions::RepeatOptions,
+                       ReadFileResult>(
+    ReadFileResult::READ_OK,
+    cmJSONObjectHelper<TestPreset::ExecutionOptions::RepeatOptions,
+                       ReadFileResult>(ReadFileResult::READ_OK,
+                                       ReadFileResult::INVALID_PRESET)
+      .Bind("mode"_s, &TestPreset::ExecutionOptions::RepeatOptions::Mode,
+            TestPresetExecutionModeHelper, true)
+      .Bind("count"_s, &TestPreset::ExecutionOptions::RepeatOptions::Count,
+            PresetIntHelper, true));
+
+ReadFileResult TestPresetExecutionNoTestsActionHelper(
+  TestPreset::ExecutionOptions::NoTestsActionEnum& out,
+  const Json::Value* value)
+{
+  if (!value) {
+    out = TestPreset::ExecutionOptions::NoTestsActionEnum::Default;
+    return ReadFileResult::READ_OK;
+  }
+
+  if (!value->isString()) {
+    return ReadFileResult::INVALID_PRESET;
+  }
+
+  if (value->asString() == "default") {
+    out = TestPreset::ExecutionOptions::NoTestsActionEnum::Default;
+    return ReadFileResult::READ_OK;
+  }
+
+  if (value->asString() == "error") {
+    out = TestPreset::ExecutionOptions::NoTestsActionEnum::Error;
+    return ReadFileResult::READ_OK;
+  }
+
+  if (value->asString() == "ignore") {
+    out = TestPreset::ExecutionOptions::NoTestsActionEnum::Ignore;
+    return ReadFileResult::READ_OK;
+  }
+
+  return ReadFileResult::INVALID_PRESET;
+}
+
+auto const TestPresetOptionalExecutionNoTestsActionHelper =
+  cmJSONOptionalHelper<TestPreset::ExecutionOptions::NoTestsActionEnum,
+                       ReadFileResult>(ReadFileResult::READ_OK,
+                                       TestPresetExecutionNoTestsActionHelper);
+
+auto const TestPresetExecutionHelper =
+  cmJSONOptionalHelper<TestPreset::ExecutionOptions, ReadFileResult>(
+    ReadFileResult::READ_OK,
+    cmJSONObjectHelper<TestPreset::ExecutionOptions, ReadFileResult>(
+      ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET)
+      .Bind("stopOnFailure"_s, &TestPreset::ExecutionOptions::StopOnFailure,
+            PresetOptionalBoolHelper, false)
+      .Bind("enableFailover"_s, &TestPreset::ExecutionOptions::EnableFailover,
+            PresetOptionalBoolHelper, false)
+      .Bind("jobs"_s, &TestPreset::ExecutionOptions::Jobs,
+            PresetOptionalIntHelper, false)
+      .Bind("resourceSpecFile"_s,
+            &TestPreset::ExecutionOptions::ResourceSpecFile,
+            PresetStringHelper, false)
+      .Bind("testLoad"_s, &TestPreset::ExecutionOptions::TestLoad,
+            PresetOptionalIntHelper, false)
+      .Bind("showOnly"_s, &TestPreset::ExecutionOptions::ShowOnly,
+            TestPresetOptionalExecutionShowOnlyHelper, false)
+      .Bind("rerunFailed"_s, &TestPreset::ExecutionOptions::RerunFailed,
+            PresetOptionalBoolHelper, false)
+      .Bind("repeat"_s, &TestPreset::ExecutionOptions::Repeat,
+            TestPresetOptionalExecutionRepeatHelper, false)
+      .Bind("interactiveDebugging"_s,
+            &TestPreset::ExecutionOptions::InteractiveDebugging,
+            PresetOptionalBoolHelper, false)
+      .Bind("scheduleRandom"_s, &TestPreset::ExecutionOptions::ScheduleRandom,
+            PresetOptionalBoolHelper, false)
+      .Bind("timeout"_s, &TestPreset::ExecutionOptions::Timeout,
+            PresetOptionalIntHelper, false)
+      .Bind("noTestsAction"_s, &TestPreset::ExecutionOptions::NoTestsAction,
+            TestPresetOptionalExecutionNoTestsActionHelper, false));
+
+auto const TestPresetFilterHelper =
+  cmJSONOptionalHelper<TestPreset::FilterOptions, ReadFileResult>(
+    ReadFileResult::READ_OK,
+    cmJSONObjectHelper<TestPreset::FilterOptions, ReadFileResult>(
+      ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET)
+      .Bind("include"_s, &TestPreset::FilterOptions::Include,
+            TestPresetOptionalFilterIncludeHelper, false)
+      .Bind("exclude"_s, &TestPreset::FilterOptions::Exclude,
+            TestPresetOptionalFilterExcludeHelper, false));
+
+auto const TestPresetHelper =
+  cmJSONObjectHelper<TestPreset, ReadFileResult>(
+    ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESET, false)
+    .Bind("name"_s, &TestPreset::Name, PresetStringHelper)
+    .Bind("inherits"_s, &TestPreset::Inherits, PresetInheritsHelper, false)
+    .Bind("hidden"_s, &TestPreset::Hidden, PresetBoolHelper, false)
+    .Bind<std::nullptr_t>("vendor"_s, nullptr,
+                          VendorHelper(ReadFileResult::INVALID_PRESET), false)
+    .Bind("displayName"_s, &TestPreset::DisplayName, PresetStringHelper, false)
+    .Bind("description"_s, &TestPreset::Description, PresetStringHelper, false)
+    .Bind("environment"_s, &TestPreset::Environment, EnvironmentMapHelper,
+          false)
+    .Bind("configurePreset"_s, &TestPreset::ConfigurePreset,
+          PresetStringHelper, false)
+    .Bind("inheritConfigureEnvironment"_s,
+          &TestPreset::InheritConfigureEnvironment, PresetOptionalBoolHelper,
+          false)
+    .Bind("configuration"_s, &TestPreset::Configuration, PresetStringHelper,
+          false)
+    .Bind("overwriteConfigurationFile"_s,
+          &TestPreset::OverwriteConfigurationFile, PresetVectorStringHelper,
+          false)
+    .Bind("output"_s, &TestPreset::Output, TestPresetOptionalOutputHelper,
+          false)
+    .Bind("filter"_s, &TestPreset::Filter, TestPresetFilterHelper, false)
+    .Bind("execution"_s, &TestPreset::Execution, TestPresetExecutionHelper,
+          false);
+
+auto const ConfigurePresetsHelper =
+  cmJSONVectorHelper<ConfigurePreset, ReadFileResult>(
+    ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESETS,
+    ConfigurePresetHelper);
+
+auto const BuildPresetsHelper =
+  cmJSONVectorHelper<BuildPreset, ReadFileResult>(
+    ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESETS,
+    BuildPresetHelper);
+
+auto const TestPresetsHelper = cmJSONVectorHelper<TestPreset, ReadFileResult>(
+  ReadFileResult::READ_OK, ReadFileResult::INVALID_PRESETS, TestPresetHelper);
 
 auto const CMakeVersionUIntHelper = cmJSONUIntHelper<ReadFileResult>(
   ReadFileResult::READ_OK, ReadFileResult::INVALID_VERSION);
@@ -322,7 +710,11 @@ auto const RootPresetsHelper =
   cmJSONObjectHelper<RootPresets, ReadFileResult>(
     ReadFileResult::READ_OK, ReadFileResult::INVALID_ROOT, false)
     .Bind<int>("version"_s, nullptr, VersionHelper)
-    .Bind("configurePresets"_s, &RootPresets::Presets, PresetsHelper, false)
+    .Bind("configurePresets"_s, &RootPresets::ConfigurePresets,
+          ConfigurePresetsHelper, false)
+    .Bind("buildPresets"_s, &RootPresets::BuildPresets, BuildPresetsHelper,
+          false)
+    .Bind("testPresets"_s, &RootPresets::TestPresets, TestPresetsHelper, false)
     .Bind("cmakeMinimumRequired"_s, &RootPresets::CMakeMinimumRequired,
           CMakeVersionHelper, false)
     .Bind<std::nullptr_t>("vendor"_s, nullptr,
@@ -335,23 +727,33 @@ void InheritString(std::string& child, const std::string& parent)
   }
 }
 
-void InheritOptionalBool(cm::optional<bool>& child,
-                         const cm::optional<bool>& parent)
+template <typename T>
+void InheritOptionalValue(cm::optional<T>& child,
+                          const cm::optional<T>& parent)
 {
   if (!child) {
     child = parent;
   }
 }
 
+template <typename T>
+void InheritVector(std::vector<T>& child, const std::vector<T>& parent)
+{
+  if (child.empty()) {
+    child = parent;
+  }
+}
+
 /**
  * Check preset inheritance for cycles (using a DAG check algorithm) while
  * also bubbling up fields through the inheritance hierarchy, then verify
  * that each preset has the required fields, either directly or through
  * inheritance.
  */
+template <class T>
 ReadFileResult VisitPreset(
-  std::map<std::string, cmCMakePresetsFile::PresetPair>& presets,
-  UnexpandedPreset& preset, std::map<std::string, CycleStatus> cycleStatus)
+  T& preset, std::map<std::string, cmCMakePresetsFile::PresetPair<T>>& presets,
+  std::map<std::string, CycleStatus> cycleStatus)
 {
   switch (cycleStatus[preset.Name]) {
     case CycleStatus::InProgress:
@@ -364,80 +766,44 @@ ReadFileResult VisitPreset(
 
   cycleStatus[preset.Name] = CycleStatus::InProgress;
 
-  if (preset.CacheVariables.count("") != 0) {
-    return ReadFileResult::INVALID_PRESET;
-  }
   if (preset.Environment.count("") != 0) {
     return ReadFileResult::INVALID_PRESET;
   }
 
+  CHECK_OK(preset.VisitPresetBeforeInherit())
+
   for (auto const& i : preset.Inherits) {
     auto parent = presets.find(i);
     if (parent == presets.end()) {
       return ReadFileResult::INVALID_PRESET;
     }
 
-    if (!preset.User && parent->second.Unexpanded.User) {
+    auto& parentPreset = parent->second.Unexpanded;
+    if (!preset.User && parentPreset.User) {
       return ReadFileResult::USER_PRESET_INHERITANCE;
     }
 
-    auto result = VisitPreset(presets, parent->second.Unexpanded, cycleStatus);
+    auto result = VisitPreset(parentPreset, presets, cycleStatus);
     if (result != ReadFileResult::READ_OK) {
       return result;
     }
 
-    InheritString(preset.Generator, parent->second.Unexpanded.Generator);
-    InheritString(preset.Architecture, parent->second.Unexpanded.Architecture);
-    InheritString(preset.Toolset, parent->second.Unexpanded.Toolset);
-    if (!preset.ArchitectureStrategy) {
-      preset.ArchitectureStrategy =
-        parent->second.Unexpanded.ArchitectureStrategy;
-    }
-    if (!preset.ToolsetStrategy) {
-      preset.ToolsetStrategy = parent->second.Unexpanded.ToolsetStrategy;
-    }
-    InheritString(preset.BinaryDir, parent->second.Unexpanded.BinaryDir);
-    InheritOptionalBool(preset.WarnDev, parent->second.Unexpanded.WarnDev);
-    InheritOptionalBool(preset.ErrorDev, parent->second.Unexpanded.ErrorDev);
-    InheritOptionalBool(preset.WarnDeprecated,
-                        parent->second.Unexpanded.WarnDeprecated);
-    InheritOptionalBool(preset.ErrorDeprecated,
-                        parent->second.Unexpanded.ErrorDeprecated);
-    InheritOptionalBool(preset.WarnUninitialized,
-                        parent->second.Unexpanded.WarnUninitialized);
-    InheritOptionalBool(preset.WarnUnusedCli,
-                        parent->second.Unexpanded.WarnUnusedCli);
-    InheritOptionalBool(preset.WarnSystemVars,
-                        parent->second.Unexpanded.WarnSystemVars);
-    for (auto const& v : parent->second.Unexpanded.CacheVariables) {
-      preset.CacheVariables.insert(v);
-    }
-    for (auto const& v : parent->second.Unexpanded.Environment) {
+    CHECK_OK(preset.VisitPresetInherit(parentPreset))
+
+    for (auto const& v : parentPreset.Environment) {
       preset.Environment.insert(v);
     }
   }
 
-  if (!preset.Hidden) {
-    if (preset.Generator.empty()) {
-      return ReadFileResult::INVALID_PRESET;
-    }
-    if (preset.BinaryDir.empty()) {
-      return ReadFileResult::INVALID_PRESET;
-    }
-    if (preset.WarnDev == false && preset.ErrorDev == true) {
-      return ReadFileResult::INVALID_PRESET;
-    }
-    if (preset.WarnDeprecated == false && preset.ErrorDeprecated == true) {
-      return ReadFileResult::INVALID_PRESET;
-    }
-  }
+  CHECK_OK(preset.VisitPresetAfterInherit())
 
   cycleStatus[preset.Name] = CycleStatus::Verified;
   return ReadFileResult::READ_OK;
 }
 
+template <class T>
 ReadFileResult ComputePresetInheritance(
-  std::map<std::string, cmCMakePresetsFile::PresetPair>& presets)
+  std::map<std::string, cmCMakePresetsFile::PresetPair<T>>& presets)
 {
   std::map<std::string, CycleStatus> cycleStatus;
   for (auto const& it : presets) {
@@ -445,7 +811,7 @@ ReadFileResult ComputePresetInheritance(
   }
 
   for (auto& it : presets) {
-    auto result = VisitPreset(presets, it.second.Unexpanded, cycleStatus);
+    auto result = VisitPreset<T>(it.second.Unexpanded, presets, cycleStatus);
     if (result != ReadFileResult::READ_OK) {
       return result;
     }
@@ -482,65 +848,186 @@ enum class ExpandMacroResult
   Error,
 };
 
-ExpandMacroResult VisitEnv(const cmCMakePresetsFile& file,
-                           cmCMakePresetsFile::ExpandedPreset& preset,
-                           std::map<std::string, CycleStatus>& envCycles,
-                           std::string& value, CycleStatus& status);
-ExpandMacroResult ExpandMacros(const cmCMakePresetsFile& file,
-                               cmCMakePresetsFile::ExpandedPreset& preset,
-                               std::map<std::string, CycleStatus>& envCycles,
-                               std::string& out);
-ExpandMacroResult ExpandMacro(const cmCMakePresetsFile& file,
-                              cmCMakePresetsFile::ExpandedPreset& preset,
-                              std::map<std::string, CycleStatus>& envCycles,
-                              std::string& out,
-                              const std::string& macroNamespace,
-                              const std::string& macroName);
+using MacroExpander = std::function<ExpandMacroResult(
+  const std::string&, const std::string&, std::string&)>;
+
+ExpandMacroResult VisitEnv(std::string& value, CycleStatus& status,
+                           const std::vector<MacroExpander>& macroExpanders);
+ExpandMacroResult ExpandMacros(
+  std::string& out, const std::vector<MacroExpander>& macroExpanders);
+ExpandMacroResult ExpandMacro(
+  std::string& out, const std::string& macroNamespace,
+  const std::string& macroName,
+  const std::vector<MacroExpander>& macroExpanders);
 
 bool ExpandMacros(const cmCMakePresetsFile& file,
-                  const UnexpandedPreset& preset,
-                  cm::optional<ExpandedPreset>& out)
+                  const ConfigurePreset& preset,
+                  cm::optional<ConfigurePreset>& out,
+                  const std::vector<MacroExpander>& macroExpanders)
 {
-  out = preset;
+  std::string binaryDir = preset.BinaryDir;
+  CHECK_EXPAND(out, binaryDir, macroExpanders)
 
-  std::map<std::string, CycleStatus> envCycles;
-  for (auto const& v : out->Environment) {
-    envCycles[v.first] = CycleStatus::Unvisited;
+  if (!cmSystemTools::FileIsFullPath(binaryDir)) {
+    binaryDir = cmStrCat(file.SourceDir, '/', binaryDir);
   }
+  out->BinaryDir = cmSystemTools::CollapseFullPath(binaryDir);
+  cmSystemTools::ConvertToUnixSlashes(out->BinaryDir);
 
-  for (auto& v : out->Environment) {
-    if (v.second) {
-      switch (VisitEnv(file, *out, envCycles, *v.second, envCycles[v.first])) {
-        case ExpandMacroResult::Error:
-          return false;
-        case ExpandMacroResult::Ignore:
-          out.reset();
-          return true;
-        case ExpandMacroResult::Ok:
-          break;
+  for (auto& variable : out->CacheVariables) {
+    if (variable.second) {
+      CHECK_EXPAND(out, variable.second->Value, macroExpanders)
+    }
+  }
+
+  return true;
+}
+
+bool ExpandMacros(const cmCMakePresetsFile&, const BuildPreset&,
+                  cm::optional<BuildPreset>& out,
+                  const std::vector<MacroExpander>& macroExpanders)
+{
+  for (auto& target : out->Targets) {
+    CHECK_EXPAND(out, target, macroExpanders)
+  }
+
+  for (auto& nativeToolOption : out->NativeToolOptions) {
+    CHECK_EXPAND(out, nativeToolOption, macroExpanders)
+  }
+
+  return true;
+}
+
+bool ExpandMacros(const cmCMakePresetsFile&, const TestPreset&,
+                  cm::optional<TestPreset>& out,
+                  const std::vector<MacroExpander>& macroExpanders)
+{
+  for (auto& overwrite : out->OverwriteConfigurationFile) {
+    CHECK_EXPAND(out, overwrite, macroExpanders);
+  }
+
+  if (out->Output) {
+    CHECK_EXPAND(out, out->Output->OutputLogFile, macroExpanders)
+  }
+
+  if (out->Filter) {
+    if (out->Filter->Include) {
+      CHECK_EXPAND(out, out->Filter->Include->Name, macroExpanders)
+      CHECK_EXPAND(out, out->Filter->Include->Label, macroExpanders)
+
+      if (out->Filter->Include->Index) {
+        CHECK_EXPAND(out, out->Filter->Include->Index->IndexFile,
+                     macroExpanders);
+      }
+    }
+
+    if (out->Filter->Exclude) {
+      CHECK_EXPAND(out, out->Filter->Exclude->Name, macroExpanders)
+      CHECK_EXPAND(out, out->Filter->Exclude->Label, macroExpanders)
+
+      if (out->Filter->Exclude->Fixtures) {
+        CHECK_EXPAND(out, out->Filter->Exclude->Fixtures->Any, macroExpanders)
+        CHECK_EXPAND(out, out->Filter->Exclude->Fixtures->Setup,
+                     macroExpanders)
+        CHECK_EXPAND(out, out->Filter->Exclude->Fixtures->Cleanup,
+                     macroExpanders)
       }
     }
   }
 
-  std::string binaryDir = preset.BinaryDir;
-  switch (ExpandMacros(file, *out, envCycles, binaryDir)) {
-    case ExpandMacroResult::Error:
-      return false;
-    case ExpandMacroResult::Ignore:
-      out.reset();
-      return true;
-    case ExpandMacroResult::Ok:
-      break;
+  if (out->Execution) {
+    CHECK_EXPAND(out, out->Execution->ResourceSpecFile, macroExpanders)
   }
-  if (!cmSystemTools::FileIsFullPath(binaryDir)) {
-    binaryDir = cmStrCat(file.SourceDir, '/', binaryDir);
+
+  return true;
+}
+
+template <class T>
+bool ExpandMacros(const cmCMakePresetsFile& file, const T& preset,
+                  cm::optional<T>& out)
+{
+  out.emplace(preset);
+
+  std::map<std::string, CycleStatus> envCycles;
+  for (auto const& v : out->Environment) {
+    envCycles[v.first] = CycleStatus::Unvisited;
   }
-  out->BinaryDir = cmSystemTools::CollapseFullPath(binaryDir);
-  cmSystemTools::ConvertToUnixSlashes(out->BinaryDir);
 
-  for (auto& variable : out->CacheVariables) {
-    if (variable.second) {
-      switch (ExpandMacros(file, *out, envCycles, variable.second->Value)) {
+  std::vector<MacroExpander> macroExpanders;
+
+  MacroExpander defaultMacroExpander =
+    [&file, &preset](const std::string& macroNamespace,
+                     const std::string& macroName,
+                     std::string& macroOut) -> ExpandMacroResult {
+    if (macroNamespace.empty()) {
+      if (macroName == "sourceDir") {
+        macroOut += file.SourceDir;
+        return ExpandMacroResult::Ok;
+      }
+      if (macroName == "sourceParentDir") {
+        macroOut += cmSystemTools::GetParentDirectory(file.SourceDir);
+        return ExpandMacroResult::Ok;
+      }
+      if (macroName == "sourceDirName") {
+        macroOut += cmSystemTools::GetFilenameName(file.SourceDir);
+        return ExpandMacroResult::Ok;
+      }
+      if (macroName == "presetName") {
+        macroOut += preset.Name;
+        return ExpandMacroResult::Ok;
+      }
+      if (macroName == "generator") {
+        // Generator only makes sense if preset is not hidden.
+        if (!preset.Hidden) {
+          macroOut += file.GetGeneratorForPreset(preset.Name);
+        }
+        return ExpandMacroResult::Ok;
+      }
+      if (macroName == "dollar") {
+        macroOut += '$';
+        return ExpandMacroResult::Ok;
+      }
+    }
+
+    return ExpandMacroResult::Ignore;
+  };
+
+  MacroExpander environmentMacroExpander =
+    [&macroExpanders, &out, &envCycles](
+      const std::string& macroNamespace, const std::string& macroName,
+      std::string& result) -> ExpandMacroResult {
+    if (macroNamespace == "env" && !macroName.empty() && out) {
+      auto v = out->Environment.find(macroName);
+      if (v != out->Environment.end() && v->second) {
+        auto e = VisitEnv(*v->second, envCycles[macroName], macroExpanders);
+        if (e != ExpandMacroResult::Ok) {
+          return e;
+        }
+        result += *v->second;
+        return ExpandMacroResult::Ok;
+      }
+    }
+
+    if (macroNamespace == "env" || macroNamespace == "penv") {
+      if (macroName.empty()) {
+        return ExpandMacroResult::Error;
+      }
+      const char* value = std::getenv(macroName.c_str());
+      if (value) {
+        result += value;
+      }
+      return ExpandMacroResult::Ok;
+    }
+
+    return ExpandMacroResult::Ignore;
+  };
+
+  macroExpanders.push_back(defaultMacroExpander);
+  macroExpanders.push_back(environmentMacroExpander);
+
+  for (auto& v : out->Environment) {
+    if (v.second) {
+      switch (VisitEnv(*v.second, envCycles[v.first], macroExpanders)) {
         case ExpandMacroResult::Error:
           return false;
         case ExpandMacroResult::Ignore:
@@ -552,13 +1039,11 @@ bool ExpandMacros(const cmCMakePresetsFile& file,
     }
   }
 
-  return true;
+  return ExpandMacros(file, preset, out, macroExpanders);
 }
 
-ExpandMacroResult VisitEnv(const cmCMakePresetsFile& file,
-                           cmCMakePresetsFile::ExpandedPreset& preset,
-                           std::map<std::string, CycleStatus>& envCycles,
-                           std::string& value, CycleStatus& status)
+ExpandMacroResult VisitEnv(std::string& value, CycleStatus& status,
+                           const std::vector<MacroExpander>& macroExpanders)
 {
   if (status == CycleStatus::Verified) {
     return ExpandMacroResult::Ok;
@@ -568,7 +1053,7 @@ ExpandMacroResult VisitEnv(const cmCMakePresetsFile& file,
   }
 
   status = CycleStatus::InProgress;
-  auto e = ExpandMacros(file, preset, envCycles, value);
+  auto e = ExpandMacros(value, macroExpanders);
   if (e != ExpandMacroResult::Ok) {
     return e;
   }
@@ -576,10 +1061,8 @@ ExpandMacroResult VisitEnv(const cmCMakePresetsFile& file,
   return ExpandMacroResult::Ok;
 }
 
-ExpandMacroResult ExpandMacros(const cmCMakePresetsFile& file,
-                               cmCMakePresetsFile::ExpandedPreset& preset,
-                               std::map<std::string, CycleStatus>& envCycles,
-                               std::string& out)
+ExpandMacroResult ExpandMacros(
+  std::string& out, const std::vector<MacroExpander>& macroExpanders)
 {
   std::string result;
   std::string macroNamespace;
@@ -626,8 +1109,8 @@ ExpandMacroResult ExpandMacros(const cmCMakePresetsFile& file,
 
       case State::MacroName:
         if (c == '}') {
-          auto e = ExpandMacro(file, preset, envCycles, result, macroNamespace,
-                               macroName);
+          auto e =
+            ExpandMacro(result, macroNamespace, macroName, macroExpanders);
           if (e != ExpandMacroResult::Ok) {
             return e;
           }
@@ -656,70 +1139,232 @@ ExpandMacroResult ExpandMacros(const cmCMakePresetsFile& file,
   return ExpandMacroResult::Ok;
 }
 
-ExpandMacroResult ExpandMacro(const cmCMakePresetsFile& file,
-                              cmCMakePresetsFile::ExpandedPreset& preset,
-                              std::map<std::string, CycleStatus>& envCycles,
-                              std::string& out,
+ExpandMacroResult ExpandMacro(std::string& out,
                               const std::string& macroNamespace,
-                              const std::string& macroName)
+                              const std::string& macroName,
+                              const std::vector<MacroExpander>& macroExpanders)
 {
-  if (macroNamespace.empty()) {
-    if (macroName == "sourceDir") {
-      out += file.SourceDir;
-      return ExpandMacroResult::Ok;
+  for (auto const& macroExpander : macroExpanders) {
+    auto result = macroExpander(macroNamespace, macroName, out);
+    if (result != ExpandMacroResult::Ignore) {
+      return result;
     }
-    if (macroName == "sourceParentDir") {
-      out += cmSystemTools::GetParentDirectory(file.SourceDir);
-      return ExpandMacroResult::Ok;
+  }
+
+  if (macroNamespace == "vendor") {
+    return ExpandMacroResult::Ignore;
+  }
+
+  return ExpandMacroResult::Error;
+}
+}
+
+cmCMakePresetsFile::ReadFileResult
+cmCMakePresetsFile::ConfigurePreset::VisitPresetInherit(
+  const cmCMakePresetsFile::Preset& parentPreset)
+{
+  auto& preset = *this;
+  const ConfigurePreset& parent =
+    static_cast<const ConfigurePreset&>(parentPreset);
+  InheritString(preset.Generator, parent.Generator);
+  InheritString(preset.Architecture, parent.Architecture);
+  InheritString(preset.Toolset, parent.Toolset);
+  if (!preset.ArchitectureStrategy) {
+    preset.ArchitectureStrategy = parent.ArchitectureStrategy;
+  }
+  if (!preset.ToolsetStrategy) {
+    preset.ToolsetStrategy = parent.ToolsetStrategy;
+  }
+  InheritString(preset.BinaryDir, parent.BinaryDir);
+  InheritOptionalValue(preset.WarnDev, parent.WarnDev);
+  InheritOptionalValue(preset.ErrorDev, parent.ErrorDev);
+  InheritOptionalValue(preset.WarnDeprecated, parent.WarnDeprecated);
+  InheritOptionalValue(preset.ErrorDeprecated, parent.ErrorDeprecated);
+  InheritOptionalValue(preset.WarnUninitialized, parent.WarnUninitialized);
+  InheritOptionalValue(preset.WarnUnusedCli, parent.WarnUnusedCli);
+  InheritOptionalValue(preset.WarnSystemVars, parent.WarnSystemVars);
+
+  for (auto const& v : parent.CacheVariables) {
+    preset.CacheVariables.insert(v);
+  }
+
+  return ReadFileResult::READ_OK;
+}
+
+cmCMakePresetsFile::ReadFileResult
+cmCMakePresetsFile::ConfigurePreset::VisitPresetBeforeInherit()
+{
+  auto& preset = *this;
+  if (preset.Environment.count("") != 0) {
+    return ReadFileResult::INVALID_PRESET;
+  }
+
+  return ReadFileResult::READ_OK;
+}
+
+cmCMakePresetsFile::ReadFileResult
+cmCMakePresetsFile::ConfigurePreset::VisitPresetAfterInherit()
+{
+  auto& preset = *this;
+  if (!preset.Hidden) {
+    if (preset.Generator.empty()) {
+      return ReadFileResult::INVALID_PRESET;
     }
-    if (macroName == "sourceDirName") {
-      out += cmSystemTools::GetFilenameName(file.SourceDir);
-      return ExpandMacroResult::Ok;
+    if (preset.BinaryDir.empty()) {
+      return ReadFileResult::INVALID_PRESET;
     }
-    if (macroName == "presetName") {
-      out += preset.Name;
-      return ExpandMacroResult::Ok;
+    if (preset.WarnDev == false && preset.ErrorDev == true) {
+      return ReadFileResult::INVALID_PRESET;
     }
-    if (macroName == "generator") {
-      out += preset.Generator;
-      return ExpandMacroResult::Ok;
+    if (preset.WarnDeprecated == false && preset.ErrorDeprecated == true) {
+      return ReadFileResult::INVALID_PRESET;
     }
-    if (macroName == "dollar") {
-      out += '$';
-      return ExpandMacroResult::Ok;
+    if (preset.CacheVariables.count("") != 0) {
+      return ReadFileResult::INVALID_PRESET;
     }
   }
 
-  if (macroNamespace == "env" && !macroName.empty()) {
-    auto v = preset.Environment.find(macroName);
-    if (v != preset.Environment.end() && v->second) {
-      auto e =
-        VisitEnv(file, preset, envCycles, *v->second, envCycles[macroName]);
-      if (e != ExpandMacroResult::Ok) {
-        return e;
-      }
-      out += *v->second;
-      return ExpandMacroResult::Ok;
+  return ReadFileResult::READ_OK;
+}
+
+cmCMakePresetsFile::ReadFileResult
+cmCMakePresetsFile::BuildPreset::VisitPresetInherit(
+  const cmCMakePresetsFile::Preset& parentPreset)
+{
+  auto& preset = *this;
+  const BuildPreset& parent = static_cast<const BuildPreset&>(parentPreset);
+
+  InheritString(preset.ConfigurePreset, parent.ConfigurePreset);
+  InheritOptionalValue(preset.InheritConfigureEnvironment,
+                       parent.InheritConfigureEnvironment);
+  InheritOptionalValue(preset.Jobs, parent.Jobs);
+  InheritVector(preset.Targets, parent.Targets);
+  InheritString(preset.Configuration, parent.Configuration);
+  InheritOptionalValue(preset.CleanFirst, parent.CleanFirst);
+  InheritOptionalValue(preset.Verbose, parent.Verbose);
+  InheritVector(preset.NativeToolOptions, parent.NativeToolOptions);
+
+  return ReadFileResult::READ_OK;
+}
+
+cmCMakePresetsFile::ReadFileResult
+cmCMakePresetsFile::BuildPreset::VisitPresetAfterInherit()
+{
+  auto& preset = *this;
+  if (!preset.Hidden && preset.ConfigurePreset.empty()) {
+    return ReadFileResult::INVALID_PRESET;
+  }
+  return ReadFileResult::READ_OK;
+}
+
+cmCMakePresetsFile::ReadFileResult
+cmCMakePresetsFile::TestPreset::VisitPresetInherit(
+  const cmCMakePresetsFile::Preset& parentPreset)
+{
+  auto& preset = *this;
+  const TestPreset& parent = static_cast<const TestPreset&>(parentPreset);
+
+  InheritString(preset.ConfigurePreset, parent.ConfigurePreset);
+  InheritOptionalValue(preset.InheritConfigureEnvironment,
+                       parent.InheritConfigureEnvironment);
+  InheritString(preset.Configuration, parent.Configuration);
+  InheritVector(preset.OverwriteConfigurationFile,
+                parent.OverwriteConfigurationFile);
+
+  if (parent.Output) {
+    if (preset.Output) {
+      auto& output = preset.Output.value();
+      const auto& parentOutput = parent.Output.value();
+      InheritOptionalValue(output.ShortProgress, parentOutput.ShortProgress);
+      InheritOptionalValue(output.Verbosity, parentOutput.Verbosity);
+      InheritOptionalValue(output.Debug, parentOutput.Debug);
+      InheritOptionalValue(output.OutputOnFailure,
+                           parentOutput.OutputOnFailure);
+      InheritString(output.OutputLogFile, parentOutput.OutputLogFile);
+      InheritOptionalValue(output.LabelSummary, parentOutput.LabelSummary);
+      InheritOptionalValue(output.SubprojectSummary,
+                           parentOutput.SubprojectSummary);
+      InheritOptionalValue(output.MaxPassedTestOutputSize,
+                           parentOutput.MaxPassedTestOutputSize);
+      InheritOptionalValue(output.MaxFailedTestOutputSize,
+                           parentOutput.MaxFailedTestOutputSize);
+      InheritOptionalValue(output.MaxTestNameWidth,
+                           parentOutput.MaxTestNameWidth);
+    } else {
+      preset.Output = parent.Output;
     }
   }
 
-  if (macroNamespace == "env" || macroNamespace == "penv") {
-    if (macroName.empty()) {
-      return ExpandMacroResult::Error;
+  if (parent.Filter) {
+    if (parent.Filter->Include) {
+      if (preset.Filter && preset.Filter->Include) {
+        auto& include = *preset.Filter->Include;
+        const auto& parentInclude = *parent.Filter->Include;
+        InheritString(include.Name, parentInclude.Name);
+        InheritString(include.Label, parentInclude.Label);
+        InheritOptionalValue(include.Index, parentInclude.Index);
+      } else {
+        if (!preset.Filter) {
+          preset.Filter.emplace();
+        }
+        preset.Filter->Include = parent.Filter->Include;
+      }
     }
-    const char* value = std::getenv(macroName.c_str());
-    if (value) {
-      out += value;
+
+    if (parent.Filter->Exclude) {
+      if (preset.Filter && preset.Filter->Exclude) {
+        auto& exclude = *preset.Filter->Exclude;
+        const auto& parentExclude = *parent.Filter->Exclude;
+        InheritString(exclude.Name, parentExclude.Name);
+        InheritString(exclude.Label, parentExclude.Label);
+        InheritOptionalValue(exclude.Fixtures, parentExclude.Fixtures);
+      } else {
+        if (!preset.Filter) {
+          preset.Filter.emplace();
+        }
+        preset.Filter->Exclude = parent.Filter->Exclude;
+      }
     }
-    return ExpandMacroResult::Ok;
   }
 
-  if (macroNamespace == "vendor") {
-    return ExpandMacroResult::Ignore;
+  if (parent.Execution) {
+    if (preset.Execution) {
+      auto& execution = *preset.Execution;
+      const auto& parentExecution = *parent.Execution;
+      InheritOptionalValue(execution.StopOnFailure,
+                           parentExecution.StopOnFailure);
+      InheritOptionalValue(execution.EnableFailover,
+                           parentExecution.EnableFailover);
+      InheritOptionalValue(execution.Jobs, parentExecution.Jobs);
+      InheritString(execution.ResourceSpecFile,
+                    parentExecution.ResourceSpecFile);
+      InheritOptionalValue(execution.TestLoad, parentExecution.TestLoad);
+      InheritOptionalValue(execution.ShowOnly, parentExecution.ShowOnly);
+      InheritOptionalValue(execution.RerunFailed, parentExecution.RerunFailed);
+      InheritOptionalValue(execution.Repeat, parentExecution.Repeat);
+      InheritOptionalValue(execution.InteractiveDebugging,
+                           parentExecution.InteractiveDebugging);
+      InheritOptionalValue(execution.ScheduleRandom,
+                           parentExecution.ScheduleRandom);
+      InheritOptionalValue(execution.Timeout, parentExecution.Timeout);
+      InheritOptionalValue(execution.NoTestsAction,
+                           parentExecution.NoTestsAction);
+    } else {
+      preset.Execution = parent.Execution;
+    }
   }
 
-  return ExpandMacroResult::Error;
+  return ReadFileResult::READ_OK;
 }
+
+cmCMakePresetsFile::ReadFileResult
+cmCMakePresetsFile::TestPreset::VisitPresetAfterInherit()
+{
+  auto& preset = *this;
+  if (!preset.Hidden && preset.ConfigurePreset.empty()) {
+    return ReadFileResult::INVALID_PRESET;
+  }
+  return ReadFileResult::READ_OK;
 }
 
 std::string cmCMakePresetsFile::GetFilename(const std::string& sourceDir)
@@ -735,17 +1380,25 @@ std::string cmCMakePresetsFile::GetUserFilename(const std::string& sourceDir)
 cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadProjectPresets(
   const std::string& sourceDir, bool allowNoFiles)
 {
-  bool haveOneFile = false;
   this->SourceDir = sourceDir;
-  this->Presets.clear();
-  this->PresetOrder.clear();
+  this->ClearPresets();
 
-  std::vector<std::string> presetOrder;
-  std::map<std::string, PresetPair> presetMap;
+  auto result = this->ReadProjectPresetsInternal(allowNoFiles);
+  if (result != ReadFileResult::READ_OK) {
+    this->ClearPresets();
+  }
+
+  return result;
+}
+
+cmCMakePresetsFile::ReadFileResult
+cmCMakePresetsFile::ReadProjectPresetsInternal(bool allowNoFiles)
+{
+  bool haveOneFile = false;
 
   std::string filename = GetUserFilename(this->SourceDir);
   if (cmSystemTools::FileExists(filename)) {
-    auto result = this->ReadJSONFile(filename, presetOrder, presetMap, true);
+    auto result = this->ReadJSONFile(filename, true);
     if (result != ReadFileResult::READ_OK) {
       return result;
     }
@@ -754,7 +1407,7 @@ cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadProjectPresets(
 
   filename = GetFilename(this->SourceDir);
   if (cmSystemTools::FileExists(filename)) {
-    auto result = this->ReadJSONFile(filename, presetOrder, presetMap, false);
+    auto result = this->ReadJSONFile(filename, false);
     if (result != ReadFileResult::READ_OK) {
       return result;
     }
@@ -766,19 +1419,50 @@ cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadProjectPresets(
                         : ReadFileResult::FILE_NOT_FOUND;
   }
 
-  auto result = ComputePresetInheritance(presetMap);
-  if (result != ReadFileResult::READ_OK) {
-    return result;
+  CHECK_OK(ComputePresetInheritance(this->ConfigurePresets))
+  CHECK_OK(ComputePresetInheritance(this->BuildPresets))
+  CHECK_OK(ComputePresetInheritance(this->TestPresets))
+
+  for (auto& it : this->ConfigurePresets) {
+    if (!ExpandMacros(*this, it.second.Unexpanded, it.second.Expanded)) {
+      return ReadFileResult::INVALID_MACRO_EXPANSION;
+    }
   }
 
-  for (auto& it : presetMap) {
+  for (auto& it : this->BuildPresets) {
+    if (!it.second.Unexpanded.Hidden) {
+      const auto configurePreset =
+        this->ConfigurePresets.find(it.second.Unexpanded.ConfigurePreset);
+      if (it.second.Unexpanded.InheritConfigureEnvironment.value_or(true) &&
+          configurePreset != this->ConfigurePresets.end()) {
+        it.second.Unexpanded.Environment.insert(
+          configurePreset->second.Unexpanded.Environment.begin(),
+          configurePreset->second.Unexpanded.Environment.end());
+      }
+    }
+
+    if (!ExpandMacros(*this, it.second.Unexpanded, it.second.Expanded)) {
+      return ReadFileResult::INVALID_MACRO_EXPANSION;
+    }
+  }
+
+  for (auto& it : this->TestPresets) {
+    if (!it.second.Unexpanded.Hidden) {
+      const auto configurePreset =
+        this->ConfigurePresets.find(it.second.Unexpanded.ConfigurePreset);
+      if (it.second.Unexpanded.InheritConfigureEnvironment.value_or(true) &&
+          configurePreset != this->ConfigurePresets.end()) {
+        it.second.Unexpanded.Environment.insert(
+          configurePreset->second.Unexpanded.Environment.begin(),
+          configurePreset->second.Unexpanded.Environment.end());
+      }
+    }
+
     if (!ExpandMacros(*this, it.second.Unexpanded, it.second.Expanded)) {
       return ReadFileResult::INVALID_MACRO_EXPANSION;
     }
   }
 
-  this->PresetOrder = std::move(presetOrder);
-  this->Presets = std::move(presetMap);
   return ReadFileResult::READ_OK;
 }
 
@@ -817,14 +1501,16 @@ const char* cmCMakePresetsFile::ResultToString(ReadFileResult result)
       return "Project preset inherits from user preset";
     case ReadFileResult::INVALID_MACRO_EXPANSION:
       return "Invalid macro expansion";
+    case ReadFileResult::BUILD_TEST_PRESETS_UNSUPPORTED:
+      return "File version must be 2 or higher for build and test preset "
+             "support.";
   }
 
   return "Unknown error";
 }
 
 cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadJSONFile(
-  const std::string& filename, std::vector<std::string>& presetOrder,
-  std::map<std::string, PresetPair>& presetMap, bool user)
+  const std::string& filename, bool user)
 {
   cmsys::ifstream fin(filename.c_str());
   if (!fin) {
@@ -848,6 +1534,12 @@ cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadJSONFile(
     return ReadFileResult::UNRECOGNIZED_VERSION;
   }
 
+  // Support for build and test presets added in version 2.
+  if (v < 2 &&
+      (root.isMember("buildPresets") || root.isMember("testPresets"))) {
+    return ReadFileResult::BUILD_TEST_PRESETS_UNSUPPORTED;
+  }
+
   RootPresets presets;
   if ((result = RootPresetsHelper(presets, &root)) !=
       ReadFileResult::READ_OK) {
@@ -866,16 +1558,158 @@ cmCMakePresetsFile::ReadFileResult cmCMakePresetsFile::ReadJSONFile(
     return ReadFileResult::UNRECOGNIZED_CMAKE_VERSION;
   }
 
-  for (auto& preset : presets.Presets) {
+  for (auto& preset : presets.ConfigurePresets) {
     preset.User = user;
     if (preset.Name.empty()) {
       return ReadFileResult::INVALID_PRESET;
     }
-    if (!presetMap.insert({ preset.Name, { preset, cm::nullopt } }).second) {
+
+    PresetPair<ConfigurePreset> presetPair;
+    presetPair.Unexpanded = preset;
+    presetPair.Expanded = cm::nullopt;
+    if (!this->ConfigurePresets
+           .emplace(std::make_pair(preset.Name, presetPair))
+           .second) {
       return ReadFileResult::DUPLICATE_PRESETS;
     }
-    presetOrder.push_back(preset.Name);
+    this->ConfigurePresetOrder.push_back(preset.Name);
+  }
+
+  for (auto& preset : presets.BuildPresets) {
+    preset.User = user;
+    if (preset.Name.empty()) {
+      return ReadFileResult::INVALID_PRESET;
+    }
+
+    PresetPair<BuildPreset> presetPair;
+    presetPair.Unexpanded = preset;
+    presetPair.Expanded = cm::nullopt;
+    if (!this->BuildPresets.emplace(preset.Name, presetPair).second) {
+      return ReadFileResult::DUPLICATE_PRESETS;
+    }
+    this->BuildPresetOrder.push_back(preset.Name);
+  }
+
+  for (auto& preset : presets.TestPresets) {
+    preset.User = user;
+    if (preset.Name.empty()) {
+      return ReadFileResult::INVALID_PRESET;
+    }
+
+    PresetPair<TestPreset> presetPair;
+    presetPair.Unexpanded = preset;
+    presetPair.Expanded = cm::nullopt;
+    if (!this->TestPresets.emplace(preset.Name, presetPair).second) {
+      return ReadFileResult::DUPLICATE_PRESETS;
+    }
+    this->TestPresetOrder.push_back(preset.Name);
   }
 
   return ReadFileResult::READ_OK;
 }
+
+void cmCMakePresetsFile::ClearPresets()
+{
+  this->ConfigurePresets.clear();
+  this->BuildPresets.clear();
+  this->TestPresets.clear();
+
+  this->ConfigurePresetOrder.clear();
+  this->BuildPresetOrder.clear();
+  this->TestPresetOrder.clear();
+}
+
+void cmCMakePresetsFile::PrintPresets(
+  const std::vector<const cmCMakePresetsFile::Preset*>& presets)
+{
+  if (presets.empty()) {
+    return;
+  }
+
+  auto longestPresetName =
+    std::max_element(presets.begin(), presets.end(),
+                     [](const cmCMakePresetsFile::Preset* a,
+                        const cmCMakePresetsFile::Preset* b) {
+                       return a->Name.length() < b->Name.length();
+                     });
+  auto longestLength = (*longestPresetName)->Name.length();
+
+  for (const auto* preset : presets) {
+    std::cout << "  \"" << preset->Name << '"';
+    const auto& description = preset->DisplayName;
+    if (!description.empty()) {
+      for (std::size_t i = 0; i < longestLength - preset->Name.length(); ++i) {
+        std::cout << ' ';
+      }
+      std::cout << " - " << description;
+    }
+    std::cout << '\n';
+  }
+}
+
+void cmCMakePresetsFile::PrintConfigurePresetList() const
+{
+  PrintConfigurePresetList([](const ConfigurePreset&) { return true; });
+}
+
+void cmCMakePresetsFile::PrintConfigurePresetList(
+  const std::function<bool(const ConfigurePreset&)>& filter) const
+{
+  std::vector<const cmCMakePresetsFile::Preset*> presets;
+  for (auto const& p : this->ConfigurePresetOrder) {
+    auto const& preset = this->ConfigurePresets.at(p);
+    if (!preset.Unexpanded.Hidden && preset.Expanded &&
+        filter(preset.Unexpanded)) {
+      presets.push_back(
+        static_cast<const cmCMakePresetsFile::Preset*>(&preset.Unexpanded));
+    }
+  }
+
+  if (!presets.empty()) {
+    std::cout << "Available configure presets:\n\n";
+    cmCMakePresetsFile::PrintPresets(presets);
+  }
+}
+
+void cmCMakePresetsFile::PrintBuildPresetList() const
+{
+  std::vector<const cmCMakePresetsFile::Preset*> presets;
+  for (auto const& p : this->BuildPresetOrder) {
+    auto const& preset = this->BuildPresets.at(p);
+    if (!preset.Unexpanded.Hidden && preset.Expanded) {
+      presets.push_back(
+        static_cast<const cmCMakePresetsFile::Preset*>(&preset.Unexpanded));
+    }
+  }
+
+  if (!presets.empty()) {
+    std::cout << "Available build presets:\n\n";
+    cmCMakePresetsFile::PrintPresets(presets);
+  }
+}
+
+void cmCMakePresetsFile::PrintTestPresetList() const
+{
+  std::vector<const cmCMakePresetsFile::Preset*> presets;
+  for (auto const& p : this->TestPresetOrder) {
+    auto const& preset = this->TestPresets.at(p);
+    if (!preset.Unexpanded.Hidden && preset.Expanded) {
+      presets.push_back(
+        static_cast<const cmCMakePresetsFile::Preset*>(&preset.Unexpanded));
+    }
+  }
+
+  if (!presets.empty()) {
+    std::cout << "Available test presets:\n\n";
+    cmCMakePresetsFile::PrintPresets(presets);
+  }
+}
+
+void cmCMakePresetsFile::PrintAllPresets() const
+{
+  this->PrintConfigurePresetList();
+  std::cout << std::endl;
+  this->PrintBuildPresetList();
+  std::cout << std::endl;
+  this->PrintTestPresetList();
+}
diff --git a/Source/cmCMakePresetsFile.h b/Source/cmCMakePresetsFile.h
index f6b159a..26810ad 100644
--- a/Source/cmCMakePresetsFile.h
+++ b/Source/cmCMakePresetsFile.h
@@ -2,6 +2,7 @@
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #pragma once
 
+#include <functional>
 #include <map>
 #include <string>
 #include <utility>
@@ -12,6 +13,27 @@
 class cmCMakePresetsFile
 {
 public:
+  enum class ReadFileResult
+  {
+    READ_OK,
+    FILE_NOT_FOUND,
+    JSON_PARSE_ERROR,
+    INVALID_ROOT,
+    NO_VERSION,
+    INVALID_VERSION,
+    UNRECOGNIZED_VERSION,
+    INVALID_CMAKE_VERSION,
+    UNRECOGNIZED_CMAKE_VERSION,
+    INVALID_PRESETS,
+    INVALID_PRESET,
+    INVALID_VARIABLE,
+    DUPLICATE_PRESETS,
+    CYCLIC_PRESET_INHERITANCE,
+    USER_PRESET_INHERITANCE,
+    INVALID_MACRO_EXPANSION,
+    BUILD_TEST_PRESETS_UNSUPPORTED,
+  };
+
   enum class ArchToolsetStrategy
   {
     Set,
@@ -29,25 +51,51 @@ public:
   {
   public:
 #if __cplusplus < 201703L && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)
-    Preset() = default;
-    Preset(const Preset& /*other*/) = default;
-    Preset(Preset&& /*other*/) = default;
-
-    Preset& operator=(const Preset& /*other*/) = default;
-
     // The move assignment operators for several STL classes did not become
     // noexcept until C++17, which causes some tools to warn about this move
     // assignment operator throwing an exception when it shouldn't. Disable the
     // move assignment operator until C++17 is enabled.
-    Preset& operator=(Preset&& /*other*/) = delete;
+    // Explicitly defining a copy assignment operator prevents the compiler
+    // from automatically generating a move assignment operator.
+    Preset& operator=(const Preset& /*other*/) = default;
 #endif
 
+    virtual ~Preset() = default;
+
     std::string Name;
     std::vector<std::string> Inherits;
     bool Hidden;
     bool User;
     std::string DisplayName;
     std::string Description;
+
+    std::map<std::string, cm::optional<std::string>> Environment;
+
+    virtual ReadFileResult VisitPresetInherit(const Preset& parent) = 0;
+    virtual ReadFileResult VisitPresetBeforeInherit()
+    {
+      return ReadFileResult::READ_OK;
+    }
+
+    virtual ReadFileResult VisitPresetAfterInherit()
+    {
+      return ReadFileResult::READ_OK;
+    }
+  };
+
+  class ConfigurePreset : public Preset
+  {
+  public:
+#if __cplusplus < 201703L && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)
+    // The move assignment operators for several STL classes did not become
+    // noexcept until C++17, which causes some tools to warn about this move
+    // assignment operator throwing an exception when it shouldn't. Disable the
+    // move assignment operator until C++17 is enabled.
+    // Explicitly defining a copy assignment operator prevents the compiler
+    // from automatically generating a move assignment operator.
+    ConfigurePreset& operator=(const ConfigurePreset& /*other*/) = default;
+#endif
+
     std::string Generator;
     std::string Architecture;
     cm::optional<ArchToolsetStrategy> ArchitectureStrategy;
@@ -56,7 +104,6 @@ public:
     std::string BinaryDir;
 
     std::map<std::string, cm::optional<CacheVariable>> CacheVariables;
-    std::map<std::string, cm::optional<std::string>> Environment;
 
     cm::optional<bool> WarnDev;
     cm::optional<bool> ErrorDev;
@@ -69,70 +116,183 @@ public:
     cm::optional<bool> DebugOutput;
     cm::optional<bool> DebugTryCompile;
     cm::optional<bool> DebugFind;
+
+    ReadFileResult VisitPresetInherit(const Preset& parent) override;
+    ReadFileResult VisitPresetBeforeInherit() override;
+    ReadFileResult VisitPresetAfterInherit() override;
   };
 
-  class UnexpandedPreset : public Preset
+  class BuildPreset : public Preset
   {
   public:
-    using Preset::Preset;
+#if __cplusplus < 201703L && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)
+    // The move assignment operators for several STL classes did not become
+    // noexcept until C++17, which causes some tools to warn about this move
+    // assignment operator throwing an exception when it shouldn't. Disable the
+    // move assignment operator until C++17 is enabled.
+    // Explicitly defining a copy assignment operator prevents the compiler
+    // from automatically generating a move assignment operator.
+    BuildPreset& operator=(const BuildPreset& /*other*/) = default;
+#endif
 
-    UnexpandedPreset() = default;
-    UnexpandedPreset(const Preset& preset)
-      : Preset(preset)
-    {
-    }
-    UnexpandedPreset(Preset&& preset)
-      : Preset(std::move(preset))
-    {
-    }
+    std::string ConfigurePreset;
+    cm::optional<bool> InheritConfigureEnvironment;
+    cm::optional<int> Jobs;
+    std::vector<std::string> Targets;
+    std::string Configuration;
+    cm::optional<bool> CleanFirst;
+    cm::optional<bool> Verbose;
+    std::vector<std::string> NativeToolOptions;
+
+    ReadFileResult VisitPresetInherit(const Preset& parent) override;
+    ReadFileResult VisitPresetAfterInherit() override;
   };
 
-  class ExpandedPreset : public Preset
+  class TestPreset : public Preset
   {
   public:
-    using Preset::Preset;
+#if __cplusplus < 201703L && (!defined(_MSVC_LANG) || _MSVC_LANG < 201703L)
+    // The move assignment operators for several STL classes did not become
+    // noexcept until C++17, which causes some tools to warn about this move
+    // assignment operator throwing an exception when it shouldn't. Disable the
+    // move assignment operator until C++17 is enabled.
+    // Explicitly defining a copy assignment operator prevents the compiler
+    // from automatically generating a move assignment operator.
+    TestPreset& operator=(const TestPreset& /*other*/) = default;
+#endif
 
-    ExpandedPreset() = default;
-    ExpandedPreset(const Preset& preset)
-      : Preset(preset)
+    struct OutputOptions
     {
-    }
-    ExpandedPreset(Preset&& preset)
-      : Preset(std::move(preset))
+      enum class VerbosityEnum
+      {
+        Default,
+        Verbose,
+        Extra
+      };
+
+      cm::optional<bool> ShortProgress;
+      cm::optional<VerbosityEnum> Verbosity;
+      cm::optional<bool> Debug;
+      cm::optional<bool> OutputOnFailure;
+      cm::optional<bool> Quiet;
+      std::string OutputLogFile;
+      cm::optional<bool> LabelSummary;
+      cm::optional<bool> SubprojectSummary;
+      cm::optional<int> MaxPassedTestOutputSize;
+      cm::optional<int> MaxFailedTestOutputSize;
+      cm::optional<int> MaxTestNameWidth;
+    };
+
+    struct IncludeOptions
     {
-    }
+      struct IndexOptions
+      {
+        cm::optional<int> Start;
+        cm::optional<int> End;
+        cm::optional<int> Stride;
+        std::vector<int> SpecificTests;
+
+        std::string IndexFile;
+      };
+
+      std::string Name;
+      std::string Label;
+      cm::optional<IndexOptions> Index;
+      cm::optional<bool> UseUnion;
+    };
+
+    struct ExcludeOptions
+    {
+      struct FixturesOptions
+      {
+        std::string Any;
+        std::string Setup;
+        std::string Cleanup;
+      };
+
+      std::string Name;
+      std::string Label;
+      cm::optional<FixturesOptions> Fixtures;
+    };
+
+    struct FilterOptions
+    {
+      cm::optional<IncludeOptions> Include;
+      cm::optional<ExcludeOptions> Exclude;
+    };
+
+    struct ExecutionOptions
+    {
+      enum class ShowOnlyEnum
+      {
+        Human,
+        JsonV1
+      };
+
+      struct RepeatOptions
+      {
+        enum class ModeEnum
+        {
+          UntilFail,
+          UntilPass,
+          AfterTimeout
+        };
+
+        ModeEnum Mode;
+        int Count;
+      };
+
+      enum class NoTestsActionEnum
+      {
+        Default,
+        Error,
+        Ignore
+      };
+
+      cm::optional<bool> StopOnFailure;
+      cm::optional<bool> EnableFailover;
+      cm::optional<int> Jobs;
+      std::string ResourceSpecFile;
+      cm::optional<int> TestLoad;
+      cm::optional<ShowOnlyEnum> ShowOnly;
+      cm::optional<bool> RerunFailed;
+
+      cm::optional<RepeatOptions> Repeat;
+      cm::optional<bool> InteractiveDebugging;
+      cm::optional<bool> ScheduleRandom;
+      cm::optional<int> Timeout;
+      cm::optional<NoTestsActionEnum> NoTestsAction;
+    };
+
+    std::string ConfigurePreset;
+    cm::optional<bool> InheritConfigureEnvironment;
+    std::string Configuration;
+    std::vector<std::string> OverwriteConfigurationFile;
+    cm::optional<OutputOptions> Output;
+    cm::optional<FilterOptions> Filter;
+    cm::optional<ExecutionOptions> Execution;
+
+    ReadFileResult VisitPresetInherit(const Preset& parent) override;
+    ReadFileResult VisitPresetAfterInherit() override;
   };
 
+  template <class T>
   class PresetPair
   {
   public:
-    UnexpandedPreset Unexpanded;
-    cm::optional<ExpandedPreset> Expanded;
+    T Unexpanded;
+    cm::optional<T> Expanded;
   };
 
-  std::string SourceDir;
-  std::map<std::string, PresetPair> Presets;
-  std::vector<std::string> PresetOrder;
+  std::map<std::string, PresetPair<ConfigurePreset>> ConfigurePresets;
+  std::map<std::string, PresetPair<BuildPreset>> BuildPresets;
+  std::map<std::string, PresetPair<TestPreset>> TestPresets;
 
-  enum class ReadFileResult
-  {
-    READ_OK,
-    FILE_NOT_FOUND,
-    JSON_PARSE_ERROR,
-    INVALID_ROOT,
-    NO_VERSION,
-    INVALID_VERSION,
-    UNRECOGNIZED_VERSION,
-    INVALID_CMAKE_VERSION,
-    UNRECOGNIZED_CMAKE_VERSION,
-    INVALID_PRESETS,
-    INVALID_PRESET,
-    INVALID_VARIABLE,
-    DUPLICATE_PRESETS,
-    CYCLIC_PRESET_INHERITANCE,
-    USER_PRESET_INHERITANCE,
-    INVALID_MACRO_EXPANSION,
-  };
+  std::vector<std::string> ConfigurePresetOrder;
+  std::vector<std::string> BuildPresetOrder;
+  std::vector<std::string> TestPresetOrder;
+
+  std::string SourceDir;
 
   static std::string GetFilename(const std::string& sourceDir);
   static std::string GetUserFilename(const std::string& sourceDir);
@@ -140,9 +300,44 @@ public:
                                     bool allowNoFiles = false);
   static const char* ResultToString(ReadFileResult result);
 
+  std::string GetGeneratorForPreset(const std::string& presetName) const
+  {
+    auto configurePresetName = presetName;
+
+    auto buildPresetIterator = this->BuildPresets.find(presetName);
+    if (buildPresetIterator != this->BuildPresets.end()) {
+      configurePresetName =
+        buildPresetIterator->second.Unexpanded.ConfigurePreset;
+    } else {
+      auto testPresetIterator = this->TestPresets.find(presetName);
+      if (testPresetIterator != this->TestPresets.end()) {
+        configurePresetName =
+          testPresetIterator->second.Unexpanded.ConfigurePreset;
+      }
+    }
+
+    auto configurePresetIterator =
+      this->ConfigurePresets.find(configurePresetName);
+    if (configurePresetIterator != this->ConfigurePresets.end()) {
+      return configurePresetIterator->second.Unexpanded.Generator;
+    }
+
+    // This should only happen if the preset is hidden
+    // or (for build or test presets) if ConfigurePreset is invalid.
+    return "";
+  }
+
+  static void PrintPresets(
+    const std::vector<const cmCMakePresetsFile::Preset*>& presets);
+  void PrintConfigurePresetList() const;
+  void PrintConfigurePresetList(
+    const std::function<bool(const ConfigurePreset&)>& filter) const;
+  void PrintBuildPresetList() const;
+  void PrintTestPresetList() const;
+  void PrintAllPresets() const;
+
 private:
-  ReadFileResult ReadJSONFile(const std::string& filename,
-                              std::vector<std::string>& presetOrder,
-                              std::map<std::string, PresetPair>& presetMap,
-                              bool user);
+  ReadFileResult ReadProjectPresetsInternal(bool allowNoFiles);
+  ReadFileResult ReadJSONFile(const std::string& filename, bool user);
+  void ClearPresets();
 };
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index 6c1071d..4bea0d5 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -18,6 +18,7 @@
 #include <vector>
 
 #include <cm/memory>
+#include <cm/optional>
 #include <cm/string_view>
 #include <cmext/algorithm>
 #include <cmext/string_view>
@@ -38,6 +39,7 @@
 #  include <unistd.h> // IWYU pragma: keep
 #endif
 
+#include "cmCMakePresetsFile.h"
 #include "cmCTestBuildAndTestHandler.h"
 #include "cmCTestBuildHandler.h"
 #include "cmCTestConfigureHandler.h"
@@ -2257,6 +2259,311 @@ bool cmCTest::AddVariableDefinition(const std::string& arg)
   return false;
 }
 
+void cmCTest::SetPersistentOptionIfNotEmpty(const std::string& value,
+                                            const std::string& optionName)
+{
+  if (!value.empty()) {
+    this->GetTestHandler()->SetPersistentOption(optionName, value.c_str());
+    this->GetMemCheckHandler()->SetPersistentOption(optionName, value.c_str());
+  }
+}
+
+bool cmCTest::SetArgsFromPreset(const std::string& presetName,
+                                bool listPresets)
+{
+  const auto workingDirectory = cmSystemTools::GetCurrentWorkingDirectory();
+
+  cmCMakePresetsFile settingsFile;
+  auto result = settingsFile.ReadProjectPresets(workingDirectory);
+  if (result != cmCMakePresetsFile::ReadFileResult::READ_OK) {
+    cmSystemTools::Error(cmStrCat("Could not read presets from ",
+                                  workingDirectory, ": ",
+                                  cmCMakePresetsFile::ResultToString(result)));
+    return false;
+  }
+
+  if (listPresets) {
+    settingsFile.PrintTestPresetList();
+    return true;
+  }
+
+  auto presetPair = settingsFile.TestPresets.find(presetName);
+  if (presetPair == settingsFile.TestPresets.end()) {
+    cmSystemTools::Error(cmStrCat("No such test preset in ", workingDirectory,
+                                  ": \"", presetName, '"'));
+    settingsFile.PrintTestPresetList();
+    return false;
+  }
+
+  if (presetPair->second.Unexpanded.Hidden) {
+    cmSystemTools::Error(cmStrCat("Cannot use hidden test preset in ",
+                                  workingDirectory, ": \"", presetName, '"'));
+    settingsFile.PrintTestPresetList();
+    return false;
+  }
+
+  auto const& expandedPreset = presetPair->second.Expanded;
+  if (!expandedPreset) {
+    cmSystemTools::Error(cmStrCat("Could not evaluate test preset \"",
+                                  presetName, "\": Invalid macro expansion"));
+    settingsFile.PrintTestPresetList();
+    return false;
+  }
+
+  auto configurePresetPair =
+    settingsFile.ConfigurePresets.find(expandedPreset->ConfigurePreset);
+  if (configurePresetPair == settingsFile.ConfigurePresets.end()) {
+    cmSystemTools::Error(cmStrCat("No such configure preset in ",
+                                  workingDirectory, ": \"",
+                                  expandedPreset->ConfigurePreset, '"'));
+    settingsFile.PrintConfigurePresetList();
+    return false;
+  }
+
+  if (configurePresetPair->second.Unexpanded.Hidden) {
+    cmSystemTools::Error(cmStrCat("Cannot use hidden configure preset in ",
+                                  workingDirectory, ": \"",
+                                  expandedPreset->ConfigurePreset, '"'));
+    settingsFile.PrintConfigurePresetList();
+    return false;
+  }
+
+  auto const& expandedConfigurePreset = configurePresetPair->second.Expanded;
+  if (!expandedConfigurePreset) {
+    cmSystemTools::Error(cmStrCat("Could not evaluate configure preset \"",
+                                  expandedPreset->ConfigurePreset,
+                                  "\": Invalid macro expansion"));
+    return false;
+  }
+
+  auto presetEnvironment = expandedPreset->Environment;
+  for (auto const& var : presetEnvironment) {
+    if (var.second) {
+      cmSystemTools::PutEnv(cmStrCat(var.first, '=', *var.second));
+    }
+  }
+
+  if (!expandedPreset->Configuration.empty()) {
+    this->SetConfigType(expandedPreset->Configuration);
+  }
+
+  // Set build directory to value specified by the configure preset.
+  this->AddCTestConfigurationOverwrite(
+    cmStrCat("BuildDirectory=", expandedConfigurePreset->BinaryDir));
+  for (const auto& kvp : expandedPreset->OverwriteConfigurationFile) {
+    this->AddCTestConfigurationOverwrite(kvp);
+  }
+
+  if (expandedPreset->Output) {
+    this->Impl->TestProgressOutput =
+      expandedPreset->Output->ShortProgress.value_or(false);
+
+    if (expandedPreset->Output->Verbosity) {
+      const auto& verbosity = *expandedPreset->Output->Verbosity;
+      switch (verbosity) {
+        case cmCMakePresetsFile::TestPreset::OutputOptions::VerbosityEnum::
+          Extra:
+          this->Impl->ExtraVerbose = true;
+          // intentional fallthrough
+        case cmCMakePresetsFile::TestPreset::OutputOptions::VerbosityEnum::
+          Verbose:
+          this->Impl->Verbose = true;
+          break;
+        case cmCMakePresetsFile::TestPreset::OutputOptions::VerbosityEnum::
+          Default:
+        default:
+          // leave default settings
+          break;
+      }
+    }
+
+    this->Impl->Debug = expandedPreset->Output->Debug.value_or(false);
+    this->Impl->ShowLineNumbers =
+      expandedPreset->Output->Debug.value_or(false);
+    this->Impl->OutputTestOutputOnTestFailure =
+      expandedPreset->Output->OutputOnFailure.value_or(false);
+    this->Impl->Quiet = expandedPreset->Output->Quiet.value_or(false);
+
+    if (!expandedPreset->Output->OutputLogFile.empty()) {
+      this->SetOutputLogFileName(expandedPreset->Output->OutputLogFile);
+    }
+
+    this->Impl->LabelSummary =
+      expandedPreset->Output->LabelSummary.value_or(true);
+    this->Impl->SubprojectSummary =
+      expandedPreset->Output->SubprojectSummary.value_or(true);
+
+    if (expandedPreset->Output->MaxPassedTestOutputSize) {
+      this->Impl->TestHandler.SetTestOutputSizePassed(
+        *expandedPreset->Output->MaxPassedTestOutputSize);
+    }
+
+    if (expandedPreset->Output->MaxFailedTestOutputSize) {
+      this->Impl->TestHandler.SetTestOutputSizeFailed(
+        *expandedPreset->Output->MaxFailedTestOutputSize);
+    }
+
+    if (expandedPreset->Output->MaxTestNameWidth) {
+      this->Impl->MaxTestNameWidth = *expandedPreset->Output->MaxTestNameWidth;
+    }
+  }
+
+  if (expandedPreset->Filter) {
+    if (expandedPreset->Filter->Include) {
+      this->SetPersistentOptionIfNotEmpty(
+        expandedPreset->Filter->Include->Name, "IncludeRegularExpression");
+      this->SetPersistentOptionIfNotEmpty(
+        expandedPreset->Filter->Include->Label, "LabelRegularExpression");
+
+      if (expandedPreset->Filter->Include->Index) {
+        if (expandedPreset->Filter->Include->Index->IndexFile.empty()) {
+          const auto& start = expandedPreset->Filter->Include->Index->Start;
+          const auto& end = expandedPreset->Filter->Include->Index->End;
+          const auto& stride = expandedPreset->Filter->Include->Index->Stride;
+          std::string indexOptions;
+          indexOptions += (start ? std::to_string(*start) : "") + ",";
+          indexOptions += (end ? std::to_string(*end) : "") + ",";
+          indexOptions += (stride ? std::to_string(*stride) : "") + ",";
+          indexOptions +=
+            cmJoin(expandedPreset->Filter->Include->Index->SpecificTests, ",");
+
+          this->SetPersistentOptionIfNotEmpty(indexOptions,
+                                              "TestsToRunInformation");
+        } else {
+          this->SetPersistentOptionIfNotEmpty(
+            expandedPreset->Filter->Include->Index->IndexFile,
+            "TestsToRunInformation");
+        }
+      }
+
+      if (expandedPreset->Filter->Include->UseUnion.value_or(false)) {
+        this->GetTestHandler()->SetPersistentOption("UseUnion", "true");
+        this->GetMemCheckHandler()->SetPersistentOption("UseUnion", "true");
+      }
+    }
+
+    if (expandedPreset->Filter->Exclude) {
+      this->SetPersistentOptionIfNotEmpty(
+        expandedPreset->Filter->Exclude->Name, "ExcludeRegularExpression");
+      this->SetPersistentOptionIfNotEmpty(
+        expandedPreset->Filter->Exclude->Label,
+        "ExcludeLabelRegularExpression");
+
+      if (expandedPreset->Filter->Exclude->Fixtures) {
+        this->SetPersistentOptionIfNotEmpty(
+          expandedPreset->Filter->Exclude->Fixtures->Any,
+          "ExcludeFixtureRegularExpression");
+        this->SetPersistentOptionIfNotEmpty(
+          expandedPreset->Filter->Exclude->Fixtures->Setup,
+          "ExcludeFixtureSetupRegularExpression");
+        this->SetPersistentOptionIfNotEmpty(
+          expandedPreset->Filter->Exclude->Fixtures->Cleanup,
+          "ExcludeFixtureCleanupRegularExpression");
+      }
+    }
+  }
+
+  if (expandedPreset->Execution) {
+    this->Impl->StopOnFailure =
+      expandedPreset->Execution->StopOnFailure.value_or(false);
+    this->Impl->Failover =
+      expandedPreset->Execution->EnableFailover.value_or(false);
+
+    if (expandedPreset->Execution->Jobs) {
+      auto jobs = *expandedPreset->Execution->Jobs;
+      this->SetParallelLevel(jobs);
+      this->Impl->ParallelLevelSetInCli = true;
+    }
+
+    this->SetPersistentOptionIfNotEmpty(
+      expandedPreset->Execution->ResourceSpecFile, "ResourceSpecFile");
+
+    if (expandedPreset->Execution->TestLoad) {
+      auto testLoad = *expandedPreset->Execution->TestLoad;
+      this->SetTestLoad(testLoad);
+    }
+
+    if (expandedPreset->Execution->ShowOnly) {
+      this->Impl->ShowOnly = true;
+
+      switch (*expandedPreset->Execution->ShowOnly) {
+        case cmCMakePresetsFile::TestPreset::ExecutionOptions::ShowOnlyEnum::
+          JsonV1:
+          this->Impl->Quiet = true;
+          this->Impl->OutputAsJson = true;
+          this->Impl->OutputAsJsonVersion = 1;
+          break;
+        case cmCMakePresetsFile::TestPreset::ExecutionOptions::ShowOnlyEnum::
+          Human:
+          // intentional fallthrough (human is the default)
+        default:
+          break;
+      }
+    }
+
+    if (expandedPreset->Execution->RerunFailed.value_or(false)) {
+      this->GetTestHandler()->SetPersistentOption("RerunFailed", "true");
+      this->GetMemCheckHandler()->SetPersistentOption("RerunFailed", "true");
+    }
+
+    if (expandedPreset->Execution->Repeat) {
+      this->Impl->RepeatCount = expandedPreset->Execution->Repeat->Count;
+      switch (expandedPreset->Execution->Repeat->Mode) {
+        case cmCMakePresetsFile::TestPreset::ExecutionOptions::RepeatOptions::
+          ModeEnum::UntilFail:
+          this->Impl->RepeatMode = cmCTest::Repeat::UntilFail;
+          break;
+        case cmCMakePresetsFile::TestPreset::ExecutionOptions::RepeatOptions::
+          ModeEnum::UntilPass:
+          this->Impl->RepeatMode = cmCTest::Repeat::UntilPass;
+          break;
+        case cmCMakePresetsFile::TestPreset::ExecutionOptions::RepeatOptions::
+          ModeEnum::AfterTimeout:
+          this->Impl->RepeatMode = cmCTest::Repeat::AfterTimeout;
+          break;
+        default:
+          // should never default since mode is required
+          return false;
+      }
+    }
+
+    if (expandedPreset->Execution->InteractiveDebugging) {
+      this->Impl->InteractiveDebugMode =
+        *expandedPreset->Execution->InteractiveDebugging;
+    }
+
+    if (expandedPreset->Execution->ScheduleRandom.value_or(false)) {
+      this->Impl->ScheduleType = "Random";
+    }
+
+    if (expandedPreset->Execution->Timeout) {
+      this->Impl->GlobalTimeout =
+        cmDuration(*expandedPreset->Execution->Timeout);
+    }
+
+    if (expandedPreset->Execution->NoTestsAction) {
+      switch (*expandedPreset->Execution->NoTestsAction) {
+        case cmCMakePresetsFile::TestPreset::ExecutionOptions::
+          NoTestsActionEnum::Error:
+          this->Impl->NoTestsMode = cmCTest::NoTests::Error;
+          break;
+        case cmCMakePresetsFile::TestPreset::ExecutionOptions::
+          NoTestsActionEnum::Ignore:
+          this->Impl->NoTestsMode = cmCTest::NoTests::Ignore;
+          break;
+        case cmCMakePresetsFile::TestPreset::ExecutionOptions::
+          NoTestsActionEnum::Default:
+          break;
+        default:
+          // should never default
+          return false;
+      }
+    }
+  }
+
+  return true;
+}
+
 // the main entry point of ctest, called from main
 int cmCTest::Run(std::vector<std::string>& args, std::string* output)
 {
@@ -2268,6 +2575,37 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
   // copy the command line
   cm::append(this->Impl->InitialCommandLineArguments, args);
 
+  // check if a test preset was specified
+
+  bool listPresets =
+    find(args.begin(), args.end(), "--list-presets") != args.end();
+  auto it = find(args.begin(), args.end(), "--preset");
+  if (listPresets || it != args.end()) {
+    std::string errormsg;
+    bool success;
+
+    if (listPresets) {
+      // If listing presets we don't need a presetName
+      success = this->SetArgsFromPreset("", listPresets);
+    } else {
+      if (++it != args.end()) {
+        auto presetName = *it;
+        success = this->SetArgsFromPreset(presetName, listPresets);
+      } else {
+        cmSystemTools::Error("'--preset' requires an argument");
+        success = false;
+      }
+    }
+
+    if (listPresets) {
+      return success ? 0 : 1;
+    }
+
+    if (!success) {
+      return 1;
+    }
+  }
+
   // process the command line arguments
   for (size_t i = 1; i < args.size(); ++i) {
     // handle the simple commandline arguments
@@ -2339,7 +2677,7 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
       this->Impl->ScheduleType = "Random";
     }
 
-    // pass the argument to all the handlers as well, but i may no longer be
+    // pass the argument to all the handlers as well, but it may no longer be
     // set to what it was originally so I'm not sure this is working as
     // intended
     for (auto& handler : this->Impl->GetTestingHandlers()) {
diff --git a/Source/cmCTest.h b/Source/cmCTest.h
index e12f8b0..4669a1c 100644
--- a/Source/cmCTest.h
+++ b/Source/cmCTest.h
@@ -461,6 +461,9 @@ public:
   void SetRunCurrentScript(bool value);
 
 private:
+  void SetPersistentOptionIfNotEmpty(const std::string& value,
+                                     const std::string& optionName);
+
   int GenerateNotesFile(const std::string& files);
 
   void BlockTestErrorDiagnostics();
@@ -484,6 +487,9 @@ private:
   /** add a variable definition from a command line -D value */
   bool AddVariableDefinition(const std::string& arg);
 
+  /** set command line arguments read from a test preset */
+  bool SetArgsFromPreset(const std::string& presetName, bool listPresets);
+
   /** parse and process most common command line arguments */
   bool HandleCommandLineArguments(size_t& i, std::vector<std::string>& args,
                                   std::string& errormsg);
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 48848a7..4b57395 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -726,6 +726,17 @@ void cmake::LoadEnvironmentPresets()
   readGeneratorVar("CMAKE_GENERATOR_TOOLSET", this->GeneratorToolset);
 }
 
+namespace {
+enum class ListPresets
+{
+  None,
+  Configure,
+  Build,
+  Test,
+  All,
+};
+}
+
 // Parse the args
 void cmake::SetArgs(const std::vector<std::string>& args)
 {
@@ -738,7 +749,8 @@ void cmake::SetArgs(const std::vector<std::string>& args)
   std::string profilingFormat;
   std::string profilingOutput;
   std::string presetName;
-  bool listPresets = false;
+
+  ListPresets listPresets = ListPresets::None;
 #endif
 
   auto SourceArgLambda = [](std::string const& value, cmake* state) -> bool {
@@ -995,11 +1007,27 @@ void cmake::SetArgs(const std::vector<std::string>& args)
                            presetName = value;
                            return true;
                          });
-  arguments.emplace_back("--list-presets", CommandArgument::Values::Zero,
-                         [&](std::string const&, cmake*) -> bool {
-                           listPresets = true;
-                           return true;
-                         });
+  arguments.emplace_back(
+    "--list-presets", CommandArgument::Values::ZeroOrOne,
+    [&](std::string const& value, cmake*) -> bool {
+      if (value.empty() || value == "configure") {
+        listPresets = ListPresets::Configure;
+      } else if (value == "build") {
+        listPresets = ListPresets::Build;
+      } else if (value == "test") {
+        listPresets = ListPresets::Test;
+      } else if (value == "all") {
+        listPresets = ListPresets::All;
+      } else {
+        cmSystemTools::Error(
+          "Invalid value specified for --list-presets.\n"
+          "Valid values are configure, build, test, or all. "
+          "When no value is passed the default is configure.");
+        return false;
+      }
+
+      return true;
+    });
 
 #endif
 
@@ -1119,7 +1147,7 @@ void cmake::SetArgs(const std::vector<std::string>& args)
   }
 
 #if !defined(CMAKE_BOOTSTRAP)
-  if (listPresets || !presetName.empty()) {
+  if (listPresets != ListPresets::None || !presetName.empty()) {
     cmCMakePresetsFile settingsFile;
     auto result = settingsFile.ReadProjectPresets(this->GetHomeDirectory());
     if (result != cmCMakePresetsFile::ReadFileResult::READ_OK) {
@@ -1128,12 +1156,24 @@ void cmake::SetArgs(const std::vector<std::string>& args)
                  ": ", cmCMakePresetsFile::ResultToString(result)));
       return;
     }
-    if (listPresets) {
-      this->PrintPresetList(settingsFile);
+
+    if (listPresets != ListPresets::None) {
+      if (listPresets == ListPresets::Configure) {
+        this->PrintPresetList(settingsFile);
+      } else if (listPresets == ListPresets::Build) {
+        settingsFile.PrintBuildPresetList();
+      } else if (listPresets == ListPresets::Test) {
+        settingsFile.PrintTestPresetList();
+      } else if (listPresets == ListPresets::All) {
+        settingsFile.PrintAllPresets();
+      }
+
+      this->SetWorkingMode(WorkingMode::HELP_MODE);
       return;
     }
-    auto preset = settingsFile.Presets.find(presetName);
-    if (preset == settingsFile.Presets.end()) {
+
+    auto preset = settingsFile.ConfigurePresets.find(presetName);
+    if (preset == settingsFile.ConfigurePresets.end()) {
       cmSystemTools::Error(cmStrCat("No such preset in ",
                                     this->GetHomeDirectory(), ": \"",
                                     presetName, '"'));
@@ -1562,44 +1602,16 @@ void cmake::PrintPresetList(const cmCMakePresetsFile& file) const
 {
   std::vector<GeneratorInfo> generators;
   this->GetRegisteredGenerators(generators, false);
+  auto filter =
+    [&generators](const cmCMakePresetsFile::ConfigurePreset& preset) -> bool {
+    auto condition = [&preset](const GeneratorInfo& info) -> bool {
+      return info.name == preset.Generator;
+    };
+    auto it = std::find_if(generators.begin(), generators.end(), condition);
+    return it != generators.end();
+  };
 
-  std::vector<cmCMakePresetsFile::UnexpandedPreset> presets;
-  for (auto const& p : file.PresetOrder) {
-    auto const& preset = file.Presets.at(p);
-    if (!preset.Unexpanded.Hidden && preset.Expanded &&
-        std::find_if(generators.begin(), generators.end(),
-                     [&preset](const GeneratorInfo& info) {
-                       return info.name == preset.Unexpanded.Generator;
-                     }) != generators.end()) {
-      presets.push_back(preset.Unexpanded);
-    }
-  }
-
-  if (presets.empty()) {
-    return;
-  }
-
-  std::cout << "Available presets:\n\n";
-
-  auto longestPresetName =
-    std::max_element(presets.begin(), presets.end(),
-                     [](const cmCMakePresetsFile::UnexpandedPreset& a,
-                        const cmCMakePresetsFile::UnexpandedPreset& b) {
-                       return a.Name.length() < b.Name.length();
-                     });
-  auto longestLength = longestPresetName->Name.length();
-
-  for (auto const& preset : presets) {
-    std::cout << "  \"" << preset.Name << '"';
-    auto const& description = preset.DisplayName;
-    if (!description.empty()) {
-      for (std::size_t i = 0; i < longestLength - preset.Name.length(); ++i) {
-        std::cout << ' ';
-      }
-      std::cout << " - " << description;
-    }
-    std::cout << '\n';
-  }
+  file.PrintConfigurePresetList(filter);
 }
 #endif
 
@@ -3068,15 +3080,119 @@ std::vector<std::string> cmake::GetDebugConfigs()
   return configs;
 }
 
-int cmake::Build(int jobs, const std::string& dir,
-                 const std::vector<std::string>& targets,
-                 const std::string& config,
-                 const std::vector<std::string>& nativeOptions, bool clean,
-                 bool verbose)
+int cmake::Build(int jobs, std::string dir, std::vector<std::string> targets,
+                 std::string config, std::vector<std::string> nativeOptions,
+                 bool clean, bool verbose, const std::string& presetName,
+                 bool listPresets)
 {
-
   this->SetHomeDirectory("");
   this->SetHomeOutputDirectory("");
+
+#if !defined(CMAKE_BOOTSTRAP)
+  if (!presetName.empty() || listPresets) {
+    this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory());
+    this->SetHomeOutputDirectory(cmSystemTools::GetCurrentWorkingDirectory());
+
+    cmCMakePresetsFile settingsFile;
+    auto result = settingsFile.ReadProjectPresets(this->GetHomeDirectory());
+    if (result != cmCMakePresetsFile::ReadFileResult::READ_OK) {
+      cmSystemTools::Error(
+        cmStrCat("Could not read presets from ", this->GetHomeDirectory(),
+                 ": ", cmCMakePresetsFile::ResultToString(result)));
+      return 1;
+    }
+
+    if (listPresets) {
+      settingsFile.PrintBuildPresetList();
+      return 0;
+    }
+
+    auto presetPair = settingsFile.BuildPresets.find(presetName);
+    if (presetPair == settingsFile.BuildPresets.end()) {
+      cmSystemTools::Error(cmStrCat("No such build preset in ",
+                                    this->GetHomeDirectory(), ": \"",
+                                    presetName, '"'));
+      settingsFile.PrintBuildPresetList();
+      return 1;
+    }
+
+    if (presetPair->second.Unexpanded.Hidden) {
+      cmSystemTools::Error(cmStrCat("Cannot use hidden build preset in ",
+                                    this->GetHomeDirectory(), ": \"",
+                                    presetName, '"'));
+      settingsFile.PrintBuildPresetList();
+      return 1;
+    }
+
+    auto const& expandedPreset = presetPair->second.Expanded;
+    if (!expandedPreset) {
+      cmSystemTools::Error(cmStrCat("Could not evaluate build preset \"",
+                                    presetName,
+                                    "\": Invalid macro expansion"));
+      settingsFile.PrintBuildPresetList();
+      return 1;
+    }
+
+    auto configurePresetPair =
+      settingsFile.ConfigurePresets.find(expandedPreset->ConfigurePreset);
+    if (configurePresetPair == settingsFile.ConfigurePresets.end()) {
+      cmSystemTools::Error(cmStrCat("No such configure preset in ",
+                                    this->GetHomeDirectory(), ": \"",
+                                    expandedPreset->ConfigurePreset, '"'));
+      this->PrintPresetList(settingsFile);
+      return 1;
+    }
+
+    if (configurePresetPair->second.Unexpanded.Hidden) {
+      cmSystemTools::Error(cmStrCat("Cannot use hidden configure preset in ",
+                                    this->GetHomeDirectory(), ": \"",
+                                    expandedPreset->ConfigurePreset, '"'));
+      this->PrintPresetList(settingsFile);
+      return 1;
+    }
+
+    auto const& expandedConfigurePreset = configurePresetPair->second.Expanded;
+    if (!expandedConfigurePreset) {
+      cmSystemTools::Error(cmStrCat("Could not evaluate configure preset \"",
+                                    expandedPreset->ConfigurePreset,
+                                    "\": Invalid macro expansion"));
+      return 1;
+    }
+
+    dir = expandedConfigurePreset->BinaryDir;
+
+    this->UnprocessedPresetEnvironment = expandedPreset->Environment;
+    this->ProcessPresetEnvironment();
+
+    if (jobs == cmake::DEFAULT_BUILD_PARALLEL_LEVEL && expandedPreset->Jobs) {
+      jobs = *expandedPreset->Jobs;
+    }
+
+    if (targets.empty()) {
+      targets.insert(targets.begin(), expandedPreset->Targets.begin(),
+                     expandedPreset->Targets.end());
+    }
+
+    if (config.empty()) {
+      config = expandedPreset->Configuration;
+    }
+
+    if (!clean && expandedPreset->CleanFirst) {
+      clean = *expandedPreset->CleanFirst;
+    }
+
+    if (!verbose && expandedPreset->Verbose) {
+      verbose = *expandedPreset->Verbose;
+    }
+
+    if (nativeOptions.empty()) {
+      nativeOptions.insert(nativeOptions.begin(),
+                           expandedPreset->NativeToolOptions.begin(),
+                           expandedPreset->NativeToolOptions.end());
+    }
+  }
+#endif
+
   if (!cmSystemTools::FileIsDirectory(dir)) {
     std::cerr << "Error: " << dir << " is not a directory\n";
     return 1;
diff --git a/Source/cmake.h b/Source/cmake.h
index d936f28..82e028c 100644
--- a/Source/cmake.h
+++ b/Source/cmake.h
@@ -238,7 +238,7 @@ public:
   bool CreateAndSetGlobalGenerator(const std::string& name, bool allowArch);
 
 #ifndef CMAKE_BOOTSTRAP
-  //! Print list of presets
+  //! Print list of configure presets
   void PrintPresetList(const cmCMakePresetsFile& file) const;
 #endif
 
@@ -556,10 +556,10 @@ public:
     cmListFileBacktrace const& backtrace = cmListFileBacktrace()) const;
 
   //! run the --build option
-  int Build(int jobs, const std::string& dir,
-            const std::vector<std::string>& targets, const std::string& config,
-            const std::vector<std::string>& nativeOptions, bool clean,
-            bool verbose);
+  int Build(int jobs, std::string dir, std::vector<std::string> targets,
+            std::string config, std::vector<std::string> nativeOptions,
+            bool clean, bool verbose, const std::string& presetName,
+            bool listPresets);
 
   //! run the --open option
   bool Open(const std::string& dir, bool dryRun);
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index ba471b7..cd3c955 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -425,6 +425,8 @@ int do_build(int ac, char const* const* av)
   bool foundClean = false;
   bool foundNonClean = false;
   bool verbose = cmSystemTools::HasEnv("VERBOSE");
+  std::string presetName;
+  bool listPresets = false;
 
   auto jLambda = [&](std::string const& value) -> bool {
     jobs = extract_job_number("-j", value);
@@ -464,6 +466,16 @@ int do_build(int ac, char const* const* av)
     cmCommandLineArgument<bool(std::string const& value)>;
 
   std::vector<CommandArgument> arguments = {
+    CommandArgument{ "--preset", CommandArgument::Values::One,
+                     [&](std::string const& value) -> bool {
+                       presetName = value;
+                       return true;
+                     } },
+    CommandArgument{ "--list-presets", CommandArgument::Values::Zero,
+                     [&](std::string const&) -> bool {
+                       listPresets = true;
+                       return true;
+                     } },
     CommandArgument{ "-j", CommandArgument::Values::ZeroOrOne, jLambda },
     CommandArgument{ "--parallel", CommandArgument::Values::ZeroOrOne,
                      parallelLambda },
@@ -494,11 +506,26 @@ int do_build(int ac, char const* const* av)
   };
 
   if (ac >= 3) {
-    dir = cmSystemTools::CollapseFullPath(av[2]);
-
     std::vector<std::string> inputArgs;
-    inputArgs.reserve(ac - 3);
-    cm::append(inputArgs, av + 3, av + ac);
+
+    bool hasPreset = false;
+    for (int i = 2; i < ac; ++i) {
+      if (strcmp(av[i], "--list-presets") == 0 ||
+          strcmp(av[i], "--preset") == 0) {
+        hasPreset = true;
+        break;
+      }
+    }
+
+    if (hasPreset) {
+      inputArgs.reserve(ac - 2);
+      cm::append(inputArgs, av + 2, av + ac);
+    } else {
+      dir = cmSystemTools::CollapseFullPath(av[2]);
+
+      inputArgs.reserve(ac - 3);
+      cm::append(inputArgs, av + 3, av + ac);
+    }
 
     decltype(inputArgs.size()) i = 0;
     for (; i < inputArgs.size() && !nativeOptionsPassed; ++i) {
@@ -551,12 +578,16 @@ int do_build(int ac, char const* const* av)
     }
   }
 
-  if (dir.empty()) {
+  if (dir.empty() && presetName.empty() && !listPresets) {
     /* clang-format off */
     std::cerr <<
-      "Usage: cmake --build <dir> [options] [-- [native-options]]\n"
+      "Usage: cmake --build [<dir> | --preset <preset>] [options] [-- [native-options]]\n"
       "Options:\n"
       "  <dir>          = Project binary directory to be built.\n"
+      "  --preset <preset>\n"
+      "                 = Specify a build preset.\n"
+      "  --list-presets\n"
+      "                 = List available build presets.\n"
       "  --parallel [<jobs>], -j [<jobs>]\n"
       "                 = Build in parallel using the given number of jobs. \n"
       "                   If <jobs> is omitted the native build tool's \n"
@@ -587,8 +618,10 @@ int do_build(int ac, char const* const* av)
   cm.SetProgressCallback([&cm](const std::string& msg, float prog) {
     cmakemainProgressCallback(msg, prog, &cm);
   });
-  return cm.Build(jobs, dir, targets, config, nativeOptions, cleanFirst,
-                  verbose);
+
+  return cm.Build(jobs, std::move(dir), std::move(targets), std::move(config),
+                  std::move(nativeOptions), cleanFirst, verbose, presetName,
+                  listPresets);
 #endif
 }
 
diff --git a/Source/ctest.cxx b/Source/ctest.cxx
index 600df1d..1404b0c 100644
--- a/Source/ctest.cxx
+++ b/Source/ctest.cxx
@@ -26,6 +26,8 @@ static const char* cmDocumentationUsage[][2] = { { nullptr,
                                                  { nullptr, nullptr } };
 
 static const char* cmDocumentationOptions[][2] = {
+  { "--preset <preset>", "Read arguments from a test preset." },
+  { "--list-presets", "List available test presets." },
   { "-C <cfg>, --build-config <cfg>", "Choose configuration to test." },
   { "--progress", "Enable short progress output from tests." },
   { "-V,--verbose", "Enable verbose output from tests." },