From af9ed543b0f9d032158f91cdce7ad6908ff9365b Mon Sep 17 00:00:00 2001 From: Brad King Date: Mon, 4 Nov 2019 16:11:11 -0500 Subject: CTest: Rename PROCESSES test property to RESOURCE_GROUPS The `PROCESSES` test property name added for CMake 3.16 is too close to the existing `PROCESSORS` test property. Furthermore, the property in principle specifies groups of resources organized in a way that is meaningful to a particular test. The groups may often correspond to processes but they could have other meanings. Since the property name `PROCESSES` has not been in a final 3.16 release yet, simply rename it to `RESOURCE_GROUPS`. Fixes: #19914 --- Help/manual/cmake-properties.7.rst | 2 +- Help/manual/ctest.1.rst | 76 ++++++------ Help/prop_test/PROCESSES.rst | 54 -------- Help/prop_test/RESOURCE_GROUPS.rst | 54 ++++++++ Help/prop_test/RESOURCE_LOCK.rst | 14 +-- Source/CTest/cmCTestMultiProcessHandler.cxx | 25 ++-- Source/CTest/cmCTestRunTest.cxx | 6 +- Source/CTest/cmCTestTestHandler.cxx | 10 +- Source/CTest/cmCTestTestHandler.h | 6 +- Tests/CMakeLib/CMakeLists.txt | 2 +- Tests/CMakeLib/testCTestProcesses.cxx | 137 -------------------- Tests/CMakeLib/testCTestResourceGroups.cxx | 138 +++++++++++++++++++++ Tests/RunCMake/CTestCommandLine/RunCMakeTest.cmake | 2 +- .../CTestCommandLine/show-only_json-v1_check.py | 6 +- .../CTestHardwareAllocation/HardwareCommon.cmake | 2 +- .../CTestHardwareAllocation/RunCMakeTest.cmake | 84 ++++++------- .../RunCMake/CTestHardwareAllocation/cthwalloc.cxx | 65 +++++----- 17 files changed, 345 insertions(+), 338 deletions(-) delete mode 100644 Help/prop_test/PROCESSES.rst create mode 100644 Help/prop_test/RESOURCE_GROUPS.rst delete mode 100644 Tests/CMakeLib/testCTestProcesses.cxx create mode 100644 Tests/CMakeLib/testCTestResourceGroups.cxx diff --git a/Help/manual/cmake-properties.7.rst b/Help/manual/cmake-properties.7.rst index 1369aa3..a59dd6b 100644 --- a/Help/manual/cmake-properties.7.rst +++ b/Help/manual/cmake-properties.7.rst @@ -414,10 +414,10 @@ Properties on Tests /prop_test/LABELS /prop_test/MEASUREMENT /prop_test/PASS_REGULAR_EXPRESSION - /prop_test/PROCESSES /prop_test/PROCESSOR_AFFINITY /prop_test/PROCESSORS /prop_test/REQUIRED_FILES + /prop_test/RESOURCE_GROUPS /prop_test/RESOURCE_LOCK /prop_test/RUN_SERIAL /prop_test/SKIP_REGULAR_EXPRESSION diff --git a/Help/manual/ctest.1.rst b/Help/manual/ctest.1.rst index a18d43f..569f0f7 100644 --- a/Help/manual/ctest.1.rst +++ b/Help/manual/ctest.1.rst @@ -1317,8 +1317,8 @@ The CTest hardware allocation feature consists of two inputs: * The :ref:`hardware specification file `, described below, which describes the hardware resources available on the system, and -* The :prop_test:`PROCESSES` property of tests, which describes the resources - required by the test +* The :prop_test:`RESOURCE_GROUPS` property of tests, which describes the + resources required by the test When CTest runs a test, the hardware allocated to that test is passed in the form of a set of @@ -1326,11 +1326,11 @@ form of a set of described below. Using this information to decide which resource to connect to is left to the test writer. -Please note that these processes are not spawned by CTest. The ``PROCESSES`` -property merely tells CTest what processes the test expects to launch. It is up -to the test itself to do this process spawning, and read the :ref:`environment -variables ` to determine which resources -each process has been allocated. +The ``RESOURCE_GROUPS`` property tells CTest what resources a test expects +to use grouped in a way meaningful to the test. The test itself must read +the :ref:`environment variables ` to +determine which resources have been allocated to each group. For example, +each group may correspond to a process the test will spawn when executed. .. _`ctest-hardware-specification-file`: @@ -1423,10 +1423,10 @@ In the example file above, there are four GPUs with ID's 0 through 3. GPU 0 has 2 slots, GPU 1 has 4, GPU 2 has 2, and GPU 3 has a default of 1 slot. There is also one cryptography chip with 4 slots. -``PROCESSES`` Property ----------------------- +``RESOURCE_GROUPS`` Property +---------------------------- -See :prop_test:`PROCESSES` for a description of this property. +See :prop_test:`RESOURCE_GROUPS` for a description of this property. .. _`ctest-hardware-environment-variables`: @@ -1436,65 +1436,67 @@ Environment Variables Once CTest has decided which resources to allocate to a test, it passes this information to the test executable as a series of environment variables. For each example below, we will assume that the test in question has a -:prop_test:`PROCESSES` property of ``2,gpus:2;gpus:4,gpus:1,crypto_chips:2``. +:prop_test:`RESOURCE_GROUPS` property of +``2,gpus:2;gpus:4,gpus:1,crypto_chips:2``. The following variables are passed to the test process: -.. envvar:: CTEST_PROCESS_COUNT +.. envvar:: CTEST_RESOURCE_GROUP_COUNT - The total number of processes specified by the :prop_test:`PROCESSES` + The total number of groups specified by the :prop_test:`RESOURCE_GROUPS` property. For example: - * ``CTEST_PROCESS_COUNT=3`` + * ``CTEST_RESOURCE_GROUP_COUNT=3`` This variable will only be defined if :manual:`ctest(1)` has been given a ``--hardware-spec-file``, or if :command:`ctest_test` has been given a ``HARDWARE_SPEC_FILE``. If no hardware specification file has been given, this variable will not be defined. -.. envvar:: CTEST_PROCESS_ +.. envvar:: CTEST_RESOURCE_GROUP_ - The list of resource types allocated to each process, with each item + The list of resource types allocated to each group, with each item separated by a comma. ```` is a number from zero to - ``CTEST_PROCESS_COUNT`` minus one. ``CTEST_PROCESS_`` is defined for - each ```` in this range. For example: + ``CTEST_RESOURCE_GROUP_COUNT`` minus one. ``CTEST_RESOURCE_GROUP_`` + is defined for each ```` in this range. For example: - * ``CTEST_PROCESS_0=gpus`` - * ``CTEST_PROCESS_1=gpus`` - * ``CTEST_PROCESS_2=crypto_chips,gpus`` + * ``CTEST_RESOURCE_GROUP_0=gpus`` + * ``CTEST_RESOURCE_GROUP_1=gpus`` + * ``CTEST_RESOURCE_GROUP_2=crypto_chips,gpus`` -.. envvar:: CTEST_PROCESS__ +.. envvar:: CTEST_RESOURCE_GROUP__ The list of resource IDs and number of slots from each ID allocated to each - process for a given resource type. This variable consists of a series of + group for a given resource type. This variable consists of a series of pairs, each pair separated by a semicolon, and with the two items in the pair separated by a comma. The first item in each pair is ``id:`` followed by the ID of a resource of type ````, and the second item is ``slots:`` followed by the number of slots from that resource allocated to - the given process. For example: + the given group. For example: - * ``CTEST_PROCESS_0_GPUS=id:0,slots:2`` - * ``CTEST_PROCESS_1_GPUS=id:2,slots:2`` - * ``CTEST_PROCESS_2_GPUS=id:1,slots:4;id:3,slots:1`` - * ``CTEST_PROCESS_2_CRYPTO_CHIPS=id:card0,slots:2`` + * ``CTEST_RESOURCE_GROUP_0_GPUS=id:0,slots:2`` + * ``CTEST_RESOURCE_GROUP_1_GPUS=id:2,slots:2`` + * ``CTEST_RESOURCE_GROUP_2_GPUS=id:1,slots:4;id:3,slots:1`` + * ``CTEST_RESOURCE_GROUP_2_CRYPTO_CHIPS=id:card0,slots:2`` - In this example, process 0 gets 2 slots from GPU ``0``, process 1 gets 2 slots - from GPU ``2``, and process 2 gets 4 slots from GPU ``1`` and 2 slots from + In this example, group 0 gets 2 slots from GPU ``0``, group 1 gets 2 slots + from GPU ``2``, and group 2 gets 4 slots from GPU ``1`` and 2 slots from cryptography chip ``card0``. - ```` is a number from zero to ``CTEST_PROCESS_COUNT`` minus one. + ```` is a number from zero to ``CTEST_RESOURCE_GROUP_COUNT`` minus one. ```` is the name of a resource type, converted to uppercase. - ``CTEST_PROCESS__`` is defined for the product of each - ```` in the range listed above and each resource type listed in - ``CTEST_PROCESS_``. + ``CTEST_RESOURCE_GROUP__`` is defined for the product + of each ```` in the range listed above and each resource type listed in + ``CTEST_RESOURCE_GROUP_``. Because some platforms have case-insensitive names for environment variables, the names of resource types may not clash in a case-insensitive environment. Because of this, for the sake of simplicity, all resource types must be listed in all lowercase in the - :ref:`hardware specification file ` and in - the :prop_test:`PROCESSES` property, and they are converted to all uppercase - in the ``CTEST_PROCESS__`` environment variable. + :ref:`hardware specification file ` and + in the :prop_test:`RESOURCE_GROUPS` property, and they are converted to all + uppercase in the ``CTEST_RESOURCE_GROUP__`` environment + variable. See Also ======== diff --git a/Help/prop_test/PROCESSES.rst b/Help/prop_test/PROCESSES.rst deleted file mode 100644 index d09c6d1..0000000 --- a/Help/prop_test/PROCESSES.rst +++ /dev/null @@ -1,54 +0,0 @@ -PROCESSES ----------- - -Set to specify the number of processes spawned by a test, and the resources -that they require. See :ref:`hardware allocation ` -for more information on how this property integrates into the CTest hardware -allocation feature. - -The ``PROCESSES`` property is a :ref:`semicolon-separated list ` of process descriptions. Each process description consists of an -optional number of processes for the description followed by a series of -resource requirements for those processes. These requirements (and the number -of processes) are separated by commas. The resource requirements consist of the -name of a resource type, followed by a colon, followed by an unsigned integer -specifying the number of slots required on one resource of the given type. - -Please note that these processes are not spawned by CTest. The ``PROCESSES`` -property merely tells CTest what processes the test expects to launch. It is up -to the test itself to do this process spawning, and read the :ref:`environment -variables ` to determine which resources -each process has been allocated. - -Consider the following example: - -.. code-block:: cmake - - add_test(NAME MyTest COMMAND MyExe) - set_property(TEST MyTest PROPERTY PROCESSES - "2,gpus:2" - "gpus:4,crypto_chips:2") - -In this example, there are two process descriptions (implicitly separated by a -semicolon.) The content of the first description is ``2,gpus:2``. This -description spawns 2 processes, each of which requires 2 slots from a single -GPU. The content of the second description is ``gpus:4,crypto_chips:2``. This -description does not specify a process count, so a default of 1 is assumed. -This single process requires 4 slots from a single GPU and 2 slots from a -single cryptography chip. In total, 3 processes are spawned from this test, -each with their own unique requirements. - -When CTest sets the :ref:`environment variables -` for a test, it assigns a process number -based on the process description, starting at 0 on the left and the number of -processes minus 1 on the right. For example, in the example above, the two -processes in the first description would have IDs of 0 and 1, and the single -process in the second description would have an ID of 2. - -Both the ``PROCESSES`` and :prop_test:`RESOURCE_LOCK` properties serve similar -purposes, but they are distinct and orthogonal. Resources specified by -``PROCESSES`` do not affect :prop_test:`RESOURCE_LOCK`, and vice versa. Whereas -:prop_test:`RESOURCE_LOCK` is a simpler property that is used for locking one -global resource, ``PROCESSES`` is a more advanced property that allows multiple -tests to simultaneously use multiple resources of the same type, specifying -their requirements in a fine-grained manner. diff --git a/Help/prop_test/RESOURCE_GROUPS.rst b/Help/prop_test/RESOURCE_GROUPS.rst new file mode 100644 index 0000000..6fdbd03 --- /dev/null +++ b/Help/prop_test/RESOURCE_GROUPS.rst @@ -0,0 +1,54 @@ +RESOURCE_GROUPS +--------------- + +Specify resources required by a test, grouped in a way that is meaningful to +the test. See :ref:`hardware allocation ` +for more information on how this property integrates into the CTest hardware +allocation feature. + +The ``RESOURCE_GROUPS`` property is a :ref:`semicolon-separated list ` of group descriptions. Each entry consists of an optional +number of groups using the description followed by a series of resource +requirements for those groups. These requirements (and the number of groups) +are separated by commas. The resource requirements consist of the name of a +resource type, followed by a colon, followed by an unsigned integer +specifying the number of slots required on one resource of the given type. + +The ``RESOURCE_GROUPS`` property tells CTest what resources a test expects +to use grouped in a way meaningful to the test. The test itself must read +the :ref:`environment variables ` to +determine which resources have been allocated to each group. For example, +each group may correspond to a process the test will spawn when executed. + +Consider the following example: + +.. code-block:: cmake + + add_test(NAME MyTest COMMAND MyExe) + set_property(TEST MyTest PROPERTY RESOURCE_GROUPS + "2,gpus:2" + "gpus:4,crypto_chips:2") + +In this example, there are two group descriptions (implicitly separated by a +semicolon.) The content of the first description is ``2,gpus:2``. This +description specifies 2 groups, each of which requires 2 slots from a single +GPU. The content of the second description is ``gpus:4,crypto_chips:2``. This +description does not specify a group count, so a default of 1 is assumed. +This single group requires 4 slots from a single GPU and 2 slots from a +single cryptography chip. In total, 3 resource groups are specified for this +test, each with its own unique requirements. + +When CTest sets the :ref:`environment variables +` for a test, it assigns a group number +based on the group description, starting at 0 on the left and the number of +groups minus 1 on the right. For example, in the example above, the two +groups in the first description would have IDs of 0 and 1, and the single +group in the second description would have an ID of 2. + +Both the ``RESOURCE_GROUPS`` and :prop_test:`RESOURCE_LOCK` properties serve +similar purposes, but they are distinct and orthogonal. Resources specified by +``RESOURCE_GROUPS`` do not affect :prop_test:`RESOURCE_LOCK`, and vice versa. +Whereas :prop_test:`RESOURCE_LOCK` is a simpler property that is used for +locking one global resource, ``RESOURCE_GROUPS`` is a more advanced property +that allows multiple tests to simultaneously use multiple resources of the +same type, specifying their requirements in a fine-grained manner. diff --git a/Help/prop_test/RESOURCE_LOCK.rst b/Help/prop_test/RESOURCE_LOCK.rst index 7d61f77..8b13a01 100644 --- a/Help/prop_test/RESOURCE_LOCK.rst +++ b/Help/prop_test/RESOURCE_LOCK.rst @@ -9,10 +9,10 @@ not to run concurrently. See also :prop_test:`FIXTURES_REQUIRED` if the resource requires any setup or cleanup steps. -Both the :prop_test:`PROCESSES` and ``RESOURCE_LOCK`` properties serve similar -purposes, but they are distinct and orthogonal. Resources specified by -:prop_test:`PROCESSES` do not affect ``RESOURCE_LOCK``, and vice versa. Whereas -``RESOURCE_LOCK`` is a simpler property that is used for locking one global -resource, :prop_test:`PROCESSES` is a more advanced property that allows -multiple tests to simultaneously use multiple resources of the same type, -specifying their requirements in a fine-grained manner. +Both the :prop_test:`RESOURCE_GROUPS` and ``RESOURCE_LOCK`` properties serve +similar purposes, but they are distinct and orthogonal. Resources specified by +:prop_test:`RESOURCE_GROUPS` do not affect ``RESOURCE_LOCK``, and vice versa. +Whereas ``RESOURCE_LOCK`` is a simpler property that is used for locking one +global resource, :prop_test:`RESOURCE_GROUPS` is a more advanced property +that allows multiple tests to simultaneously use multiple resources of the +same type, specifying their requirements in a fine-grained manner. diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx index 7e8d548..c71ae7b 100644 --- a/Source/CTest/cmCTestMultiProcessHandler.cxx +++ b/Source/CTest/cmCTestMultiProcessHandler.cxx @@ -230,7 +230,7 @@ bool cmCTestMultiProcessHandler::AllocateHardware(int index) } auto& allocatedHardware = this->AllocatedHardware[index]; - allocatedHardware.resize(this->Properties[index]->Processes.size()); + allocatedHardware.resize(this->Properties[index]->ResourceGroups.size()); for (auto const& it : allocations) { for (auto const& alloc : it.second) { bool result = this->HardwareAllocator.AllocateResource( @@ -252,7 +252,7 @@ bool cmCTestMultiProcessHandler::TryAllocateHardware( allocations.clear(); std::size_t processIndex = 0; - for (auto const& process : this->Properties[index]->Processes) { + for (auto const& process : this->Properties[index]->ResourceGroups) { for (auto const& requirement : process) { for (int i = 0; i < requirement.UnitsNeeded; ++i) { allocations[requirement.ResourceType].push_back( @@ -912,14 +912,14 @@ static Json::Value DumpTimeoutAfterMatch( return timeoutAfterMatch; } -static Json::Value DumpProcessesToJsonArray( +static Json::Value DumpResourceGroupsToJsonArray( const std::vector< std::vector>& - processes) + resourceGroups) { - Json::Value jsonProcesses = Json::arrayValue; - for (auto const& it : processes) { - Json::Value jsonProcess = Json::objectValue; + Json::Value jsonResourceGroups = Json::arrayValue; + for (auto const& it : resourceGroups) { + Json::Value jsonResourceGroup = Json::objectValue; Json::Value requirements = Json::arrayValue; for (auto const& it2 : it) { Json::Value res = Json::objectValue; @@ -928,10 +928,10 @@ static Json::Value DumpProcessesToJsonArray( res["slots"] = it2.SlotsNeeded; requirements.append(res); } - jsonProcess["requirements"] = requirements; - jsonProcesses.append(jsonProcess); + jsonResourceGroup["requirements"] = requirements; + jsonResourceGroups.append(jsonResourceGroup); } - return jsonProcesses; + return jsonResourceGroups; } static Json::Value DumpCTestProperty(std::string const& name, @@ -1005,9 +1005,10 @@ static Json::Value DumpCTestProperties( "PASS_REGULAR_EXPRESSION", DumpRegExToJsonArray(testProperties.RequiredRegularExpressions))); } - if (!testProperties.Processes.empty()) { + if (!testProperties.ResourceGroups.empty()) { properties.append(DumpCTestProperty( - "PROCESSES", DumpProcessesToJsonArray(testProperties.Processes))); + "RESOURCE_GROUPS", + DumpResourceGroupsToJsonArray(testProperties.ResourceGroups))); } if (testProperties.WantAffinity) { properties.append( diff --git a/Source/CTest/cmCTestRunTest.cxx b/Source/CTest/cmCTestRunTest.cxx index 7f7f736..91eeb71 100644 --- a/Source/CTest/cmCTestRunTest.cxx +++ b/Source/CTest/cmCTestRunTest.cxx @@ -693,7 +693,7 @@ bool cmCTestRunTest::ForkProcess(cmDuration testTimeOut, bool explicitTimeout, if (this->UseAllocatedHardware) { this->SetupHardwareEnvironment(); } else { - cmSystemTools::UnsetEnv("CTEST_PROCESS_COUNT"); + cmSystemTools::UnsetEnv("CTEST_RESOURCE_GROUP_COUNT"); } return this->TestProcess->StartProcess(this->MultiTestHandler.Loop, @@ -702,13 +702,13 @@ bool cmCTestRunTest::ForkProcess(cmDuration testTimeOut, bool explicitTimeout, void cmCTestRunTest::SetupHardwareEnvironment() { - std::string processCount = "CTEST_PROCESS_COUNT="; + std::string processCount = "CTEST_RESOURCE_GROUP_COUNT="; processCount += std::to_string(this->AllocatedHardware.size()); cmSystemTools::PutEnv(processCount); std::size_t i = 0; for (auto const& process : this->AllocatedHardware) { - std::string prefix = "CTEST_PROCESS_"; + std::string prefix = "CTEST_RESOURCE_GROUP_"; prefix += std::to_string(i); std::string resourceList = prefix + '='; prefix += '_'; diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx index 2be62ae..0f21f91 100644 --- a/Source/CTest/cmCTestTestHandler.cxx +++ b/Source/CTest/cmCTestTestHandler.cxx @@ -1626,11 +1626,11 @@ std::string cmCTestTestHandler::FindExecutable( return fullPath; } -bool cmCTestTestHandler::ParseProcessesProperty( +bool cmCTestTestHandler::ParseResourceGroupsProperty( const std::string& val, - std::vector>& processes) + std::vector>& resourceGroups) { - cmCTestProcessesLexerHelper lexer(processes); + cmCTestProcessesLexerHelper lexer(resourceGroups); return lexer.ParseString(val); } @@ -2203,8 +2203,8 @@ bool cmCTestTestHandler::SetTestsProperties( if (key == "PROCESSOR_AFFINITY") { rt.WantAffinity = cmIsOn(val); } - if (key == "PROCESSES") { - if (!ParseProcessesProperty(val, rt.Processes)) { + if (key == "RESOURCE_GROUPS") { + if (!ParseResourceGroupsProperty(val, rt.ResourceGroups)) { return false; } } diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h index 525215c..e2fde42 100644 --- a/Source/CTest/cmCTestTestHandler.h +++ b/Source/CTest/cmCTestTestHandler.h @@ -158,7 +158,7 @@ public: std::set FixturesCleanup; std::set FixturesRequired; std::set RequireSuccessDepends; - std::vector> Processes; + std::vector> ResourceGroups; // Private test generator properties used to track backtraces cmListFileBacktrace Backtrace; }; @@ -202,9 +202,9 @@ public: std::vector& extraPaths, std::vector& failed); - static bool ParseProcessesProperty( + static bool ParseResourceGroupsProperty( const std::string& val, - std::vector>& processes); + std::vector>& resourceGroups); using ListOfTests = std::vector; diff --git a/Tests/CMakeLib/CMakeLists.txt b/Tests/CMakeLib/CMakeLists.txt index bc2079f..8e11fdf 100644 --- a/Tests/CMakeLib/CMakeLists.txt +++ b/Tests/CMakeLib/CMakeLists.txt @@ -8,9 +8,9 @@ include_directories( set(CMakeLib_TESTS testArgumentParser.cxx testCTestBinPacker.cxx - testCTestProcesses.cxx testCTestHardwareAllocator.cxx testCTestHardwareSpec.cxx + testCTestResourceGroups.cxx testGeneratedFileStream.cxx testRST.cxx testRange.cxx diff --git a/Tests/CMakeLib/testCTestProcesses.cxx b/Tests/CMakeLib/testCTestProcesses.cxx deleted file mode 100644 index acf4f67..0000000 --- a/Tests/CMakeLib/testCTestProcesses.cxx +++ /dev/null @@ -1,137 +0,0 @@ -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ - -#include -#include -#include - -#include "cmCTestTestHandler.h" - -struct ExpectedParseResult -{ - std::string String; - bool ExpectedReturnValue; - std::vector> - ExpectedValue; -}; - -static const std::vector expectedResults{ - /* clang-format off */ - { "threads:2", true, { - { { "threads", 2, 1 } }, - } }, - { "3,threads:2", true, { - { { "threads", 2, 1 } }, - { { "threads", 2, 1 } }, - { { "threads", 2, 1 } }, - } }, - { "3,threads:2,gpus:4", true, { - { { "threads", 2, 1 }, { "gpus", 4, 1 } }, - { { "threads", 2, 1 }, { "gpus", 4, 1 } }, - { { "threads", 2, 1 }, { "gpus", 4, 1 } }, - } }, - { "2,threads:2;gpus:4", true, { - { { "threads", 2, 1 } }, - { { "threads", 2, 1 } }, - { { "gpus", 4, 1 } }, - } }, - { "threads:2;2,gpus:4", true, { - { { "threads", 2, 1 } }, - { { "gpus", 4, 1 } }, - { { "gpus", 4, 1 } }, - } }, - { "threads:2;gpus:4", true, { - { { "threads", 2, 1 } }, - { { "gpus", 4, 1 } }, - } }, - { "1,threads:2;0,gpus:4", true, { - { { "threads", 2, 1 } }, - } }, - { "1,_:1", true, { - { { "_", 1, 1 } }, - } }, - { "1,a:1", true, { - { { "a", 1, 1 } }, - } }, - { "2", true, { - {}, - {}, - } }, - { "1;2,threads:1", true, { - {}, - { { "threads", 1, 1 } }, - { { "threads", 1, 1 } }, - } }, - { "1,,threads:1", true, { - { { "threads", 1, 1 } }, - } }, - { ";1,threads:1", true, { - { { "threads", 1, 1 } }, - } }, - { "1,threads:1;", true, { - { { "threads", 1, 1 } }, - } }, - { "1,threads:1,", true, { - { { "threads", 1, 1 } }, - } }, - { "threads:1;;threads:2", true, { - { { "threads", 1, 1 } }, - { { "threads", 2, 1 } }, - } }, - { "1,", true, { - {}, - } }, - { ";", true, {} }, - { "", true, {} }, - { ",", false, {} }, - { "1,0:1", false, {} }, - { "1,A:1", false, {} }, - { "1,a-b:1", false, {} }, - { "invalid", false, {} }, - { ",1,invalid:1", false, {} }, - { "1,1", false, {} }, - { "-1,invalid:1", false, {} }, - { "1,invalid:*", false, {} }, - { "1,invalid:-1", false, {} }, - { "1,invalid:-", false, {} }, - { "1,invalid:ab2", false, {} }, - { "1,invalid :2", false, {} }, - { "1, invalid:2", false, {} }, - { "1,invalid:ab", false, {} }, - /* clang-format on */ -}; - -bool TestExpectedParseResult(const ExpectedParseResult& expected) -{ - std::vector> - result; - bool retval; - if ((retval = cmCTestTestHandler::ParseProcessesProperty( - expected.String, result)) != expected.ExpectedReturnValue) { - std::cout << "ParseProcessesProperty(\"" << expected.String - << "\") returned " << retval << ", should be " - << expected.ExpectedReturnValue << std::endl; - return false; - } - - if (result != expected.ExpectedValue) { - std::cout << "ParseProcessesProperty(\"" << expected.String - << "\") did not yield expected set of processes" << std::endl; - return false; - } - - return true; -} - -int testCTestProcesses(int /*unused*/, char* /*unused*/ []) -{ - int retval = 0; - - for (auto const& expected : expectedResults) { - if (!TestExpectedParseResult(expected)) { - retval = 1; - } - } - - return retval; -} diff --git a/Tests/CMakeLib/testCTestResourceGroups.cxx b/Tests/CMakeLib/testCTestResourceGroups.cxx new file mode 100644 index 0000000..5fd7d4a --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceGroups.cxx @@ -0,0 +1,138 @@ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ + +#include +#include +#include + +#include "cmCTestTestHandler.h" + +struct ExpectedParseResult +{ + std::string String; + bool ExpectedReturnValue; + std::vector> + ExpectedValue; +}; + +static const std::vector expectedResults{ + /* clang-format off */ + { "threads:2", true, { + { { "threads", 2, 1 } }, + } }, + { "3,threads:2", true, { + { { "threads", 2, 1 } }, + { { "threads", 2, 1 } }, + { { "threads", 2, 1 } }, + } }, + { "3,threads:2,gpus:4", true, { + { { "threads", 2, 1 }, { "gpus", 4, 1 } }, + { { "threads", 2, 1 }, { "gpus", 4, 1 } }, + { { "threads", 2, 1 }, { "gpus", 4, 1 } }, + } }, + { "2,threads:2;gpus:4", true, { + { { "threads", 2, 1 } }, + { { "threads", 2, 1 } }, + { { "gpus", 4, 1 } }, + } }, + { "threads:2;2,gpus:4", true, { + { { "threads", 2, 1 } }, + { { "gpus", 4, 1 } }, + { { "gpus", 4, 1 } }, + } }, + { "threads:2;gpus:4", true, { + { { "threads", 2, 1 } }, + { { "gpus", 4, 1 } }, + } }, + { "1,threads:2;0,gpus:4", true, { + { { "threads", 2, 1 } }, + } }, + { "1,_:1", true, { + { { "_", 1, 1 } }, + } }, + { "1,a:1", true, { + { { "a", 1, 1 } }, + } }, + { "2", true, { + {}, + {}, + } }, + { "1;2,threads:1", true, { + {}, + { { "threads", 1, 1 } }, + { { "threads", 1, 1 } }, + } }, + { "1,,threads:1", true, { + { { "threads", 1, 1 } }, + } }, + { ";1,threads:1", true, { + { { "threads", 1, 1 } }, + } }, + { "1,threads:1;", true, { + { { "threads", 1, 1 } }, + } }, + { "1,threads:1,", true, { + { { "threads", 1, 1 } }, + } }, + { "threads:1;;threads:2", true, { + { { "threads", 1, 1 } }, + { { "threads", 2, 1 } }, + } }, + { "1,", true, { + {}, + } }, + { ";", true, {} }, + { "", true, {} }, + { ",", false, {} }, + { "1,0:1", false, {} }, + { "1,A:1", false, {} }, + { "1,a-b:1", false, {} }, + { "invalid", false, {} }, + { ",1,invalid:1", false, {} }, + { "1,1", false, {} }, + { "-1,invalid:1", false, {} }, + { "1,invalid:*", false, {} }, + { "1,invalid:-1", false, {} }, + { "1,invalid:-", false, {} }, + { "1,invalid:ab2", false, {} }, + { "1,invalid :2", false, {} }, + { "1, invalid:2", false, {} }, + { "1,invalid:ab", false, {} }, + /* clang-format on */ +}; + +bool TestExpectedParseResult(const ExpectedParseResult& expected) +{ + std::vector> + result; + bool retval; + if ((retval = cmCTestTestHandler::ParseResourceGroupsProperty( + expected.String, result)) != expected.ExpectedReturnValue) { + std::cout << "ParseResourceGroupsProperty(\"" << expected.String + << "\") returned " << retval << ", should be " + << expected.ExpectedReturnValue << std::endl; + return false; + } + + if (result != expected.ExpectedValue) { + std::cout << "ParseResourceGroupsProperty(\"" << expected.String + << "\") did not yield expected set of resource groups" + << std::endl; + return false; + } + + return true; +} + +int testCTestResourceGroups(int /*unused*/, char* /*unused*/ []) +{ + int retval = 0; + + for (auto const& expected : expectedResults) { + if (!TestExpectedParseResult(expected)) { + retval = 1; + } + } + + return retval; +} diff --git a/Tests/RunCMake/CTestCommandLine/RunCMakeTest.cmake b/Tests/RunCMake/CTestCommandLine/RunCMakeTest.cmake index fd2c97f..6b23162 100644 --- a/Tests/RunCMake/CTestCommandLine/RunCMakeTest.cmake +++ b/Tests/RunCMake/CTestCommandLine/RunCMakeTest.cmake @@ -258,7 +258,7 @@ function(run_ShowOnly) add_test(ShowOnly \"${CMAKE_COMMAND}\" -E echo) set_tests_properties(ShowOnly PROPERTIES WILL_FAIL true - PROCESSES \"2,threads:2,gpus:4;gpus:2,threads:4\" + RESOURCE_GROUPS \"2,threads:2,gpus:4;gpus:2,threads:4\" REQUIRED_FILES RequiredFileDoesNotExist _BACKTRACE_TRIPLES \"file1;1;add_test;file0;;\" ) diff --git a/Tests/RunCMake/CTestCommandLine/show-only_json-v1_check.py b/Tests/RunCMake/CTestCommandLine/show-only_json-v1_check.py index 6eb8624..b818650 100644 --- a/Tests/RunCMake/CTestCommandLine/show-only_json-v1_check.py +++ b/Tests/RunCMake/CTestCommandLine/show-only_json-v1_check.py @@ -80,12 +80,12 @@ def check_willfail_property(p): assert p["name"] == "WILL_FAIL" assert p["value"] == True -def check_processes_property(p): +def check_resource_groups_property(p): assert is_dict(p) assert sorted(p.keys()) == ["name", "value"] assert is_string(p["name"]) assert is_list(p["value"]) - assert p["name"] == "PROCESSES" + assert p["name"] == "RESOURCE_GROUPS" assert len(p["value"]) == 3 assert is_dict(p["value"][0]) @@ -147,7 +147,7 @@ def check_workingdir_property(p): def check_properties(p): assert is_list(p) assert len(p) == 4 - check_processes_property(p[0]) + check_resource_groups_property(p[0]) check_reqfiles_property(p[1]) check_willfail_property(p[2]) check_workingdir_property(p[3]) diff --git a/Tests/RunCMake/CTestHardwareAllocation/HardwareCommon.cmake b/Tests/RunCMake/CTestHardwareAllocation/HardwareCommon.cmake index 3893d40..3288f35 100644 --- a/Tests/RunCMake/CTestHardwareAllocation/HardwareCommon.cmake +++ b/Tests/RunCMake/CTestHardwareAllocation/HardwareCommon.cmake @@ -11,7 +11,7 @@ function(add_hardware_test name sleep_time proc) else() add_test(NAME "${name}" COMMAND "${CTHWALLOC_COMMAND}" write "${CMAKE_BINARY_DIR}/cthwalloc.log" "${name}" "${sleep_time}") endif() - set_property(TEST "${name}" PROPERTY PROCESSES "${proc}") + set_property(TEST "${name}" PROPERTY RESOURCE_GROUPS "${proc}") list(APPEND HARDWARE_TESTS "${name}") set(HARDWARE_TESTS "${HARDWARE_TESTS}" PARENT_SCOPE) endfunction() diff --git a/Tests/RunCMake/CTestHardwareAllocation/RunCMakeTest.cmake b/Tests/RunCMake/CTestHardwareAllocation/RunCMakeTest.cmake index d666922..f69afc7 100644 --- a/Tests/RunCMake/CTestHardwareAllocation/RunCMakeTest.cmake +++ b/Tests/RunCMake/CTestHardwareAllocation/RunCMakeTest.cmake @@ -38,7 +38,7 @@ function(run_cthwalloc_verify name tests) run_cmake_command(${name} "${CTHWALLOC_COMMAND}" verify "${RunCMake_SOURCE_DIR}/${name}.log" "${CMAKE_CURRENT_LIST_DIR}/hwspec.json" "${tests}") endfunction() -unset(ENV{CTEST_PROCESS_COUNT}) +unset(ENV{CTEST_RESOURCE_GROUP_COUNT}) set(RunCMake_TEST_NO_CLEAN 1) file(REMOVE_RECURSE "${RunCMake_BINARY_DIR}/cthwalloc-write-proc-good1-build") file(MAKE_DIRECTORY "${RunCMake_BINARY_DIR}/cthwalloc-write-proc-good1-build") @@ -49,75 +49,75 @@ dealloc widgets 0 1 end test1 ]]) run_cthwalloc_write_proc_nodel(cthwalloc-write-proc-good1 "1,widgets:2,transmogrifiers:1;2,widgets:1,widgets:2" - CTEST_PROCESS_COUNT=3 - CTEST_PROCESS_0=widgets,transmogrifiers - CTEST_PROCESS_0_WIDGETS=id:0,slots:2 - CTEST_PROCESS_0_TRANSMOGRIFIERS=id:calvin,slots:1 - CTEST_PROCESS_1=widgets - "CTEST_PROCESS_1_WIDGETS=id:0,slots:1\\;id:2,slots:2" - CTEST_PROCESS_2=widgets - "CTEST_PROCESS_2_WIDGETS=id:0,slots:1\\;id:2,slots:2" + CTEST_RESOURCE_GROUP_COUNT=3 + CTEST_RESOURCE_GROUP_0=widgets,transmogrifiers + CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2 + CTEST_RESOURCE_GROUP_0_TRANSMOGRIFIERS=id:calvin,slots:1 + CTEST_RESOURCE_GROUP_1=widgets + "CTEST_RESOURCE_GROUP_1_WIDGETS=id:0,slots:1\\;id:2,slots:2" + CTEST_RESOURCE_GROUP_2=widgets + "CTEST_RESOURCE_GROUP_2_WIDGETS=id:0,slots:1\\;id:2,slots:2" ) set(RunCMake_TEST_NO_CLEAN 0) run_cthwalloc_write_proc(cthwalloc-write-proc-good2 "widgets:8" - CTEST_PROCESS_COUNT=1 - CTEST_PROCESS_0=widgets - CTEST_PROCESS_0_WIDGETS=id:3,slots:8 + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:8 ) run_cthwalloc_write_proc(cthwalloc-write-proc-nocount "widgets:8") run_cthwalloc_write_proc(cthwalloc-write-proc-badcount "widgets:8" - CTEST_PROCESS_COUNT=2 + CTEST_RESOURCE_GROUP_COUNT=2 ) run_cthwalloc_write_proc(cthwalloc-write-proc-nores "widgets:8" - CTEST_PROCESS_COUNT=1 + CTEST_RESOURCE_GROUP_COUNT=1 ) run_cthwalloc_write_proc(cthwalloc-write-proc-badres "widgets:8" - CTEST_PROCESS_COUNT=1 - CTEST_PROCESS_0=widgets,transmogrifiers + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets,transmogrifiers ) run_cthwalloc_write_proc(cthwalloc-write-proc-nowidgets "widgets:8" - CTEST_PROCESS_COUNT=1 - CTEST_PROCESS_0=widgets + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets ) run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets1 "widgets:8" - CTEST_PROCESS_COUNT=1 - CTEST_PROCESS_0=widgets - CTEST_PROCESS_0_WIDGETS= + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + CTEST_RESOURCE_GROUP_0_WIDGETS= ) run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets2 "widgets:8" - CTEST_PROCESS_COUNT=1 - CTEST_PROCESS_0=widgets - "CTEST_PROCESS_0_WIDGETS=id:3,slots:8\\;id:0,slots:1" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + "CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:8\\;id:0,slots:1" ) run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets3 "widgets:8" - CTEST_PROCESS_COUNT=1 - CTEST_PROCESS_0=widgets - CTEST_PROCESS_0_WIDGETS=id:3,slots:7 + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:7 ) run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets4 "widgets:8" - CTEST_PROCESS_COUNT=1 - CTEST_PROCESS_0=widgets - CTEST_PROCESS_0_WIDGETS=invalid + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + CTEST_RESOURCE_GROUP_0_WIDGETS=invalid ) run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets5 "widgets:2,widgets:2" - CTEST_PROCESS_COUNT=1 - CTEST_PROCESS_0=widgets - "CTEST_PROCESS_0_WIDGETS=id:0,slots:2\\;id:0,slots:1" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + "CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2\\;id:0,slots:1" ) run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets6 "widgets:2" - CTEST_PROCESS_COUNT=1 - CTEST_PROCESS_0=widgets - "CTEST_PROCESS_0_WIDGETS=id:0,slots:2\\;id:0,slots:1" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + "CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2\\;id:0,slots:1" ) run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets7 "widgets:2,widgets:2" - CTEST_PROCESS_COUNT=1 - CTEST_PROCESS_0=widgets - CTEST_PROCESS_0_WIDGETS=id:0,slots:2 + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2 ) run_cthwalloc_write_noproc(cthwalloc-write-noproc-good1) run_cthwalloc_write_noproc(cthwalloc-write-noproc-count - CTEST_PROCESS_COUNT=1 + CTEST_RESOURCE_GROUP_COUNT=1 ) run_cthwalloc_verify(cthwalloc-verify-good1 "test1;test2") @@ -162,6 +162,6 @@ run_ctest_hardware(notenough1 1 0) run_ctest_hardware(notenough2 1 0) run_ctest_hardware(ensure_parallel 2 0) -set(ENV{CTEST_PROCESS_COUNT} 2) +set(ENV{CTEST_RESOURCE_GROUP_COUNT} 2) run_ctest_hardware(process_count 1 0) -unset(ENV{CTEST_PROCESS_COUNT}) +unset(ENV{CTEST_RESOURCE_GROUP_COUNT}) diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx index eee2c7f..e5f0283 100644 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx +++ b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx @@ -26,11 +26,11 @@ * This helper program is used to verify that the CTest hardware allocation * feature is working correctly. It consists of two stages: * - * 1) write - This stage receives the PROCESSES property of the test and - * compares it with the values passed in the CTEST_PROCESS_* environment - * variables. If it received all of the resources it expected, then it - * writes this information to a log file, which will be read in the verify - * stage. + * 1) write - This stage receives the RESOURCE_GROUPS property of the test and + * compares it with the values passed in the CTEST_RESOURCE_GROUP_* + * environment variables. If it received all of the resources it expected, + * then it writes this information to a log file, which will be read in + * the verify stage. * 2) verify - This stage compares the log file with the hardware spec file to * make sure that no resources were over-subscribed, deallocated without * being allocated, or allocated without being deallocated. @@ -46,7 +46,7 @@ static int usageWrite(const char* argv0) { std::cout << "Usage: " << argv0 << " write " - " []" + " []" << std::endl; return 1; } @@ -71,28 +71,30 @@ static int doWrite(int argc, char const* const* argv) std::string, std::vector>> hardware; if (argc == 6) { - // Parse processes property - std::string processesProperty = argv[5]; + // Parse RESOURCE_GROUPS property + std::string resourceGroupsProperty = argv[5]; std::vector< std::vector> - processes; - bool result = - cmCTestTestHandler::ParseProcessesProperty(processesProperty, processes); + resourceGroups; + bool result = cmCTestTestHandler::ParseResourceGroupsProperty( + resourceGroupsProperty, resourceGroups); (void)result; assert(result); - // Verify process count - const char* processCountEnv = cmSystemTools::GetEnv("CTEST_PROCESS_COUNT"); - if (!processCountEnv) { - std::cout << "CTEST_PROCESS_COUNT should be defined" << std::endl; + // Verify group count + const char* resourceGroupCountEnv = + cmSystemTools::GetEnv("CTEST_RESOURCE_GROUP_COUNT"); + if (!resourceGroupCountEnv) { + std::cout << "CTEST_RESOURCE_GROUP_COUNT should be defined" << std::endl; return 1; } - int processCount = std::atoi(processCountEnv); - if (processes.size() != std::size_t(processCount)) { - std::cout << "CTEST_PROCESS_COUNT does not match expected processes" - << std::endl - << "Expected: " << processes.size() << std::endl - << "Actual: " << processCount << std::endl; + int resourceGroupCount = std::atoi(resourceGroupCountEnv); + if (resourceGroups.size() != std::size_t(resourceGroupCount)) { + std::cout + << "CTEST_RESOURCE_GROUP_COUNT does not match expected resource groups" + << std::endl + << "Expected: " << resourceGroups.size() << std::endl + << "Actual: " << resourceGroupCount << std::endl; return 1; } @@ -110,15 +112,15 @@ static int doWrite(int argc, char const* const* argv) std::size_t i = 0; cmsys::ofstream fout(logFile.c_str(), std::ios::app); fout << "begin " << testName << std::endl; - for (auto& process : processes) { + for (auto& resourceGroup : resourceGroups) { try { // Build and verify set of expected resources std::set expectedResources; - for (auto const& it : process) { + for (auto const& it : resourceGroup) { expectedResources.insert(it.ResourceType); } - std::string prefix = "CTEST_PROCESS_"; + std::string prefix = "CTEST_RESOURCE_GROUP_"; prefix += std::to_string(i); const char* actualResourcesCStr = cmSystemTools::GetEnv(prefix); if (!actualResourcesCStr) { @@ -147,7 +149,7 @@ static int doWrite(int argc, char const* const* argv) std::vector> hwEntry; for (auto const& type : actualResources) { - auto it = process.begin(); + auto it = resourceGroup.begin(); std::string varName = prefix; varName += cmSystemTools::UpperCase(type); @@ -161,7 +163,7 @@ static int doWrite(int argc, char const* const* argv) for (auto const& r : received) { while (it->ResourceType != type || it->UnitsNeeded == 0) { ++it; - if (it == process.end()) { + if (it == resourceGroup.end()) { std::cout << varName << " did not list expected resources" << std::endl; return 1; @@ -198,7 +200,7 @@ static int doWrite(int argc, char const* const* argv) bool ended = false; while (it->ResourceType != type || it->UnitsNeeded == 0) { ++it; - if (it == process.end()) { + if (it == resourceGroup.end()) { ended = true; break; } @@ -225,8 +227,9 @@ static int doWrite(int argc, char const* const* argv) return 1; } } else { - if (cmSystemTools::GetEnv("CTEST_PROCESS_COUNT")) { - std::cout << "CTEST_PROCESS_COUNT should not be defined" << std::endl; + if (cmSystemTools::GetEnv("CTEST_RESOURCE_GROUP_COUNT")) { + std::cout << "CTEST_RESOURCE_GROUP_COUNT should not be defined" + << std::endl; return 1; } } @@ -246,8 +249,8 @@ static int doWrite(int argc, char const* const* argv) return 1; } cmsys::ofstream fout(logFile.c_str(), std::ios::app); - for (auto const& process : hardware) { - for (auto const& it : process) { + for (auto const& group : hardware) { + for (auto const& it : group) { for (auto const& it2 : it.second) { fout << "dealloc " << it.first << " " << it2.Id << " " << it2.Slots << std::endl; -- cgit v0.12 From 73a40b19ffa49bfc92fbe10bd0fd3821b7facae6 Mon Sep 17 00:00:00 2001 From: Brad King Date: Mon, 4 Nov 2019 17:29:03 -0500 Subject: CTest: Rename "Processes" lexer to "ResourceGroups" The corresponding test property `PROCESSES` has been renamed to `RESOURCE_GROUPS`. --- Source/CMakeLists.txt | 8 +- Source/CTest/cmCTestProcessesLexerHelper.cxx | 55 - Source/CTest/cmCTestProcessesLexerHelper.h | 44 - Source/CTest/cmCTestResourceGroupsLexerHelper.cxx | 55 + Source/CTest/cmCTestResourceGroupsLexerHelper.h | 44 + Source/CTest/cmCTestTestHandler.cxx | 4 +- Source/LexerParser/.gitattributes | 4 +- Source/LexerParser/cmCTestProcessesLexer.cxx | 2224 -------------------- Source/LexerParser/cmCTestProcessesLexer.h | 692 ------ Source/LexerParser/cmCTestProcessesLexer.in.l | 102 - Source/LexerParser/cmCTestResourceGroupsLexer.cxx | 2224 ++++++++++++++++++++ Source/LexerParser/cmCTestResourceGroupsLexer.h | 692 ++++++ Source/LexerParser/cmCTestResourceGroupsLexer.in.l | 102 + Utilities/Scripts/regenerate-lexers.bash | 2 +- 14 files changed, 3126 insertions(+), 3126 deletions(-) delete mode 100644 Source/CTest/cmCTestProcessesLexerHelper.cxx delete mode 100644 Source/CTest/cmCTestProcessesLexerHelper.h create mode 100644 Source/CTest/cmCTestResourceGroupsLexerHelper.cxx create mode 100644 Source/CTest/cmCTestResourceGroupsLexerHelper.h delete mode 100644 Source/LexerParser/cmCTestProcessesLexer.cxx delete mode 100644 Source/LexerParser/cmCTestProcessesLexer.h delete mode 100644 Source/LexerParser/cmCTestProcessesLexer.in.l create mode 100644 Source/LexerParser/cmCTestResourceGroupsLexer.cxx create mode 100644 Source/LexerParser/cmCTestResourceGroupsLexer.h create mode 100644 Source/LexerParser/cmCTestResourceGroupsLexer.in.l diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index 63e08de..0ae3d2a 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -925,8 +925,8 @@ set(CTEST_SRCS cmCTest.cxx CTest/cmCTestMemCheckCommand.cxx CTest/cmCTestMemCheckHandler.cxx CTest/cmCTestMultiProcessHandler.cxx - CTest/cmCTestProcessesLexerHelper.cxx CTest/cmCTestReadCustomFilesCommand.cxx + CTest/cmCTestResourceGroupsLexerHelper.cxx CTest/cmCTestRunScriptCommand.cxx CTest/cmCTestRunTest.cxx CTest/cmCTestScriptHandler.cxx @@ -958,9 +958,9 @@ set(CTEST_SRCS cmCTest.cxx CTest/cmCTestP4.cxx CTest/cmCTestP4.h - LexerParser/cmCTestProcessesLexer.cxx - LexerParser/cmCTestProcessesLexer.h - LexerParser/cmCTestProcessesLexer.in.l + LexerParser/cmCTestResourceGroupsLexer.cxx + LexerParser/cmCTestResourceGroupsLexer.h + LexerParser/cmCTestResourceGroupsLexer.in.l ) # Build CTestLib diff --git a/Source/CTest/cmCTestProcessesLexerHelper.cxx b/Source/CTest/cmCTestProcessesLexerHelper.cxx deleted file mode 100644 index 797164b..0000000 --- a/Source/CTest/cmCTestProcessesLexerHelper.cxx +++ /dev/null @@ -1,55 +0,0 @@ -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ -#include "cmCTestProcessesLexerHelper.h" - -#include "cmCTestProcessesLexer.h" -#include "cmCTestTestHandler.h" - -cmCTestProcessesLexerHelper::cmCTestProcessesLexerHelper( - std::vector>& - output) - : Output(output) -{ -} - -bool cmCTestProcessesLexerHelper::ParseString(const std::string& value) -{ - yyscan_t lexer; - cmCTestProcesses_yylex_init_extra(this, &lexer); - - auto state = cmCTestProcesses_yy_scan_string(value.c_str(), lexer); - int retval = cmCTestProcesses_yylex(lexer); - cmCTestProcesses_yy_delete_buffer(state, lexer); - - cmCTestProcesses_yylex_destroy(lexer); - return retval == 0; -} - -void cmCTestProcessesLexerHelper::SetProcessCount(unsigned int count) -{ - this->ProcessCount = count; -} - -void cmCTestProcessesLexerHelper::SetResourceType(const std::string& type) -{ - this->ResourceType = type; -} - -void cmCTestProcessesLexerHelper::SetNeededSlots(int count) -{ - this->NeededSlots = count; -} - -void cmCTestProcessesLexerHelper::WriteRequirement() -{ - this->Process.push_back({ this->ResourceType, this->NeededSlots, 1 }); -} - -void cmCTestProcessesLexerHelper::WriteProcess() -{ - for (unsigned int i = 0; i < this->ProcessCount; ++i) { - this->Output.push_back(this->Process); - } - this->Process.clear(); - this->ProcessCount = 1; -} diff --git a/Source/CTest/cmCTestProcessesLexerHelper.h b/Source/CTest/cmCTestProcessesLexerHelper.h deleted file mode 100644 index 6c9289f..0000000 --- a/Source/CTest/cmCTestProcessesLexerHelper.h +++ /dev/null @@ -1,44 +0,0 @@ -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ -#ifndef cmCTestProcessesLexerHelper_h -#define cmCTestProcessesLexerHelper_h - -#include -#include - -#include "cmCTestTestHandler.h" - -class cmCTestProcessesLexerHelper -{ -public: - struct ParserType - { - }; - - cmCTestProcessesLexerHelper( - std::vector< - std::vector>& - output); - ~cmCTestProcessesLexerHelper() = default; - - bool ParseString(const std::string& value); - - void SetProcessCount(unsigned int count); - void SetResourceType(const std::string& type); - void SetNeededSlots(int count); - void WriteRequirement(); - void WriteProcess(); - -private: - std::vector>& - Output; - - unsigned int ProcessCount = 1; - std::string ResourceType; - int NeededSlots; - std::vector Process; -}; - -#define YY_EXTRA_TYPE cmCTestProcessesLexerHelper* - -#endif diff --git a/Source/CTest/cmCTestResourceGroupsLexerHelper.cxx b/Source/CTest/cmCTestResourceGroupsLexerHelper.cxx new file mode 100644 index 0000000..072af42 --- /dev/null +++ b/Source/CTest/cmCTestResourceGroupsLexerHelper.cxx @@ -0,0 +1,55 @@ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ +#include "cmCTestResourceGroupsLexerHelper.h" + +#include "cmCTestResourceGroupsLexer.h" +#include "cmCTestTestHandler.h" + +cmCTestResourceGroupsLexerHelper::cmCTestResourceGroupsLexerHelper( + std::vector>& + output) + : Output(output) +{ +} + +bool cmCTestResourceGroupsLexerHelper::ParseString(const std::string& value) +{ + yyscan_t lexer; + cmCTestResourceGroups_yylex_init_extra(this, &lexer); + + auto state = cmCTestResourceGroups_yy_scan_string(value.c_str(), lexer); + int retval = cmCTestResourceGroups_yylex(lexer); + cmCTestResourceGroups_yy_delete_buffer(state, lexer); + + cmCTestResourceGroups_yylex_destroy(lexer); + return retval == 0; +} + +void cmCTestResourceGroupsLexerHelper::SetProcessCount(unsigned int count) +{ + this->ProcessCount = count; +} + +void cmCTestResourceGroupsLexerHelper::SetResourceType(const std::string& type) +{ + this->ResourceType = type; +} + +void cmCTestResourceGroupsLexerHelper::SetNeededSlots(int count) +{ + this->NeededSlots = count; +} + +void cmCTestResourceGroupsLexerHelper::WriteRequirement() +{ + this->Process.push_back({ this->ResourceType, this->NeededSlots, 1 }); +} + +void cmCTestResourceGroupsLexerHelper::WriteProcess() +{ + for (unsigned int i = 0; i < this->ProcessCount; ++i) { + this->Output.push_back(this->Process); + } + this->Process.clear(); + this->ProcessCount = 1; +} diff --git a/Source/CTest/cmCTestResourceGroupsLexerHelper.h b/Source/CTest/cmCTestResourceGroupsLexerHelper.h new file mode 100644 index 0000000..2cb6cb1 --- /dev/null +++ b/Source/CTest/cmCTestResourceGroupsLexerHelper.h @@ -0,0 +1,44 @@ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ +#ifndef cmCTestResourceGroupsLexerHelper_h +#define cmCTestResourceGroupsLexerHelper_h + +#include +#include + +#include "cmCTestTestHandler.h" + +class cmCTestResourceGroupsLexerHelper +{ +public: + struct ParserType + { + }; + + cmCTestResourceGroupsLexerHelper( + std::vector< + std::vector>& + output); + ~cmCTestResourceGroupsLexerHelper() = default; + + bool ParseString(const std::string& value); + + void SetProcessCount(unsigned int count); + void SetResourceType(const std::string& type); + void SetNeededSlots(int count); + void WriteRequirement(); + void WriteProcess(); + +private: + std::vector>& + Output; + + unsigned int ProcessCount = 1; + std::string ResourceType; + int NeededSlots; + std::vector Process; +}; + +#define YY_EXTRA_TYPE cmCTestResourceGroupsLexerHelper* + +#endif diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx index 0f21f91..ec5c4bc 100644 --- a/Source/CTest/cmCTestTestHandler.cxx +++ b/Source/CTest/cmCTestTestHandler.cxx @@ -29,7 +29,7 @@ #include "cmAlgorithms.h" #include "cmCTest.h" #include "cmCTestMultiProcessHandler.h" -#include "cmCTestProcessesLexerHelper.h" +#include "cmCTestResourceGroupsLexerHelper.h" #include "cmDuration.h" #include "cmExecutionStatus.h" #include "cmGeneratedFileStream.h" @@ -1630,7 +1630,7 @@ bool cmCTestTestHandler::ParseResourceGroupsProperty( const std::string& val, std::vector>& resourceGroups) { - cmCTestProcessesLexerHelper lexer(resourceGroups); + cmCTestResourceGroupsLexerHelper lexer(resourceGroups); return lexer.ParseString(val); } diff --git a/Source/LexerParser/.gitattributes b/Source/LexerParser/.gitattributes index e5a1d8b..bf70249 100644 --- a/Source/LexerParser/.gitattributes +++ b/Source/LexerParser/.gitattributes @@ -2,8 +2,8 @@ /cmCommandArgumentLexer.h generated /cmCommandArgumentParser.cxx generated /cmCommandArgumentParserTokens.h generated -/cmCTestProcessesLexer.cxx generated -/cmCTestProcessesLexer.h generated +/cmCTestResourceGroupsLexer.cxx generated +/cmCTestResourceGroupsLexer.h generated /cmDependsJavaLexer.cxx generated /cmDependsJavaLexer.h generated /cmDependsJavaParser.cxx generated diff --git a/Source/LexerParser/cmCTestProcessesLexer.cxx b/Source/LexerParser/cmCTestProcessesLexer.cxx deleted file mode 100644 index 2a5dab3..0000000 --- a/Source/LexerParser/cmCTestProcessesLexer.cxx +++ /dev/null @@ -1,2224 +0,0 @@ -#include "cmStandardLexer.h" - -#define FLEXINT_H 1 -#define YY_INT_ALIGNED short int - -/* A lexical scanner generated by flex */ - -#define FLEX_SCANNER -#define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 4 -#if YY_FLEX_SUBMINOR_VERSION > 0 -#define FLEX_BETA -#endif - -#ifdef yy_create_buffer -#define cmCTestProcesses_yy_create_buffer_ALREADY_DEFINED -#else -#define yy_create_buffer cmCTestProcesses_yy_create_buffer -#endif - -#ifdef yy_delete_buffer -#define cmCTestProcesses_yy_delete_buffer_ALREADY_DEFINED -#else -#define yy_delete_buffer cmCTestProcesses_yy_delete_buffer -#endif - -#ifdef yy_scan_buffer -#define cmCTestProcesses_yy_scan_buffer_ALREADY_DEFINED -#else -#define yy_scan_buffer cmCTestProcesses_yy_scan_buffer -#endif - -#ifdef yy_scan_string -#define cmCTestProcesses_yy_scan_string_ALREADY_DEFINED -#else -#define yy_scan_string cmCTestProcesses_yy_scan_string -#endif - -#ifdef yy_scan_bytes -#define cmCTestProcesses_yy_scan_bytes_ALREADY_DEFINED -#else -#define yy_scan_bytes cmCTestProcesses_yy_scan_bytes -#endif - -#ifdef yy_init_buffer -#define cmCTestProcesses_yy_init_buffer_ALREADY_DEFINED -#else -#define yy_init_buffer cmCTestProcesses_yy_init_buffer -#endif - -#ifdef yy_flush_buffer -#define cmCTestProcesses_yy_flush_buffer_ALREADY_DEFINED -#else -#define yy_flush_buffer cmCTestProcesses_yy_flush_buffer -#endif - -#ifdef yy_load_buffer_state -#define cmCTestProcesses_yy_load_buffer_state_ALREADY_DEFINED -#else -#define yy_load_buffer_state cmCTestProcesses_yy_load_buffer_state -#endif - -#ifdef yy_switch_to_buffer -#define cmCTestProcesses_yy_switch_to_buffer_ALREADY_DEFINED -#else -#define yy_switch_to_buffer cmCTestProcesses_yy_switch_to_buffer -#endif - -#ifdef yypush_buffer_state -#define cmCTestProcesses_yypush_buffer_state_ALREADY_DEFINED -#else -#define yypush_buffer_state cmCTestProcesses_yypush_buffer_state -#endif - -#ifdef yypop_buffer_state -#define cmCTestProcesses_yypop_buffer_state_ALREADY_DEFINED -#else -#define yypop_buffer_state cmCTestProcesses_yypop_buffer_state -#endif - -#ifdef yyensure_buffer_stack -#define cmCTestProcesses_yyensure_buffer_stack_ALREADY_DEFINED -#else -#define yyensure_buffer_stack cmCTestProcesses_yyensure_buffer_stack -#endif - -#ifdef yylex -#define cmCTestProcesses_yylex_ALREADY_DEFINED -#else -#define yylex cmCTestProcesses_yylex -#endif - -#ifdef yyrestart -#define cmCTestProcesses_yyrestart_ALREADY_DEFINED -#else -#define yyrestart cmCTestProcesses_yyrestart -#endif - -#ifdef yylex_init -#define cmCTestProcesses_yylex_init_ALREADY_DEFINED -#else -#define yylex_init cmCTestProcesses_yylex_init -#endif - -#ifdef yylex_init_extra -#define cmCTestProcesses_yylex_init_extra_ALREADY_DEFINED -#else -#define yylex_init_extra cmCTestProcesses_yylex_init_extra -#endif - -#ifdef yylex_destroy -#define cmCTestProcesses_yylex_destroy_ALREADY_DEFINED -#else -#define yylex_destroy cmCTestProcesses_yylex_destroy -#endif - -#ifdef yyget_debug -#define cmCTestProcesses_yyget_debug_ALREADY_DEFINED -#else -#define yyget_debug cmCTestProcesses_yyget_debug -#endif - -#ifdef yyset_debug -#define cmCTestProcesses_yyset_debug_ALREADY_DEFINED -#else -#define yyset_debug cmCTestProcesses_yyset_debug -#endif - -#ifdef yyget_extra -#define cmCTestProcesses_yyget_extra_ALREADY_DEFINED -#else -#define yyget_extra cmCTestProcesses_yyget_extra -#endif - -#ifdef yyset_extra -#define cmCTestProcesses_yyset_extra_ALREADY_DEFINED -#else -#define yyset_extra cmCTestProcesses_yyset_extra -#endif - -#ifdef yyget_in -#define cmCTestProcesses_yyget_in_ALREADY_DEFINED -#else -#define yyget_in cmCTestProcesses_yyget_in -#endif - -#ifdef yyset_in -#define cmCTestProcesses_yyset_in_ALREADY_DEFINED -#else -#define yyset_in cmCTestProcesses_yyset_in -#endif - -#ifdef yyget_out -#define cmCTestProcesses_yyget_out_ALREADY_DEFINED -#else -#define yyget_out cmCTestProcesses_yyget_out -#endif - -#ifdef yyset_out -#define cmCTestProcesses_yyset_out_ALREADY_DEFINED -#else -#define yyset_out cmCTestProcesses_yyset_out -#endif - -#ifdef yyget_leng -#define cmCTestProcesses_yyget_leng_ALREADY_DEFINED -#else -#define yyget_leng cmCTestProcesses_yyget_leng -#endif - -#ifdef yyget_text -#define cmCTestProcesses_yyget_text_ALREADY_DEFINED -#else -#define yyget_text cmCTestProcesses_yyget_text -#endif - -#ifdef yyget_lineno -#define cmCTestProcesses_yyget_lineno_ALREADY_DEFINED -#else -#define yyget_lineno cmCTestProcesses_yyget_lineno -#endif - -#ifdef yyset_lineno -#define cmCTestProcesses_yyset_lineno_ALREADY_DEFINED -#else -#define yyset_lineno cmCTestProcesses_yyset_lineno -#endif - -#ifdef yyget_column -#define cmCTestProcesses_yyget_column_ALREADY_DEFINED -#else -#define yyget_column cmCTestProcesses_yyget_column -#endif - -#ifdef yyset_column -#define cmCTestProcesses_yyset_column_ALREADY_DEFINED -#else -#define yyset_column cmCTestProcesses_yyset_column -#endif - -#ifdef yywrap -#define cmCTestProcesses_yywrap_ALREADY_DEFINED -#else -#define yywrap cmCTestProcesses_yywrap -#endif - -#ifdef yyalloc -#define cmCTestProcesses_yyalloc_ALREADY_DEFINED -#else -#define yyalloc cmCTestProcesses_yyalloc -#endif - -#ifdef yyrealloc -#define cmCTestProcesses_yyrealloc_ALREADY_DEFINED -#else -#define yyrealloc cmCTestProcesses_yyrealloc -#endif - -#ifdef yyfree -#define cmCTestProcesses_yyfree_ALREADY_DEFINED -#else -#define yyfree cmCTestProcesses_yyfree -#endif - -/* First, we deal with platform-specific or compiler-specific issues. */ - -/* begin standard C headers. */ -#include -#include -#include -#include - -/* end standard C headers. */ - -/* flex integer type definitions */ - -#ifndef FLEXINT_H -#define FLEXINT_H - -/* C99 systems have . Non-C99 systems may or may not. */ - -#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - -/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. - */ -#ifndef __STDC_LIMIT_MACROS -#define __STDC_LIMIT_MACROS 1 -#endif - -#include -typedef int8_t flex_int8_t; -typedef uint8_t flex_uint8_t; -typedef int16_t flex_int16_t; -typedef uint16_t flex_uint16_t; -typedef int32_t flex_int32_t; -typedef uint32_t flex_uint32_t; -#else -typedef signed char flex_int8_t; -typedef short int flex_int16_t; -typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; -typedef unsigned short int flex_uint16_t; -typedef unsigned int flex_uint32_t; - -/* Limits of integral types. */ -#ifndef INT8_MIN -#define INT8_MIN (-128) -#endif -#ifndef INT16_MIN -#define INT16_MIN (-32767-1) -#endif -#ifndef INT32_MIN -#define INT32_MIN (-2147483647-1) -#endif -#ifndef INT8_MAX -#define INT8_MAX (127) -#endif -#ifndef INT16_MAX -#define INT16_MAX (32767) -#endif -#ifndef INT32_MAX -#define INT32_MAX (2147483647) -#endif -#ifndef UINT8_MAX -#define UINT8_MAX (255U) -#endif -#ifndef UINT16_MAX -#define UINT16_MAX (65535U) -#endif -#ifndef UINT32_MAX -#define UINT32_MAX (4294967295U) -#endif - -#ifndef SIZE_MAX -#define SIZE_MAX (~(size_t)0) -#endif - -#endif /* ! C99 */ - -#endif /* ! FLEXINT_H */ - -/* begin standard C++ headers. */ - -/* TODO: this is always defined, so inline it */ -#define yyconst const - -#if defined(__GNUC__) && __GNUC__ >= 3 -#define yynoreturn __attribute__((__noreturn__)) -#else -#define yynoreturn -#endif - -/* Returned upon end-of-file. */ -#define YY_NULL 0 - -/* Promotes a possibly negative, possibly signed char to an - * integer in range [0..255] for use as an array index. - */ -#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) - -/* An opaque pointer. */ -#ifndef YY_TYPEDEF_YY_SCANNER_T -#define YY_TYPEDEF_YY_SCANNER_T -typedef void* yyscan_t; -#endif - -/* For convenience, these vars (plus the bison vars far below) - are macros in the reentrant scanner. */ -#define yyin yyg->yyin_r -#define yyout yyg->yyout_r -#define yyextra yyg->yyextra_r -#define yyleng yyg->yyleng_r -#define yytext yyg->yytext_r -#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) -#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) -#define yy_flex_debug yyg->yy_flex_debug_r - -/* Enter a start condition. This macro really ought to take a parameter, - * but we do it the disgusting crufty way forced on us by the ()-less - * definition of BEGIN. - */ -#define BEGIN yyg->yy_start = 1 + 2 * -/* Translate the current start state into a value that can be later handed - * to BEGIN to return to the state. The YYSTATE alias is for lex - * compatibility. - */ -#define YY_START ((yyg->yy_start - 1) / 2) -#define YYSTATE YY_START -/* Action number for EOF rule of a given start state. */ -#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) -/* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE yyrestart( yyin , yyscanner ) -#define YY_END_OF_BUFFER_CHAR 0 - -/* Size of default input buffer. */ -#ifndef YY_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k. - * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. - * Ditto for the __ia64__ case accordingly. - */ -#define YY_BUF_SIZE 32768 -#else -#define YY_BUF_SIZE 16384 -#endif /* __ia64__ */ -#endif - -/* The state buf must be large enough to hold one state per character in the main buffer. - */ -#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) - -#ifndef YY_TYPEDEF_YY_BUFFER_STATE -#define YY_TYPEDEF_YY_BUFFER_STATE -typedef struct yy_buffer_state *YY_BUFFER_STATE; -#endif - -#ifndef YY_TYPEDEF_YY_SIZE_T -#define YY_TYPEDEF_YY_SIZE_T -typedef size_t yy_size_t; -#endif - -#define EOB_ACT_CONTINUE_SCAN 0 -#define EOB_ACT_END_OF_FILE 1 -#define EOB_ACT_LAST_MATCH 2 - - #define YY_LESS_LINENO(n) - #define YY_LINENO_REWIND_TO(ptr) - -/* Return all but the first "n" matched characters back to the input stream. */ -#define yyless(n) \ - do \ - { \ - /* Undo effects of setting up yytext. */ \ - int yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg);\ - *yy_cp = yyg->yy_hold_char; \ - YY_RESTORE_YY_MORE_OFFSET \ - yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ - YY_DO_BEFORE_ACTION; /* set up yytext again */ \ - } \ - while ( 0 ) -#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) - -#ifndef YY_STRUCT_YY_BUFFER_STATE -#define YY_STRUCT_YY_BUFFER_STATE -struct yy_buffer_state - { - FILE *yy_input_file; - - char *yy_ch_buf; /* input buffer */ - char *yy_buf_pos; /* current position in input buffer */ - - /* Size of input buffer in bytes, not including room for EOB - * characters. - */ - int yy_buf_size; - - /* Number of characters read into yy_ch_buf, not including EOB - * characters. - */ - int yy_n_chars; - - /* Whether we "own" the buffer - i.e., we know we created it, - * and can realloc() it to grow it, and should free() it to - * delete it. - */ - int yy_is_our_buffer; - - /* Whether this is an "interactive" input source; if so, and - * if we're using stdio for input, then we want to use getc() - * instead of fread(), to make sure we stop fetching input after - * each newline. - */ - int yy_is_interactive; - - /* Whether we're considered to be at the beginning of a line. - * If so, '^' rules will be active on the next match, otherwise - * not. - */ - int yy_at_bol; - - int yy_bs_lineno; /**< The line count. */ - int yy_bs_column; /**< The column count. */ - - /* Whether to try to fill the input buffer when we reach the - * end of it. - */ - int yy_fill_buffer; - - int yy_buffer_status; - -#define YY_BUFFER_NEW 0 -#define YY_BUFFER_NORMAL 1 - /* When an EOF's been seen but there's still some text to process - * then we mark the buffer as YY_EOF_PENDING, to indicate that we - * shouldn't try reading from the input source any more. We might - * still have a bunch of tokens to match, though, because of - * possible backing-up. - * - * When we actually see the EOF, we change the status to "new" - * (via yyrestart()), so that the user can continue scanning by - * just pointing yyin at a new input file. - */ -#define YY_BUFFER_EOF_PENDING 2 - - }; -#endif /* !YY_STRUCT_YY_BUFFER_STATE */ - -/* We provide macros for accessing buffer states in case in the - * future we want to put the buffer states in a more general - * "scanner state". - * - * Returns the top of the stack, or NULL. - */ -#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ - ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ - : NULL) -/* Same as previous macro, but useful when we know that the buffer stack is not - * NULL or when we need an lvalue. For internal use only. - */ -#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] - -void yyrestart ( FILE *input_file , yyscan_t yyscanner ); -void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); -YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner ); -void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); -void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); -void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); -void yypop_buffer_state ( yyscan_t yyscanner ); - -static void yyensure_buffer_stack ( yyscan_t yyscanner ); -static void yy_load_buffer_state ( yyscan_t yyscanner ); -static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner ); -#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner) - -YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner ); -YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner ); -YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner ); - -void *yyalloc ( yy_size_t , yyscan_t yyscanner ); -void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner ); -void yyfree ( void * , yyscan_t yyscanner ); - -#define yy_new_buffer yy_create_buffer -#define yy_set_interactive(is_interactive) \ - { \ - if ( ! YY_CURRENT_BUFFER ){ \ - yyensure_buffer_stack (yyscanner); \ - YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \ - } \ - YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ - } -#define yy_set_bol(at_bol) \ - { \ - if ( ! YY_CURRENT_BUFFER ){\ - yyensure_buffer_stack (yyscanner); \ - YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \ - } \ - YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ - } -#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) - -/* Begin user sect3 */ - -#define cmCTestProcesses_yywrap(yyscanner) (/*CONSTCOND*/1) -#define YY_SKIP_YYWRAP -typedef flex_uint8_t YY_CHAR; - -typedef int yy_state_type; - -#define yytext_ptr yytext_r - -static yy_state_type yy_get_previous_state ( yyscan_t yyscanner ); -static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner); -static int yy_get_next_buffer ( yyscan_t yyscanner ); -static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner ); - -/* Done after the current pattern has been matched and before the - * corresponding action - sets up yytext. - */ -#define YY_DO_BEFORE_ACTION \ - yyg->yytext_ptr = yy_bp; \ - yyleng = (int) (yy_cp - yy_bp); \ - yyg->yy_hold_char = *yy_cp; \ - *yy_cp = '\0'; \ - yyg->yy_c_buf_p = yy_cp; -#define YY_NUM_RULES 8 -#define YY_END_OF_BUFFER 9 -/* This struct is not used in this scanner, - but its presence is necessary. */ -struct yy_trans_info - { - flex_int32_t yy_verify; - flex_int32_t yy_nxt; - }; -static const flex_int16_t yy_accept[29] = - { 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 9, 7, 2, 5, 7, 4, 6, 3, - 2, 5, 0, 1, 4, 6, 3, 0 - } ; - -static const YY_CHAR yy_ec[256] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 3, 1, 1, 1, 4, 4, 4, - 4, 4, 4, 4, 4, 4, 4, 5, 6, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 7, 1, 7, 7, 7, 7, - - 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, - 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, - 7, 7, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1 - } ; - -static const YY_CHAR yy_meta[8] = - { 0, - 1, 1, 1, 2, 2, 1, 2 - } ; - -static const flex_int16_t yy_base[30] = - { 0, - 0, 0, 0, 0, 7, 0, 31, 12, 17, 0, - 0, 0, 34, 36, 29, 26, 26, 27, 23, 24, - 23, 20, 20, 36, 21, 16, 13, 36, 14 - } ; - -static const flex_int16_t yy_def[30] = - { 0, - 28, 1, 1, 1, 28, 5, 1, 5, 5, 9, - 5, 5, 28, 28, 28, 28, 29, 28, 28, 28, - 28, 28, 29, 28, 28, 28, 28, 0, 28 - } ; - -static const flex_int16_t yy_nxt[44] = - { 0, - 14, 14, 14, 15, 14, 16, 17, 14, 14, 18, - 14, 14, 19, 14, 14, 23, 27, 16, 17, 14, - 20, 26, 14, 25, 24, 22, 21, 27, 26, 25, - 24, 22, 21, 28, 14, 13, 28, 28, 28, 28, - 28, 28, 28 - } ; - -static const flex_int16_t yy_chk[44] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 5, 5, 5, - 5, 5, 5, 5, 8, 29, 27, 8, 8, 9, - 9, 26, 9, 25, 23, 22, 21, 20, 19, 18, - 17, 16, 15, 13, 7, 28, 28, 28, 28, 28, - 28, 28, 28 - } ; - -/* The intent behind this definition is that it'll catch - * any uses of REJECT which flex missed. - */ -#define REJECT reject_used_but_not_detected -#define yymore() yymore_used_but_not_detected -#define YY_MORE_ADJ 0 -#define YY_RESTORE_YY_MORE_OFFSET -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ -/* - -This file must be translated to C++ and modified to build everywhere. - -Run flex >= 2.6 like this: - - flex --nounistd -DFLEXINT_H --noline --header-file=cmCTestProcessesLexer.h -ocmCTestProcessesLexer.cxx cmCTestProcessesLexer.in.l - -Modify cmCTestProcessesLexer.cxx: - - remove trailing whitespace: sed -i 's/\s*$//' cmCTestProcessesLexer.h cmCTestProcessesLexer.cxx - - remove blank lines at end of file: sed -i '${/^$/d;}' cmCTestProcessesLexer.h cmCTestProcessesLexer.cxx - - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmCTestProcessesLexer.cxx - -*/ - -/* IWYU pragma: no_forward_declare yyguts_t */ - -#ifndef __clang_analyzer__ /* Suppress clang scan-build warnings */ - -#include "cmCTestProcessesLexerHelper.h" - -#include - -#include - -/*--------------------------------------------------------------------------*/ - -#define INITIAL 0 -#define PROCESSES_START 1 -#define PROCESSES_END 2 -#define RESOURCE_START 3 -#define RESOURCE_COUNT 4 -#define RESOURCE_END 5 - -#ifndef YY_EXTRA_TYPE -#define YY_EXTRA_TYPE void * -#endif - -/* Holds the entire state of the reentrant scanner. */ -struct yyguts_t - { - - /* User-defined. Not touched by flex. */ - YY_EXTRA_TYPE yyextra_r; - - /* The rest are the same as the globals declared in the non-reentrant scanner. */ - FILE *yyin_r, *yyout_r; - size_t yy_buffer_stack_top; /**< index of top of stack. */ - size_t yy_buffer_stack_max; /**< capacity of stack. */ - YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ - char yy_hold_char; - int yy_n_chars; - int yyleng_r; - char *yy_c_buf_p; - int yy_init; - int yy_start; - int yy_did_buffer_switch_on_eof; - int yy_start_stack_ptr; - int yy_start_stack_depth; - int *yy_start_stack; - yy_state_type yy_last_accepting_state; - char* yy_last_accepting_cpos; - - int yylineno_r; - int yy_flex_debug_r; - - char *yytext_r; - int yy_more_flag; - int yy_more_len; - - }; /* end struct yyguts_t */ - -static int yy_init_globals ( yyscan_t yyscanner ); - -int yylex_init (yyscan_t* scanner); - -int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner); - -/* Accessor methods to globals. - These are made visible to non-reentrant scanners for convenience. */ - -int yylex_destroy ( yyscan_t yyscanner ); - -int yyget_debug ( yyscan_t yyscanner ); - -void yyset_debug ( int debug_flag , yyscan_t yyscanner ); - -YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner ); - -void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner ); - -FILE *yyget_in ( yyscan_t yyscanner ); - -void yyset_in ( FILE * _in_str , yyscan_t yyscanner ); - -FILE *yyget_out ( yyscan_t yyscanner ); - -void yyset_out ( FILE * _out_str , yyscan_t yyscanner ); - - int yyget_leng ( yyscan_t yyscanner ); - -char *yyget_text ( yyscan_t yyscanner ); - -int yyget_lineno ( yyscan_t yyscanner ); - -void yyset_lineno ( int _line_number , yyscan_t yyscanner ); - -int yyget_column ( yyscan_t yyscanner ); - -void yyset_column ( int _column_no , yyscan_t yyscanner ); - -/* Macros after this point can all be overridden by user definitions in - * section 1. - */ - -#ifndef YY_SKIP_YYWRAP -#ifdef __cplusplus -extern "C" int yywrap ( yyscan_t yyscanner ); -#else -extern int yywrap ( yyscan_t yyscanner ); -#endif -#endif - -#ifndef YY_NO_UNPUT - - static void yyunput ( int c, char *buf_ptr , yyscan_t yyscanner); - -#endif - -#ifndef yytext_ptr -static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner); -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen ( const char * , yyscan_t yyscanner); -#endif - -#ifndef YY_NO_INPUT -#ifdef __cplusplus -static int yyinput ( yyscan_t yyscanner ); -#else -static int input ( yyscan_t yyscanner ); -#endif - -#endif - -/* Amount of stuff to slurp up with each read. */ -#ifndef YY_READ_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k */ -#define YY_READ_BUF_SIZE 16384 -#else -#define YY_READ_BUF_SIZE 8192 -#endif /* __ia64__ */ -#endif - -/* Copy whatever the last rule matched to the standard output. */ -#ifndef ECHO -/* This used to be an fputs(), but since the string might contain NUL's, - * we now use fwrite(). - */ -#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) -#endif - -/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, - * is returned in "result". - */ -#ifndef YY_INPUT -#define YY_INPUT(buf,result,max_size) \ - if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ - { \ - int c = '*'; \ - int n; \ - for ( n = 0; n < max_size && \ - (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ - buf[n] = (char) c; \ - if ( c == '\n' ) \ - buf[n++] = (char) c; \ - if ( c == EOF && ferror( yyin ) ) \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - result = n; \ - } \ - else \ - { \ - errno=0; \ - while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ - { \ - if( errno != EINTR) \ - { \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - break; \ - } \ - errno=0; \ - clearerr(yyin); \ - } \ - }\ -\ - -#endif - -/* No semi-colon after return; correct usage is to write "yyterminate();" - - * we don't want an extra ';' after the "return" because that will cause - * some compilers to complain about unreachable statements. - */ -#ifndef yyterminate -#define yyterminate() return YY_NULL -#endif - -/* Number of entries by which start-condition stack grows. */ -#ifndef YY_START_STACK_INCR -#define YY_START_STACK_INCR 25 -#endif - -/* Report a fatal error. */ -#ifndef YY_FATAL_ERROR -#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) -#endif - -/* end tables serialization structures and prototypes */ - -/* Default declaration of generated scanner - a define so the user can - * easily add parameters. - */ -#ifndef YY_DECL -#define YY_DECL_IS_OURS 1 - -extern int yylex (yyscan_t yyscanner); - -#define YY_DECL int yylex (yyscan_t yyscanner) -#endif /* !YY_DECL */ - -/* Code executed at the beginning of each rule, after yytext and yyleng - * have been set up. - */ -#ifndef YY_USER_ACTION -#define YY_USER_ACTION -#endif - -/* Code executed at the end of each rule. */ -#ifndef YY_BREAK -#define YY_BREAK /*LINTED*/break; -#endif - -#define YY_RULE_SETUP \ - YY_USER_ACTION - -/** The main scanner function which does all the work. - */ -YY_DECL -{ - yy_state_type yy_current_state; - char *yy_cp, *yy_bp; - int yy_act; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - if ( !yyg->yy_init ) - { - yyg->yy_init = 1; - -#ifdef YY_USER_INIT - YY_USER_INIT; -#endif - - if ( ! yyg->yy_start ) - yyg->yy_start = 1; /* first start state */ - - if ( ! yyin ) - yyin = stdin; - - if ( ! yyout ) - yyout = stdout; - - if ( ! YY_CURRENT_BUFFER ) { - yyensure_buffer_stack (yyscanner); - YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); - } - - yy_load_buffer_state( yyscanner ); - } - - { - - while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ - { - yy_cp = yyg->yy_c_buf_p; - - /* Support of yytext. */ - *yy_cp = yyg->yy_hold_char; - - /* yy_bp points to the position in yy_ch_buf of the start of - * the current run. - */ - yy_bp = yy_cp; - - yy_current_state = yyg->yy_start; -yy_match: - do - { - YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; - if ( yy_accept[yy_current_state] ) - { - yyg->yy_last_accepting_state = yy_current_state; - yyg->yy_last_accepting_cpos = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 29 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - ++yy_cp; - } - while ( yy_base[yy_current_state] != 36 ); - -yy_find_action: - yy_act = yy_accept[yy_current_state]; - if ( yy_act == 0 ) - { /* have to back up */ - yy_cp = yyg->yy_last_accepting_cpos; - yy_current_state = yyg->yy_last_accepting_state; - yy_act = yy_accept[yy_current_state]; - } - - YY_DO_BEFORE_ACTION; - -do_action: /* This label is used only to access EOF actions. */ - - switch ( yy_act ) - { /* beginning of action switch */ - case 0: /* must back up */ - /* undo the effects of YY_DO_BEFORE_ACTION */ - *yy_cp = yyg->yy_hold_char; - yy_cp = yyg->yy_last_accepting_cpos; - yy_current_state = yyg->yy_last_accepting_state; - goto yy_find_action; - -case 1: -YY_RULE_SETUP -{ - BEGIN(RESOURCE_COUNT); - yyextra->SetResourceType(std::string(yytext, yyleng - 1)); -} - YY_BREAK -case 2: -YY_RULE_SETUP -{ - BEGIN(PROCESSES_END); - std::size_t len = yyleng; - yyextra->SetProcessCount(std::stoll(yytext, &len, 10)); -} - YY_BREAK -case 3: -YY_RULE_SETUP -{ - BEGIN(RESOURCE_END); - std::size_t len = yyleng; - yyextra->SetNeededSlots(std::stoll(yytext, &len, 10)); - yyextra->WriteRequirement(); -} - YY_BREAK -case 4: -YY_RULE_SETUP -{ - BEGIN(RESOURCE_START); -} - YY_BREAK -case 5: -YY_RULE_SETUP -{ - BEGIN(PROCESSES_START); -} - YY_BREAK -case 6: -YY_RULE_SETUP -{ - BEGIN(PROCESSES_START); - yyextra->WriteProcess(); -} - YY_BREAK -case YY_STATE_EOF(RESOURCE_START): -case YY_STATE_EOF(PROCESSES_END): -case YY_STATE_EOF(RESOURCE_END): -{ - yyextra->WriteProcess(); - return 0; -} - YY_BREAK -case YY_STATE_EOF(INITIAL): -case YY_STATE_EOF(PROCESSES_START): -{ - return 0; -} - YY_BREAK -case YY_STATE_EOF(RESOURCE_COUNT): -{ - return 1; -} - YY_BREAK -case 7: -/* rule 7 can match eol */ -YY_RULE_SETUP -{ - return 1; -} - YY_BREAK -case 8: -YY_RULE_SETUP -YY_FATAL_ERROR( "flex scanner jammed" ); - YY_BREAK - - case YY_END_OF_BUFFER: - { - /* Amount of text matched not including the EOB char. */ - int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; - - /* Undo the effects of YY_DO_BEFORE_ACTION. */ - *yy_cp = yyg->yy_hold_char; - YY_RESTORE_YY_MORE_OFFSET - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) - { - /* We're scanning a new file or input source. It's - * possible that this happened because the user - * just pointed yyin at a new source and called - * yylex(). If so, then we have to assure - * consistency between YY_CURRENT_BUFFER and our - * globals. Here is the right place to do so, because - * this is the first action (other than possibly a - * back-up) that will match for the new input source. - */ - yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; - } - - /* Note that here we test for yy_c_buf_p "<=" to the position - * of the first EOB in the buffer, since yy_c_buf_p will - * already have been incremented past the NUL character - * (since all states make transitions on EOB to the - * end-of-buffer state). Contrast this with the test - * in input(). - */ - if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) - { /* This was really a NUL. */ - yy_state_type yy_next_state; - - yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( yyscanner ); - - /* Okay, we're now positioned to make the NUL - * transition. We couldn't have - * yy_get_previous_state() go ahead and do it - * for us because it doesn't know how to deal - * with the possibility of jamming (and we don't - * want to build jamming into it because then it - * will run more slowly). - */ - - yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); - - yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; - - if ( yy_next_state ) - { - /* Consume the NUL. */ - yy_cp = ++yyg->yy_c_buf_p; - yy_current_state = yy_next_state; - goto yy_match; - } - - else - { - yy_cp = yyg->yy_c_buf_p; - goto yy_find_action; - } - } - - else switch ( yy_get_next_buffer( yyscanner ) ) - { - case EOB_ACT_END_OF_FILE: - { - yyg->yy_did_buffer_switch_on_eof = 0; - - if ( yywrap( yyscanner ) ) - { - /* Note: because we've taken care in - * yy_get_next_buffer() to have set up - * yytext, we can now set up - * yy_c_buf_p so that if some total - * hoser (like flex itself) wants to - * call the scanner after we return the - * YY_NULL, it'll still work - another - * YY_NULL will get returned. - */ - yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; - - yy_act = YY_STATE_EOF(YY_START); - goto do_action; - } - - else - { - if ( ! yyg->yy_did_buffer_switch_on_eof ) - YY_NEW_FILE; - } - break; - } - - case EOB_ACT_CONTINUE_SCAN: - yyg->yy_c_buf_p = - yyg->yytext_ptr + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( yyscanner ); - - yy_cp = yyg->yy_c_buf_p; - yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; - goto yy_match; - - case EOB_ACT_LAST_MATCH: - yyg->yy_c_buf_p = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; - - yy_current_state = yy_get_previous_state( yyscanner ); - - yy_cp = yyg->yy_c_buf_p; - yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; - goto yy_find_action; - } - break; - } - - default: - YY_FATAL_ERROR( - "fatal flex scanner internal error--no action found" ); - } /* end of action switch */ - } /* end of scanning one token */ - } /* end of user's declarations */ -} /* end of yylex */ - -/* yy_get_next_buffer - try to read in a new buffer - * - * Returns a code representing an action: - * EOB_ACT_LAST_MATCH - - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position - * EOB_ACT_END_OF_FILE - end of file - */ -static int yy_get_next_buffer (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - char *source = yyg->yytext_ptr; - int number_to_move, i; - int ret_val; - - if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) - YY_FATAL_ERROR( - "fatal flex scanner internal error--end of buffer missed" ); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) - { /* Don't try to fill the buffer, so this is an EOF. */ - if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) - { - /* We matched a single character, the EOB, so - * treat this as a final EOF. - */ - return EOB_ACT_END_OF_FILE; - } - - else - { - /* We matched some text prior to the EOB, first - * process it. - */ - return EOB_ACT_LAST_MATCH; - } - } - - /* Try to read more data. */ - - /* First move last chars to start of buffer. */ - number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); - - for ( i = 0; i < number_to_move; ++i ) - *(dest++) = *(source++); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) - /* don't do the read, it's not guaranteed to return an EOF, - * just force an EOF - */ - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; - - else - { - int num_to_read = - YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; - - while ( num_to_read <= 0 ) - { /* Not enough room in the buffer - grow it. */ - - /* just a shorter name for the current buffer */ - YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; - - int yy_c_buf_p_offset = - (int) (yyg->yy_c_buf_p - b->yy_ch_buf); - - if ( b->yy_is_our_buffer ) - { - int new_size = b->yy_buf_size * 2; - - if ( new_size <= 0 ) - b->yy_buf_size += b->yy_buf_size / 8; - else - b->yy_buf_size *= 2; - - b->yy_ch_buf = (char *) - /* Include room in for 2 EOB chars. */ - yyrealloc( (void *) b->yy_ch_buf, - (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); - } - else - /* Can't grow it, we don't own it. */ - b->yy_ch_buf = NULL; - - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( - "fatal error - scanner input buffer overflow" ); - - yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; - - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - - number_to_move - 1; - - } - - if ( num_to_read > YY_READ_BUF_SIZE ) - num_to_read = YY_READ_BUF_SIZE; - - /* Read in more data. */ - YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), - yyg->yy_n_chars, num_to_read ); - - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; - } - - if ( yyg->yy_n_chars == 0 ) - { - if ( number_to_move == YY_MORE_ADJ ) - { - ret_val = EOB_ACT_END_OF_FILE; - yyrestart( yyin , yyscanner); - } - - else - { - ret_val = EOB_ACT_LAST_MATCH; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = - YY_BUFFER_EOF_PENDING; - } - } - - else - ret_val = EOB_ACT_CONTINUE_SCAN; - - if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { - /* Extend the array by 50%, plus the number we really need. */ - int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( - (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); - if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); - /* "- 2" to take care of EOB's */ - YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); - } - - yyg->yy_n_chars += number_to_move; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; - - yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; - - return ret_val; -} - -/* yy_get_previous_state - get the state just before the EOB char was reached */ - - static yy_state_type yy_get_previous_state (yyscan_t yyscanner) -{ - yy_state_type yy_current_state; - char *yy_cp; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - yy_current_state = yyg->yy_start; - - for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) - { - YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); - if ( yy_accept[yy_current_state] ) - { - yyg->yy_last_accepting_state = yy_current_state; - yyg->yy_last_accepting_cpos = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 29 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - } - - return yy_current_state; -} - -/* yy_try_NUL_trans - try to make a transition on the NUL character - * - * synopsis - * next_state = yy_try_NUL_trans( current_state ); - */ - static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) -{ - int yy_is_jam; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ - char *yy_cp = yyg->yy_c_buf_p; - - YY_CHAR yy_c = 1; - if ( yy_accept[yy_current_state] ) - { - yyg->yy_last_accepting_state = yy_current_state; - yyg->yy_last_accepting_cpos = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 29 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 28); - - (void)yyg; - return yy_is_jam ? 0 : yy_current_state; -} - -#ifndef YY_NO_UNPUT - - static void yyunput (int c, char * yy_bp , yyscan_t yyscanner) -{ - char *yy_cp; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - yy_cp = yyg->yy_c_buf_p; - - /* undo effects of setting up yytext */ - *yy_cp = yyg->yy_hold_char; - - if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) - { /* need to shift things up to make room */ - /* +2 for EOB chars. */ - int number_to_move = yyg->yy_n_chars + 2; - char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ - YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; - char *source = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; - - while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) - *--dest = *--source; - - yy_cp += (int) (dest - source); - yy_bp += (int) (dest - source); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = - yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; - - if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) - YY_FATAL_ERROR( "flex scanner push-back overflow" ); - } - - *--yy_cp = (char) c; - - yyg->yytext_ptr = yy_bp; - yyg->yy_hold_char = *yy_cp; - yyg->yy_c_buf_p = yy_cp; -} - -#endif - -#ifndef YY_NO_INPUT -#ifdef __cplusplus - static int yyinput (yyscan_t yyscanner) -#else - static int input (yyscan_t yyscanner) -#endif - -{ - int c; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - *yyg->yy_c_buf_p = yyg->yy_hold_char; - - if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) - { - /* yy_c_buf_p now points to the character we want to return. - * If this occurs *before* the EOB characters, then it's a - * valid NUL; if not, then we've hit the end of the buffer. - */ - if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) - /* This was really a NUL. */ - *yyg->yy_c_buf_p = '\0'; - - else - { /* need more input */ - int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr); - ++yyg->yy_c_buf_p; - - switch ( yy_get_next_buffer( yyscanner ) ) - { - case EOB_ACT_LAST_MATCH: - /* This happens because yy_g_n_b() - * sees that we've accumulated a - * token and flags that we need to - * try matching the token before - * proceeding. But for input(), - * there's no matching to consider. - * So convert the EOB_ACT_LAST_MATCH - * to EOB_ACT_END_OF_FILE. - */ - - /* Reset buffer status. */ - yyrestart( yyin , yyscanner); - - /*FALLTHROUGH*/ - - case EOB_ACT_END_OF_FILE: - { - if ( yywrap( yyscanner ) ) - return 0; - - if ( ! yyg->yy_did_buffer_switch_on_eof ) - YY_NEW_FILE; -#ifdef __cplusplus - return yyinput(yyscanner); -#else - return input(yyscanner); -#endif - } - - case EOB_ACT_CONTINUE_SCAN: - yyg->yy_c_buf_p = yyg->yytext_ptr + offset; - break; - } - } - } - - c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */ - *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ - yyg->yy_hold_char = *++yyg->yy_c_buf_p; - - return c; -} -#endif /* ifndef YY_NO_INPUT */ - -/** Immediately switch to a different input stream. - * @param input_file A readable stream. - * @param yyscanner The scanner object. - * @note This function does not reset the start condition to @c INITIAL . - */ - void yyrestart (FILE * input_file , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - if ( ! YY_CURRENT_BUFFER ){ - yyensure_buffer_stack (yyscanner); - YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); - } - - yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); - yy_load_buffer_state( yyscanner ); -} - -/** Switch to a different input buffer. - * @param new_buffer The new input buffer. - * @param yyscanner The scanner object. - */ - void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - /* TODO. We should be able to replace this entire function body - * with - * yypop_buffer_state(); - * yypush_buffer_state(new_buffer); - */ - yyensure_buffer_stack (yyscanner); - if ( YY_CURRENT_BUFFER == new_buffer ) - return; - - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *yyg->yy_c_buf_p = yyg->yy_hold_char; - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; - } - - YY_CURRENT_BUFFER_LVALUE = new_buffer; - yy_load_buffer_state( yyscanner ); - - /* We don't actually know whether we did this switch during - * EOF (yywrap()) processing, but the only time this flag - * is looked at is after yywrap() is called, so it's safe - * to go ahead and always set it. - */ - yyg->yy_did_buffer_switch_on_eof = 1; -} - -static void yy_load_buffer_state (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; - yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; - yyg->yy_hold_char = *yyg->yy_c_buf_p; -} - -/** Allocate and initialize an input buffer state. - * @param file A readable stream. - * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. - * @param yyscanner The scanner object. - * @return the allocated buffer state. - */ - YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner) -{ - YY_BUFFER_STATE b; - - b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); - - b->yy_buf_size = size; - - /* yy_ch_buf has to be 2 characters longer than the size given because - * we need to put in 2 end-of-buffer characters. - */ - b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); - - b->yy_is_our_buffer = 1; - - yy_init_buffer( b, file , yyscanner); - - return b; -} - -/** Destroy the buffer. - * @param b a buffer created with yy_create_buffer() - * @param yyscanner The scanner object. - */ - void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - if ( ! b ) - return; - - if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ - YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; - - if ( b->yy_is_our_buffer ) - yyfree( (void *) b->yy_ch_buf , yyscanner ); - - yyfree( (void *) b , yyscanner ); -} - -/* Initializes or reinitializes a buffer. - * This function is sometimes called more than once on the same buffer, - * such as during a yyrestart() or at EOF. - */ - static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) - -{ - int oerrno = errno; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - yy_flush_buffer( b , yyscanner); - - b->yy_input_file = file; - b->yy_fill_buffer = 1; - - /* If b is the current buffer, then yy_init_buffer was _probably_ - * called from yyrestart() or through yy_get_next_buffer. - * In that case, we don't want to reset the lineno or column. - */ - if (b != YY_CURRENT_BUFFER){ - b->yy_bs_lineno = 1; - b->yy_bs_column = 0; - } - - b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; - - errno = oerrno; -} - -/** Discard all buffered characters. On the next scan, YY_INPUT will be called. - * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. - * @param yyscanner The scanner object. - */ - void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - if ( ! b ) - return; - - b->yy_n_chars = 0; - - /* We always need two end-of-buffer characters. The first causes - * a transition to the end-of-buffer state. The second causes - * a jam in that state. - */ - b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; - b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; - - b->yy_buf_pos = &b->yy_ch_buf[0]; - - b->yy_at_bol = 1; - b->yy_buffer_status = YY_BUFFER_NEW; - - if ( b == YY_CURRENT_BUFFER ) - yy_load_buffer_state( yyscanner ); -} - -/** Pushes the new state onto the stack. The new state becomes - * the current state. This function will allocate the stack - * if necessary. - * @param new_buffer The new state. - * @param yyscanner The scanner object. - */ -void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - if (new_buffer == NULL) - return; - - yyensure_buffer_stack(yyscanner); - - /* This block is copied from yy_switch_to_buffer. */ - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *yyg->yy_c_buf_p = yyg->yy_hold_char; - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; - } - - /* Only push if top exists. Otherwise, replace top. */ - if (YY_CURRENT_BUFFER) - yyg->yy_buffer_stack_top++; - YY_CURRENT_BUFFER_LVALUE = new_buffer; - - /* copied from yy_switch_to_buffer. */ - yy_load_buffer_state( yyscanner ); - yyg->yy_did_buffer_switch_on_eof = 1; -} - -/** Removes and deletes the top of the stack, if present. - * The next element becomes the new top. - * @param yyscanner The scanner object. - */ -void yypop_buffer_state (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - if (!YY_CURRENT_BUFFER) - return; - - yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); - YY_CURRENT_BUFFER_LVALUE = NULL; - if (yyg->yy_buffer_stack_top > 0) - --yyg->yy_buffer_stack_top; - - if (YY_CURRENT_BUFFER) { - yy_load_buffer_state( yyscanner ); - yyg->yy_did_buffer_switch_on_eof = 1; - } -} - -/* Allocates the stack if it does not exist. - * Guarantees space for at least one push. - */ -static void yyensure_buffer_stack (yyscan_t yyscanner) -{ - yy_size_t num_to_alloc; - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - if (!yyg->yy_buffer_stack) { - - /* First allocation is just for 2 elements, since we don't know if this - * scanner will even need a stack. We use 2 instead of 1 to avoid an - * immediate realloc on the next call. - */ - num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ - yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc - (num_to_alloc * sizeof(struct yy_buffer_state*) - , yyscanner); - if ( ! yyg->yy_buffer_stack ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - - memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); - - yyg->yy_buffer_stack_max = num_to_alloc; - yyg->yy_buffer_stack_top = 0; - return; - } - - if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ - - /* Increase the buffer to prepare for a possible push. */ - yy_size_t grow_size = 8 /* arbitrary grow size */; - - num_to_alloc = yyg->yy_buffer_stack_max + grow_size; - yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc - (yyg->yy_buffer_stack, - num_to_alloc * sizeof(struct yy_buffer_state*) - , yyscanner); - if ( ! yyg->yy_buffer_stack ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - - /* zero only the new slots.*/ - memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); - yyg->yy_buffer_stack_max = num_to_alloc; - } -} - -/** Setup the input buffer state to scan directly from a user-specified character buffer. - * @param base the character buffer - * @param size the size in bytes of the character buffer - * @param yyscanner The scanner object. - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) -{ - YY_BUFFER_STATE b; - - if ( size < 2 || - base[size-2] != YY_END_OF_BUFFER_CHAR || - base[size-1] != YY_END_OF_BUFFER_CHAR ) - /* They forgot to leave room for the EOB's. */ - return NULL; - - b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); - - b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ - b->yy_buf_pos = b->yy_ch_buf = base; - b->yy_is_our_buffer = 0; - b->yy_input_file = NULL; - b->yy_n_chars = b->yy_buf_size; - b->yy_is_interactive = 0; - b->yy_at_bol = 1; - b->yy_fill_buffer = 0; - b->yy_buffer_status = YY_BUFFER_NEW; - - yy_switch_to_buffer( b , yyscanner ); - - return b; -} - -/** Setup the input buffer state to scan a string. The next call to yylex() will - * scan from a @e copy of @a str. - * @param yystr a NUL-terminated string to scan - * @param yyscanner The scanner object. - * @return the newly allocated buffer state object. - * @note If you want to scan bytes that may contain NUL values, then use - * yy_scan_bytes() instead. - */ -YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner) -{ - - return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); -} - -/** Setup the input buffer state to scan the given bytes. The next call to yylex() will - * scan from a @e copy of @a bytes. - * @param yybytes the byte buffer to scan - * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. - * @param yyscanner The scanner object. - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner) -{ - YY_BUFFER_STATE b; - char *buf; - yy_size_t n; - int i; - - /* Get memory for full buffer, including space for trailing EOB's. */ - n = (yy_size_t) (_yybytes_len + 2); - buf = (char *) yyalloc( n , yyscanner ); - if ( ! buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); - - for ( i = 0; i < _yybytes_len; ++i ) - buf[i] = yybytes[i]; - - buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - - b = yy_scan_buffer( buf, n , yyscanner); - if ( ! b ) - YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); - - /* It's okay to grow etc. this buffer, and we should throw it - * away when we're done. - */ - b->yy_is_our_buffer = 1; - - return b; -} - -#ifndef YY_EXIT_FAILURE -#define YY_EXIT_FAILURE 2 -#endif - -static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - (void)yyg; - fprintf( stderr, "%s\n", msg ); - exit( YY_EXIT_FAILURE ); -} - -/* Redefine yyless() so it works in section 3 code. */ - -#undef yyless -#define yyless(n) \ - do \ - { \ - /* Undo effects of setting up yytext. */ \ - int yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg);\ - yytext[yyleng] = yyg->yy_hold_char; \ - yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ - yyg->yy_hold_char = *yyg->yy_c_buf_p; \ - *yyg->yy_c_buf_p = '\0'; \ - yyleng = yyless_macro_arg; \ - } \ - while ( 0 ) - -/* Accessor methods (get/set functions) to struct members. */ - -/** Get the user-defined data for this scanner. - * @param yyscanner The scanner object. - */ -YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yyextra; -} - -/** Get the current line number. - * @param yyscanner The scanner object. - */ -int yyget_lineno (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - if (! YY_CURRENT_BUFFER) - return 0; - - return yylineno; -} - -/** Get the current column number. - * @param yyscanner The scanner object. - */ -int yyget_column (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - if (! YY_CURRENT_BUFFER) - return 0; - - return yycolumn; -} - -/** Get the input stream. - * @param yyscanner The scanner object. - */ -FILE *yyget_in (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yyin; -} - -/** Get the output stream. - * @param yyscanner The scanner object. - */ -FILE *yyget_out (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yyout; -} - -/** Get the length of the current token. - * @param yyscanner The scanner object. - */ -int yyget_leng (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yyleng; -} - -/** Get the current token. - * @param yyscanner The scanner object. - */ - -char *yyget_text (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yytext; -} - -/** Set the user-defined data. This data is never touched by the scanner. - * @param user_defined The data to be associated with this scanner. - * @param yyscanner The scanner object. - */ -void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyextra = user_defined ; -} - -/** Set the current line number. - * @param _line_number line number - * @param yyscanner The scanner object. - */ -void yyset_lineno (int _line_number , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - /* lineno is only valid if an input buffer exists. */ - if (! YY_CURRENT_BUFFER ) - YY_FATAL_ERROR( "yyset_lineno called with no buffer" ); - - yylineno = _line_number; -} - -/** Set the current column. - * @param _column_no column number - * @param yyscanner The scanner object. - */ -void yyset_column (int _column_no , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - /* column is only valid if an input buffer exists. */ - if (! YY_CURRENT_BUFFER ) - YY_FATAL_ERROR( "yyset_column called with no buffer" ); - - yycolumn = _column_no; -} - -/** Set the input stream. This does not discard the current - * input buffer. - * @param _in_str A readable stream. - * @param yyscanner The scanner object. - * @see yy_switch_to_buffer - */ -void yyset_in (FILE * _in_str , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyin = _in_str ; -} - -void yyset_out (FILE * _out_str , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yyout = _out_str ; -} - -int yyget_debug (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - return yy_flex_debug; -} - -void yyset_debug (int _bdebug , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - yy_flex_debug = _bdebug ; -} - -/* Accessor methods for yylval and yylloc */ - -/* User-visible API */ - -/* yylex_init is special because it creates the scanner itself, so it is - * the ONLY reentrant function that doesn't take the scanner as the last argument. - * That's why we explicitly handle the declaration, instead of using our macros. - */ -int yylex_init(yyscan_t* ptr_yy_globals) -{ - if (ptr_yy_globals == NULL){ - errno = EINVAL; - return 1; - } - - *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); - - if (*ptr_yy_globals == NULL){ - errno = ENOMEM; - return 1; - } - - /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ - memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); - - return yy_init_globals ( *ptr_yy_globals ); -} - -/* yylex_init_extra has the same functionality as yylex_init, but follows the - * convention of taking the scanner as the last argument. Note however, that - * this is a *pointer* to a scanner, as it will be allocated by this call (and - * is the reason, too, why this function also must handle its own declaration). - * The user defined value in the first argument will be available to yyalloc in - * the yyextra field. - */ -int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals ) -{ - struct yyguts_t dummy_yyguts; - - yyset_extra (yy_user_defined, &dummy_yyguts); - - if (ptr_yy_globals == NULL){ - errno = EINVAL; - return 1; - } - - *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); - - if (*ptr_yy_globals == NULL){ - errno = ENOMEM; - return 1; - } - - /* By setting to 0xAA, we expose bugs in - yy_init_globals. Leave at 0x00 for releases. */ - memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); - - yyset_extra (yy_user_defined, *ptr_yy_globals); - - return yy_init_globals ( *ptr_yy_globals ); -} - -static int yy_init_globals (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - /* Initialization is the same as for the non-reentrant scanner. - * This function is called from yylex_destroy(), so don't allocate here. - */ - - yyg->yy_buffer_stack = NULL; - yyg->yy_buffer_stack_top = 0; - yyg->yy_buffer_stack_max = 0; - yyg->yy_c_buf_p = NULL; - yyg->yy_init = 0; - yyg->yy_start = 0; - - yyg->yy_start_stack_ptr = 0; - yyg->yy_start_stack_depth = 0; - yyg->yy_start_stack = NULL; - -/* Defined in main.c */ -#ifdef YY_STDINIT - yyin = stdin; - yyout = stdout; -#else - yyin = NULL; - yyout = NULL; -#endif - - /* For future reference: Set errno on error, since we are called by - * yylex_init() - */ - return 0; -} - -/* yylex_destroy is for both reentrant and non-reentrant scanners. */ -int yylex_destroy (yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - - /* Pop the buffer stack, destroying each element. */ - while(YY_CURRENT_BUFFER){ - yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); - YY_CURRENT_BUFFER_LVALUE = NULL; - yypop_buffer_state(yyscanner); - } - - /* Destroy the stack itself. */ - yyfree(yyg->yy_buffer_stack , yyscanner); - yyg->yy_buffer_stack = NULL; - - /* Destroy the start condition stack. */ - yyfree( yyg->yy_start_stack , yyscanner ); - yyg->yy_start_stack = NULL; - - /* Reset the globals. This is important in a non-reentrant scanner so the next time - * yylex() is called, initialization will occur. */ - yy_init_globals( yyscanner); - - /* Destroy the main struct (reentrant only). */ - yyfree ( yyscanner , yyscanner ); - yyscanner = NULL; - return 0; -} - -/* - * Internal utility routines. - */ - -#ifndef yytext_ptr -static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - (void)yyg; - - int i; - for ( i = 0; i < n; ++i ) - s1[i] = s2[i]; -} -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen (const char * s , yyscan_t yyscanner) -{ - int n; - for ( n = 0; s[n]; ++n ) - ; - - return n; -} -#endif - -void *yyalloc (yy_size_t size , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - (void)yyg; - return malloc(size); -} - -void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - (void)yyg; - - /* The cast to (char *) in the following accommodates both - * implementations that use char* generic pointers, and those - * that use void* generic pointers. It works with the latter - * because both ANSI C and C++ allow castless assignment from - * any pointer type to void*, and deal with argument conversions - * as though doing an assignment. - */ - return realloc(ptr, size); -} - -void yyfree (void * ptr , yyscan_t yyscanner) -{ - struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; - (void)yyg; - free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ -} - -#define YYTABLES_NAME "yytables" - -/*--------------------------------------------------------------------------*/ - -#endif /* __clang_analyzer__ */ diff --git a/Source/LexerParser/cmCTestProcessesLexer.h b/Source/LexerParser/cmCTestProcessesLexer.h deleted file mode 100644 index b6437b4..0000000 --- a/Source/LexerParser/cmCTestProcessesLexer.h +++ /dev/null @@ -1,692 +0,0 @@ -#ifndef cmCTestProcesses_yyHEADER_H -#define cmCTestProcesses_yyHEADER_H 1 -#define cmCTestProcesses_yyIN_HEADER 1 - -#define FLEXINT_H 1 -#define YY_INT_ALIGNED short int - -/* A lexical scanner generated by flex */ - -#define FLEX_SCANNER -#define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 4 -#if YY_FLEX_SUBMINOR_VERSION > 0 -#define FLEX_BETA -#endif - -#ifdef yy_create_buffer -#define cmCTestProcesses_yy_create_buffer_ALREADY_DEFINED -#else -#define yy_create_buffer cmCTestProcesses_yy_create_buffer -#endif - -#ifdef yy_delete_buffer -#define cmCTestProcesses_yy_delete_buffer_ALREADY_DEFINED -#else -#define yy_delete_buffer cmCTestProcesses_yy_delete_buffer -#endif - -#ifdef yy_scan_buffer -#define cmCTestProcesses_yy_scan_buffer_ALREADY_DEFINED -#else -#define yy_scan_buffer cmCTestProcesses_yy_scan_buffer -#endif - -#ifdef yy_scan_string -#define cmCTestProcesses_yy_scan_string_ALREADY_DEFINED -#else -#define yy_scan_string cmCTestProcesses_yy_scan_string -#endif - -#ifdef yy_scan_bytes -#define cmCTestProcesses_yy_scan_bytes_ALREADY_DEFINED -#else -#define yy_scan_bytes cmCTestProcesses_yy_scan_bytes -#endif - -#ifdef yy_init_buffer -#define cmCTestProcesses_yy_init_buffer_ALREADY_DEFINED -#else -#define yy_init_buffer cmCTestProcesses_yy_init_buffer -#endif - -#ifdef yy_flush_buffer -#define cmCTestProcesses_yy_flush_buffer_ALREADY_DEFINED -#else -#define yy_flush_buffer cmCTestProcesses_yy_flush_buffer -#endif - -#ifdef yy_load_buffer_state -#define cmCTestProcesses_yy_load_buffer_state_ALREADY_DEFINED -#else -#define yy_load_buffer_state cmCTestProcesses_yy_load_buffer_state -#endif - -#ifdef yy_switch_to_buffer -#define cmCTestProcesses_yy_switch_to_buffer_ALREADY_DEFINED -#else -#define yy_switch_to_buffer cmCTestProcesses_yy_switch_to_buffer -#endif - -#ifdef yypush_buffer_state -#define cmCTestProcesses_yypush_buffer_state_ALREADY_DEFINED -#else -#define yypush_buffer_state cmCTestProcesses_yypush_buffer_state -#endif - -#ifdef yypop_buffer_state -#define cmCTestProcesses_yypop_buffer_state_ALREADY_DEFINED -#else -#define yypop_buffer_state cmCTestProcesses_yypop_buffer_state -#endif - -#ifdef yyensure_buffer_stack -#define cmCTestProcesses_yyensure_buffer_stack_ALREADY_DEFINED -#else -#define yyensure_buffer_stack cmCTestProcesses_yyensure_buffer_stack -#endif - -#ifdef yylex -#define cmCTestProcesses_yylex_ALREADY_DEFINED -#else -#define yylex cmCTestProcesses_yylex -#endif - -#ifdef yyrestart -#define cmCTestProcesses_yyrestart_ALREADY_DEFINED -#else -#define yyrestart cmCTestProcesses_yyrestart -#endif - -#ifdef yylex_init -#define cmCTestProcesses_yylex_init_ALREADY_DEFINED -#else -#define yylex_init cmCTestProcesses_yylex_init -#endif - -#ifdef yylex_init_extra -#define cmCTestProcesses_yylex_init_extra_ALREADY_DEFINED -#else -#define yylex_init_extra cmCTestProcesses_yylex_init_extra -#endif - -#ifdef yylex_destroy -#define cmCTestProcesses_yylex_destroy_ALREADY_DEFINED -#else -#define yylex_destroy cmCTestProcesses_yylex_destroy -#endif - -#ifdef yyget_debug -#define cmCTestProcesses_yyget_debug_ALREADY_DEFINED -#else -#define yyget_debug cmCTestProcesses_yyget_debug -#endif - -#ifdef yyset_debug -#define cmCTestProcesses_yyset_debug_ALREADY_DEFINED -#else -#define yyset_debug cmCTestProcesses_yyset_debug -#endif - -#ifdef yyget_extra -#define cmCTestProcesses_yyget_extra_ALREADY_DEFINED -#else -#define yyget_extra cmCTestProcesses_yyget_extra -#endif - -#ifdef yyset_extra -#define cmCTestProcesses_yyset_extra_ALREADY_DEFINED -#else -#define yyset_extra cmCTestProcesses_yyset_extra -#endif - -#ifdef yyget_in -#define cmCTestProcesses_yyget_in_ALREADY_DEFINED -#else -#define yyget_in cmCTestProcesses_yyget_in -#endif - -#ifdef yyset_in -#define cmCTestProcesses_yyset_in_ALREADY_DEFINED -#else -#define yyset_in cmCTestProcesses_yyset_in -#endif - -#ifdef yyget_out -#define cmCTestProcesses_yyget_out_ALREADY_DEFINED -#else -#define yyget_out cmCTestProcesses_yyget_out -#endif - -#ifdef yyset_out -#define cmCTestProcesses_yyset_out_ALREADY_DEFINED -#else -#define yyset_out cmCTestProcesses_yyset_out -#endif - -#ifdef yyget_leng -#define cmCTestProcesses_yyget_leng_ALREADY_DEFINED -#else -#define yyget_leng cmCTestProcesses_yyget_leng -#endif - -#ifdef yyget_text -#define cmCTestProcesses_yyget_text_ALREADY_DEFINED -#else -#define yyget_text cmCTestProcesses_yyget_text -#endif - -#ifdef yyget_lineno -#define cmCTestProcesses_yyget_lineno_ALREADY_DEFINED -#else -#define yyget_lineno cmCTestProcesses_yyget_lineno -#endif - -#ifdef yyset_lineno -#define cmCTestProcesses_yyset_lineno_ALREADY_DEFINED -#else -#define yyset_lineno cmCTestProcesses_yyset_lineno -#endif - -#ifdef yyget_column -#define cmCTestProcesses_yyget_column_ALREADY_DEFINED -#else -#define yyget_column cmCTestProcesses_yyget_column -#endif - -#ifdef yyset_column -#define cmCTestProcesses_yyset_column_ALREADY_DEFINED -#else -#define yyset_column cmCTestProcesses_yyset_column -#endif - -#ifdef yywrap -#define cmCTestProcesses_yywrap_ALREADY_DEFINED -#else -#define yywrap cmCTestProcesses_yywrap -#endif - -#ifdef yyalloc -#define cmCTestProcesses_yyalloc_ALREADY_DEFINED -#else -#define yyalloc cmCTestProcesses_yyalloc -#endif - -#ifdef yyrealloc -#define cmCTestProcesses_yyrealloc_ALREADY_DEFINED -#else -#define yyrealloc cmCTestProcesses_yyrealloc -#endif - -#ifdef yyfree -#define cmCTestProcesses_yyfree_ALREADY_DEFINED -#else -#define yyfree cmCTestProcesses_yyfree -#endif - -/* First, we deal with platform-specific or compiler-specific issues. */ - -/* begin standard C headers. */ -#include -#include -#include -#include - -/* end standard C headers. */ - -/* flex integer type definitions */ - -#ifndef FLEXINT_H -#define FLEXINT_H - -/* C99 systems have . Non-C99 systems may or may not. */ - -#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - -/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. - */ -#ifndef __STDC_LIMIT_MACROS -#define __STDC_LIMIT_MACROS 1 -#endif - -#include -typedef int8_t flex_int8_t; -typedef uint8_t flex_uint8_t; -typedef int16_t flex_int16_t; -typedef uint16_t flex_uint16_t; -typedef int32_t flex_int32_t; -typedef uint32_t flex_uint32_t; -#else -typedef signed char flex_int8_t; -typedef short int flex_int16_t; -typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; -typedef unsigned short int flex_uint16_t; -typedef unsigned int flex_uint32_t; - -/* Limits of integral types. */ -#ifndef INT8_MIN -#define INT8_MIN (-128) -#endif -#ifndef INT16_MIN -#define INT16_MIN (-32767-1) -#endif -#ifndef INT32_MIN -#define INT32_MIN (-2147483647-1) -#endif -#ifndef INT8_MAX -#define INT8_MAX (127) -#endif -#ifndef INT16_MAX -#define INT16_MAX (32767) -#endif -#ifndef INT32_MAX -#define INT32_MAX (2147483647) -#endif -#ifndef UINT8_MAX -#define UINT8_MAX (255U) -#endif -#ifndef UINT16_MAX -#define UINT16_MAX (65535U) -#endif -#ifndef UINT32_MAX -#define UINT32_MAX (4294967295U) -#endif - -#ifndef SIZE_MAX -#define SIZE_MAX (~(size_t)0) -#endif - -#endif /* ! C99 */ - -#endif /* ! FLEXINT_H */ - -/* begin standard C++ headers. */ - -/* TODO: this is always defined, so inline it */ -#define yyconst const - -#if defined(__GNUC__) && __GNUC__ >= 3 -#define yynoreturn __attribute__((__noreturn__)) -#else -#define yynoreturn -#endif - -/* An opaque pointer. */ -#ifndef YY_TYPEDEF_YY_SCANNER_T -#define YY_TYPEDEF_YY_SCANNER_T -typedef void* yyscan_t; -#endif - -/* For convenience, these vars (plus the bison vars far below) - are macros in the reentrant scanner. */ -#define yyin yyg->yyin_r -#define yyout yyg->yyout_r -#define yyextra yyg->yyextra_r -#define yyleng yyg->yyleng_r -#define yytext yyg->yytext_r -#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) -#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) -#define yy_flex_debug yyg->yy_flex_debug_r - -/* Size of default input buffer. */ -#ifndef YY_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k. - * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. - * Ditto for the __ia64__ case accordingly. - */ -#define YY_BUF_SIZE 32768 -#else -#define YY_BUF_SIZE 16384 -#endif /* __ia64__ */ -#endif - -#ifndef YY_TYPEDEF_YY_BUFFER_STATE -#define YY_TYPEDEF_YY_BUFFER_STATE -typedef struct yy_buffer_state *YY_BUFFER_STATE; -#endif - -#ifndef YY_TYPEDEF_YY_SIZE_T -#define YY_TYPEDEF_YY_SIZE_T -typedef size_t yy_size_t; -#endif - -#ifndef YY_STRUCT_YY_BUFFER_STATE -#define YY_STRUCT_YY_BUFFER_STATE -struct yy_buffer_state - { - FILE *yy_input_file; - - char *yy_ch_buf; /* input buffer */ - char *yy_buf_pos; /* current position in input buffer */ - - /* Size of input buffer in bytes, not including room for EOB - * characters. - */ - int yy_buf_size; - - /* Number of characters read into yy_ch_buf, not including EOB - * characters. - */ - int yy_n_chars; - - /* Whether we "own" the buffer - i.e., we know we created it, - * and can realloc() it to grow it, and should free() it to - * delete it. - */ - int yy_is_our_buffer; - - /* Whether this is an "interactive" input source; if so, and - * if we're using stdio for input, then we want to use getc() - * instead of fread(), to make sure we stop fetching input after - * each newline. - */ - int yy_is_interactive; - - /* Whether we're considered to be at the beginning of a line. - * If so, '^' rules will be active on the next match, otherwise - * not. - */ - int yy_at_bol; - - int yy_bs_lineno; /**< The line count. */ - int yy_bs_column; /**< The column count. */ - - /* Whether to try to fill the input buffer when we reach the - * end of it. - */ - int yy_fill_buffer; - - int yy_buffer_status; - - }; -#endif /* !YY_STRUCT_YY_BUFFER_STATE */ - -void yyrestart ( FILE *input_file , yyscan_t yyscanner ); -void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); -YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner ); -void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); -void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); -void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); -void yypop_buffer_state ( yyscan_t yyscanner ); - -YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner ); -YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner ); -YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner ); - -void *yyalloc ( yy_size_t , yyscan_t yyscanner ); -void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner ); -void yyfree ( void * , yyscan_t yyscanner ); - -/* Begin user sect3 */ - -#define cmCTestProcesses_yywrap(yyscanner) (/*CONSTCOND*/1) -#define YY_SKIP_YYWRAP - -#define yytext_ptr yytext_r - -#ifdef YY_HEADER_EXPORT_START_CONDITIONS -#define INITIAL 0 -#define PROCESSES_START 1 -#define PROCESSES_END 2 -#define RESOURCE_START 3 -#define RESOURCE_COUNT 4 -#define RESOURCE_END 5 - -#endif - -#ifndef YY_EXTRA_TYPE -#define YY_EXTRA_TYPE void * -#endif - -int yylex_init (yyscan_t* scanner); - -int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner); - -/* Accessor methods to globals. - These are made visible to non-reentrant scanners for convenience. */ - -int yylex_destroy ( yyscan_t yyscanner ); - -int yyget_debug ( yyscan_t yyscanner ); - -void yyset_debug ( int debug_flag , yyscan_t yyscanner ); - -YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner ); - -void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner ); - -FILE *yyget_in ( yyscan_t yyscanner ); - -void yyset_in ( FILE * _in_str , yyscan_t yyscanner ); - -FILE *yyget_out ( yyscan_t yyscanner ); - -void yyset_out ( FILE * _out_str , yyscan_t yyscanner ); - - int yyget_leng ( yyscan_t yyscanner ); - -char *yyget_text ( yyscan_t yyscanner ); - -int yyget_lineno ( yyscan_t yyscanner ); - -void yyset_lineno ( int _line_number , yyscan_t yyscanner ); - -int yyget_column ( yyscan_t yyscanner ); - -void yyset_column ( int _column_no , yyscan_t yyscanner ); - -/* Macros after this point can all be overridden by user definitions in - * section 1. - */ - -#ifndef YY_SKIP_YYWRAP -#ifdef __cplusplus -extern "C" int yywrap ( yyscan_t yyscanner ); -#else -extern int yywrap ( yyscan_t yyscanner ); -#endif -#endif - -#ifndef yytext_ptr -static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner); -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen ( const char * , yyscan_t yyscanner); -#endif - -#ifndef YY_NO_INPUT - -#endif - -/* Amount of stuff to slurp up with each read. */ -#ifndef YY_READ_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k */ -#define YY_READ_BUF_SIZE 16384 -#else -#define YY_READ_BUF_SIZE 8192 -#endif /* __ia64__ */ -#endif - -/* Number of entries by which start-condition stack grows. */ -#ifndef YY_START_STACK_INCR -#define YY_START_STACK_INCR 25 -#endif - -/* Default declaration of generated scanner - a define so the user can - * easily add parameters. - */ -#ifndef YY_DECL -#define YY_DECL_IS_OURS 1 - -extern int yylex (yyscan_t yyscanner); - -#define YY_DECL int yylex (yyscan_t yyscanner) -#endif /* !YY_DECL */ - -/* yy_get_previous_state - get the state just before the EOB char was reached */ - -#undef YY_NEW_FILE -#undef YY_FLUSH_BUFFER -#undef yy_set_bol -#undef yy_new_buffer -#undef yy_set_interactive -#undef YY_DO_BEFORE_ACTION - -#ifdef YY_DECL_IS_OURS -#undef YY_DECL_IS_OURS -#undef YY_DECL -#endif - -#ifndef cmCTestProcesses_yy_create_buffer_ALREADY_DEFINED -#undef yy_create_buffer -#endif -#ifndef cmCTestProcesses_yy_delete_buffer_ALREADY_DEFINED -#undef yy_delete_buffer -#endif -#ifndef cmCTestProcesses_yy_scan_buffer_ALREADY_DEFINED -#undef yy_scan_buffer -#endif -#ifndef cmCTestProcesses_yy_scan_string_ALREADY_DEFINED -#undef yy_scan_string -#endif -#ifndef cmCTestProcesses_yy_scan_bytes_ALREADY_DEFINED -#undef yy_scan_bytes -#endif -#ifndef cmCTestProcesses_yy_init_buffer_ALREADY_DEFINED -#undef yy_init_buffer -#endif -#ifndef cmCTestProcesses_yy_flush_buffer_ALREADY_DEFINED -#undef yy_flush_buffer -#endif -#ifndef cmCTestProcesses_yy_load_buffer_state_ALREADY_DEFINED -#undef yy_load_buffer_state -#endif -#ifndef cmCTestProcesses_yy_switch_to_buffer_ALREADY_DEFINED -#undef yy_switch_to_buffer -#endif -#ifndef cmCTestProcesses_yypush_buffer_state_ALREADY_DEFINED -#undef yypush_buffer_state -#endif -#ifndef cmCTestProcesses_yypop_buffer_state_ALREADY_DEFINED -#undef yypop_buffer_state -#endif -#ifndef cmCTestProcesses_yyensure_buffer_stack_ALREADY_DEFINED -#undef yyensure_buffer_stack -#endif -#ifndef cmCTestProcesses_yylex_ALREADY_DEFINED -#undef yylex -#endif -#ifndef cmCTestProcesses_yyrestart_ALREADY_DEFINED -#undef yyrestart -#endif -#ifndef cmCTestProcesses_yylex_init_ALREADY_DEFINED -#undef yylex_init -#endif -#ifndef cmCTestProcesses_yylex_init_extra_ALREADY_DEFINED -#undef yylex_init_extra -#endif -#ifndef cmCTestProcesses_yylex_destroy_ALREADY_DEFINED -#undef yylex_destroy -#endif -#ifndef cmCTestProcesses_yyget_debug_ALREADY_DEFINED -#undef yyget_debug -#endif -#ifndef cmCTestProcesses_yyset_debug_ALREADY_DEFINED -#undef yyset_debug -#endif -#ifndef cmCTestProcesses_yyget_extra_ALREADY_DEFINED -#undef yyget_extra -#endif -#ifndef cmCTestProcesses_yyset_extra_ALREADY_DEFINED -#undef yyset_extra -#endif -#ifndef cmCTestProcesses_yyget_in_ALREADY_DEFINED -#undef yyget_in -#endif -#ifndef cmCTestProcesses_yyset_in_ALREADY_DEFINED -#undef yyset_in -#endif -#ifndef cmCTestProcesses_yyget_out_ALREADY_DEFINED -#undef yyget_out -#endif -#ifndef cmCTestProcesses_yyset_out_ALREADY_DEFINED -#undef yyset_out -#endif -#ifndef cmCTestProcesses_yyget_leng_ALREADY_DEFINED -#undef yyget_leng -#endif -#ifndef cmCTestProcesses_yyget_text_ALREADY_DEFINED -#undef yyget_text -#endif -#ifndef cmCTestProcesses_yyget_lineno_ALREADY_DEFINED -#undef yyget_lineno -#endif -#ifndef cmCTestProcesses_yyset_lineno_ALREADY_DEFINED -#undef yyset_lineno -#endif -#ifndef cmCTestProcesses_yyget_column_ALREADY_DEFINED -#undef yyget_column -#endif -#ifndef cmCTestProcesses_yyset_column_ALREADY_DEFINED -#undef yyset_column -#endif -#ifndef cmCTestProcesses_yywrap_ALREADY_DEFINED -#undef yywrap -#endif -#ifndef cmCTestProcesses_yyget_lval_ALREADY_DEFINED -#undef yyget_lval -#endif -#ifndef cmCTestProcesses_yyset_lval_ALREADY_DEFINED -#undef yyset_lval -#endif -#ifndef cmCTestProcesses_yyget_lloc_ALREADY_DEFINED -#undef yyget_lloc -#endif -#ifndef cmCTestProcesses_yyset_lloc_ALREADY_DEFINED -#undef yyset_lloc -#endif -#ifndef cmCTestProcesses_yyalloc_ALREADY_DEFINED -#undef yyalloc -#endif -#ifndef cmCTestProcesses_yyrealloc_ALREADY_DEFINED -#undef yyrealloc -#endif -#ifndef cmCTestProcesses_yyfree_ALREADY_DEFINED -#undef yyfree -#endif -#ifndef cmCTestProcesses_yytext_ALREADY_DEFINED -#undef yytext -#endif -#ifndef cmCTestProcesses_yyleng_ALREADY_DEFINED -#undef yyleng -#endif -#ifndef cmCTestProcesses_yyin_ALREADY_DEFINED -#undef yyin -#endif -#ifndef cmCTestProcesses_yyout_ALREADY_DEFINED -#undef yyout -#endif -#ifndef cmCTestProcesses_yy_flex_debug_ALREADY_DEFINED -#undef yy_flex_debug -#endif -#ifndef cmCTestProcesses_yylineno_ALREADY_DEFINED -#undef yylineno -#endif -#ifndef cmCTestProcesses_yytables_fload_ALREADY_DEFINED -#undef yytables_fload -#endif -#ifndef cmCTestProcesses_yytables_destroy_ALREADY_DEFINED -#undef yytables_destroy -#endif -#ifndef cmCTestProcesses_yyTABLES_NAME_ALREADY_DEFINED -#undef yyTABLES_NAME -#endif - -#undef cmCTestProcesses_yyIN_HEADER -#endif /* cmCTestProcesses_yyHEADER_H */ diff --git a/Source/LexerParser/cmCTestProcessesLexer.in.l b/Source/LexerParser/cmCTestProcessesLexer.in.l deleted file mode 100644 index ef494d5..0000000 --- a/Source/LexerParser/cmCTestProcessesLexer.in.l +++ /dev/null @@ -1,102 +0,0 @@ -%{ -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ -/* - -This file must be translated to C++ and modified to build everywhere. - -Run flex >= 2.6 like this: - - flex --nounistd -DFLEXINT_H --noline --header-file=cmCTestProcessesLexer.h -ocmCTestProcessesLexer.cxx cmCTestProcessesLexer.in.l - -Modify cmCTestProcessesLexer.cxx: - - remove trailing whitespace: sed -i 's/\s*$//' cmCTestProcessesLexer.h cmCTestProcessesLexer.cxx - - remove blank lines at end of file: sed -i '${/^$/d;}' cmCTestProcessesLexer.h cmCTestProcessesLexer.cxx - - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmCTestProcessesLexer.cxx - -*/ - -/* IWYU pragma: no_forward_declare yyguts_t */ - -#ifndef __clang_analyzer__ /* Suppress clang scan-build warnings */ - -#include "cmCTestProcessesLexerHelper.h" - -#include - -#include - -/*--------------------------------------------------------------------------*/ -%} - -%option prefix="cmCTestProcesses_yy" - -%option reentrant -%option noyywrap -%option nodefault -%pointer - -%s PROCESSES_START -%s PROCESSES_END -%s RESOURCE_START -%s RESOURCE_COUNT -%s RESOURCE_END - -NUMBER [0-9]+ -IDENTIFIER [a-z_][a-z0-9_]* - -%% - -{IDENTIFIER}: { - BEGIN(RESOURCE_COUNT); - yyextra->SetResourceType(std::string(yytext, yyleng - 1)); -} - -{NUMBER} { - BEGIN(PROCESSES_END); - std::size_t len = yyleng; - yyextra->SetProcessCount(std::stoll(yytext, &len, 10)); -} - -{NUMBER} { - BEGIN(RESOURCE_END); - std::size_t len = yyleng; - yyextra->SetNeededSlots(std::stoll(yytext, &len, 10)); - yyextra->WriteRequirement(); -} - -,+ { - BEGIN(RESOURCE_START); -} - -;+ { - BEGIN(PROCESSES_START); -} - -;+ { - BEGIN(PROCESSES_START); - yyextra->WriteProcess(); -} - -<> { - yyextra->WriteProcess(); - return 0; -} - -<> { - return 0; -} - -<> { - return 1; -} - -.|\n { - return 1; -} - -%% - -/*--------------------------------------------------------------------------*/ - -#endif /* __clang_analyzer__ */ diff --git a/Source/LexerParser/cmCTestResourceGroupsLexer.cxx b/Source/LexerParser/cmCTestResourceGroupsLexer.cxx new file mode 100644 index 0000000..de07c46 --- /dev/null +++ b/Source/LexerParser/cmCTestResourceGroupsLexer.cxx @@ -0,0 +1,2224 @@ +#include "cmStandardLexer.h" + +#define FLEXINT_H 1 +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +#ifdef yy_create_buffer +#define cmCTestResourceGroups_yy_create_buffer_ALREADY_DEFINED +#else +#define yy_create_buffer cmCTestResourceGroups_yy_create_buffer +#endif + +#ifdef yy_delete_buffer +#define cmCTestResourceGroups_yy_delete_buffer_ALREADY_DEFINED +#else +#define yy_delete_buffer cmCTestResourceGroups_yy_delete_buffer +#endif + +#ifdef yy_scan_buffer +#define cmCTestResourceGroups_yy_scan_buffer_ALREADY_DEFINED +#else +#define yy_scan_buffer cmCTestResourceGroups_yy_scan_buffer +#endif + +#ifdef yy_scan_string +#define cmCTestResourceGroups_yy_scan_string_ALREADY_DEFINED +#else +#define yy_scan_string cmCTestResourceGroups_yy_scan_string +#endif + +#ifdef yy_scan_bytes +#define cmCTestResourceGroups_yy_scan_bytes_ALREADY_DEFINED +#else +#define yy_scan_bytes cmCTestResourceGroups_yy_scan_bytes +#endif + +#ifdef yy_init_buffer +#define cmCTestResourceGroups_yy_init_buffer_ALREADY_DEFINED +#else +#define yy_init_buffer cmCTestResourceGroups_yy_init_buffer +#endif + +#ifdef yy_flush_buffer +#define cmCTestResourceGroups_yy_flush_buffer_ALREADY_DEFINED +#else +#define yy_flush_buffer cmCTestResourceGroups_yy_flush_buffer +#endif + +#ifdef yy_load_buffer_state +#define cmCTestResourceGroups_yy_load_buffer_state_ALREADY_DEFINED +#else +#define yy_load_buffer_state cmCTestResourceGroups_yy_load_buffer_state +#endif + +#ifdef yy_switch_to_buffer +#define cmCTestResourceGroups_yy_switch_to_buffer_ALREADY_DEFINED +#else +#define yy_switch_to_buffer cmCTestResourceGroups_yy_switch_to_buffer +#endif + +#ifdef yypush_buffer_state +#define cmCTestResourceGroups_yypush_buffer_state_ALREADY_DEFINED +#else +#define yypush_buffer_state cmCTestResourceGroups_yypush_buffer_state +#endif + +#ifdef yypop_buffer_state +#define cmCTestResourceGroups_yypop_buffer_state_ALREADY_DEFINED +#else +#define yypop_buffer_state cmCTestResourceGroups_yypop_buffer_state +#endif + +#ifdef yyensure_buffer_stack +#define cmCTestResourceGroups_yyensure_buffer_stack_ALREADY_DEFINED +#else +#define yyensure_buffer_stack cmCTestResourceGroups_yyensure_buffer_stack +#endif + +#ifdef yylex +#define cmCTestResourceGroups_yylex_ALREADY_DEFINED +#else +#define yylex cmCTestResourceGroups_yylex +#endif + +#ifdef yyrestart +#define cmCTestResourceGroups_yyrestart_ALREADY_DEFINED +#else +#define yyrestart cmCTestResourceGroups_yyrestart +#endif + +#ifdef yylex_init +#define cmCTestResourceGroups_yylex_init_ALREADY_DEFINED +#else +#define yylex_init cmCTestResourceGroups_yylex_init +#endif + +#ifdef yylex_init_extra +#define cmCTestResourceGroups_yylex_init_extra_ALREADY_DEFINED +#else +#define yylex_init_extra cmCTestResourceGroups_yylex_init_extra +#endif + +#ifdef yylex_destroy +#define cmCTestResourceGroups_yylex_destroy_ALREADY_DEFINED +#else +#define yylex_destroy cmCTestResourceGroups_yylex_destroy +#endif + +#ifdef yyget_debug +#define cmCTestResourceGroups_yyget_debug_ALREADY_DEFINED +#else +#define yyget_debug cmCTestResourceGroups_yyget_debug +#endif + +#ifdef yyset_debug +#define cmCTestResourceGroups_yyset_debug_ALREADY_DEFINED +#else +#define yyset_debug cmCTestResourceGroups_yyset_debug +#endif + +#ifdef yyget_extra +#define cmCTestResourceGroups_yyget_extra_ALREADY_DEFINED +#else +#define yyget_extra cmCTestResourceGroups_yyget_extra +#endif + +#ifdef yyset_extra +#define cmCTestResourceGroups_yyset_extra_ALREADY_DEFINED +#else +#define yyset_extra cmCTestResourceGroups_yyset_extra +#endif + +#ifdef yyget_in +#define cmCTestResourceGroups_yyget_in_ALREADY_DEFINED +#else +#define yyget_in cmCTestResourceGroups_yyget_in +#endif + +#ifdef yyset_in +#define cmCTestResourceGroups_yyset_in_ALREADY_DEFINED +#else +#define yyset_in cmCTestResourceGroups_yyset_in +#endif + +#ifdef yyget_out +#define cmCTestResourceGroups_yyget_out_ALREADY_DEFINED +#else +#define yyget_out cmCTestResourceGroups_yyget_out +#endif + +#ifdef yyset_out +#define cmCTestResourceGroups_yyset_out_ALREADY_DEFINED +#else +#define yyset_out cmCTestResourceGroups_yyset_out +#endif + +#ifdef yyget_leng +#define cmCTestResourceGroups_yyget_leng_ALREADY_DEFINED +#else +#define yyget_leng cmCTestResourceGroups_yyget_leng +#endif + +#ifdef yyget_text +#define cmCTestResourceGroups_yyget_text_ALREADY_DEFINED +#else +#define yyget_text cmCTestResourceGroups_yyget_text +#endif + +#ifdef yyget_lineno +#define cmCTestResourceGroups_yyget_lineno_ALREADY_DEFINED +#else +#define yyget_lineno cmCTestResourceGroups_yyget_lineno +#endif + +#ifdef yyset_lineno +#define cmCTestResourceGroups_yyset_lineno_ALREADY_DEFINED +#else +#define yyset_lineno cmCTestResourceGroups_yyset_lineno +#endif + +#ifdef yyget_column +#define cmCTestResourceGroups_yyget_column_ALREADY_DEFINED +#else +#define yyget_column cmCTestResourceGroups_yyget_column +#endif + +#ifdef yyset_column +#define cmCTestResourceGroups_yyset_column_ALREADY_DEFINED +#else +#define yyset_column cmCTestResourceGroups_yyset_column +#endif + +#ifdef yywrap +#define cmCTestResourceGroups_yywrap_ALREADY_DEFINED +#else +#define yywrap cmCTestResourceGroups_yywrap +#endif + +#ifdef yyalloc +#define cmCTestResourceGroups_yyalloc_ALREADY_DEFINED +#else +#define yyalloc cmCTestResourceGroups_yyalloc +#endif + +#ifdef yyrealloc +#define cmCTestResourceGroups_yyrealloc_ALREADY_DEFINED +#else +#define yyrealloc cmCTestResourceGroups_yyrealloc +#endif + +#ifdef yyfree +#define cmCTestResourceGroups_yyfree_ALREADY_DEFINED +#else +#define yyfree cmCTestResourceGroups_yyfree +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. + */ +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) + +/* An opaque pointer. */ +#ifndef YY_TYPEDEF_YY_SCANNER_T +#define YY_TYPEDEF_YY_SCANNER_T +typedef void* yyscan_t; +#endif + +/* For convenience, these vars (plus the bison vars far below) + are macros in the reentrant scanner. */ +#define yyin yyg->yyin_r +#define yyout yyg->yyout_r +#define yyextra yyg->yyextra_r +#define yyleng yyg->yyleng_r +#define yytext yyg->yytext_r +#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) +#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) +#define yy_flex_debug yyg->yy_flex_debug_r + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yyg->yy_start = 1 + 2 * +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yyg->yy_start - 1) / 2) +#define YYSTATE YY_START +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin , yyscanner ) +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + #define YY_LINENO_REWIND_TO(ptr) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = yyg->yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) +#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ + ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] + +void yyrestart ( FILE *input_file , yyscan_t yyscanner ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner ); +void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); +void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); +void yypop_buffer_state ( yyscan_t yyscanner ); + +static void yyensure_buffer_stack ( yyscan_t yyscanner ); +static void yy_load_buffer_state ( yyscan_t yyscanner ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner) + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner ); + +void *yyalloc ( yy_size_t , yyscan_t yyscanner ); +void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner ); +void yyfree ( void * , yyscan_t yyscanner ); + +#define yy_new_buffer yy_create_buffer +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (yyscanner); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (yyscanner); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ + +#define cmCTestResourceGroups_yywrap(yyscanner) (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP +typedef flex_uint8_t YY_CHAR; + +typedef int yy_state_type; + +#define yytext_ptr yytext_r + +static yy_state_type yy_get_previous_state ( yyscan_t yyscanner ); +static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner); +static int yy_get_next_buffer ( yyscan_t yyscanner ); +static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yyg->yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yyg->yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yyg->yy_c_buf_p = yy_cp; +#define YY_NUM_RULES 8 +#define YY_END_OF_BUFFER 9 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static const flex_int16_t yy_accept[29] = + { 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 9, 7, 2, 5, 7, 4, 6, 3, + 2, 5, 0, 1, 4, 6, 3, 0 + } ; + +static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 3, 1, 1, 1, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 5, 6, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 7, 1, 7, 7, 7, 7, + + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static const YY_CHAR yy_meta[8] = + { 0, + 1, 1, 1, 2, 2, 1, 2 + } ; + +static const flex_int16_t yy_base[30] = + { 0, + 0, 0, 0, 0, 7, 0, 31, 12, 17, 0, + 0, 0, 34, 36, 29, 26, 26, 27, 23, 24, + 23, 20, 20, 36, 21, 16, 13, 36, 14 + } ; + +static const flex_int16_t yy_def[30] = + { 0, + 28, 1, 1, 1, 28, 5, 1, 5, 5, 9, + 5, 5, 28, 28, 28, 28, 29, 28, 28, 28, + 28, 28, 29, 28, 28, 28, 28, 0, 28 + } ; + +static const flex_int16_t yy_nxt[44] = + { 0, + 14, 14, 14, 15, 14, 16, 17, 14, 14, 18, + 14, 14, 19, 14, 14, 23, 27, 16, 17, 14, + 20, 26, 14, 25, 24, 22, 21, 27, 26, 25, + 24, 22, 21, 28, 14, 13, 28, 28, 28, 28, + 28, 28, 28 + } ; + +static const flex_int16_t yy_chk[44] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 5, 5, 5, + 5, 5, 5, 5, 8, 29, 27, 8, 8, 9, + 9, 26, 9, 25, 23, 22, 21, 20, 19, 18, + 17, 16, 15, 13, 7, 28, 28, 28, 28, 28, + 28, 28, 28 + } ; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ +/* + +This file must be translated to C++ and modified to build everywhere. + +Run flex >= 2.6 like this: + + flex --nounistd -DFLEXINT_H --noline --header-file=cmCTestResourceGroupsLexer.h -ocmCTestResourceGroupsLexer.cxx cmCTestResourceGroupsLexer.in.l + +Modify cmCTestResourceGroupsLexer.cxx: + - remove trailing whitespace: sed -i 's/\s*$//' cmCTestResourceGroupsLexer.h cmCTestResourceGroupsLexer.cxx + - remove blank lines at end of file: sed -i '${/^$/d;}' cmCTestResourceGroupsLexer.h cmCTestResourceGroupsLexer.cxx + - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmCTestResourceGroupsLexer.cxx + +*/ + +/* IWYU pragma: no_forward_declare yyguts_t */ + +#ifndef __clang_analyzer__ /* Suppress clang scan-build warnings */ + +#include "cmCTestResourceGroupsLexerHelper.h" + +#include + +#include + +/*--------------------------------------------------------------------------*/ + +#define INITIAL 0 +#define RESOURCE_GROUPS_START 1 +#define RESOURCE_GROUPS_END 2 +#define RESOURCE_START 3 +#define RESOURCE_COUNT 4 +#define RESOURCE_END 5 + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +/* Holds the entire state of the reentrant scanner. */ +struct yyguts_t + { + + /* User-defined. Not touched by flex. */ + YY_EXTRA_TYPE yyextra_r; + + /* The rest are the same as the globals declared in the non-reentrant scanner. */ + FILE *yyin_r, *yyout_r; + size_t yy_buffer_stack_top; /**< index of top of stack. */ + size_t yy_buffer_stack_max; /**< capacity of stack. */ + YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ + char yy_hold_char; + int yy_n_chars; + int yyleng_r; + char *yy_c_buf_p; + int yy_init; + int yy_start; + int yy_did_buffer_switch_on_eof; + int yy_start_stack_ptr; + int yy_start_stack_depth; + int *yy_start_stack; + yy_state_type yy_last_accepting_state; + char* yy_last_accepting_cpos; + + int yylineno_r; + int yy_flex_debug_r; + + char *yytext_r; + int yy_more_flag; + int yy_more_len; + + }; /* end struct yyguts_t */ + +static int yy_init_globals ( yyscan_t yyscanner ); + +int yylex_init (yyscan_t* scanner); + +int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( yyscan_t yyscanner ); + +int yyget_debug ( yyscan_t yyscanner ); + +void yyset_debug ( int debug_flag , yyscan_t yyscanner ); + +YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner ); + +FILE *yyget_in ( yyscan_t yyscanner ); + +void yyset_in ( FILE * _in_str , yyscan_t yyscanner ); + +FILE *yyget_out ( yyscan_t yyscanner ); + +void yyset_out ( FILE * _out_str , yyscan_t yyscanner ); + + int yyget_leng ( yyscan_t yyscanner ); + +char *yyget_text ( yyscan_t yyscanner ); + +int yyget_lineno ( yyscan_t yyscanner ); + +void yyset_lineno ( int _line_number , yyscan_t yyscanner ); + +int yyget_column ( yyscan_t yyscanner ); + +void yyset_column ( int _column_no , yyscan_t yyscanner ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( yyscan_t yyscanner ); +#else +extern int yywrap ( yyscan_t yyscanner ); +#endif +#endif + +#ifndef YY_NO_UNPUT + + static void yyunput ( int c, char *buf_ptr , yyscan_t yyscanner); + +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * , yyscan_t yyscanner); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput ( yyscan_t yyscanner ); +#else +static int input ( yyscan_t yyscanner ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + int n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (yyscan_t yyscanner); + +#define YY_DECL int yylex (yyscan_t yyscanner) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK /*LINTED*/break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if ( !yyg->yy_init ) + { + yyg->yy_init = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yyg->yy_start ) + yyg->yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (yyscanner); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); + } + + yy_load_buffer_state( yyscanner ); + } + + { + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { + yy_cp = yyg->yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yyg->yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yyg->yy_start; +yy_match: + do + { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + yyg->yy_last_accepting_state = yy_current_state; + yyg->yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 29 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 36 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yyg->yy_last_accepting_cpos; + yy_current_state = yyg->yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yyg->yy_hold_char; + yy_cp = yyg->yy_last_accepting_cpos; + yy_current_state = yyg->yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +{ + BEGIN(RESOURCE_COUNT); + yyextra->SetResourceType(std::string(yytext, yyleng - 1)); +} + YY_BREAK +case 2: +YY_RULE_SETUP +{ + BEGIN(RESOURCE_GROUPS_END); + std::size_t len = yyleng; + yyextra->SetProcessCount(std::stoll(yytext, &len, 10)); +} + YY_BREAK +case 3: +YY_RULE_SETUP +{ + BEGIN(RESOURCE_END); + std::size_t len = yyleng; + yyextra->SetNeededSlots(std::stoll(yytext, &len, 10)); + yyextra->WriteRequirement(); +} + YY_BREAK +case 4: +YY_RULE_SETUP +{ + BEGIN(RESOURCE_START); +} + YY_BREAK +case 5: +YY_RULE_SETUP +{ + BEGIN(RESOURCE_GROUPS_START); +} + YY_BREAK +case 6: +YY_RULE_SETUP +{ + BEGIN(RESOURCE_GROUPS_START); + yyextra->WriteProcess(); +} + YY_BREAK +case YY_STATE_EOF(RESOURCE_START): +case YY_STATE_EOF(RESOURCE_GROUPS_END): +case YY_STATE_EOF(RESOURCE_END): +{ + yyextra->WriteProcess(); + return 0; +} + YY_BREAK +case YY_STATE_EOF(INITIAL): +case YY_STATE_EOF(RESOURCE_GROUPS_START): +{ + return 0; +} + YY_BREAK +case YY_STATE_EOF(RESOURCE_COUNT): +{ + return 1; +} + YY_BREAK +case 7: +/* rule 7 can match eol */ +YY_RULE_SETUP +{ + return 1; +} + YY_BREAK +case 8: +YY_RULE_SETUP +YY_FATAL_ERROR( "flex scanner jammed" ); + YY_BREAK + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yyg->yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( yyscanner ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); + + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yyg->yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yyg->yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( yyscanner ) ) + { + case EOB_ACT_END_OF_FILE: + { + yyg->yy_did_buffer_switch_on_eof = 0; + + if ( yywrap( yyscanner ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yyg->yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yyg->yy_c_buf_p = + yyg->yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( yyscanner ); + + yy_cp = yyg->yy_c_buf_p; + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yyg->yy_c_buf_p = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; + + yy_current_state = yy_get_previous_state( yyscanner ); + + yy_cp = yyg->yy_c_buf_p; + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ +} /* end of yylex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = yyg->yytext_ptr; + int number_to_move, i; + int ret_val; + + if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) (yyg->yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + yyg->yy_n_chars, num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + if ( yyg->yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin , yyscanner); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + yyg->yy_n_chars += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (yyscan_t yyscanner) +{ + yy_state_type yy_current_state; + char *yy_cp; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + yy_current_state = yyg->yy_start; + + for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) + { + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yyg->yy_last_accepting_state = yy_current_state; + yyg->yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 29 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) +{ + int yy_is_jam; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ + char *yy_cp = yyg->yy_c_buf_p; + + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yyg->yy_last_accepting_state = yy_current_state; + yyg->yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 29 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 28); + + (void)yyg; + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_UNPUT + + static void yyunput (int c, char * yy_bp , yyscan_t yyscanner) +{ + char *yy_cp; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + yy_cp = yyg->yy_c_buf_p; + + /* undo effects of setting up yytext */ + *yy_cp = yyg->yy_hold_char; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + { /* need to shift things up to make room */ + /* +2 for EOB chars. */ + int number_to_move = yyg->yy_n_chars + 2; + char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; + char *source = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; + + while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + *--dest = *--source; + + yy_cp += (int) (dest - source); + yy_bp += (int) (dest - source); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = + yyg->yy_n_chars = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size; + + if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) + YY_FATAL_ERROR( "flex scanner push-back overflow" ); + } + + *--yy_cp = (char) c; + + yyg->yytext_ptr = yy_bp; + yyg->yy_hold_char = *yy_cp; + yyg->yy_c_buf_p = yy_cp; +} + +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (yyscan_t yyscanner) +#else + static int input (yyscan_t yyscanner) +#endif + +{ + int c; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + *yyg->yy_c_buf_p = yyg->yy_hold_char; + + if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) + /* This was really a NUL. */ + *yyg->yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr); + ++yyg->yy_c_buf_p; + + switch ( yy_get_next_buffer( yyscanner ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin , yyscanner); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( yyscanner ) ) + return 0; + + if ( ! yyg->yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(yyscanner); +#else + return input(yyscanner); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yyg->yy_c_buf_p = yyg->yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */ + *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ + yyg->yy_hold_char = *++yyg->yy_c_buf_p; + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * @param yyscanner The scanner object. + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (yyscanner); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); + yy_load_buffer_state( yyscanner ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * @param yyscanner The scanner object. + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (yyscanner); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *yyg->yy_c_buf_p = yyg->yy_hold_char; + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( yyscanner ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yyg->yy_did_buffer_switch_on_eof = 1; +} + +static void yy_load_buffer_state (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + yyg->yy_hold_char = *yyg->yy_c_buf_p; +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * @param yyscanner The scanner object. + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file , yyscanner); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * @param yyscanner The scanner object. + */ + void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree( (void *) b->yy_ch_buf , yyscanner ); + + yyfree( (void *) b , yyscanner ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) + +{ + int oerrno = errno; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + yy_flush_buffer( b , yyscanner); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * @param yyscanner The scanner object. + */ + void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( yyscanner ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * @param yyscanner The scanner object. + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(yyscanner); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *yyg->yy_c_buf_p = yyg->yy_hold_char; + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + yyg->yy_buffer_stack_top++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( yyscanner ); + yyg->yy_did_buffer_switch_on_eof = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * @param yyscanner The scanner object. + */ +void yypop_buffer_state (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); + YY_CURRENT_BUFFER_LVALUE = NULL; + if (yyg->yy_buffer_stack_top > 0) + --yyg->yy_buffer_stack_top; + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( yyscanner ); + yyg->yy_did_buffer_switch_on_eof = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (yyscan_t yyscanner) +{ + yy_size_t num_to_alloc; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (!yyg->yy_buffer_stack) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + , yyscanner); + if ( ! yyg->yy_buffer_stack ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + yyg->yy_buffer_stack_max = num_to_alloc; + yyg->yy_buffer_stack_top = 0; + return; + } + + if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = yyg->yy_buffer_stack_max + grow_size; + yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc + (yyg->yy_buffer_stack, + num_to_alloc * sizeof(struct yy_buffer_state*) + , yyscanner); + if ( ! yyg->yy_buffer_stack ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); + yyg->yy_buffer_stack_max = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return NULL; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b , yyscanner ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner) +{ + + return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); +} + +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n , yyscanner ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n , yyscanner); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = yyg->yy_hold_char; \ + yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ + yyg->yy_hold_char = *yyg->yy_c_buf_p; \ + *yyg->yy_c_buf_p = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the user-defined data for this scanner. + * @param yyscanner The scanner object. + */ +YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyextra; +} + +/** Get the current line number. + * @param yyscanner The scanner object. + */ +int yyget_lineno (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (! YY_CURRENT_BUFFER) + return 0; + + return yylineno; +} + +/** Get the current column number. + * @param yyscanner The scanner object. + */ +int yyget_column (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (! YY_CURRENT_BUFFER) + return 0; + + return yycolumn; +} + +/** Get the input stream. + * @param yyscanner The scanner object. + */ +FILE *yyget_in (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyin; +} + +/** Get the output stream. + * @param yyscanner The scanner object. + */ +FILE *yyget_out (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyout; +} + +/** Get the length of the current token. + * @param yyscanner The scanner object. + */ +int yyget_leng (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyleng; +} + +/** Get the current token. + * @param yyscanner The scanner object. + */ + +char *yyget_text (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yytext; +} + +/** Set the user-defined data. This data is never touched by the scanner. + * @param user_defined The data to be associated with this scanner. + * @param yyscanner The scanner object. + */ +void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyextra = user_defined ; +} + +/** Set the current line number. + * @param _line_number line number + * @param yyscanner The scanner object. + */ +void yyset_lineno (int _line_number , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* lineno is only valid if an input buffer exists. */ + if (! YY_CURRENT_BUFFER ) + YY_FATAL_ERROR( "yyset_lineno called with no buffer" ); + + yylineno = _line_number; +} + +/** Set the current column. + * @param _column_no column number + * @param yyscanner The scanner object. + */ +void yyset_column (int _column_no , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* column is only valid if an input buffer exists. */ + if (! YY_CURRENT_BUFFER ) + YY_FATAL_ERROR( "yyset_column called with no buffer" ); + + yycolumn = _column_no; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param _in_str A readable stream. + * @param yyscanner The scanner object. + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * _in_str , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyin = _in_str ; +} + +void yyset_out (FILE * _out_str , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyout = _out_str ; +} + +int yyget_debug (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yy_flex_debug; +} + +void yyset_debug (int _bdebug , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yy_flex_debug = _bdebug ; +} + +/* Accessor methods for yylval and yylloc */ + +/* User-visible API */ + +/* yylex_init is special because it creates the scanner itself, so it is + * the ONLY reentrant function that doesn't take the scanner as the last argument. + * That's why we explicitly handle the declaration, instead of using our macros. + */ +int yylex_init(yyscan_t* ptr_yy_globals) +{ + if (ptr_yy_globals == NULL){ + errno = EINVAL; + return 1; + } + + *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); + + if (*ptr_yy_globals == NULL){ + errno = ENOMEM; + return 1; + } + + /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ + memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); + + return yy_init_globals ( *ptr_yy_globals ); +} + +/* yylex_init_extra has the same functionality as yylex_init, but follows the + * convention of taking the scanner as the last argument. Note however, that + * this is a *pointer* to a scanner, as it will be allocated by this call (and + * is the reason, too, why this function also must handle its own declaration). + * The user defined value in the first argument will be available to yyalloc in + * the yyextra field. + */ +int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals ) +{ + struct yyguts_t dummy_yyguts; + + yyset_extra (yy_user_defined, &dummy_yyguts); + + if (ptr_yy_globals == NULL){ + errno = EINVAL; + return 1; + } + + *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); + + if (*ptr_yy_globals == NULL){ + errno = ENOMEM; + return 1; + } + + /* By setting to 0xAA, we expose bugs in + yy_init_globals. Leave at 0x00 for releases. */ + memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); + + yyset_extra (yy_user_defined, *ptr_yy_globals); + + return yy_init_globals ( *ptr_yy_globals ); +} + +static int yy_init_globals (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + yyg->yy_buffer_stack = NULL; + yyg->yy_buffer_stack_top = 0; + yyg->yy_buffer_stack_max = 0; + yyg->yy_c_buf_p = NULL; + yyg->yy_init = 0; + yyg->yy_start = 0; + + yyg->yy_start_stack_ptr = 0; + yyg->yy_start_stack_depth = 0; + yyg->yy_start_stack = NULL; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = NULL; + yyout = NULL; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} + +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(yyscanner); + } + + /* Destroy the stack itself. */ + yyfree(yyg->yy_buffer_stack , yyscanner); + yyg->yy_buffer_stack = NULL; + + /* Destroy the start condition stack. */ + yyfree( yyg->yy_start_stack , yyscanner ); + yyg->yy_start_stack = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( yyscanner); + + /* Destroy the main struct (reentrant only). */ + yyfree ( yyscanner , yyscanner ); + yyscanner = NULL; + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + + int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (const char * s , yyscan_t yyscanner) +{ + int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + return malloc(size); +} + +void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return realloc(ptr, size); +} + +void yyfree (void * ptr , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +/*--------------------------------------------------------------------------*/ + +#endif /* __clang_analyzer__ */ diff --git a/Source/LexerParser/cmCTestResourceGroupsLexer.h b/Source/LexerParser/cmCTestResourceGroupsLexer.h new file mode 100644 index 0000000..e323a50 --- /dev/null +++ b/Source/LexerParser/cmCTestResourceGroupsLexer.h @@ -0,0 +1,692 @@ +#ifndef cmCTestResourceGroups_yyHEADER_H +#define cmCTestResourceGroups_yyHEADER_H 1 +#define cmCTestResourceGroups_yyIN_HEADER 1 + +#define FLEXINT_H 1 +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +#ifdef yy_create_buffer +#define cmCTestResourceGroups_yy_create_buffer_ALREADY_DEFINED +#else +#define yy_create_buffer cmCTestResourceGroups_yy_create_buffer +#endif + +#ifdef yy_delete_buffer +#define cmCTestResourceGroups_yy_delete_buffer_ALREADY_DEFINED +#else +#define yy_delete_buffer cmCTestResourceGroups_yy_delete_buffer +#endif + +#ifdef yy_scan_buffer +#define cmCTestResourceGroups_yy_scan_buffer_ALREADY_DEFINED +#else +#define yy_scan_buffer cmCTestResourceGroups_yy_scan_buffer +#endif + +#ifdef yy_scan_string +#define cmCTestResourceGroups_yy_scan_string_ALREADY_DEFINED +#else +#define yy_scan_string cmCTestResourceGroups_yy_scan_string +#endif + +#ifdef yy_scan_bytes +#define cmCTestResourceGroups_yy_scan_bytes_ALREADY_DEFINED +#else +#define yy_scan_bytes cmCTestResourceGroups_yy_scan_bytes +#endif + +#ifdef yy_init_buffer +#define cmCTestResourceGroups_yy_init_buffer_ALREADY_DEFINED +#else +#define yy_init_buffer cmCTestResourceGroups_yy_init_buffer +#endif + +#ifdef yy_flush_buffer +#define cmCTestResourceGroups_yy_flush_buffer_ALREADY_DEFINED +#else +#define yy_flush_buffer cmCTestResourceGroups_yy_flush_buffer +#endif + +#ifdef yy_load_buffer_state +#define cmCTestResourceGroups_yy_load_buffer_state_ALREADY_DEFINED +#else +#define yy_load_buffer_state cmCTestResourceGroups_yy_load_buffer_state +#endif + +#ifdef yy_switch_to_buffer +#define cmCTestResourceGroups_yy_switch_to_buffer_ALREADY_DEFINED +#else +#define yy_switch_to_buffer cmCTestResourceGroups_yy_switch_to_buffer +#endif + +#ifdef yypush_buffer_state +#define cmCTestResourceGroups_yypush_buffer_state_ALREADY_DEFINED +#else +#define yypush_buffer_state cmCTestResourceGroups_yypush_buffer_state +#endif + +#ifdef yypop_buffer_state +#define cmCTestResourceGroups_yypop_buffer_state_ALREADY_DEFINED +#else +#define yypop_buffer_state cmCTestResourceGroups_yypop_buffer_state +#endif + +#ifdef yyensure_buffer_stack +#define cmCTestResourceGroups_yyensure_buffer_stack_ALREADY_DEFINED +#else +#define yyensure_buffer_stack cmCTestResourceGroups_yyensure_buffer_stack +#endif + +#ifdef yylex +#define cmCTestResourceGroups_yylex_ALREADY_DEFINED +#else +#define yylex cmCTestResourceGroups_yylex +#endif + +#ifdef yyrestart +#define cmCTestResourceGroups_yyrestart_ALREADY_DEFINED +#else +#define yyrestart cmCTestResourceGroups_yyrestart +#endif + +#ifdef yylex_init +#define cmCTestResourceGroups_yylex_init_ALREADY_DEFINED +#else +#define yylex_init cmCTestResourceGroups_yylex_init +#endif + +#ifdef yylex_init_extra +#define cmCTestResourceGroups_yylex_init_extra_ALREADY_DEFINED +#else +#define yylex_init_extra cmCTestResourceGroups_yylex_init_extra +#endif + +#ifdef yylex_destroy +#define cmCTestResourceGroups_yylex_destroy_ALREADY_DEFINED +#else +#define yylex_destroy cmCTestResourceGroups_yylex_destroy +#endif + +#ifdef yyget_debug +#define cmCTestResourceGroups_yyget_debug_ALREADY_DEFINED +#else +#define yyget_debug cmCTestResourceGroups_yyget_debug +#endif + +#ifdef yyset_debug +#define cmCTestResourceGroups_yyset_debug_ALREADY_DEFINED +#else +#define yyset_debug cmCTestResourceGroups_yyset_debug +#endif + +#ifdef yyget_extra +#define cmCTestResourceGroups_yyget_extra_ALREADY_DEFINED +#else +#define yyget_extra cmCTestResourceGroups_yyget_extra +#endif + +#ifdef yyset_extra +#define cmCTestResourceGroups_yyset_extra_ALREADY_DEFINED +#else +#define yyset_extra cmCTestResourceGroups_yyset_extra +#endif + +#ifdef yyget_in +#define cmCTestResourceGroups_yyget_in_ALREADY_DEFINED +#else +#define yyget_in cmCTestResourceGroups_yyget_in +#endif + +#ifdef yyset_in +#define cmCTestResourceGroups_yyset_in_ALREADY_DEFINED +#else +#define yyset_in cmCTestResourceGroups_yyset_in +#endif + +#ifdef yyget_out +#define cmCTestResourceGroups_yyget_out_ALREADY_DEFINED +#else +#define yyget_out cmCTestResourceGroups_yyget_out +#endif + +#ifdef yyset_out +#define cmCTestResourceGroups_yyset_out_ALREADY_DEFINED +#else +#define yyset_out cmCTestResourceGroups_yyset_out +#endif + +#ifdef yyget_leng +#define cmCTestResourceGroups_yyget_leng_ALREADY_DEFINED +#else +#define yyget_leng cmCTestResourceGroups_yyget_leng +#endif + +#ifdef yyget_text +#define cmCTestResourceGroups_yyget_text_ALREADY_DEFINED +#else +#define yyget_text cmCTestResourceGroups_yyget_text +#endif + +#ifdef yyget_lineno +#define cmCTestResourceGroups_yyget_lineno_ALREADY_DEFINED +#else +#define yyget_lineno cmCTestResourceGroups_yyget_lineno +#endif + +#ifdef yyset_lineno +#define cmCTestResourceGroups_yyset_lineno_ALREADY_DEFINED +#else +#define yyset_lineno cmCTestResourceGroups_yyset_lineno +#endif + +#ifdef yyget_column +#define cmCTestResourceGroups_yyget_column_ALREADY_DEFINED +#else +#define yyget_column cmCTestResourceGroups_yyget_column +#endif + +#ifdef yyset_column +#define cmCTestResourceGroups_yyset_column_ALREADY_DEFINED +#else +#define yyset_column cmCTestResourceGroups_yyset_column +#endif + +#ifdef yywrap +#define cmCTestResourceGroups_yywrap_ALREADY_DEFINED +#else +#define yywrap cmCTestResourceGroups_yywrap +#endif + +#ifdef yyalloc +#define cmCTestResourceGroups_yyalloc_ALREADY_DEFINED +#else +#define yyalloc cmCTestResourceGroups_yyalloc +#endif + +#ifdef yyrealloc +#define cmCTestResourceGroups_yyrealloc_ALREADY_DEFINED +#else +#define yyrealloc cmCTestResourceGroups_yyrealloc +#endif + +#ifdef yyfree +#define cmCTestResourceGroups_yyfree_ALREADY_DEFINED +#else +#define yyfree cmCTestResourceGroups_yyfree +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* An opaque pointer. */ +#ifndef YY_TYPEDEF_YY_SCANNER_T +#define YY_TYPEDEF_YY_SCANNER_T +typedef void* yyscan_t; +#endif + +/* For convenience, these vars (plus the bison vars far below) + are macros in the reentrant scanner. */ +#define yyin yyg->yyin_r +#define yyout yyg->yyout_r +#define yyextra yyg->yyextra_r +#define yyleng yyg->yyleng_r +#define yytext yyg->yytext_r +#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) +#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) +#define yy_flex_debug yyg->yy_flex_debug_r + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +void yyrestart ( FILE *input_file , yyscan_t yyscanner ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner ); +void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); +void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); +void yypop_buffer_state ( yyscan_t yyscanner ); + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner ); + +void *yyalloc ( yy_size_t , yyscan_t yyscanner ); +void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner ); +void yyfree ( void * , yyscan_t yyscanner ); + +/* Begin user sect3 */ + +#define cmCTestResourceGroups_yywrap(yyscanner) (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP + +#define yytext_ptr yytext_r + +#ifdef YY_HEADER_EXPORT_START_CONDITIONS +#define INITIAL 0 +#define RESOURCE_GROUPS_START 1 +#define RESOURCE_GROUPS_END 2 +#define RESOURCE_START 3 +#define RESOURCE_COUNT 4 +#define RESOURCE_END 5 + +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +int yylex_init (yyscan_t* scanner); + +int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( yyscan_t yyscanner ); + +int yyget_debug ( yyscan_t yyscanner ); + +void yyset_debug ( int debug_flag , yyscan_t yyscanner ); + +YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner ); + +FILE *yyget_in ( yyscan_t yyscanner ); + +void yyset_in ( FILE * _in_str , yyscan_t yyscanner ); + +FILE *yyget_out ( yyscan_t yyscanner ); + +void yyset_out ( FILE * _out_str , yyscan_t yyscanner ); + + int yyget_leng ( yyscan_t yyscanner ); + +char *yyget_text ( yyscan_t yyscanner ); + +int yyget_lineno ( yyscan_t yyscanner ); + +void yyset_lineno ( int _line_number , yyscan_t yyscanner ); + +int yyget_column ( yyscan_t yyscanner ); + +void yyset_column ( int _column_no , yyscan_t yyscanner ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( yyscan_t yyscanner ); +#else +extern int yywrap ( yyscan_t yyscanner ); +#endif +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * , yyscan_t yyscanner); +#endif + +#ifndef YY_NO_INPUT + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (yyscan_t yyscanner); + +#define YY_DECL int yylex (yyscan_t yyscanner) +#endif /* !YY_DECL */ + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +#undef YY_NEW_FILE +#undef YY_FLUSH_BUFFER +#undef yy_set_bol +#undef yy_new_buffer +#undef yy_set_interactive +#undef YY_DO_BEFORE_ACTION + +#ifdef YY_DECL_IS_OURS +#undef YY_DECL_IS_OURS +#undef YY_DECL +#endif + +#ifndef cmCTestResourceGroups_yy_create_buffer_ALREADY_DEFINED +#undef yy_create_buffer +#endif +#ifndef cmCTestResourceGroups_yy_delete_buffer_ALREADY_DEFINED +#undef yy_delete_buffer +#endif +#ifndef cmCTestResourceGroups_yy_scan_buffer_ALREADY_DEFINED +#undef yy_scan_buffer +#endif +#ifndef cmCTestResourceGroups_yy_scan_string_ALREADY_DEFINED +#undef yy_scan_string +#endif +#ifndef cmCTestResourceGroups_yy_scan_bytes_ALREADY_DEFINED +#undef yy_scan_bytes +#endif +#ifndef cmCTestResourceGroups_yy_init_buffer_ALREADY_DEFINED +#undef yy_init_buffer +#endif +#ifndef cmCTestResourceGroups_yy_flush_buffer_ALREADY_DEFINED +#undef yy_flush_buffer +#endif +#ifndef cmCTestResourceGroups_yy_load_buffer_state_ALREADY_DEFINED +#undef yy_load_buffer_state +#endif +#ifndef cmCTestResourceGroups_yy_switch_to_buffer_ALREADY_DEFINED +#undef yy_switch_to_buffer +#endif +#ifndef cmCTestResourceGroups_yypush_buffer_state_ALREADY_DEFINED +#undef yypush_buffer_state +#endif +#ifndef cmCTestResourceGroups_yypop_buffer_state_ALREADY_DEFINED +#undef yypop_buffer_state +#endif +#ifndef cmCTestResourceGroups_yyensure_buffer_stack_ALREADY_DEFINED +#undef yyensure_buffer_stack +#endif +#ifndef cmCTestResourceGroups_yylex_ALREADY_DEFINED +#undef yylex +#endif +#ifndef cmCTestResourceGroups_yyrestart_ALREADY_DEFINED +#undef yyrestart +#endif +#ifndef cmCTestResourceGroups_yylex_init_ALREADY_DEFINED +#undef yylex_init +#endif +#ifndef cmCTestResourceGroups_yylex_init_extra_ALREADY_DEFINED +#undef yylex_init_extra +#endif +#ifndef cmCTestResourceGroups_yylex_destroy_ALREADY_DEFINED +#undef yylex_destroy +#endif +#ifndef cmCTestResourceGroups_yyget_debug_ALREADY_DEFINED +#undef yyget_debug +#endif +#ifndef cmCTestResourceGroups_yyset_debug_ALREADY_DEFINED +#undef yyset_debug +#endif +#ifndef cmCTestResourceGroups_yyget_extra_ALREADY_DEFINED +#undef yyget_extra +#endif +#ifndef cmCTestResourceGroups_yyset_extra_ALREADY_DEFINED +#undef yyset_extra +#endif +#ifndef cmCTestResourceGroups_yyget_in_ALREADY_DEFINED +#undef yyget_in +#endif +#ifndef cmCTestResourceGroups_yyset_in_ALREADY_DEFINED +#undef yyset_in +#endif +#ifndef cmCTestResourceGroups_yyget_out_ALREADY_DEFINED +#undef yyget_out +#endif +#ifndef cmCTestResourceGroups_yyset_out_ALREADY_DEFINED +#undef yyset_out +#endif +#ifndef cmCTestResourceGroups_yyget_leng_ALREADY_DEFINED +#undef yyget_leng +#endif +#ifndef cmCTestResourceGroups_yyget_text_ALREADY_DEFINED +#undef yyget_text +#endif +#ifndef cmCTestResourceGroups_yyget_lineno_ALREADY_DEFINED +#undef yyget_lineno +#endif +#ifndef cmCTestResourceGroups_yyset_lineno_ALREADY_DEFINED +#undef yyset_lineno +#endif +#ifndef cmCTestResourceGroups_yyget_column_ALREADY_DEFINED +#undef yyget_column +#endif +#ifndef cmCTestResourceGroups_yyset_column_ALREADY_DEFINED +#undef yyset_column +#endif +#ifndef cmCTestResourceGroups_yywrap_ALREADY_DEFINED +#undef yywrap +#endif +#ifndef cmCTestResourceGroups_yyget_lval_ALREADY_DEFINED +#undef yyget_lval +#endif +#ifndef cmCTestResourceGroups_yyset_lval_ALREADY_DEFINED +#undef yyset_lval +#endif +#ifndef cmCTestResourceGroups_yyget_lloc_ALREADY_DEFINED +#undef yyget_lloc +#endif +#ifndef cmCTestResourceGroups_yyset_lloc_ALREADY_DEFINED +#undef yyset_lloc +#endif +#ifndef cmCTestResourceGroups_yyalloc_ALREADY_DEFINED +#undef yyalloc +#endif +#ifndef cmCTestResourceGroups_yyrealloc_ALREADY_DEFINED +#undef yyrealloc +#endif +#ifndef cmCTestResourceGroups_yyfree_ALREADY_DEFINED +#undef yyfree +#endif +#ifndef cmCTestResourceGroups_yytext_ALREADY_DEFINED +#undef yytext +#endif +#ifndef cmCTestResourceGroups_yyleng_ALREADY_DEFINED +#undef yyleng +#endif +#ifndef cmCTestResourceGroups_yyin_ALREADY_DEFINED +#undef yyin +#endif +#ifndef cmCTestResourceGroups_yyout_ALREADY_DEFINED +#undef yyout +#endif +#ifndef cmCTestResourceGroups_yy_flex_debug_ALREADY_DEFINED +#undef yy_flex_debug +#endif +#ifndef cmCTestResourceGroups_yylineno_ALREADY_DEFINED +#undef yylineno +#endif +#ifndef cmCTestResourceGroups_yytables_fload_ALREADY_DEFINED +#undef yytables_fload +#endif +#ifndef cmCTestResourceGroups_yytables_destroy_ALREADY_DEFINED +#undef yytables_destroy +#endif +#ifndef cmCTestResourceGroups_yyTABLES_NAME_ALREADY_DEFINED +#undef yyTABLES_NAME +#endif + +#undef cmCTestResourceGroups_yyIN_HEADER +#endif /* cmCTestResourceGroups_yyHEADER_H */ diff --git a/Source/LexerParser/cmCTestResourceGroupsLexer.in.l b/Source/LexerParser/cmCTestResourceGroupsLexer.in.l new file mode 100644 index 0000000..2aabea4 --- /dev/null +++ b/Source/LexerParser/cmCTestResourceGroupsLexer.in.l @@ -0,0 +1,102 @@ +%{ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ +/* + +This file must be translated to C++ and modified to build everywhere. + +Run flex >= 2.6 like this: + + flex --nounistd -DFLEXINT_H --noline --header-file=cmCTestResourceGroupsLexer.h -ocmCTestResourceGroupsLexer.cxx cmCTestResourceGroupsLexer.in.l + +Modify cmCTestResourceGroupsLexer.cxx: + - remove trailing whitespace: sed -i 's/\s*$//' cmCTestResourceGroupsLexer.h cmCTestResourceGroupsLexer.cxx + - remove blank lines at end of file: sed -i '${/^$/d;}' cmCTestResourceGroupsLexer.h cmCTestResourceGroupsLexer.cxx + - #include "cmStandardLexer.h" at the top: sed -i '1i#include "cmStandardLexer.h"' cmCTestResourceGroupsLexer.cxx + +*/ + +/* IWYU pragma: no_forward_declare yyguts_t */ + +#ifndef __clang_analyzer__ /* Suppress clang scan-build warnings */ + +#include "cmCTestResourceGroupsLexerHelper.h" + +#include + +#include + +/*--------------------------------------------------------------------------*/ +%} + +%option prefix="cmCTestResourceGroups_yy" + +%option reentrant +%option noyywrap +%option nodefault +%pointer + +%s RESOURCE_GROUPS_START +%s RESOURCE_GROUPS_END +%s RESOURCE_START +%s RESOURCE_COUNT +%s RESOURCE_END + +NUMBER [0-9]+ +IDENTIFIER [a-z_][a-z0-9_]* + +%% + +{IDENTIFIER}: { + BEGIN(RESOURCE_COUNT); + yyextra->SetResourceType(std::string(yytext, yyleng - 1)); +} + +{NUMBER} { + BEGIN(RESOURCE_GROUPS_END); + std::size_t len = yyleng; + yyextra->SetProcessCount(std::stoll(yytext, &len, 10)); +} + +{NUMBER} { + BEGIN(RESOURCE_END); + std::size_t len = yyleng; + yyextra->SetNeededSlots(std::stoll(yytext, &len, 10)); + yyextra->WriteRequirement(); +} + +,+ { + BEGIN(RESOURCE_START); +} + +;+ { + BEGIN(RESOURCE_GROUPS_START); +} + +;+ { + BEGIN(RESOURCE_GROUPS_START); + yyextra->WriteProcess(); +} + +<> { + yyextra->WriteProcess(); + return 0; +} + +<> { + return 0; +} + +<> { + return 1; +} + +.|\n { + return 1; +} + +%% + +/*--------------------------------------------------------------------------*/ + +#endif /* __clang_analyzer__ */ diff --git a/Utilities/Scripts/regenerate-lexers.bash b/Utilities/Scripts/regenerate-lexers.bash index 2bd58fe..1b61b70 100755 --- a/Utilities/Scripts/regenerate-lexers.bash +++ b/Utilities/Scripts/regenerate-lexers.bash @@ -11,7 +11,7 @@ pushd "${BASH_SOURCE%/*}/../../Source/LexerParser" > /dev/null for lexer in \ CommandArgument \ - CTestProcesses \ + CTestResourceGroups \ DependsJava \ Expr \ Fortran -- cgit v0.12 From a7c1e15cc46aa97cc19c9eb84fe8cad55c650bfa Mon Sep 17 00:00:00 2001 From: Craig Scott Date: Tue, 5 Nov 2019 16:20:35 +1100 Subject: CTest: Rename hardware -> resources for CMake variables, command options Only changes the user-visible effects of renaming hardware allocation to resource allocation. Code changes are the minimum needed to achieve that. --- Help/command/ctest_test.rst | 8 +-- Help/manual/ctest.1.rst | 71 +++++++++++----------- Help/prop_test/RESOURCE_GROUPS.rst | 8 +-- Help/release/3.16.rst | 4 +- Source/CTest/cmCTestMultiProcessHandler.cxx | 2 +- Source/CTest/cmCTestTestCommand.cxx | 4 +- Source/CTest/cmCTestTestHandler.cxx | 4 +- Source/cmCTest.cxx | 6 +- Source/ctest.cxx | 2 +- .../RunCMake/CTestHardwareAllocation/cthwalloc.cxx | 4 +- .../notenough1-ctest-s-hw-stderr.txt | 2 +- .../notenough2-ctest-s-hw-stderr.txt | 2 +- .../RunCMake/CTestHardwareAllocation/test.cmake.in | 2 +- 13 files changed, 59 insertions(+), 60 deletions(-) diff --git a/Help/command/ctest_test.rst b/Help/command/ctest_test.rst index 0a33da3..7a3393b 100644 --- a/Help/command/ctest_test.rst +++ b/Help/command/ctest_test.rst @@ -17,7 +17,7 @@ Perform the :ref:`CTest Test Step` as a :ref:`Dashboard Client`. [EXCLUDE_FIXTURE_SETUP ] [EXCLUDE_FIXTURE_CLEANUP ] [PARALLEL_LEVEL ] - [HARDWARE_SPEC_FILE ] + [RESOURCE_SPEC_FILE ] [TEST_LOAD ] [SCHEDULE_RANDOM ] [STOP_TIME ] @@ -83,10 +83,10 @@ The options are: Specify a positive number representing the number of tests to be run in parallel. -``HARDWARE_SPEC_FILE `` +``RESOURCE_SPEC_FILE `` Specify a - :ref:`hardware specification file `. See - :ref:`ctest-hardware-allocation` for more information. + :ref:`resource specification file `. See + :ref:`ctest-resource-allocation` for more information. ``TEST_LOAD `` While running tests in parallel, try not to start tests when they diff --git a/Help/manual/ctest.1.rst b/Help/manual/ctest.1.rst index 569f0f7..be1ec5d 100644 --- a/Help/manual/ctest.1.rst +++ b/Help/manual/ctest.1.rst @@ -90,14 +90,14 @@ Options See `Label and Subproject Summary`_. -``--hardware-spec-file `` - Run CTest with :ref:`hardware allocation ` enabled, +``--resource-spec-file `` + Run CTest with :ref:`resource allocation ` enabled, using the - :ref:`hardware specification file ` + :ref:`resource specification file ` specified in ````. When ``ctest`` is run as a `Dashboard Client`_ this sets the - ``HardwareSpecFile`` option of the `CTest Test Step`_. + ``ResourceSpecFile`` option of the `CTest Test Step`_. ``--test-load `` While running tests in parallel (e.g. with ``-j``), try not to start @@ -967,10 +967,10 @@ Arguments to the command may specify some of the step settings. Configuration settings include: -``HardwareSpecFile`` +``ResourceSpecFile`` Specify a - :ref:`hardware specification file `. See - :ref:`ctest-hardware-allocation` for more information. + :ref:`resource specification file `. See + :ref:`ctest-resource-allocation` for more information. ``LabelsForSubprojects`` Specify a semicolon-separated list of labels that will be treated as @@ -1281,22 +1281,22 @@ model is defined as follows: Test properties. Can contain keys for each of the supported test properties. -.. _`ctest-hardware-allocation`: +.. _`ctest-resource-allocation`: -Hardware Allocation +Resource Allocation =================== -CTest provides a mechanism for tests to specify the hardware that they need and -how much of it they need, and for users to specify the hardware availiable on +CTest provides a mechanism for tests to specify the resources that they need +in a fine-grained way, and for users to specify the resources availiable on the running machine. This allows CTest to internally keep track of which -hardware is in use and which is free, scheduling tests in a way that prevents -them from trying to claim hardware that is not available. +resources are in use and which are free, scheduling tests in a way that +prevents them from trying to claim resources that are not available. A common use case for this feature is for tests that require the use of a GPU. Multiple tests can simultaneously allocate memory from a GPU, but if too many tests try to do this at once, some of them will fail to allocate, resulting in a failed test, even though the test would have succeeded if it had the memory -it needed. By using the hardware allocation feature, each test can specify how +it needed. By using the resource allocation feature, each test can specify how much memory it requires from a GPU, allowing CTest to schedule tests in a way that running several of these tests at once does not exhaust the GPU's memory pool. @@ -1312,36 +1312,35 @@ When a test is executed, and slots from a resource are allocated to that test, tests may assume that they have exclusive use of those slots for the duration of the test's process. -The CTest hardware allocation feature consists of two inputs: +The CTest resource allocation feature consists of two inputs: -* The :ref:`hardware specification file `, - described below, which describes the hardware resources available on the - system, and +* The :ref:`resource specification file `, + described below, which describes the resources available on the system. * The :prop_test:`RESOURCE_GROUPS` property of tests, which describes the - resources required by the test + resources required by the test. -When CTest runs a test, the hardware allocated to that test is passed in the +When CTest runs a test, the resources allocated to that test are passed in the form of a set of -:ref:`environment variables ` as +:ref:`environment variables ` as described below. Using this information to decide which resource to connect to is left to the test writer. The ``RESOURCE_GROUPS`` property tells CTest what resources a test expects to use grouped in a way meaningful to the test. The test itself must read -the :ref:`environment variables ` to +the :ref:`environment variables ` to determine which resources have been allocated to each group. For example, each group may correspond to a process the test will spawn when executed. -.. _`ctest-hardware-specification-file`: +.. _`ctest-resource-specification-file`: -Hardware Specification File +Resource Specification File --------------------------- -The hardware specification file is a JSON file which is passed to CTest, either -on the :manual:`ctest(1)` command line as ``--hardware-spec-file``, or as the -``HARDWARE_SPEC_FILE`` argument of :command:`ctest_test`. The hardware +The resource specification file is a JSON file which is passed to CTest, either +on the :manual:`ctest(1)` command line as ``--resource-spec-file``, or as the +``RESOURCE_SPEC_FILE`` argument of :command:`ctest_test`. The resource specification file must be a JSON object. All examples in this document assume -the following hardware specification file: +the following resource specification file: .. code-block:: json @@ -1378,11 +1377,11 @@ the following hardware specification file: The members are: ``local`` - A JSON array consisting of CPU sockets present on the system. Currently, only - one socket is supported. + A JSON array of resource sets present on the system. Currently, this array + is restricted to being of size 1. - Each socket is a JSON object with members whose names are equal to the - desired resource types, such as ``gpu``. These names must start with a + Each array element is a JSON object with members whose names are equal to the + desired resource types, such as ``gpus``. These names must start with a lowercase letter or an underscore, and subsequent characters can be a lowercase letter, a digit, or an underscore. Uppercase letters are not allowed, because certain platforms have case-insensitive environment @@ -1428,7 +1427,7 @@ also one cryptography chip with 4 slots. See :prop_test:`RESOURCE_GROUPS` for a description of this property. -.. _`ctest-hardware-environment-variables`: +.. _`ctest-resource-environment-variables`: Environment Variables --------------------- @@ -1449,8 +1448,8 @@ The following variables are passed to the test process: * ``CTEST_RESOURCE_GROUP_COUNT=3`` This variable will only be defined if :manual:`ctest(1)` has been given a - ``--hardware-spec-file``, or if :command:`ctest_test` has been given a - ``HARDWARE_SPEC_FILE``. If no hardware specification file has been given, + ``--resource-spec-file``, or if :command:`ctest_test` has been given a + ``RESOURCE_SPEC_FILE``. If no resource specification file has been given, this variable will not be defined. .. envvar:: CTEST_RESOURCE_GROUP_ @@ -1493,7 +1492,7 @@ The following variables are passed to the test process: the names of resource types may not clash in a case-insensitive environment. Because of this, for the sake of simplicity, all resource types must be listed in all lowercase in the - :ref:`hardware specification file ` and + :ref:`resource specification file ` and in the :prop_test:`RESOURCE_GROUPS` property, and they are converted to all uppercase in the ``CTEST_RESOURCE_GROUP__`` environment variable. diff --git a/Help/prop_test/RESOURCE_GROUPS.rst b/Help/prop_test/RESOURCE_GROUPS.rst index 6fdbd03..436451c 100644 --- a/Help/prop_test/RESOURCE_GROUPS.rst +++ b/Help/prop_test/RESOURCE_GROUPS.rst @@ -2,8 +2,8 @@ RESOURCE_GROUPS --------------- Specify resources required by a test, grouped in a way that is meaningful to -the test. See :ref:`hardware allocation ` -for more information on how this property integrates into the CTest hardware +the test. See :ref:`resource allocation ` +for more information on how this property integrates into the CTest resource allocation feature. The ``RESOURCE_GROUPS`` property is a :ref:`semicolon-separated list ` to +the :ref:`environment variables ` to determine which resources have been allocated to each group. For example, each group may correspond to a process the test will spawn when executed. @@ -39,7 +39,7 @@ single cryptography chip. In total, 3 resource groups are specified for this test, each with its own unique requirements. When CTest sets the :ref:`environment variables -` for a test, it assigns a group number +` for a test, it assigns a group number based on the group description, starting at 0 on the left and the number of groups minus 1 on the right. For example, in the example above, the two groups in the first description would have IDs of 0 and 1, and the single diff --git a/Help/release/3.16.rst b/Help/release/3.16.rst index 570f536..dff0e1d 100644 --- a/Help/release/3.16.rst +++ b/Help/release/3.16.rst @@ -190,8 +190,8 @@ Autogen CTest ----- -* :manual:`ctest(1)` now has the ability to serialize tests based on hardware - requirements for each test. See :ref:`ctest-hardware-allocation` for +* :manual:`ctest(1)` now has the ability to schedule tests based on resource + requirements for each test. See :ref:`ctest-resource-allocation` for details. * A new test property, :prop_test:`SKIP_REGULAR_EXPRESSION`, has been added. diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx index c71ae7b..5248d2c 100644 --- a/Source/CTest/cmCTestMultiProcessHandler.cxx +++ b/Source/CTest/cmCTestMultiProcessHandler.cxx @@ -195,7 +195,7 @@ bool cmCTestMultiProcessHandler::StartTestProcess(int test) this->AllocateResources(test); if (!this->TestsHaveSufficientHardware[test]) { - testRun->StartFailure("Insufficient hardware"); + testRun->StartFailure("Insufficient resources"); this->FinishTestProcess(testRun, false); return false; } diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx index 5496353..f17ed86 100644 --- a/Source/CTest/cmCTestTestCommand.cxx +++ b/Source/CTest/cmCTestTestCommand.cxx @@ -32,7 +32,7 @@ void cmCTestTestCommand::BindArguments() this->Bind("SCHEDULE_RANDOM"_s, this->ScheduleRandom); this->Bind("STOP_TIME"_s, this->StopTime); this->Bind("TEST_LOAD"_s, this->TestLoad); - this->Bind("HARDWARE_SPEC_FILE"_s, this->HardwareSpecFile); + this->Bind("RESOURCE_SPEC_FILE"_s, this->HardwareSpecFile); } cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler() @@ -89,7 +89,7 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler() handler->SetOption("ScheduleRandom", this->ScheduleRandom.c_str()); } if (!this->HardwareSpecFile.empty()) { - handler->SetOption("HardwareSpecFile", this->HardwareSpecFile.c_str()); + handler->SetOption("ResourceSpecFile", this->HardwareSpecFile.c_str()); } if (!this->StopTime.empty()) { this->CTest->SetStopTime(this->StopTime); diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx index ec5c4bc..2220074 100644 --- a/Source/CTest/cmCTestTestHandler.cxx +++ b/Source/CTest/cmCTestTestHandler.cxx @@ -510,12 +510,12 @@ bool cmCTestTestHandler::ProcessOptions() } this->SetRerunFailed(cmIsOn(this->GetOption("RerunFailed"))); - val = this->GetOption("HardwareSpecFile"); + val = this->GetOption("ResourceSpecFile"); if (val) { this->UseHardwareSpec = true; if (!this->HardwareSpec.ReadFromJSONFile(val)) { cmCTestLog(this->CTest, ERROR_MESSAGE, - "Could not read hardware spec file: " << val << std::endl); + "Could not read resource spec file: " << val << std::endl); return false; } } diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx index 10b7646..6eae26e 100644 --- a/Source/cmCTest.cxx +++ b/Source/cmCTest.cxx @@ -2090,12 +2090,12 @@ bool cmCTest::HandleCommandLineArguments(size_t& i, "ExcludeFixtureCleanupRegularExpression", args[i].c_str()); } - if (this->CheckArgument(arg, "--hardware-spec-file") && + if (this->CheckArgument(arg, "--resource-spec-file") && i < args.size() - 1) { i++; - this->GetTestHandler()->SetPersistentOption("HardwareSpecFile", + this->GetTestHandler()->SetPersistentOption("ResourceSpecFile", args[i].c_str()); - this->GetMemCheckHandler()->SetPersistentOption("HardwareSpecFile", + this->GetMemCheckHandler()->SetPersistentOption("ResourceSpecFile", args[i].c_str()); } diff --git a/Source/ctest.cxx b/Source/ctest.cxx index 91ee598..0d65902 100644 --- a/Source/ctest.cxx +++ b/Source/ctest.cxx @@ -103,7 +103,7 @@ static const char* cmDocumentationOptions[][2] = { "times without failing in order to pass" }, { "--max-width ", "Set the max width for a test name to output" }, { "--interactive-debug-mode [0|1]", "Set the interactive mode to 0 or 1." }, - { "--hardware-spec-file ", "Set the hardware spec file to use." }, + { "--resource-spec-file ", "Set the resource spec file to use." }, { "--no-label-summary", "Disable timing summary information for labels." }, { "--no-subproject-summary", "Disable timing summary information for " diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx index e5f0283..1a61e6f 100644 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx +++ b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx @@ -54,7 +54,7 @@ static int usageWrite(const char* argv0) static int usageVerify(const char* argv0) { std::cout << "Usage: " << argv0 - << " verify []" + << " verify []" << std::endl; return 1; } @@ -286,7 +286,7 @@ static int doVerify(int argc, char const* const* argv) cmCTestHardwareSpec spec; if (!spec.ReadFromJSONFile(hwFile)) { - std::cout << "Could not read hardware spec " << hwFile << std::endl; + std::cout << "Could not read resource spec " << hwFile << std::endl; return 1; } diff --git a/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-stderr.txt b/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-stderr.txt index d465cd3..f1ea087 100644 --- a/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-stderr.txt +++ b/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-stderr.txt @@ -1,4 +1,4 @@ -^Insufficient hardware +^Insufficient resources CMake Error at [^ ]*/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw/test\.cmake:[0-9]+ \(message\): Tests did not pass$ diff --git a/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-stderr.txt b/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-stderr.txt index 912f0fb..bc03156 100644 --- a/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-stderr.txt +++ b/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-stderr.txt @@ -1,4 +1,4 @@ -^Insufficient hardware +^Insufficient resources CMake Error at [^ ]*/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw/test\.cmake:[0-9]+ \(message\): Tests did not pass$ diff --git a/Tests/RunCMake/CTestHardwareAllocation/test.cmake.in b/Tests/RunCMake/CTestHardwareAllocation/test.cmake.in index 5ba3587..a4884dc 100644 --- a/Tests/RunCMake/CTestHardwareAllocation/test.cmake.in +++ b/Tests/RunCMake/CTestHardwareAllocation/test.cmake.in @@ -15,7 +15,7 @@ ctest_configure(OPTIONS ctest_build() if(CTEST_HARDWARE_ALLOC_ENABLED) - set(hwspec HARDWARE_SPEC_FILE "@RunCMake_SOURCE_DIR@/hwspec.json") + set(hwspec RESOURCE_SPEC_FILE "@RunCMake_SOURCE_DIR@/hwspec.json") endif() ctest_test(${hwspec} RETURN_VALUE retval PARALLEL_LEVEL ${CTEST_PARALLEL} SCHEDULE_RANDOM ${CTEST_RANDOM}) if(retval) -- cgit v0.12 From 6ce27d3a2efad4e40d4354a7d17e4259fb4c1e24 Mon Sep 17 00:00:00 2001 From: Craig Scott Date: Tue, 5 Nov 2019 17:14:33 +1100 Subject: cmCTestMultiProcessHandler: Rename resource locking functions Renaming these ahead of other refactoring which will use the previous names. The previous names more accurately reflect their purpose after this commit anyway (talking about locking and unlocking rather than allocating and deallocating). --- Source/CTest/cmCTestMultiProcessHandler.cxx | 8 ++++---- Source/CTest/cmCTestMultiProcessHandler.h | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx index 5248d2c..df36aa2 100644 --- a/Source/CTest/cmCTestMultiProcessHandler.cxx +++ b/Source/CTest/cmCTestMultiProcessHandler.cxx @@ -192,7 +192,7 @@ bool cmCTestMultiProcessHandler::StartTestProcess(int test) // Always lock the resources we'll be using, even if we fail to set the // working directory because FinishTestProcess() will try to unlock them - this->AllocateResources(test); + this->LockResources(test); if (!this->TestsHaveSufficientHardware[test]) { testRun->StartFailure("Insufficient resources"); @@ -346,7 +346,7 @@ void cmCTestMultiProcessHandler::SetStopTimePassed() } } -void cmCTestMultiProcessHandler::AllocateResources(int index) +void cmCTestMultiProcessHandler::LockResources(int index) { this->LockedResources.insert( this->Properties[index]->LockedResources.begin(), @@ -357,7 +357,7 @@ void cmCTestMultiProcessHandler::AllocateResources(int index) } } -void cmCTestMultiProcessHandler::DeallocateResources(int index) +void cmCTestMultiProcessHandler::UnlockResources(int index) { for (std::string const& i : this->Properties[index]->LockedResources) { this->LockedResources.erase(i); @@ -603,7 +603,7 @@ void cmCTestMultiProcessHandler::FinishTestProcess(cmCTestRunTest* runner, this->TestRunningMap[test] = false; this->WriteCheckpoint(test); this->DeallocateHardware(test); - this->DeallocateResources(test); + this->UnlockResources(test); this->RunningCount -= GetProcessorsUsed(test); for (auto p : properties->Affinity) { diff --git a/Source/CTest/cmCTestMultiProcessHandler.h b/Source/CTest/cmCTestMultiProcessHandler.h index da716f0..f0ffdbb 100644 --- a/Source/CTest/cmCTestMultiProcessHandler.h +++ b/Source/CTest/cmCTestMultiProcessHandler.h @@ -134,8 +134,8 @@ protected: bool CheckStopTimePassed(); void SetStopTimePassed(); - void AllocateResources(int index); - void DeallocateResources(int index); + void LockResources(int index); + void UnlockResources(int index); bool AllocateHardware(int index); bool TryAllocateHardware( -- cgit v0.12 From c544cb66984f16cc63ebace16ccd911adc550b9d Mon Sep 17 00:00:00 2001 From: Craig Scott Date: Tue, 5 Nov 2019 17:27:58 +1100 Subject: CTest: Rename hardware -> resources for source code --- Source/CMakeLists.txt | 4 +- Source/CTest/cmCTestBinPacker.cxx | 132 +++---- Source/CTest/cmCTestBinPacker.h | 10 +- Source/CTest/cmCTestHardwareAllocator.cxx | 86 ----- Source/CTest/cmCTestHardwareAllocator.h | 39 -- Source/CTest/cmCTestHardwareSpec.cxx | 133 ------- Source/CTest/cmCTestHardwareSpec.h | 40 -- Source/CTest/cmCTestMultiProcessHandler.cxx | 70 ++-- Source/CTest/cmCTestMultiProcessHandler.h | 28 +- Source/CTest/cmCTestResourceAllocator.cxx | 86 +++++ Source/CTest/cmCTestResourceAllocator.h | 39 ++ Source/CTest/cmCTestResourceSpec.cxx | 133 +++++++ Source/CTest/cmCTestResourceSpec.h | 40 ++ Source/CTest/cmCTestRunTest.cxx | 10 +- Source/CTest/cmCTestRunTest.h | 21 +- Source/CTest/cmCTestTestCommand.cxx | 6 +- Source/CTest/cmCTestTestCommand.h | 2 +- Source/CTest/cmCTestTestHandler.cxx | 12 +- Source/CTest/cmCTestTestHandler.h | 6 +- Tests/CMakeLib/CMakeLists.txt | 6 +- Tests/CMakeLib/testCTestBinPacker.cxx | 18 +- Tests/CMakeLib/testCTestHardwareAllocator.cxx | 426 --------------------- Tests/CMakeLib/testCTestHardwareSpec.cxx | 84 ---- .../CMakeLib/testCTestHardwareSpec_data/spec1.json | 23 -- .../testCTestHardwareSpec_data/spec10.json | 11 - .../testCTestHardwareSpec_data/spec11.json | 12 - .../testCTestHardwareSpec_data/spec12.json | 1 - .../testCTestHardwareSpec_data/spec13.json | 1 - .../testCTestHardwareSpec_data/spec14.json | 8 - .../testCTestHardwareSpec_data/spec15.json | 8 - .../testCTestHardwareSpec_data/spec16.json | 8 - .../testCTestHardwareSpec_data/spec17.json | 11 - .../testCTestHardwareSpec_data/spec18.json | 11 - .../CMakeLib/testCTestHardwareSpec_data/spec2.json | 4 - .../CMakeLib/testCTestHardwareSpec_data/spec3.json | 8 - .../CMakeLib/testCTestHardwareSpec_data/spec4.json | 4 - .../CMakeLib/testCTestHardwareSpec_data/spec5.json | 2 - .../CMakeLib/testCTestHardwareSpec_data/spec6.json | 5 - .../CMakeLib/testCTestHardwareSpec_data/spec7.json | 8 - .../CMakeLib/testCTestHardwareSpec_data/spec8.json | 9 - .../CMakeLib/testCTestHardwareSpec_data/spec9.json | 10 - Tests/CMakeLib/testCTestResourceAllocator.cxx | 426 +++++++++++++++++++++ Tests/CMakeLib/testCTestResourceSpec.cxx | 84 ++++ .../CMakeLib/testCTestResourceSpec_data/spec1.json | 23 ++ .../testCTestResourceSpec_data/spec10.json | 11 + .../testCTestResourceSpec_data/spec11.json | 12 + .../testCTestResourceSpec_data/spec12.json | 1 + .../testCTestResourceSpec_data/spec13.json | 1 + .../testCTestResourceSpec_data/spec14.json | 8 + .../testCTestResourceSpec_data/spec15.json | 8 + .../testCTestResourceSpec_data/spec16.json | 8 + .../testCTestResourceSpec_data/spec17.json | 11 + .../testCTestResourceSpec_data/spec18.json | 11 + .../CMakeLib/testCTestResourceSpec_data/spec2.json | 4 + .../CMakeLib/testCTestResourceSpec_data/spec3.json | 8 + .../CMakeLib/testCTestResourceSpec_data/spec4.json | 4 + .../CMakeLib/testCTestResourceSpec_data/spec5.json | 2 + .../CMakeLib/testCTestResourceSpec_data/spec6.json | 5 + .../CMakeLib/testCTestResourceSpec_data/spec7.json | 8 + .../CMakeLib/testCTestResourceSpec_data/spec8.json | 9 + .../CMakeLib/testCTestResourceSpec_data/spec9.json | 10 + .../RunCMake/CTestHardwareAllocation/cthwalloc.cxx | 34 +- 62 files changed, 1134 insertions(+), 1129 deletions(-) delete mode 100644 Source/CTest/cmCTestHardwareAllocator.cxx delete mode 100644 Source/CTest/cmCTestHardwareAllocator.h delete mode 100644 Source/CTest/cmCTestHardwareSpec.cxx delete mode 100644 Source/CTest/cmCTestHardwareSpec.h create mode 100644 Source/CTest/cmCTestResourceAllocator.cxx create mode 100644 Source/CTest/cmCTestResourceAllocator.h create mode 100644 Source/CTest/cmCTestResourceSpec.cxx create mode 100644 Source/CTest/cmCTestResourceSpec.h delete mode 100644 Tests/CMakeLib/testCTestHardwareAllocator.cxx delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec.cxx delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec1.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec10.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec11.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec12.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec13.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec14.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec15.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec16.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec17.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec18.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec2.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec3.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec4.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec5.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec6.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec7.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec8.json delete mode 100644 Tests/CMakeLib/testCTestHardwareSpec_data/spec9.json create mode 100644 Tests/CMakeLib/testCTestResourceAllocator.cxx create mode 100644 Tests/CMakeLib/testCTestResourceSpec.cxx create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec1.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec10.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec11.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec12.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec13.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec14.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec15.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec16.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec17.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec18.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec2.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec3.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec4.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec5.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec6.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec7.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec8.json create mode 100644 Tests/CMakeLib/testCTestResourceSpec_data/spec9.json diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index 0ae3d2a..b5099b7 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -919,8 +919,8 @@ set(CTEST_SRCS cmCTest.cxx CTest/cmCTestEmptyBinaryDirectoryCommand.cxx CTest/cmCTestGenericHandler.cxx CTest/cmCTestHandlerCommand.cxx - CTest/cmCTestHardwareAllocator.cxx - CTest/cmCTestHardwareSpec.cxx + CTest/cmCTestResourceAllocator.cxx + CTest/cmCTestResourceSpec.cxx CTest/cmCTestLaunch.cxx CTest/cmCTestMemCheckCommand.cxx CTest/cmCTestMemCheckHandler.cxx diff --git a/Source/CTest/cmCTestBinPacker.cxx b/Source/CTest/cmCTestBinPacker.cxx index e9e3bee..e21b14d 100644 --- a/Source/CTest/cmCTestBinPacker.cxx +++ b/Source/CTest/cmCTestBinPacker.cxx @@ -23,7 +23,7 @@ namespace { /* * The following algorithm is used to do two things: * - * 1) Determine if a test's hardware requirements can fit within the hardware + * 1) Determine if a test's resource requirements can fit within the resources * present on the system, and * 2) Do the actual allocation * @@ -34,46 +34,46 @@ namespace { * more combinations can be tried. */ template -static bool AllocateCTestHardware( - const std::map& hardware, - const std::vector& hardwareSorted, std::size_t currentIndex, +static bool AllocateCTestResources( + const std::map& resources, + const std::vector& resourcesSorted, std::size_t currentIndex, std::vector& allocations) { // Iterate through all large enough resources until we find a solution - std::size_t hardwareIndex = 0; - while (hardwareIndex < hardwareSorted.size()) { - auto const& resource = hardware.at(hardwareSorted[hardwareIndex]); + std::size_t resourceIndex = 0; + while (resourceIndex < resourcesSorted.size()) { + auto const& resource = resources.at(resourcesSorted[resourceIndex]); if (resource.Free() >= static_cast(allocations[currentIndex]->SlotsNeeded)) { // Preemptively allocate the resource - allocations[currentIndex]->Id = hardwareSorted[hardwareIndex]; + allocations[currentIndex]->Id = resourcesSorted[resourceIndex]; if (currentIndex + 1 >= allocations.size()) { // We have a solution return true; } // Move the resource up the list until it is sorted again - auto hardware2 = hardware; - auto hardwareSorted2 = hardwareSorted; - hardware2[hardwareSorted2[hardwareIndex]].Locked += + auto resources2 = resources; + auto resourcesSorted2 = resourcesSorted; + resources2[resourcesSorted2[resourceIndex]].Locked += allocations[currentIndex]->SlotsNeeded; - AllocationStrategy::IncrementalSort(hardware2, hardwareSorted2, - hardwareIndex); + AllocationStrategy::IncrementalSort(resources2, resourcesSorted2, + resourceIndex); // Recurse one level deeper - if (AllocateCTestHardware( - hardware2, hardwareSorted2, currentIndex + 1, allocations)) { + if (AllocateCTestResources( + resources2, resourcesSorted2, currentIndex + 1, allocations)) { return true; } } // No solution found here, deallocate the resource and try the next one allocations[currentIndex]->Id.clear(); - auto freeSlots = hardware.at(hardwareSorted.at(hardwareIndex)).Free(); + auto freeSlots = resources.at(resourcesSorted.at(resourceIndex)).Free(); do { - ++hardwareIndex; - } while (hardwareIndex < hardwareSorted.size() && - hardware.at(hardwareSorted.at(hardwareIndex)).Free() == + ++resourceIndex; + } while (resourceIndex < resourcesSorted.size() && + resources.at(resourcesSorted.at(resourceIndex)).Free() == freeSlots); } @@ -82,8 +82,8 @@ static bool AllocateCTestHardware( } template -static bool AllocateCTestHardware( - const std::map& hardware, +static bool AllocateCTestResources( + const std::map& resources, std::vector& allocations) { // Sort the resource requirements in descending order by slots needed @@ -99,103 +99,105 @@ static bool AllocateCTestHardware( }); // Sort the resources according to sort strategy - std::vector hardwareSorted; - hardwareSorted.reserve(hardware.size()); - for (auto const& hw : hardware) { - hardwareSorted.push_back(hw.first); + std::vector resourcesSorted; + resourcesSorted.reserve(resources.size()); + for (auto const& res : resources) { + resourcesSorted.push_back(res.first); } - AllocationStrategy::InitialSort(hardware, hardwareSorted); + AllocationStrategy::InitialSort(resources, resourcesSorted); // Do the actual allocation - return AllocateCTestHardware( - hardware, hardwareSorted, std::size_t(0), allocationsPtr); + return AllocateCTestResources( + resources, resourcesSorted, std::size_t(0), allocationsPtr); } class RoundRobinAllocationStrategy { public: static void InitialSort( - const std::map& hardware, - std::vector& hardwareSorted); + const std::map& resources, + std::vector& resourcesSorted); static void IncrementalSort( - const std::map& hardware, - std::vector& hardwareSorted, std::size_t lastAllocatedIndex); + const std::map& resources, + std::vector& resourcesSorted, std::size_t lastAllocatedIndex); }; void RoundRobinAllocationStrategy::InitialSort( - const std::map& hardware, - std::vector& hardwareSorted) + const std::map& resources, + std::vector& resourcesSorted) { std::stable_sort( - hardwareSorted.rbegin(), hardwareSorted.rend(), - [&hardware](const std::string& id1, const std::string& id2) { - return hardware.at(id1).Free() < hardware.at(id2).Free(); + resourcesSorted.rbegin(), resourcesSorted.rend(), + [&resources](const std::string& id1, const std::string& id2) { + return resources.at(id1).Free() < resources.at(id2).Free(); }); } void RoundRobinAllocationStrategy::IncrementalSort( - const std::map& hardware, - std::vector& hardwareSorted, std::size_t lastAllocatedIndex) + const std::map& resources, + std::vector& resourcesSorted, std::size_t lastAllocatedIndex) { - auto tmp = hardwareSorted[lastAllocatedIndex]; + auto tmp = resourcesSorted[lastAllocatedIndex]; std::size_t i = lastAllocatedIndex; - while (i < hardwareSorted.size() - 1 && - hardware.at(hardwareSorted[i + 1]).Free() > hardware.at(tmp).Free()) { - hardwareSorted[i] = hardwareSorted[i + 1]; + while (i < resourcesSorted.size() - 1 && + resources.at(resourcesSorted[i + 1]).Free() > + resources.at(tmp).Free()) { + resourcesSorted[i] = resourcesSorted[i + 1]; ++i; } - hardwareSorted[i] = tmp; + resourcesSorted[i] = tmp; } class BlockAllocationStrategy { public: static void InitialSort( - const std::map& hardware, - std::vector& hardwareSorted); + const std::map& resources, + std::vector& resourcesSorted); static void IncrementalSort( - const std::map& hardware, - std::vector& hardwareSorted, std::size_t lastAllocatedIndex); + const std::map& resources, + std::vector& resourcesSorted, std::size_t lastAllocatedIndex); }; void BlockAllocationStrategy::InitialSort( - const std::map& hardware, - std::vector& hardwareSorted) + const std::map& resources, + std::vector& resourcesSorted) { std::stable_sort( - hardwareSorted.rbegin(), hardwareSorted.rend(), - [&hardware](const std::string& id1, const std::string& id2) { - return hardware.at(id1).Free() < hardware.at(id2).Free(); + resourcesSorted.rbegin(), resourcesSorted.rend(), + [&resources](const std::string& id1, const std::string& id2) { + return resources.at(id1).Free() < resources.at(id2).Free(); }); } void BlockAllocationStrategy::IncrementalSort( - const std::map&, - std::vector& hardwareSorted, std::size_t lastAllocatedIndex) + const std::map&, + std::vector& resourcesSorted, std::size_t lastAllocatedIndex) { - auto tmp = hardwareSorted[lastAllocatedIndex]; + auto tmp = resourcesSorted[lastAllocatedIndex]; std::size_t i = lastAllocatedIndex; while (i > 0) { - hardwareSorted[i] = hardwareSorted[i - 1]; + resourcesSorted[i] = resourcesSorted[i - 1]; --i; } - hardwareSorted[i] = tmp; + resourcesSorted[i] = tmp; } } -bool cmAllocateCTestHardwareRoundRobin( - const std::map& hardware, +bool cmAllocateCTestResourcesRoundRobin( + const std::map& resources, std::vector& allocations) { - return AllocateCTestHardware(hardware, - allocations); + return AllocateCTestResources(resources, + allocations); } -bool cmAllocateCTestHardwareBlock( - const std::map& hardware, +bool cmAllocateCTestResourcesBlock( + const std::map& resources, std::vector& allocations) { - return AllocateCTestHardware(hardware, allocations); + return AllocateCTestResources(resources, + allocations); } diff --git a/Source/CTest/cmCTestBinPacker.h b/Source/CTest/cmCTestBinPacker.h index 54f03d7..ff02b85 100644 --- a/Source/CTest/cmCTestBinPacker.h +++ b/Source/CTest/cmCTestBinPacker.h @@ -8,7 +8,7 @@ #include #include -#include "cmCTestHardwareAllocator.h" +#include "cmCTestResourceAllocator.h" struct cmCTestBinPackerAllocation { @@ -20,12 +20,12 @@ struct cmCTestBinPackerAllocation bool operator!=(const cmCTestBinPackerAllocation& other) const; }; -bool cmAllocateCTestHardwareRoundRobin( - const std::map& hardware, +bool cmAllocateCTestResourcesRoundRobin( + const std::map& resources, std::vector& allocations); -bool cmAllocateCTestHardwareBlock( - const std::map& hardware, +bool cmAllocateCTestResourcesBlock( + const std::map& resources, std::vector& allocations); #endif diff --git a/Source/CTest/cmCTestHardwareAllocator.cxx b/Source/CTest/cmCTestHardwareAllocator.cxx deleted file mode 100644 index 2d1833d..0000000 --- a/Source/CTest/cmCTestHardwareAllocator.cxx +++ /dev/null @@ -1,86 +0,0 @@ -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ - -#include "cmCTestHardwareAllocator.h" - -#include -#include - -#include "cmCTestHardwareSpec.h" - -void cmCTestHardwareAllocator::InitializeFromHardwareSpec( - const cmCTestHardwareSpec& spec) -{ - this->Resources.clear(); - - for (auto const& it : spec.LocalSocket.Resources) { - auto& res = this->Resources[it.first]; - for (auto const& specRes : it.second) { - res[specRes.Id].Total = specRes.Capacity; - res[specRes.Id].Locked = 0; - } - } -} - -const std::map>& -cmCTestHardwareAllocator::GetResources() const -{ - return this->Resources; -} - -bool cmCTestHardwareAllocator::AllocateResource(const std::string& name, - const std::string& id, - unsigned int slots) -{ - auto it = this->Resources.find(name); - if (it == this->Resources.end()) { - return false; - } - - auto resIt = it->second.find(id); - if (resIt == it->second.end()) { - return false; - } - - if (resIt->second.Total < resIt->second.Locked + slots) { - return false; - } - - resIt->second.Locked += slots; - return true; -} - -bool cmCTestHardwareAllocator::DeallocateResource(const std::string& name, - const std::string& id, - unsigned int slots) -{ - auto it = this->Resources.find(name); - if (it == this->Resources.end()) { - return false; - } - - auto resIt = it->second.find(id); - if (resIt == it->second.end()) { - return false; - } - - if (resIt->second.Locked < slots) { - return false; - } - - resIt->second.Locked -= slots; - return true; -} - -bool cmCTestHardwareAllocator::Resource::operator==( - const Resource& other) const -{ - return this->Total == other.Total && this->Locked == other.Locked; -} - -bool cmCTestHardwareAllocator::Resource::operator!=( - const Resource& other) const -{ - return !(*this == other); -} diff --git a/Source/CTest/cmCTestHardwareAllocator.h b/Source/CTest/cmCTestHardwareAllocator.h deleted file mode 100644 index 441f84d..0000000 --- a/Source/CTest/cmCTestHardwareAllocator.h +++ /dev/null @@ -1,39 +0,0 @@ -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ -#ifndef cmCTestHardwareAllocator_h -#define cmCTestHardwareAllocator_h - -#include -#include - -class cmCTestHardwareSpec; - -class cmCTestHardwareAllocator -{ -public: - struct Resource - { - unsigned int Total; - unsigned int Locked; - - unsigned int Free() const { return this->Total - this->Locked; } - - bool operator==(const Resource& other) const; - bool operator!=(const Resource& other) const; - }; - - void InitializeFromHardwareSpec(const cmCTestHardwareSpec& spec); - - const std::map>& GetResources() - const; - - bool AllocateResource(const std::string& name, const std::string& id, - unsigned int slots); - bool DeallocateResource(const std::string& name, const std::string& id, - unsigned int slots); - -private: - std::map> Resources; -}; - -#endif diff --git a/Source/CTest/cmCTestHardwareSpec.cxx b/Source/CTest/cmCTestHardwareSpec.cxx deleted file mode 100644 index 137398a..0000000 --- a/Source/CTest/cmCTestHardwareSpec.cxx +++ /dev/null @@ -1,133 +0,0 @@ -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ -#include "cmCTestHardwareSpec.h" - -#include -#include -#include -#include - -#include "cmsys/FStream.hxx" -#include "cmsys/RegularExpression.hxx" - -#include "cm_jsoncpp_reader.h" -#include "cm_jsoncpp_value.h" - -static const cmsys::RegularExpression IdentifierRegex{ "^[a-z_][a-z0-9_]*$" }; -static const cmsys::RegularExpression IdRegex{ "^[a-z0-9_]+$" }; - -bool cmCTestHardwareSpec::ReadFromJSONFile(const std::string& filename) -{ - cmsys::ifstream fin(filename.c_str()); - if (!fin) { - return false; - } - - Json::Value root; - Json::CharReaderBuilder builder; - if (!Json::parseFromStream(builder, fin, &root, nullptr)) { - return false; - } - - if (!root.isObject()) { - return false; - } - - auto const& local = root["local"]; - if (!local.isArray()) { - return false; - } - if (local.size() > 1) { - return false; - } - - if (local.empty()) { - this->LocalSocket.Resources.clear(); - return true; - } - - auto const& localSocket = local[0]; - if (!localSocket.isObject()) { - return false; - } - std::map> resources; - cmsys::RegularExpressionMatch match; - for (auto const& key : localSocket.getMemberNames()) { - if (IdentifierRegex.find(key.c_str(), match)) { - auto const& value = localSocket[key]; - auto& r = resources[key]; - if (value.isArray()) { - for (auto const& item : value) { - if (item.isObject()) { - cmCTestHardwareSpec::Resource resource; - - if (!item.isMember("id")) { - return false; - } - auto const& id = item["id"]; - if (!id.isString()) { - return false; - } - resource.Id = id.asString(); - if (!IdRegex.find(resource.Id.c_str(), match)) { - return false; - } - - if (item.isMember("slots")) { - auto const& capacity = item["slots"]; - if (!capacity.isConvertibleTo(Json::uintValue)) { - return false; - } - resource.Capacity = capacity.asUInt(); - } else { - resource.Capacity = 1; - } - - r.push_back(resource); - } else { - return false; - } - } - } else { - return false; - } - } - } - - this->LocalSocket.Resources = std::move(resources); - return true; -} - -bool cmCTestHardwareSpec::operator==(const cmCTestHardwareSpec& other) const -{ - return this->LocalSocket == other.LocalSocket; -} - -bool cmCTestHardwareSpec::operator!=(const cmCTestHardwareSpec& other) const -{ - return !(*this == other); -} - -bool cmCTestHardwareSpec::Socket::operator==( - const cmCTestHardwareSpec::Socket& other) const -{ - return this->Resources == other.Resources; -} - -bool cmCTestHardwareSpec::Socket::operator!=( - const cmCTestHardwareSpec::Socket& other) const -{ - return !(*this == other); -} - -bool cmCTestHardwareSpec::Resource::operator==( - const cmCTestHardwareSpec::Resource& other) const -{ - return this->Id == other.Id && this->Capacity == other.Capacity; -} - -bool cmCTestHardwareSpec::Resource::operator!=( - const cmCTestHardwareSpec::Resource& other) const -{ - return !(*this == other); -} diff --git a/Source/CTest/cmCTestHardwareSpec.h b/Source/CTest/cmCTestHardwareSpec.h deleted file mode 100644 index a0b4cae..0000000 --- a/Source/CTest/cmCTestHardwareSpec.h +++ /dev/null @@ -1,40 +0,0 @@ -/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying - file Copyright.txt or https://cmake.org/licensing for details. */ -#ifndef cmCTestHardwareSpec_h -#define cmCTestHardwareSpec_h - -#include -#include -#include - -class cmCTestHardwareSpec -{ -public: - class Resource - { - public: - std::string Id; - unsigned int Capacity; - - bool operator==(const Resource& other) const; - bool operator!=(const Resource& other) const; - }; - - class Socket - { - public: - std::map> Resources; - - bool operator==(const Socket& other) const; - bool operator!=(const Socket& other) const; - }; - - Socket LocalSocket; - - bool ReadFromJSONFile(const std::string& filename); - - bool operator==(const cmCTestHardwareSpec& other) const; - bool operator!=(const cmCTestHardwareSpec& other) const; -}; - -#endif diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx index df36aa2..02d396e 100644 --- a/Source/CTest/cmCTestMultiProcessHandler.cxx +++ b/Source/CTest/cmCTestMultiProcessHandler.cxx @@ -140,7 +140,7 @@ void cmCTestMultiProcessHandler::RunTests() assert(this->Completed == this->Total); assert(this->Tests.empty()); } - assert(this->AllHardwareAvailable()); + assert(this->AllResourcesAvailable()); this->MarkFinished(); this->UpdateCostData(); @@ -177,9 +177,9 @@ bool cmCTestMultiProcessHandler::StartTestProcess(int test) } testRun->SetIndex(test); testRun->SetTestProperties(this->Properties[test]); - if (this->TestHandler->UseHardwareSpec) { - testRun->SetUseAllocatedHardware(true); - testRun->SetAllocatedHardware(this->AllocatedHardware[test]); + if (this->TestHandler->UseResourceSpec) { + testRun->SetUseAllocatedResources(true); + testRun->SetAllocatedResources(this->AllocatedResources[test]); } // Find any failed dependencies for this test. We assume the more common @@ -194,7 +194,7 @@ bool cmCTestMultiProcessHandler::StartTestProcess(int test) // working directory because FinishTestProcess() will try to unlock them this->LockResources(test); - if (!this->TestsHaveSufficientHardware[test]) { + if (!this->TestsHaveSufficientResources[test]) { testRun->StartFailure("Insufficient resources"); this->FinishTestProcess(testRun, false); return false; @@ -218,26 +218,26 @@ bool cmCTestMultiProcessHandler::StartTestProcess(int test) return false; } -bool cmCTestMultiProcessHandler::AllocateHardware(int index) +bool cmCTestMultiProcessHandler::AllocateResources(int index) { - if (!this->TestHandler->UseHardwareSpec) { + if (!this->TestHandler->UseResourceSpec) { return true; } std::map> allocations; - if (!this->TryAllocateHardware(index, allocations)) { + if (!this->TryAllocateResources(index, allocations)) { return false; } - auto& allocatedHardware = this->AllocatedHardware[index]; - allocatedHardware.resize(this->Properties[index]->ResourceGroups.size()); + auto& allocatedResources = this->AllocatedResources[index]; + allocatedResources.resize(this->Properties[index]->ResourceGroups.size()); for (auto const& it : allocations) { for (auto const& alloc : it.second) { - bool result = this->HardwareAllocator.AllocateResource( + bool result = this->ResourceAllocator.AllocateResource( it.first, alloc.Id, alloc.SlotsNeeded); (void)result; assert(result); - allocatedHardware[alloc.ProcessIndex][it.first].push_back( + allocatedResources[alloc.ProcessIndex][it.first].push_back( { alloc.Id, static_cast(alloc.SlotsNeeded) }); } } @@ -245,7 +245,7 @@ bool cmCTestMultiProcessHandler::AllocateHardware(int index) return true; } -bool cmCTestMultiProcessHandler::TryAllocateHardware( +bool cmCTestMultiProcessHandler::TryAllocateResources( int index, std::map>& allocations) { @@ -262,13 +262,13 @@ bool cmCTestMultiProcessHandler::TryAllocateHardware( ++processIndex; } - auto const& availableHardware = this->HardwareAllocator.GetResources(); + auto const& availableResources = this->ResourceAllocator.GetResources(); for (auto& it : allocations) { - if (!availableHardware.count(it.first)) { + if (!availableResources.count(it.first)) { return false; } - if (!cmAllocateCTestHardwareRoundRobin(availableHardware.at(it.first), - it.second)) { + if (!cmAllocateCTestResourcesRoundRobin(availableResources.at(it.first), + it.second)) { return false; } } @@ -276,19 +276,19 @@ bool cmCTestMultiProcessHandler::TryAllocateHardware( return true; } -void cmCTestMultiProcessHandler::DeallocateHardware(int index) +void cmCTestMultiProcessHandler::DeallocateResources(int index) { - if (!this->TestHandler->UseHardwareSpec) { + if (!this->TestHandler->UseResourceSpec) { return; } { - auto& allocatedHardware = this->AllocatedHardware[index]; - for (auto const& processAlloc : allocatedHardware) { + auto& allocatedResources = this->AllocatedResources[index]; + for (auto const& processAlloc : allocatedResources) { for (auto const& it : processAlloc) { auto resourceType = it.first; for (auto const& it2 : it.second) { - bool success = this->HardwareAllocator.DeallocateResource( + bool success = this->ResourceAllocator.DeallocateResource( resourceType, it2.Id, it2.Slots); (void)success; assert(success); @@ -296,12 +296,12 @@ void cmCTestMultiProcessHandler::DeallocateHardware(int index) } } } - this->AllocatedHardware.erase(index); + this->AllocatedResources.erase(index); } -bool cmCTestMultiProcessHandler::AllHardwareAvailable() +bool cmCTestMultiProcessHandler::AllResourcesAvailable() { - for (auto const& it : this->HardwareAllocator.GetResources()) { + for (auto const& it : this->ResourceAllocator.GetResources()) { for (auto const& it2 : it.second) { if (it2.second.Locked != 0) { return false; @@ -312,13 +312,13 @@ bool cmCTestMultiProcessHandler::AllHardwareAvailable() return true; } -void cmCTestMultiProcessHandler::CheckHardwareAvailable() +void cmCTestMultiProcessHandler::CheckResourcesAvailable() { for (auto test : this->SortedTests) { std::map> allocations; - this->TestsHaveSufficientHardware[test] = - !this->TestHandler->UseHardwareSpec || - this->TryAllocateHardware(test, allocations); + this->TestsHaveSufficientResources[test] = + !this->TestHandler->UseResourceSpec || + this->TryAllocateResources(test, allocations); } } @@ -404,10 +404,10 @@ bool cmCTestMultiProcessHandler::StartTest(int test) } } - // Allocate hardware - if (this->TestsHaveSufficientHardware[test] && - !this->AllocateHardware(test)) { - this->DeallocateHardware(test); + // Allocate resources + if (this->TestsHaveSufficientResources[test] && + !this->AllocateResources(test)) { + this->DeallocateResources(test); return false; } @@ -417,7 +417,7 @@ bool cmCTestMultiProcessHandler::StartTest(int test) } // This test was not able to start because it is waiting // on depends to run - this->DeallocateHardware(test); + this->DeallocateResources(test); return false; } @@ -602,7 +602,7 @@ void cmCTestMultiProcessHandler::FinishTestProcess(cmCTestRunTest* runner, this->TestFinishMap[test] = true; this->TestRunningMap[test] = false; this->WriteCheckpoint(test); - this->DeallocateHardware(test); + this->DeallocateResources(test); this->UnlockResources(test); this->RunningCount -= GetProcessorsUsed(test); diff --git a/Source/CTest/cmCTestMultiProcessHandler.h b/Source/CTest/cmCTestMultiProcessHandler.h index f0ffdbb..1db4bfd 100644 --- a/Source/CTest/cmCTestMultiProcessHandler.h +++ b/Source/CTest/cmCTestMultiProcessHandler.h @@ -14,13 +14,13 @@ #include "cm_uv.h" -#include "cmCTestHardwareAllocator.h" +#include "cmCTestResourceAllocator.h" #include "cmCTestTestHandler.h" #include "cmUVHandlePtr.h" class cmCTest; struct cmCTestBinPackerAllocation; -class cmCTestHardwareSpec; +class cmCTestResourceSpec; class cmCTestRunTest; /** \class cmCTestMultiProcessHandler @@ -47,7 +47,7 @@ public: : public std::map { }; - struct HardwareAllocation + struct ResourceAllocation { std::string Id; unsigned int Slots; @@ -87,12 +87,12 @@ public: void SetQuiet(bool b) { this->Quiet = b; } - void InitHardwareAllocator(const cmCTestHardwareSpec& spec) + void InitResourceAllocator(const cmCTestResourceSpec& spec) { - this->HardwareAllocator.InitializeFromHardwareSpec(spec); + this->ResourceAllocator.InitializeFromResourceSpec(spec); } - void CheckHardwareAvailable(); + void CheckResourcesAvailable(); protected: // Start the next test or tests as many as are allowed by @@ -137,13 +137,13 @@ protected: void LockResources(int index); void UnlockResources(int index); - bool AllocateHardware(int index); - bool TryAllocateHardware( + bool AllocateResources(int index); + bool TryAllocateResources( int index, std::map>& allocations); - void DeallocateHardware(int index); - bool AllHardwareAvailable(); + void DeallocateResources(int index); + bool AllResourcesAvailable(); // map from test number to set of depend tests TestMap Tests; @@ -166,10 +166,10 @@ protected: std::vector LastTestsFailed; std::set LockedResources; std::map>>> - AllocatedHardware; - std::map TestsHaveSufficientHardware; - cmCTestHardwareAllocator HardwareAllocator; + std::vector>>> + AllocatedResources; + std::map TestsHaveSufficientResources; + cmCTestResourceAllocator ResourceAllocator; std::vector* TestResults; size_t ParallelLevel; // max number of process that can be run at once unsigned long TestLoad; diff --git a/Source/CTest/cmCTestResourceAllocator.cxx b/Source/CTest/cmCTestResourceAllocator.cxx new file mode 100644 index 0000000..9d468a7 --- /dev/null +++ b/Source/CTest/cmCTestResourceAllocator.cxx @@ -0,0 +1,86 @@ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ + +#include "cmCTestResourceAllocator.h" + +#include +#include + +#include "cmCTestResourceSpec.h" + +void cmCTestResourceAllocator::InitializeFromResourceSpec( + const cmCTestResourceSpec& spec) +{ + this->Resources.clear(); + + for (auto const& it : spec.LocalSocket.Resources) { + auto& res = this->Resources[it.first]; + for (auto const& specRes : it.second) { + res[specRes.Id].Total = specRes.Capacity; + res[specRes.Id].Locked = 0; + } + } +} + +const std::map>& +cmCTestResourceAllocator::GetResources() const +{ + return this->Resources; +} + +bool cmCTestResourceAllocator::AllocateResource(const std::string& name, + const std::string& id, + unsigned int slots) +{ + auto it = this->Resources.find(name); + if (it == this->Resources.end()) { + return false; + } + + auto resIt = it->second.find(id); + if (resIt == it->second.end()) { + return false; + } + + if (resIt->second.Total < resIt->second.Locked + slots) { + return false; + } + + resIt->second.Locked += slots; + return true; +} + +bool cmCTestResourceAllocator::DeallocateResource(const std::string& name, + const std::string& id, + unsigned int slots) +{ + auto it = this->Resources.find(name); + if (it == this->Resources.end()) { + return false; + } + + auto resIt = it->second.find(id); + if (resIt == it->second.end()) { + return false; + } + + if (resIt->second.Locked < slots) { + return false; + } + + resIt->second.Locked -= slots; + return true; +} + +bool cmCTestResourceAllocator::Resource::operator==( + const Resource& other) const +{ + return this->Total == other.Total && this->Locked == other.Locked; +} + +bool cmCTestResourceAllocator::Resource::operator!=( + const Resource& other) const +{ + return !(*this == other); +} diff --git a/Source/CTest/cmCTestResourceAllocator.h b/Source/CTest/cmCTestResourceAllocator.h new file mode 100644 index 0000000..9f0b9c9 --- /dev/null +++ b/Source/CTest/cmCTestResourceAllocator.h @@ -0,0 +1,39 @@ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ +#ifndef cmCTestResourceAllocator_h +#define cmCTestResourceAllocator_h + +#include +#include + +class cmCTestResourceSpec; + +class cmCTestResourceAllocator +{ +public: + struct Resource + { + unsigned int Total; + unsigned int Locked; + + unsigned int Free() const { return this->Total - this->Locked; } + + bool operator==(const Resource& other) const; + bool operator!=(const Resource& other) const; + }; + + void InitializeFromResourceSpec(const cmCTestResourceSpec& spec); + + const std::map>& GetResources() + const; + + bool AllocateResource(const std::string& name, const std::string& id, + unsigned int slots); + bool DeallocateResource(const std::string& name, const std::string& id, + unsigned int slots); + +private: + std::map> Resources; +}; + +#endif diff --git a/Source/CTest/cmCTestResourceSpec.cxx b/Source/CTest/cmCTestResourceSpec.cxx new file mode 100644 index 0000000..b4a2b30 --- /dev/null +++ b/Source/CTest/cmCTestResourceSpec.cxx @@ -0,0 +1,133 @@ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ +#include "cmCTestResourceSpec.h" + +#include +#include +#include +#include + +#include "cmsys/FStream.hxx" +#include "cmsys/RegularExpression.hxx" + +#include "cm_jsoncpp_reader.h" +#include "cm_jsoncpp_value.h" + +static const cmsys::RegularExpression IdentifierRegex{ "^[a-z_][a-z0-9_]*$" }; +static const cmsys::RegularExpression IdRegex{ "^[a-z0-9_]+$" }; + +bool cmCTestResourceSpec::ReadFromJSONFile(const std::string& filename) +{ + cmsys::ifstream fin(filename.c_str()); + if (!fin) { + return false; + } + + Json::Value root; + Json::CharReaderBuilder builder; + if (!Json::parseFromStream(builder, fin, &root, nullptr)) { + return false; + } + + if (!root.isObject()) { + return false; + } + + auto const& local = root["local"]; + if (!local.isArray()) { + return false; + } + if (local.size() > 1) { + return false; + } + + if (local.empty()) { + this->LocalSocket.Resources.clear(); + return true; + } + + auto const& localSocket = local[0]; + if (!localSocket.isObject()) { + return false; + } + std::map> resources; + cmsys::RegularExpressionMatch match; + for (auto const& key : localSocket.getMemberNames()) { + if (IdentifierRegex.find(key.c_str(), match)) { + auto const& value = localSocket[key]; + auto& r = resources[key]; + if (value.isArray()) { + for (auto const& item : value) { + if (item.isObject()) { + cmCTestResourceSpec::Resource resource; + + if (!item.isMember("id")) { + return false; + } + auto const& id = item["id"]; + if (!id.isString()) { + return false; + } + resource.Id = id.asString(); + if (!IdRegex.find(resource.Id.c_str(), match)) { + return false; + } + + if (item.isMember("slots")) { + auto const& capacity = item["slots"]; + if (!capacity.isConvertibleTo(Json::uintValue)) { + return false; + } + resource.Capacity = capacity.asUInt(); + } else { + resource.Capacity = 1; + } + + r.push_back(resource); + } else { + return false; + } + } + } else { + return false; + } + } + } + + this->LocalSocket.Resources = std::move(resources); + return true; +} + +bool cmCTestResourceSpec::operator==(const cmCTestResourceSpec& other) const +{ + return this->LocalSocket == other.LocalSocket; +} + +bool cmCTestResourceSpec::operator!=(const cmCTestResourceSpec& other) const +{ + return !(*this == other); +} + +bool cmCTestResourceSpec::Socket::operator==( + const cmCTestResourceSpec::Socket& other) const +{ + return this->Resources == other.Resources; +} + +bool cmCTestResourceSpec::Socket::operator!=( + const cmCTestResourceSpec::Socket& other) const +{ + return !(*this == other); +} + +bool cmCTestResourceSpec::Resource::operator==( + const cmCTestResourceSpec::Resource& other) const +{ + return this->Id == other.Id && this->Capacity == other.Capacity; +} + +bool cmCTestResourceSpec::Resource::operator!=( + const cmCTestResourceSpec::Resource& other) const +{ + return !(*this == other); +} diff --git a/Source/CTest/cmCTestResourceSpec.h b/Source/CTest/cmCTestResourceSpec.h new file mode 100644 index 0000000..4646db8 --- /dev/null +++ b/Source/CTest/cmCTestResourceSpec.h @@ -0,0 +1,40 @@ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing for details. */ +#ifndef cmCTestResourceSpec_h +#define cmCTestResourceSpec_h + +#include +#include +#include + +class cmCTestResourceSpec +{ +public: + class Resource + { + public: + std::string Id; + unsigned int Capacity; + + bool operator==(const Resource& other) const; + bool operator!=(const Resource& other) const; + }; + + class Socket + { + public: + std::map> Resources; + + bool operator==(const Socket& other) const; + bool operator!=(const Socket& other) const; + }; + + Socket LocalSocket; + + bool ReadFromJSONFile(const std::string& filename); + + bool operator==(const cmCTestResourceSpec& other) const; + bool operator!=(const cmCTestResourceSpec& other) const; +}; + +#endif diff --git a/Source/CTest/cmCTestRunTest.cxx b/Source/CTest/cmCTestRunTest.cxx index 91eeb71..3091050 100644 --- a/Source/CTest/cmCTestRunTest.cxx +++ b/Source/CTest/cmCTestRunTest.cxx @@ -690,8 +690,8 @@ bool cmCTestRunTest::ForkProcess(cmDuration testTimeOut, bool explicitTimeout, cmSystemTools::AppendEnv(*environment); } - if (this->UseAllocatedHardware) { - this->SetupHardwareEnvironment(); + if (this->UseAllocatedResources) { + this->SetupResourcesEnvironment(); } else { cmSystemTools::UnsetEnv("CTEST_RESOURCE_GROUP_COUNT"); } @@ -700,14 +700,14 @@ bool cmCTestRunTest::ForkProcess(cmDuration testTimeOut, bool explicitTimeout, affinity); } -void cmCTestRunTest::SetupHardwareEnvironment() +void cmCTestRunTest::SetupResourcesEnvironment() { std::string processCount = "CTEST_RESOURCE_GROUP_COUNT="; - processCount += std::to_string(this->AllocatedHardware.size()); + processCount += std::to_string(this->AllocatedResources.size()); cmSystemTools::PutEnv(processCount); std::size_t i = 0; - for (auto const& process : this->AllocatedHardware) { + for (auto const& process : this->AllocatedResources) { std::string prefix = "CTEST_RESOURCE_GROUP_"; prefix += std::to_string(i); std::string resourceList = prefix + '='; diff --git a/Source/CTest/cmCTestRunTest.h b/Source/CTest/cmCTestRunTest.h index 085a6b8..f781c7a 100644 --- a/Source/CTest/cmCTestRunTest.h +++ b/Source/CTest/cmCTestRunTest.h @@ -84,14 +84,17 @@ public: bool TimedOutForStopTime() const { return this->TimeoutIsForStopTime; } - void SetUseAllocatedHardware(bool use) { this->UseAllocatedHardware = use; } - void SetAllocatedHardware( + void SetUseAllocatedResources(bool use) + { + this->UseAllocatedResources = use; + } + void SetAllocatedResources( const std::vector< std::map>>& - hardware) + std::vector>>& + resources) { - this->AllocatedHardware = hardware; + this->AllocatedResources = resources; } private: @@ -105,7 +108,7 @@ private: // Run post processing of the process output for MemCheck void MemCheckPostProcess(); - void SetupHardwareEnvironment(); + void SetupResourcesEnvironment(); // Returns "completed/total Test #Index: " std::string GetTestPrefix(size_t completed, size_t total) const; @@ -125,10 +128,10 @@ private: std::string StartTime; std::string ActualCommand; std::vector Arguments; - bool UseAllocatedHardware = false; + bool UseAllocatedResources = false; std::vector>> - AllocatedHardware; + std::string, std::vector>> + AllocatedResources; bool RunUntilFail; int NumberOfRunsLeft; bool RunAgain; diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx index f17ed86..9784214 100644 --- a/Source/CTest/cmCTestTestCommand.cxx +++ b/Source/CTest/cmCTestTestCommand.cxx @@ -32,7 +32,7 @@ void cmCTestTestCommand::BindArguments() this->Bind("SCHEDULE_RANDOM"_s, this->ScheduleRandom); this->Bind("STOP_TIME"_s, this->StopTime); this->Bind("TEST_LOAD"_s, this->TestLoad); - this->Bind("RESOURCE_SPEC_FILE"_s, this->HardwareSpecFile); + this->Bind("RESOURCE_SPEC_FILE"_s, this->ResourceSpecFile); } cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler() @@ -88,8 +88,8 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler() if (!this->ScheduleRandom.empty()) { handler->SetOption("ScheduleRandom", this->ScheduleRandom.c_str()); } - if (!this->HardwareSpecFile.empty()) { - handler->SetOption("ResourceSpecFile", this->HardwareSpecFile.c_str()); + if (!this->ResourceSpecFile.empty()) { + handler->SetOption("ResourceSpecFile", this->ResourceSpecFile.c_str()); } if (!this->StopTime.empty()) { this->CTest->SetStopTime(this->StopTime); diff --git a/Source/CTest/cmCTestTestCommand.h b/Source/CTest/cmCTestTestCommand.h index dc15279..4019694 100644 --- a/Source/CTest/cmCTestTestCommand.h +++ b/Source/CTest/cmCTestTestCommand.h @@ -58,7 +58,7 @@ protected: std::string ScheduleRandom; std::string StopTime; std::string TestLoad; - std::string HardwareSpecFile; + std::string ResourceSpecFile; }; #endif diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx index 2220074..8e3ac22 100644 --- a/Source/CTest/cmCTestTestHandler.cxx +++ b/Source/CTest/cmCTestTestHandler.cxx @@ -289,7 +289,7 @@ cmCTestTestHandler::cmCTestTestHandler() this->UseIncludeRegExpFlag = false; this->UseExcludeRegExpFlag = false; this->UseExcludeRegExpFirst = false; - this->UseHardwareSpec = false; + this->UseResourceSpec = false; this->CustomMaximumPassedTestOutputSize = 1 * 1024; this->CustomMaximumFailedTestOutputSize = 300 * 1024; @@ -512,8 +512,8 @@ bool cmCTestTestHandler::ProcessOptions() val = this->GetOption("ResourceSpecFile"); if (val) { - this->UseHardwareSpec = true; - if (!this->HardwareSpec.ReadFromJSONFile(val)) { + this->UseResourceSpec = true; + if (!this->ResourceSpec.ReadFromJSONFile(val)) { cmCTestLog(this->CTest, ERROR_MESSAGE, "Could not read resource spec file: " << val << std::endl); return false; @@ -1237,8 +1237,8 @@ void cmCTestTestHandler::ProcessDirectory(std::vector& passed, } else { parallel->SetTestLoad(this->CTest->GetTestLoad()); } - if (this->UseHardwareSpec) { - parallel->InitHardwareAllocator(this->HardwareSpec); + if (this->UseResourceSpec) { + parallel->InitResourceAllocator(this->ResourceSpec); } *this->LogFile @@ -1283,7 +1283,7 @@ void cmCTestTestHandler::ProcessDirectory(std::vector& passed, parallel->SetPassFailVectors(&passed, &failed); this->TestResults.clear(); parallel->SetTestResults(&this->TestResults); - parallel->CheckHardwareAvailable(); + parallel->CheckResourcesAvailable(); if (this->CTest->ShouldPrintLabels()) { parallel->PrintLabels(); diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h index e2fde42..eab75d0 100644 --- a/Source/CTest/cmCTestTestHandler.h +++ b/Source/CTest/cmCTestTestHandler.h @@ -19,7 +19,7 @@ #include "cmsys/RegularExpression.hxx" #include "cmCTestGenericHandler.h" -#include "cmCTestHardwareSpec.h" +#include "cmCTestResourceSpec.h" #include "cmDuration.h" #include "cmListFileCache.h" @@ -336,8 +336,8 @@ private: cmsys::RegularExpression IncludeTestsRegularExpression; cmsys::RegularExpression ExcludeTestsRegularExpression; - bool UseHardwareSpec; - cmCTestHardwareSpec HardwareSpec; + bool UseResourceSpec; + cmCTestResourceSpec ResourceSpec; void GenerateRegressionImages(cmXMLWriter& xml, const std::string& dart); cmsys::RegularExpression DartStuff1; diff --git a/Tests/CMakeLib/CMakeLists.txt b/Tests/CMakeLib/CMakeLists.txt index 8e11fdf..840afc1 100644 --- a/Tests/CMakeLib/CMakeLists.txt +++ b/Tests/CMakeLib/CMakeLists.txt @@ -8,8 +8,8 @@ include_directories( set(CMakeLib_TESTS testArgumentParser.cxx testCTestBinPacker.cxx - testCTestHardwareAllocator.cxx - testCTestHardwareSpec.cxx + testCTestResourceAllocator.cxx + testCTestResourceSpec.cxx testCTestResourceGroups.cxx testGeneratedFileStream.cxx testRST.cxx @@ -32,7 +32,7 @@ add_executable(testUVProcessChainHelper testUVProcessChainHelper.cxx) set(testRST_ARGS ${CMAKE_CURRENT_SOURCE_DIR}) set(testUVProcessChain_ARGS $) set(testUVStreambuf_ARGS $) -set(testCTestHardwareSpec_ARGS ${CMAKE_CURRENT_SOURCE_DIR}) +set(testCTestResourceSpec_ARGS ${CMAKE_CURRENT_SOURCE_DIR}) if(WIN32) list(APPEND CMakeLib_TESTS diff --git a/Tests/CMakeLib/testCTestBinPacker.cxx b/Tests/CMakeLib/testCTestBinPacker.cxx index 62ea55b..6f09af2 100644 --- a/Tests/CMakeLib/testCTestBinPacker.cxx +++ b/Tests/CMakeLib/testCTestBinPacker.cxx @@ -5,12 +5,12 @@ #include #include "cmCTestBinPacker.h" -#include "cmCTestHardwareAllocator.h" +#include "cmCTestResourceAllocator.h" struct ExpectedPackResult { std::vector SlotsNeeded; - std::map Hardware; + std::map Resources; bool ExpectedReturnValue; std::vector ExpectedRoundRobinAllocations; std::vector ExpectedBlockAllocations; @@ -233,18 +233,18 @@ bool TestExpectedPackResult(const ExpectedPackResult& expected) roundRobinAllocations.push_back({ index++, n, "" }); } - bool roundRobinResult = cmAllocateCTestHardwareRoundRobin( - expected.Hardware, roundRobinAllocations); + bool roundRobinResult = cmAllocateCTestResourcesRoundRobin( + expected.Resources, roundRobinAllocations); if (roundRobinResult != expected.ExpectedReturnValue) { std::cout - << "cmAllocateCTestHardwareRoundRobin did not return expected value" + << "cmAllocateCTestResourcesRoundRobin did not return expected value" << std::endl; return false; } if (roundRobinResult && roundRobinAllocations != expected.ExpectedRoundRobinAllocations) { - std::cout << "cmAllocateCTestHardwareRoundRobin did not return expected " + std::cout << "cmAllocateCTestResourcesRoundRobin did not return expected " "allocations" << std::endl; return false; @@ -258,15 +258,15 @@ bool TestExpectedPackResult(const ExpectedPackResult& expected) } bool blockResult = - cmAllocateCTestHardwareBlock(expected.Hardware, blockAllocations); + cmAllocateCTestResourcesBlock(expected.Resources, blockAllocations); if (blockResult != expected.ExpectedReturnValue) { - std::cout << "cmAllocateCTestHardwareBlock did not return expected value" + std::cout << "cmAllocateCTestResourcesBlock did not return expected value" << std::endl; return false; } if (blockResult && blockAllocations != expected.ExpectedBlockAllocations) { - std::cout << "cmAllocateCTestHardwareBlock did not return expected" + std::cout << "cmAllocateCTestResourcesBlock did not return expected" " allocations" << std::endl; return false; diff --git a/Tests/CMakeLib/testCTestHardwareAllocator.cxx b/Tests/CMakeLib/testCTestHardwareAllocator.cxx deleted file mode 100644 index 6f05d03..0000000 --- a/Tests/CMakeLib/testCTestHardwareAllocator.cxx +++ /dev/null @@ -1,426 +0,0 @@ -#include -#include -#include -#include - -#include "cmCTestHardwareAllocator.h" -#include "cmCTestHardwareSpec.h" - -static const cmCTestHardwareSpec spec{ { { - /* clang-format off */ - { "gpus", { { "0", 4 }, { "1", 8 }, { "2", 0 }, { "3", 8 } } }, - /* clang-format on */ -} } }; - -bool testInitializeFromHardwareSpec() -{ - bool retval = true; - - cmCTestHardwareAllocator allocator; - allocator.InitializeFromHardwareSpec(spec); - - static const std::map< - std::string, std::map> - expected{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 0 } }, - { "1", { 8, 0 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (allocator.GetResources() != expected) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - return retval; -} - -bool testAllocateResource() -{ - bool retval = true; - - cmCTestHardwareAllocator allocator; - allocator.InitializeFromHardwareSpec(spec); - - static const std::map< - std::string, std::map> - expected1{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 2 } }, - { "1", { 8, 0 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (!allocator.AllocateResource("gpus", "0", 2)) { - std::cout - << "AllocateResource(\"gpus\", \"0\", 2) returned false, should be " - "true\n"; - retval = false; - } - if (allocator.GetResources() != expected1) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - static const std::map< - std::string, std::map> - expected2{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 4 } }, - { "1", { 8, 0 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (!allocator.AllocateResource("gpus", "0", 2)) { - std::cout - << "AllocateResource(\"gpus\", \"0\", 2) returned false, should be " - "true\n"; - retval = false; - } - if (allocator.GetResources() != expected2) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - static const std::map< - std::string, std::map> - expected3{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 4 } }, - { "1", { 8, 0 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (allocator.AllocateResource("gpus", "0", 1)) { - std::cout - << "AllocateResource(\"gpus\", \"0\", 1) returned true, should be " - "false\n"; - retval = false; - } - if (allocator.GetResources() != expected3) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - static const std::map< - std::string, std::map> - expected4{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 4 } }, - { "1", { 8, 7 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (!allocator.AllocateResource("gpus", "1", 7)) { - std::cout - << "AllocateResource(\"gpus\", \"1\", 7) returned false, should be " - "true\n"; - retval = false; - } - if (allocator.AllocateResource("gpus", "1", 2)) { - std::cout - << "AllocateResource(\"gpus\", \"1\", 2) returned true, should be " - "false\n"; - retval = false; - } - if (allocator.GetResources() != expected4) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - static const std::map< - std::string, std::map> - expected5{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 4 } }, - { "1", { 8, 7 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (allocator.AllocateResource("gpus", "2", 1)) { - std::cout - << "AllocateResource(\"gpus\", \"2\", 1) returned true, should be " - "false\n"; - retval = false; - } - if (allocator.GetResources() != expected5) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - static const std::map< - std::string, std::map> - expected6{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 4 } }, - { "1", { 8, 7 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (allocator.AllocateResource("gpus", "4", 1)) { - std::cout - << "AllocateResource(\"gpus\", \"4\", 1) returned true, should be " - "false\n"; - retval = false; - } - if (allocator.GetResources() != expected6) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - static const std::map< - std::string, std::map> - expected7{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 4 } }, - { "1", { 8, 7 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (allocator.AllocateResource("threads", "0", 1)) { - std::cout - << "AllocateResource(\"threads\", \"0\", 1) returned true, should be" - " false\n"; - retval = false; - } - if (allocator.GetResources() != expected7) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - return retval; -} - -bool testDeallocateResource() -{ - bool retval = true; - - cmCTestHardwareAllocator allocator; - allocator.InitializeFromHardwareSpec(spec); - - static const std::map< - std::string, std::map> - expected1{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 1 } }, - { "1", { 8, 0 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (!allocator.AllocateResource("gpus", "0", 2)) { - std::cout - << "AllocateResource(\"gpus\", \"0\", 2) returned false, should be " - "true\n"; - retval = false; - } - if (!allocator.DeallocateResource("gpus", "0", 1)) { - std::cout - << "DeallocateResource(\"gpus\", \"0\", 1) returned false, should be" - " true\n"; - retval = false; - } - if (allocator.GetResources() != expected1) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - static const std::map< - std::string, std::map> - expected2{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 1 } }, - { "1", { 8, 0 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (allocator.DeallocateResource("gpus", "0", 2)) { - std::cout - << "DeallocateResource(\"gpus\", \"0\", 2) returned true, should be" - " false\n"; - retval = false; - } - if (allocator.GetResources() != expected2) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - static const std::map< - std::string, std::map> - expected3{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 0 } }, - { "1", { 8, 0 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (!allocator.DeallocateResource("gpus", "0", 1)) { - std::cout - << "DeallocateResource(\"gpus\", \"0\", 1) returned false, should be" - " true\n"; - retval = false; - } - if (allocator.GetResources() != expected3) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - static const std::map< - std::string, std::map> - expected4{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 0 } }, - { "1", { 8, 0 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (allocator.DeallocateResource("gpus", "0", 1)) { - std::cout - << "DeallocateResource(\"gpus\", \"0\", 1) returned true, should be" - " false\n"; - retval = false; - } - if (allocator.GetResources() != expected4) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - static const std::map< - std::string, std::map> - expected5{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 0 } }, - { "1", { 8, 0 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (allocator.DeallocateResource("gpus", "4", 1)) { - std::cout - << "DeallocateResource(\"gpus\", \"4\", 1) returned true, should be" - " false\n"; - retval = false; - } - if (allocator.GetResources() != expected5) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - static const std::map< - std::string, std::map> - expected6{ - /* clang-format off */ - { "gpus", { - { "0", { 4, 0 } }, - { "1", { 8, 0 } }, - { "2", { 0, 0 } }, - { "3", { 8, 0 } }, - } }, - /* clang-format on */ - }; - if (allocator.DeallocateResource("threads", "0", 1)) { - std::cout - << "DeallocateResource(\"threads\", \"0\", 1) returned true, should be" - " false\n"; - retval = false; - } - if (allocator.GetResources() != expected6) { - std::cout << "GetResources() did not return expected value\n"; - retval = false; - } - - return retval; -} - -bool testResourceFree() -{ - bool retval = true; - - const cmCTestHardwareAllocator::Resource r1{ 5, 0 }; - if (r1.Free() != 5) { - std::cout << "cmCTestHardwareAllocator::Resource::Free() did not return " - "expected value for { 5, 0 }\n"; - retval = false; - } - - const cmCTestHardwareAllocator::Resource r2{ 3, 2 }; - if (r2.Free() != 1) { - std::cout << "cmCTestHardwareAllocator::Resource::Free() did not return " - "expected value for { 3, 2 }\n"; - retval = false; - } - - const cmCTestHardwareAllocator::Resource r3{ 4, 4 }; - if (r3.Free() != 0) { - std::cout << "cmCTestHardwareAllocator::Resource::Free() did not return " - "expected value for { 4, 4 }\n"; - retval = false; - } - - return retval; -} - -int testCTestHardwareAllocator(int, char** const) -{ - int retval = 0; - - if (!testInitializeFromHardwareSpec()) { - std::cout << "in testInitializeFromHardwareSpec()\n"; - retval = -1; - } - - if (!testAllocateResource()) { - std::cout << "in testAllocateResource()\n"; - retval = -1; - } - - if (!testDeallocateResource()) { - std::cout << "in testDeallocateResource()\n"; - retval = -1; - } - - if (!testResourceFree()) { - std::cout << "in testResourceFree()\n"; - retval = -1; - } - - return retval; -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec.cxx b/Tests/CMakeLib/testCTestHardwareSpec.cxx deleted file mode 100644 index 3e3eccc..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec.cxx +++ /dev/null @@ -1,84 +0,0 @@ -#include -#include -#include - -#include "cmCTestHardwareSpec.h" - -struct ExpectedSpec -{ - std::string Path; - bool ParseResult; - cmCTestHardwareSpec Expected; -}; - -static const std::vector expectedHardwareSpecs = { - /* clang-format off */ - {"spec1.json", true, {{{ - {"gpus", { - {"2", 4}, - {"e", 1}, - }}, - {"threads", { - }}, - }}}}, - {"spec2.json", true, {{{ - }}}}, - {"spec3.json", false, {{{}}}}, - {"spec4.json", false, {{{}}}}, - {"spec5.json", false, {{{}}}}, - {"spec6.json", false, {{{}}}}, - {"spec7.json", false, {{{}}}}, - {"spec8.json", false, {{{}}}}, - {"spec9.json", false, {{{}}}}, - {"spec10.json", false, {{{}}}}, - {"spec11.json", false, {{{}}}}, - {"spec12.json", false, {{{}}}}, - {"spec13.json", false, {{{}}}}, - {"spec14.json", true, {{{}}}}, - {"spec15.json", true, {{{}}}}, - {"spec16.json", true, {{{}}}}, - {"spec17.json", false, {{{}}}}, - {"spec18.json", false, {{{}}}}, - {"noexist.json", false, {{{}}}}, - /* clang-format on */ -}; - -static bool testSpec(const std::string& path, bool expectedResult, - const cmCTestHardwareSpec& expected) -{ - cmCTestHardwareSpec actual; - bool result = actual.ReadFromJSONFile(path); - if (result != expectedResult) { - std::cout << "ReadFromJSONFile(\"" << path << "\") returned " << result - << ", should be " << expectedResult << std::endl; - return false; - } - - if (result && actual != expected) { - std::cout << "ReadFromJSONFile(\"" << path - << "\") did not give expected spec" << std::endl; - return false; - } - - return true; -} - -int testCTestHardwareSpec(int argc, char** const argv) -{ - if (argc < 2) { - std::cout << "Invalid arguments.\n"; - return -1; - } - - int retval = 0; - for (auto const& spec : expectedHardwareSpecs) { - std::string path = argv[1]; - path += "/testCTestHardwareSpec_data/"; - path += spec.Path; - if (!testSpec(path, spec.ParseResult, spec.Expected)) { - retval = -1; - } - } - - return retval; -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec1.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec1.json deleted file mode 100644 index ee3d0ce..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec1.json +++ /dev/null @@ -1,23 +0,0 @@ -{ - "local": [ - { - "gpus": [ - { - "id": "2", - "slots": 4 - }, - { - "id": "e" - } - ], - ".reserved": [ - { - "id": "a", - "slots": 3 - } - ], - "threads": [ - ] - } - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec10.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec10.json deleted file mode 100644 index 22105d7..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec10.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "local": [ - { - "gpus": [ - { - "id": 4 - } - ] - } - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec11.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec11.json deleted file mode 100644 index 1e37ef5..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec11.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "local": [ - { - "gpus": [ - { - "id": "4", - "slots": "giraffe" - } - ] - } - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec12.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec12.json deleted file mode 100644 index fe51488..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec12.json +++ /dev/null @@ -1 +0,0 @@ -[] diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec13.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec13.json deleted file mode 100644 index 6b7a9f4..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec13.json +++ /dev/null @@ -1 +0,0 @@ -not json diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec14.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec14.json deleted file mode 100644 index ce708c7..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec14.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "local": [ - { - "0": [ - ] - } - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec15.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec15.json deleted file mode 100644 index 78b6990..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec15.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "local": [ - { - "-": [ - ] - } - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec16.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec16.json deleted file mode 100644 index 95c7d26..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec16.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "local": [ - { - "A": [ - ] - } - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec17.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec17.json deleted file mode 100644 index 1b6ab4b..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec17.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "local": [ - { - "gpus": [ - { - "id": "A" - } - ] - } - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec18.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec18.json deleted file mode 100644 index 1a17df7..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec18.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "local": [ - { - "gpus": [ - { - "id": "-" - } - ] - } - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec2.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec2.json deleted file mode 100644 index 6175b1a..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec2.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "local": [ - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec3.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec3.json deleted file mode 100644 index 82453ec..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec3.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "local": [ - { - }, - { - } - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec4.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec4.json deleted file mode 100644 index 05e73d7..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec4.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "local": { - } -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec5.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec5.json deleted file mode 100644 index 2c63c08..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec5.json +++ /dev/null @@ -1,2 +0,0 @@ -{ -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec6.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec6.json deleted file mode 100644 index 93c790d..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec6.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "local": [ - [] - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec7.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec7.json deleted file mode 100644 index 28b6a4f..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec7.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "local": [ - { - "gpus": { - } - } - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec8.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec8.json deleted file mode 100644 index 79bd224..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec8.json +++ /dev/null @@ -1,9 +0,0 @@ -{ - "local": [ - { - "gpus": [ - [] - ] - } - ] -} diff --git a/Tests/CMakeLib/testCTestHardwareSpec_data/spec9.json b/Tests/CMakeLib/testCTestHardwareSpec_data/spec9.json deleted file mode 100644 index 6bb1def..0000000 --- a/Tests/CMakeLib/testCTestHardwareSpec_data/spec9.json +++ /dev/null @@ -1,10 +0,0 @@ -{ - "local": [ - { - "gpus": [ - { - } - ] - } - ] -} diff --git a/Tests/CMakeLib/testCTestResourceAllocator.cxx b/Tests/CMakeLib/testCTestResourceAllocator.cxx new file mode 100644 index 0000000..33d6b91 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceAllocator.cxx @@ -0,0 +1,426 @@ +#include +#include +#include +#include + +#include "cmCTestResourceAllocator.h" +#include "cmCTestResourceSpec.h" + +static const cmCTestResourceSpec spec{ { { + /* clang-format off */ + { "gpus", { { "0", 4 }, { "1", 8 }, { "2", 0 }, { "3", 8 } } }, + /* clang-format on */ +} } }; + +bool testInitializeFromResourceSpec() +{ + bool retval = true; + + cmCTestResourceAllocator allocator; + allocator.InitializeFromResourceSpec(spec); + + static const std::map< + std::string, std::map> + expected{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 0 } }, + { "1", { 8, 0 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (allocator.GetResources() != expected) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + return retval; +} + +bool testAllocateResource() +{ + bool retval = true; + + cmCTestResourceAllocator allocator; + allocator.InitializeFromResourceSpec(spec); + + static const std::map< + std::string, std::map> + expected1{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 2 } }, + { "1", { 8, 0 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (!allocator.AllocateResource("gpus", "0", 2)) { + std::cout + << "AllocateResource(\"gpus\", \"0\", 2) returned false, should be " + "true\n"; + retval = false; + } + if (allocator.GetResources() != expected1) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + static const std::map< + std::string, std::map> + expected2{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 4 } }, + { "1", { 8, 0 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (!allocator.AllocateResource("gpus", "0", 2)) { + std::cout + << "AllocateResource(\"gpus\", \"0\", 2) returned false, should be " + "true\n"; + retval = false; + } + if (allocator.GetResources() != expected2) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + static const std::map< + std::string, std::map> + expected3{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 4 } }, + { "1", { 8, 0 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (allocator.AllocateResource("gpus", "0", 1)) { + std::cout + << "AllocateResource(\"gpus\", \"0\", 1) returned true, should be " + "false\n"; + retval = false; + } + if (allocator.GetResources() != expected3) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + static const std::map< + std::string, std::map> + expected4{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 4 } }, + { "1", { 8, 7 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (!allocator.AllocateResource("gpus", "1", 7)) { + std::cout + << "AllocateResource(\"gpus\", \"1\", 7) returned false, should be " + "true\n"; + retval = false; + } + if (allocator.AllocateResource("gpus", "1", 2)) { + std::cout + << "AllocateResource(\"gpus\", \"1\", 2) returned true, should be " + "false\n"; + retval = false; + } + if (allocator.GetResources() != expected4) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + static const std::map< + std::string, std::map> + expected5{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 4 } }, + { "1", { 8, 7 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (allocator.AllocateResource("gpus", "2", 1)) { + std::cout + << "AllocateResource(\"gpus\", \"2\", 1) returned true, should be " + "false\n"; + retval = false; + } + if (allocator.GetResources() != expected5) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + static const std::map< + std::string, std::map> + expected6{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 4 } }, + { "1", { 8, 7 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (allocator.AllocateResource("gpus", "4", 1)) { + std::cout + << "AllocateResource(\"gpus\", \"4\", 1) returned true, should be " + "false\n"; + retval = false; + } + if (allocator.GetResources() != expected6) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + static const std::map< + std::string, std::map> + expected7{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 4 } }, + { "1", { 8, 7 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (allocator.AllocateResource("threads", "0", 1)) { + std::cout + << "AllocateResource(\"threads\", \"0\", 1) returned true, should be" + " false\n"; + retval = false; + } + if (allocator.GetResources() != expected7) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + return retval; +} + +bool testDeallocateResource() +{ + bool retval = true; + + cmCTestResourceAllocator allocator; + allocator.InitializeFromResourceSpec(spec); + + static const std::map< + std::string, std::map> + expected1{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 1 } }, + { "1", { 8, 0 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (!allocator.AllocateResource("gpus", "0", 2)) { + std::cout + << "AllocateResource(\"gpus\", \"0\", 2) returned false, should be " + "true\n"; + retval = false; + } + if (!allocator.DeallocateResource("gpus", "0", 1)) { + std::cout + << "DeallocateResource(\"gpus\", \"0\", 1) returned false, should be" + " true\n"; + retval = false; + } + if (allocator.GetResources() != expected1) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + static const std::map< + std::string, std::map> + expected2{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 1 } }, + { "1", { 8, 0 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (allocator.DeallocateResource("gpus", "0", 2)) { + std::cout + << "DeallocateResource(\"gpus\", \"0\", 2) returned true, should be" + " false\n"; + retval = false; + } + if (allocator.GetResources() != expected2) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + static const std::map< + std::string, std::map> + expected3{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 0 } }, + { "1", { 8, 0 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (!allocator.DeallocateResource("gpus", "0", 1)) { + std::cout + << "DeallocateResource(\"gpus\", \"0\", 1) returned false, should be" + " true\n"; + retval = false; + } + if (allocator.GetResources() != expected3) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + static const std::map< + std::string, std::map> + expected4{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 0 } }, + { "1", { 8, 0 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (allocator.DeallocateResource("gpus", "0", 1)) { + std::cout + << "DeallocateResource(\"gpus\", \"0\", 1) returned true, should be" + " false\n"; + retval = false; + } + if (allocator.GetResources() != expected4) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + static const std::map< + std::string, std::map> + expected5{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 0 } }, + { "1", { 8, 0 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (allocator.DeallocateResource("gpus", "4", 1)) { + std::cout + << "DeallocateResource(\"gpus\", \"4\", 1) returned true, should be" + " false\n"; + retval = false; + } + if (allocator.GetResources() != expected5) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + static const std::map< + std::string, std::map> + expected6{ + /* clang-format off */ + { "gpus", { + { "0", { 4, 0 } }, + { "1", { 8, 0 } }, + { "2", { 0, 0 } }, + { "3", { 8, 0 } }, + } }, + /* clang-format on */ + }; + if (allocator.DeallocateResource("threads", "0", 1)) { + std::cout + << "DeallocateResource(\"threads\", \"0\", 1) returned true, should be" + " false\n"; + retval = false; + } + if (allocator.GetResources() != expected6) { + std::cout << "GetResources() did not return expected value\n"; + retval = false; + } + + return retval; +} + +bool testResourceFree() +{ + bool retval = true; + + const cmCTestResourceAllocator::Resource r1{ 5, 0 }; + if (r1.Free() != 5) { + std::cout << "cmCTestResourceAllocator::Resource::Free() did not return " + "expected value for { 5, 0 }\n"; + retval = false; + } + + const cmCTestResourceAllocator::Resource r2{ 3, 2 }; + if (r2.Free() != 1) { + std::cout << "cmCTestResourceAllocator::Resource::Free() did not return " + "expected value for { 3, 2 }\n"; + retval = false; + } + + const cmCTestResourceAllocator::Resource r3{ 4, 4 }; + if (r3.Free() != 0) { + std::cout << "cmCTestResourceAllocator::Resource::Free() did not return " + "expected value for { 4, 4 }\n"; + retval = false; + } + + return retval; +} + +int testCTestResourceAllocator(int, char** const) +{ + int retval = 0; + + if (!testInitializeFromResourceSpec()) { + std::cout << "in testInitializeFromResourceSpec()\n"; + retval = -1; + } + + if (!testAllocateResource()) { + std::cout << "in testAllocateResource()\n"; + retval = -1; + } + + if (!testDeallocateResource()) { + std::cout << "in testDeallocateResource()\n"; + retval = -1; + } + + if (!testResourceFree()) { + std::cout << "in testResourceFree()\n"; + retval = -1; + } + + return retval; +} diff --git a/Tests/CMakeLib/testCTestResourceSpec.cxx b/Tests/CMakeLib/testCTestResourceSpec.cxx new file mode 100644 index 0000000..e4bc770 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec.cxx @@ -0,0 +1,84 @@ +#include +#include +#include + +#include "cmCTestResourceSpec.h" + +struct ExpectedSpec +{ + std::string Path; + bool ParseResult; + cmCTestResourceSpec Expected; +}; + +static const std::vector expectedResourceSpecs = { + /* clang-format off */ + {"spec1.json", true, {{{ + {"gpus", { + {"2", 4}, + {"e", 1}, + }}, + {"threads", { + }}, + }}}}, + {"spec2.json", true, {{{ + }}}}, + {"spec3.json", false, {{{}}}}, + {"spec4.json", false, {{{}}}}, + {"spec5.json", false, {{{}}}}, + {"spec6.json", false, {{{}}}}, + {"spec7.json", false, {{{}}}}, + {"spec8.json", false, {{{}}}}, + {"spec9.json", false, {{{}}}}, + {"spec10.json", false, {{{}}}}, + {"spec11.json", false, {{{}}}}, + {"spec12.json", false, {{{}}}}, + {"spec13.json", false, {{{}}}}, + {"spec14.json", true, {{{}}}}, + {"spec15.json", true, {{{}}}}, + {"spec16.json", true, {{{}}}}, + {"spec17.json", false, {{{}}}}, + {"spec18.json", false, {{{}}}}, + {"noexist.json", false, {{{}}}}, + /* clang-format on */ +}; + +static bool testSpec(const std::string& path, bool expectedResult, + const cmCTestResourceSpec& expected) +{ + cmCTestResourceSpec actual; + bool result = actual.ReadFromJSONFile(path); + if (result != expectedResult) { + std::cout << "ReadFromJSONFile(\"" << path << "\") returned " << result + << ", should be " << expectedResult << std::endl; + return false; + } + + if (result && actual != expected) { + std::cout << "ReadFromJSONFile(\"" << path + << "\") did not give expected spec" << std::endl; + return false; + } + + return true; +} + +int testCTestResourceSpec(int argc, char** const argv) +{ + if (argc < 2) { + std::cout << "Invalid arguments.\n"; + return -1; + } + + int retval = 0; + for (auto const& spec : expectedResourceSpecs) { + std::string path = argv[1]; + path += "/testCTestResourceSpec_data/"; + path += spec.Path; + if (!testSpec(path, spec.ParseResult, spec.Expected)) { + retval = -1; + } + } + + return retval; +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec1.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec1.json new file mode 100644 index 0000000..ee3d0ce --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec1.json @@ -0,0 +1,23 @@ +{ + "local": [ + { + "gpus": [ + { + "id": "2", + "slots": 4 + }, + { + "id": "e" + } + ], + ".reserved": [ + { + "id": "a", + "slots": 3 + } + ], + "threads": [ + ] + } + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec10.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec10.json new file mode 100644 index 0000000..22105d7 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec10.json @@ -0,0 +1,11 @@ +{ + "local": [ + { + "gpus": [ + { + "id": 4 + } + ] + } + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec11.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec11.json new file mode 100644 index 0000000..1e37ef5 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec11.json @@ -0,0 +1,12 @@ +{ + "local": [ + { + "gpus": [ + { + "id": "4", + "slots": "giraffe" + } + ] + } + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec12.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec12.json new file mode 100644 index 0000000..fe51488 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec12.json @@ -0,0 +1 @@ +[] diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec13.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec13.json new file mode 100644 index 0000000..6b7a9f4 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec13.json @@ -0,0 +1 @@ +not json diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec14.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec14.json new file mode 100644 index 0000000..ce708c7 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec14.json @@ -0,0 +1,8 @@ +{ + "local": [ + { + "0": [ + ] + } + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec15.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec15.json new file mode 100644 index 0000000..78b6990 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec15.json @@ -0,0 +1,8 @@ +{ + "local": [ + { + "-": [ + ] + } + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec16.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec16.json new file mode 100644 index 0000000..95c7d26 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec16.json @@ -0,0 +1,8 @@ +{ + "local": [ + { + "A": [ + ] + } + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec17.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec17.json new file mode 100644 index 0000000..1b6ab4b --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec17.json @@ -0,0 +1,11 @@ +{ + "local": [ + { + "gpus": [ + { + "id": "A" + } + ] + } + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec18.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec18.json new file mode 100644 index 0000000..1a17df7 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec18.json @@ -0,0 +1,11 @@ +{ + "local": [ + { + "gpus": [ + { + "id": "-" + } + ] + } + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec2.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec2.json new file mode 100644 index 0000000..6175b1a --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec2.json @@ -0,0 +1,4 @@ +{ + "local": [ + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec3.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec3.json new file mode 100644 index 0000000..82453ec --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec3.json @@ -0,0 +1,8 @@ +{ + "local": [ + { + }, + { + } + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec4.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec4.json new file mode 100644 index 0000000..05e73d7 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec4.json @@ -0,0 +1,4 @@ +{ + "local": { + } +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec5.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec5.json new file mode 100644 index 0000000..2c63c08 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec5.json @@ -0,0 +1,2 @@ +{ +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec6.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec6.json new file mode 100644 index 0000000..93c790d --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec6.json @@ -0,0 +1,5 @@ +{ + "local": [ + [] + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec7.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec7.json new file mode 100644 index 0000000..28b6a4f --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec7.json @@ -0,0 +1,8 @@ +{ + "local": [ + { + "gpus": { + } + } + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec8.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec8.json new file mode 100644 index 0000000..79bd224 --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec8.json @@ -0,0 +1,9 @@ +{ + "local": [ + { + "gpus": [ + [] + ] + } + ] +} diff --git a/Tests/CMakeLib/testCTestResourceSpec_data/spec9.json b/Tests/CMakeLib/testCTestResourceSpec_data/spec9.json new file mode 100644 index 0000000..6bb1def --- /dev/null +++ b/Tests/CMakeLib/testCTestResourceSpec_data/spec9.json @@ -0,0 +1,10 @@ +{ + "local": [ + { + "gpus": [ + { + } + ] + } + ] +} diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx index 1a61e6f..27644af 100644 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx +++ b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx @@ -13,9 +13,9 @@ #include "cmsys/Encoding.hxx" #include "cmsys/FStream.hxx" -#include "cmCTestHardwareAllocator.h" -#include "cmCTestHardwareSpec.h" #include "cmCTestMultiProcessHandler.h" +#include "cmCTestResourceAllocator.h" +#include "cmCTestResourceSpec.h" #include "cmCTestTestHandler.h" #include "cmFileLock.h" #include "cmFileLockResult.h" @@ -23,7 +23,7 @@ #include "cmSystemTools.h" /* - * This helper program is used to verify that the CTest hardware allocation + * This helper program is used to verify that the CTest resource allocation * feature is working correctly. It consists of two stages: * * 1) write - This stage receives the RESOURCE_GROUPS property of the test and @@ -31,7 +31,7 @@ * environment variables. If it received all of the resources it expected, * then it writes this information to a log file, which will be read in * the verify stage. - * 2) verify - This stage compares the log file with the hardware spec file to + * 2) verify - This stage compares the log file with the resource spec file to * make sure that no resources were over-subscribed, deallocated without * being allocated, or allocated without being deallocated. */ @@ -68,8 +68,8 @@ static int doWrite(int argc, char const* const* argv) std::string testName = argv[3]; unsigned int sleepTime = std::atoi(argv[4]); std::vector>> - hardware; + std::string, std::vector>> + resources; if (argc == 6) { // Parse RESOURCE_GROUPS property std::string resourceGroupsProperty = argv[5]; @@ -146,8 +146,8 @@ static int doWrite(int argc, char const* const* argv) // Verify that we got what we asked for and write it to the log prefix += '_'; std::map> - hwEntry; + std::vector> + resEntry; for (auto const& type : actualResources) { auto it = resourceGroup.begin(); @@ -194,7 +194,7 @@ static int doWrite(int argc, char const* const* argv) fout << "alloc " << type << " " << id << " " << amount << std::endl; - hwEntry[type].push_back({ id, amount }); + resEntry[type].push_back({ id, amount }); } bool ended = false; @@ -212,7 +212,7 @@ static int doWrite(int argc, char const* const* argv) return 1; } } - hardware.push_back(hwEntry); + resources.push_back(resEntry); ++i; } catch (...) { @@ -249,7 +249,7 @@ static int doWrite(int argc, char const* const* argv) return 1; } cmsys::ofstream fout(logFile.c_str(), std::ios::app); - for (auto const& group : hardware) { + for (auto const& group : resources) { for (auto const& it : group) { for (auto const& it2 : it.second) { fout << "dealloc " << it.first << " " << it2.Id << " " << it2.Slots @@ -276,7 +276,7 @@ static int doVerify(int argc, char const* const* argv) return usageVerify(argv[0]); } std::string logFile = argv[2]; - std::string hwFile = argv[3]; + std::string resFile = argv[3]; std::string testNames; if (argc == 5) { testNames = argv[4]; @@ -284,14 +284,14 @@ static int doVerify(int argc, char const* const* argv) auto testNameList = cmExpandedList(testNames, false); std::set testNameSet(testNameList.begin(), testNameList.end()); - cmCTestHardwareSpec spec; - if (!spec.ReadFromJSONFile(hwFile)) { - std::cout << "Could not read resource spec " << hwFile << std::endl; + cmCTestResourceSpec spec; + if (!spec.ReadFromJSONFile(resFile)) { + std::cout << "Could not read resource spec " << resFile << std::endl; return 1; } - cmCTestHardwareAllocator allocator; - allocator.InitializeFromHardwareSpec(spec); + cmCTestResourceAllocator allocator; + allocator.InitializeFromResourceSpec(spec); cmsys::ifstream fin(logFile.c_str(), std::ios::in); if (!fin) { -- cgit v0.12 From eb9d945f142ac7638baaf879fb9464fa39e3e9a7 Mon Sep 17 00:00:00 2001 From: Craig Scott Date: Tue, 5 Nov 2019 18:40:50 +1100 Subject: CTest: Rename hardware -> resources for RunCMake tests Also includes variants like hw -> res --- Tests/RunCMake/CMakeLists.txt | 24 +- .../CTestHardwareAllocation/CMakeLists.txt.in | 9 - .../CTestHardwareAllocation/HardwareCommon.cmake | 23 -- .../CTestHardwareAllocation/RunCMakeTest.cmake | 167 --------- .../checkfree1-ctest-s-hw-check.cmake | 1 - .../CTestHardwareAllocation/checkfree1.cmake | 7 - .../checkfree2-ctest-s-hw-check.cmake | 1 - .../CTestHardwareAllocation/checkfree2.cmake | 8 - .../cthwalloc-verify-baddealloc-result.txt | 1 - .../cthwalloc-verify-baddealloc.log | 2 - .../cthwalloc-verify-badtest1-result.txt | 1 - .../cthwalloc-verify-badtest1.log | 1 - .../cthwalloc-verify-badtest2-result.txt | 1 - .../cthwalloc-verify-badtest2.log | 2 - .../cthwalloc-verify-badtest3-result.txt | 1 - .../cthwalloc-verify-badtest3.log | 3 - .../cthwalloc-verify-badtest4-result.txt | 1 - .../cthwalloc-verify-badtest4.log | 3 - .../cthwalloc-verify-badtest5-result.txt | 1 - .../cthwalloc-verify-badtest5.log | 1 - .../cthwalloc-verify-good1.log | 14 - .../cthwalloc-verify-good2.log | 0 .../cthwalloc-verify-leak-result.txt | 1 - .../cthwalloc-verify-leak.log | 1 - .../cthwalloc-verify-nobegin-result.txt | 1 - .../cthwalloc-verify-nobegin.log | 0 .../cthwalloc-verify-noend-result.txt | 1 - .../cthwalloc-verify-noend.log | 1 - .../cthwalloc-verify-noid-result.txt | 1 - .../cthwalloc-verify-noid.log | 2 - .../cthwalloc-verify-nolog-result.txt | 1 - .../cthwalloc-verify-nores-result.txt | 1 - .../cthwalloc-verify-nores.log | 2 - .../cthwalloc-verify-notenough-result.txt | 1 - .../cthwalloc-verify-notenough.log | 2 - .../cthwalloc-write-noproc-count-result.txt | 1 - .../cthwalloc-write-proc-badcount-result.txt | 1 - .../cthwalloc-write-proc-badres-result.txt | 1 - .../cthwalloc-write-proc-badwidgets1-result.txt | 1 - .../cthwalloc-write-proc-badwidgets2-result.txt | 1 - .../cthwalloc-write-proc-badwidgets3-result.txt | 1 - .../cthwalloc-write-proc-badwidgets4-result.txt | 1 - .../cthwalloc-write-proc-badwidgets5-result.txt | 1 - .../cthwalloc-write-proc-badwidgets6-result.txt | 1 - .../cthwalloc-write-proc-badwidgets7-result.txt | 1 - .../cthwalloc-write-proc-good1-check.cmake | 20 -- .../cthwalloc-write-proc-good2-check.cmake | 6 - .../cthwalloc-write-proc-nocount-result.txt | 1 - .../cthwalloc-write-proc-nores-result.txt | 1 - .../cthwalloc-write-proc-nowidgets-result.txt | 1 - .../RunCMake/CTestHardwareAllocation/cthwalloc.cxx | 399 --------------------- .../ensure_parallel-ctest-s-hw-check.cmake | 16 - .../CTestHardwareAllocation/ensure_parallel.cmake | 11 - Tests/RunCMake/CTestHardwareAllocation/hwspec.json | 55 --- .../lotsoftests-ctest-s-hw-check.cmake | 1 - .../CTestHardwareAllocation/lotsoftests.cmake | 16 - .../notenough1-ctest-s-hw-check.cmake | 3 - .../notenough1-ctest-s-hw-result.txt | 1 - .../notenough1-ctest-s-hw-stderr.txt | 4 - .../CTestHardwareAllocation/notenough1.cmake | 5 - .../notenough2-ctest-s-hw-check.cmake | 3 - .../notenough2-ctest-s-hw-result.txt | 1 - .../notenough2-ctest-s-hw-stderr.txt | 4 - .../CTestHardwareAllocation/notenough2.cmake | 5 - .../process_count-ctest-s-hw-check.cmake | 1 - .../CTestHardwareAllocation/process_count.cmake | 5 - .../RunCMake/CTestHardwareAllocation/test.cmake.in | 23 -- .../CTestResourceAllocation/CMakeLists.txt.in | 9 + .../CTestResourceAllocation/ResourceCommon.cmake | 23 ++ .../CTestResourceAllocation/RunCMakeTest.cmake | 167 +++++++++ .../checkfree1-ctest-s-res-check.cmake | 1 + .../CTestResourceAllocation/checkfree1.cmake | 7 + .../checkfree2-ctest-s-res-check.cmake | 1 + .../CTestResourceAllocation/checkfree2.cmake | 8 + .../ctresalloc-verify-baddealloc-result.txt | 1 + .../ctresalloc-verify-baddealloc.log | 2 + .../ctresalloc-verify-badtest1-result.txt | 1 + .../ctresalloc-verify-badtest1.log | 1 + .../ctresalloc-verify-badtest2-result.txt | 1 + .../ctresalloc-verify-badtest2.log | 2 + .../ctresalloc-verify-badtest3-result.txt | 1 + .../ctresalloc-verify-badtest3.log | 3 + .../ctresalloc-verify-badtest4-result.txt | 1 + .../ctresalloc-verify-badtest4.log | 3 + .../ctresalloc-verify-badtest5-result.txt | 1 + .../ctresalloc-verify-badtest5.log | 1 + .../ctresalloc-verify-good1.log | 14 + .../ctresalloc-verify-good2.log | 0 .../ctresalloc-verify-leak-result.txt | 1 + .../ctresalloc-verify-leak.log | 1 + .../ctresalloc-verify-nobegin-result.txt | 1 + .../ctresalloc-verify-nobegin.log | 0 .../ctresalloc-verify-noend-result.txt | 1 + .../ctresalloc-verify-noend.log | 1 + .../ctresalloc-verify-noid-result.txt | 1 + .../ctresalloc-verify-noid.log | 2 + .../ctresalloc-verify-nolog-result.txt | 1 + .../ctresalloc-verify-nores-result.txt | 1 + .../ctresalloc-verify-nores.log | 2 + .../ctresalloc-verify-notenough-result.txt | 1 + .../ctresalloc-verify-notenough.log | 2 + .../ctresalloc-write-noproc-count-result.txt | 1 + .../ctresalloc-write-proc-badcount-result.txt | 1 + .../ctresalloc-write-proc-badres-result.txt | 1 + .../ctresalloc-write-proc-badwidgets1-result.txt | 1 + .../ctresalloc-write-proc-badwidgets2-result.txt | 1 + .../ctresalloc-write-proc-badwidgets3-result.txt | 1 + .../ctresalloc-write-proc-badwidgets4-result.txt | 1 + .../ctresalloc-write-proc-badwidgets5-result.txt | 1 + .../ctresalloc-write-proc-badwidgets6-result.txt | 1 + .../ctresalloc-write-proc-badwidgets7-result.txt | 1 + .../ctresalloc-write-proc-good1-check.cmake | 20 ++ .../ctresalloc-write-proc-good2-check.cmake | 6 + .../ctresalloc-write-proc-nocount-result.txt | 1 + .../ctresalloc-write-proc-nores-result.txt | 1 + .../ctresalloc-write-proc-nowidgets-result.txt | 1 + .../CTestResourceAllocation/ctresalloc.cxx | 399 +++++++++++++++++++++ .../ensure_parallel-ctest-s-res-check.cmake | 16 + .../CTestResourceAllocation/ensure_parallel.cmake | 11 + .../lotsoftests-ctest-s-res-check.cmake | 1 + .../CTestResourceAllocation/lotsoftests.cmake | 16 + .../notenough1-ctest-s-res-check.cmake | 3 + .../notenough1-ctest-s-res-result.txt | 1 + .../notenough1-ctest-s-res-stderr.txt | 4 + .../CTestResourceAllocation/notenough1.cmake | 5 + .../notenough2-ctest-s-res-check.cmake | 3 + .../notenough2-ctest-s-res-result.txt | 1 + .../notenough2-ctest-s-res-stderr.txt | 4 + .../CTestResourceAllocation/notenough2.cmake | 5 + .../process_count-ctest-s-res-check.cmake | 1 + .../CTestResourceAllocation/process_count.cmake | 5 + .../RunCMake/CTestResourceAllocation/resspec.json | 55 +++ .../RunCMake/CTestResourceAllocation/test.cmake.in | 23 ++ 133 files changed, 867 insertions(+), 867 deletions(-) delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/CMakeLists.txt.in delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/HardwareCommon.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/RunCMakeTest.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/checkfree1-ctest-s-hw-check.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/checkfree1.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/checkfree2-ctest-s-hw-check.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/checkfree2.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-baddealloc-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-baddealloc.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest1-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest1.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest2-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest2.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest3-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest3.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest4-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest4.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest5-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest5.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-good1.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-good2.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-leak-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-leak.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nobegin-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nobegin.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noend-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noend.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noid-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noid.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nolog-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nores-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nores.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-notenough-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-notenough.log delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-noproc-count-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badcount-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badres-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets1-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets2-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets3-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets4-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets5-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets6-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets7-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-good1-check.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-good2-check.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nocount-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nores-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nowidgets-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/ensure_parallel-ctest-s-hw-check.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/ensure_parallel.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/hwspec.json delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/lotsoftests-ctest-s-hw-check.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/lotsoftests.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-check.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-stderr.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/notenough1.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-check.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-result.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-stderr.txt delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/notenough2.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/process_count-ctest-s-hw-check.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/process_count.cmake delete mode 100644 Tests/RunCMake/CTestHardwareAllocation/test.cmake.in create mode 100644 Tests/RunCMake/CTestResourceAllocation/CMakeLists.txt.in create mode 100644 Tests/RunCMake/CTestResourceAllocation/ResourceCommon.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/RunCMakeTest.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/checkfree1-ctest-s-res-check.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/checkfree1.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/checkfree2-ctest-s-res-check.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/checkfree2.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-baddealloc-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-baddealloc.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest1-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest1.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest2-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest2.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest3-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest3.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest4-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest4.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest5-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest5.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-good1.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-good2.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-leak-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-leak.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nobegin-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nobegin.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noend-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noend.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noid-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noid.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nolog-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nores-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nores.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-notenough-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-notenough.log create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-noproc-count-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badcount-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badres-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets1-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets2-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets3-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets4-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets5-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets6-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets7-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-good1-check.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-good2-check.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nocount-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nores-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nowidgets-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/ctresalloc.cxx create mode 100644 Tests/RunCMake/CTestResourceAllocation/ensure_parallel-ctest-s-res-check.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/ensure_parallel.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/lotsoftests-ctest-s-res-check.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/lotsoftests.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-check.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-stderr.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/notenough1.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-check.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-result.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-stderr.txt create mode 100644 Tests/RunCMake/CTestResourceAllocation/notenough2.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/process_count-ctest-s-res-check.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/process_count.cmake create mode 100644 Tests/RunCMake/CTestResourceAllocation/resspec.json create mode 100644 Tests/RunCMake/CTestResourceAllocation/test.cmake.in diff --git a/Tests/RunCMake/CMakeLists.txt b/Tests/RunCMake/CMakeLists.txt index 0925c0e..bf40e48 100644 --- a/Tests/RunCMake/CMakeLists.txt +++ b/Tests/RunCMake/CMakeLists.txt @@ -335,7 +335,7 @@ add_RunCMake_test(no_install_prefix) add_RunCMake_test(configure_file) add_RunCMake_test(CTestTimeoutAfterMatch) -# cthwalloc links against CMakeLib and CTestLib, which means it can't be built +# ctresalloc links against CMakeLib and CTestLib, which means it can't be built # if CMake_TEST_EXTERNAL_CMAKE is activated (the compiler might be different.) # So, it has to be provided in the original build tree. if(CMake_TEST_EXTERNAL_CMAKE) @@ -343,7 +343,7 @@ if(CMake_TEST_EXTERNAL_CMAKE) if(NOT CMAKE_VERSION VERSION_LESS 3.12) set(no_package_root_path NO_PACKAGE_ROOT_PATH) endif() - find_program(cthwalloc cthwalloc PATHS ${CMake_TEST_EXTERNAL_CMAKE} + find_program(ctresalloc ctresalloc PATHS ${CMake_TEST_EXTERNAL_CMAKE} NO_DEFAULT_PATH ${no_package_root_path} NO_CMAKE_PATH @@ -352,25 +352,25 @@ if(CMake_TEST_EXTERNAL_CMAKE) NO_CMAKE_SYSTEM_PATH NO_CMAKE_FIND_ROOT_PATH ) - if(cthwalloc) - add_executable(cthwalloc IMPORTED) - set_property(TARGET cthwalloc PROPERTY IMPORTED_LOCATION ${cthwalloc}) + if(ctresalloc) + add_executable(ctresalloc IMPORTED) + set_property(TARGET ctresalloc PROPERTY IMPORTED_LOCATION ${ctresalloc}) endif() else() - add_executable(cthwalloc CTestHardwareAllocation/cthwalloc.cxx) - target_link_libraries(cthwalloc CTestLib) - target_include_directories(cthwalloc PRIVATE + add_executable(ctresalloc CTestResourceAllocation/ctresalloc.cxx) + target_link_libraries(ctresalloc CTestLib) + target_include_directories(ctresalloc PRIVATE ${CMake_BINARY_DIR}/Source ${CMake_SOURCE_DIR}/Source ${CMake_SOURCE_DIR}/Source/CTest ) - set_property(TARGET cthwalloc PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMake_BIN_DIR}) + set_property(TARGET ctresalloc PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMake_BIN_DIR}) endif() -if(TARGET cthwalloc) - add_RunCMake_test(CTestHardwareAllocation -DCTHWALLOC_COMMAND=$) +if(TARGET ctresalloc) + add_RunCMake_test(CTestResourceAllocation -DCTRESALLOC_COMMAND=$) else() - message(WARNING "Could not find or build cthwalloc") + message(WARNING "Could not find or build ctresalloc") endif() find_package(Qt4 QUIET) diff --git a/Tests/RunCMake/CTestHardwareAllocation/CMakeLists.txt.in b/Tests/RunCMake/CTestHardwareAllocation/CMakeLists.txt.in deleted file mode 100644 index d6cff63..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/CMakeLists.txt.in +++ /dev/null @@ -1,9 +0,0 @@ -cmake_minimum_required(VERSION 3.15) -set(CASE_NAME "@CASE_NAME@") -if(CASE_NAME MATCHES "^(.*)-ctest-s") - set(projname "${CMAKE_MATCH_1}") - project(${projname} NONE) - include(CTest) - include("@RunCMake_SOURCE_DIR@/HardwareCommon.cmake") - include("@RunCMake_SOURCE_DIR@/${projname}.cmake") -endif() diff --git a/Tests/RunCMake/CTestHardwareAllocation/HardwareCommon.cmake b/Tests/RunCMake/CTestHardwareAllocation/HardwareCommon.cmake deleted file mode 100644 index 3288f35..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/HardwareCommon.cmake +++ /dev/null @@ -1,23 +0,0 @@ -function(setup_hardware_tests) - if(CTEST_HARDWARE_ALLOC_ENABLED) - add_test(NAME HardwareSetup COMMAND "${CMAKE_COMMAND}" -E remove -f "${CMAKE_BINARY_DIR}/cthwalloc.log") - endif() -endfunction() - -function(add_hardware_test name sleep_time proc) - if(CTEST_HARDWARE_ALLOC_ENABLED) - add_test(NAME "${name}" COMMAND "${CTHWALLOC_COMMAND}" write "${CMAKE_BINARY_DIR}/cthwalloc.log" "${name}" "${sleep_time}" "${proc}") - set_property(TEST "${name}" PROPERTY DEPENDS HardwareSetup) - else() - add_test(NAME "${name}" COMMAND "${CTHWALLOC_COMMAND}" write "${CMAKE_BINARY_DIR}/cthwalloc.log" "${name}" "${sleep_time}") - endif() - set_property(TEST "${name}" PROPERTY RESOURCE_GROUPS "${proc}") - list(APPEND HARDWARE_TESTS "${name}") - set(HARDWARE_TESTS "${HARDWARE_TESTS}" PARENT_SCOPE) -endfunction() - -function(cleanup_hardware_tests) - if(CTEST_HARDWARE_ALLOC_ENABLED) - file(WRITE "${CMAKE_BINARY_DIR}/hwtests.txt" "${HARDWARE_TESTS}") - endif() -endfunction() diff --git a/Tests/RunCMake/CTestHardwareAllocation/RunCMakeTest.cmake b/Tests/RunCMake/CTestHardwareAllocation/RunCMakeTest.cmake deleted file mode 100644 index f69afc7..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/RunCMakeTest.cmake +++ /dev/null @@ -1,167 +0,0 @@ -include(RunCMake) -include(RunCTest) - -############################################################################### -# Test cthwalloc itself - we want to make sure it's not just rubber-stamping -# the test results -############################################################################### - -function(cthwalloc_verify_log expected_contents) - if(NOT EXISTS "${RunCMake_TEST_BINARY_DIR}/cthwalloc.log") - string(APPEND RunCMake_TEST_FAILED "Log file was not written\n") - set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE) - return() - endif() - file(READ "${RunCMake_TEST_BINARY_DIR}/cthwalloc.log" actual_contents) - if(NOT actual_contents STREQUAL expected_contents) - string(APPEND RunCMake_TEST_FAILED "Actual log did not match expected log\n") - set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE) - endif() -endfunction() - -function(run_cthwalloc_write_proc name proc) - file(REMOVE "${RunCMake_BINARY_DIR}/${name}-build/cthwalloc.log") - run_cthwalloc_write_proc_nodel("${name}" "${proc}" "${ARGN}") -endfunction() - -function(run_cthwalloc_write_proc_nodel name proc) - string(REPLACE ";" "\\;" proc "${proc}") - run_cmake_command(${name} "${CMAKE_COMMAND}" -E env "${ARGN}" "${CTHWALLOC_COMMAND}" write "${RunCMake_BINARY_DIR}/${name}-build/cthwalloc.log" "${name}" 0 "${proc}") -endfunction() - -function(run_cthwalloc_write_noproc name) - run_cmake_command(${name} "${CMAKE_COMMAND}" -E env "${ARGN}" "${CTHWALLOC_COMMAND}" write "${RunCMake_BINARY_DIR}/${name}-build/cthwalloc.log" "${name}" 0) -endfunction() - -function(run_cthwalloc_verify name tests) - string(REPLACE ";" "\\;" tests "${tests}") - run_cmake_command(${name} "${CTHWALLOC_COMMAND}" verify "${RunCMake_SOURCE_DIR}/${name}.log" "${CMAKE_CURRENT_LIST_DIR}/hwspec.json" "${tests}") -endfunction() - -unset(ENV{CTEST_RESOURCE_GROUP_COUNT}) -set(RunCMake_TEST_NO_CLEAN 1) -file(REMOVE_RECURSE "${RunCMake_BINARY_DIR}/cthwalloc-write-proc-good1-build") -file(MAKE_DIRECTORY "${RunCMake_BINARY_DIR}/cthwalloc-write-proc-good1-build") -file(WRITE "${RunCMake_BINARY_DIR}/cthwalloc-write-proc-good1-build/cthwalloc.log" -[[begin test1 -alloc widgets 0 1 -dealloc widgets 0 1 -end test1 -]]) -run_cthwalloc_write_proc_nodel(cthwalloc-write-proc-good1 "1,widgets:2,transmogrifiers:1;2,widgets:1,widgets:2" - CTEST_RESOURCE_GROUP_COUNT=3 - CTEST_RESOURCE_GROUP_0=widgets,transmogrifiers - CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2 - CTEST_RESOURCE_GROUP_0_TRANSMOGRIFIERS=id:calvin,slots:1 - CTEST_RESOURCE_GROUP_1=widgets - "CTEST_RESOURCE_GROUP_1_WIDGETS=id:0,slots:1\\;id:2,slots:2" - CTEST_RESOURCE_GROUP_2=widgets - "CTEST_RESOURCE_GROUP_2_WIDGETS=id:0,slots:1\\;id:2,slots:2" - ) -set(RunCMake_TEST_NO_CLEAN 0) -run_cthwalloc_write_proc(cthwalloc-write-proc-good2 "widgets:8" - CTEST_RESOURCE_GROUP_COUNT=1 - CTEST_RESOURCE_GROUP_0=widgets - CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:8 - ) -run_cthwalloc_write_proc(cthwalloc-write-proc-nocount "widgets:8") -run_cthwalloc_write_proc(cthwalloc-write-proc-badcount "widgets:8" - CTEST_RESOURCE_GROUP_COUNT=2 - ) -run_cthwalloc_write_proc(cthwalloc-write-proc-nores "widgets:8" - CTEST_RESOURCE_GROUP_COUNT=1 - ) -run_cthwalloc_write_proc(cthwalloc-write-proc-badres "widgets:8" - CTEST_RESOURCE_GROUP_COUNT=1 - CTEST_RESOURCE_GROUP_0=widgets,transmogrifiers - ) -run_cthwalloc_write_proc(cthwalloc-write-proc-nowidgets "widgets:8" - CTEST_RESOURCE_GROUP_COUNT=1 - CTEST_RESOURCE_GROUP_0=widgets - ) -run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets1 "widgets:8" - CTEST_RESOURCE_GROUP_COUNT=1 - CTEST_RESOURCE_GROUP_0=widgets - CTEST_RESOURCE_GROUP_0_WIDGETS= - ) -run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets2 "widgets:8" - CTEST_RESOURCE_GROUP_COUNT=1 - CTEST_RESOURCE_GROUP_0=widgets - "CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:8\\;id:0,slots:1" - ) -run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets3 "widgets:8" - CTEST_RESOURCE_GROUP_COUNT=1 - CTEST_RESOURCE_GROUP_0=widgets - CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:7 - ) -run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets4 "widgets:8" - CTEST_RESOURCE_GROUP_COUNT=1 - CTEST_RESOURCE_GROUP_0=widgets - CTEST_RESOURCE_GROUP_0_WIDGETS=invalid - ) -run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets5 "widgets:2,widgets:2" - CTEST_RESOURCE_GROUP_COUNT=1 - CTEST_RESOURCE_GROUP_0=widgets - "CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2\\;id:0,slots:1" - ) -run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets6 "widgets:2" - CTEST_RESOURCE_GROUP_COUNT=1 - CTEST_RESOURCE_GROUP_0=widgets - "CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2\\;id:0,slots:1" - ) -run_cthwalloc_write_proc(cthwalloc-write-proc-badwidgets7 "widgets:2,widgets:2" - CTEST_RESOURCE_GROUP_COUNT=1 - CTEST_RESOURCE_GROUP_0=widgets - CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2 - ) - -run_cthwalloc_write_noproc(cthwalloc-write-noproc-good1) -run_cthwalloc_write_noproc(cthwalloc-write-noproc-count - CTEST_RESOURCE_GROUP_COUNT=1 - ) - -run_cthwalloc_verify(cthwalloc-verify-good1 "test1;test2") -run_cthwalloc_verify(cthwalloc-verify-good2 "") -run_cthwalloc_verify(cthwalloc-verify-nolog "") -run_cthwalloc_verify(cthwalloc-verify-nores "") -run_cthwalloc_verify(cthwalloc-verify-noid "") -run_cthwalloc_verify(cthwalloc-verify-notenough "") -run_cthwalloc_verify(cthwalloc-verify-baddealloc "") -run_cthwalloc_verify(cthwalloc-verify-leak "") -run_cthwalloc_verify(cthwalloc-verify-badtest1 "") -run_cthwalloc_verify(cthwalloc-verify-badtest2 "test1") -run_cthwalloc_verify(cthwalloc-verify-badtest3 "test1") -run_cthwalloc_verify(cthwalloc-verify-badtest4 "test1") -run_cthwalloc_verify(cthwalloc-verify-badtest5 "test1") -run_cthwalloc_verify(cthwalloc-verify-nobegin "test1") -run_cthwalloc_verify(cthwalloc-verify-noend "test1") - -############################################################################### -# Now test the hardware allocation feature of CTest -############################################################################### - -function(run_ctest_hardware name parallel random) - run_ctest("${name}-ctest-s-hw" "-DCTEST_HARDWARE_ALLOC_ENABLED=1" "-DCTHWALLOC_COMMAND=${CTHWALLOC_COMMAND}" "-DCTEST_PARALLEL=${parallel}" "-DCTEST_RANDOM=${random}") - run_ctest("${name}-ctest-s-nohw" "-DCTEST_HARDWARE_ALLOC_ENABLED=0" "-DCTHWALLOC_COMMAND=${CTHWALLOC_COMMAND}" "-DCTEST_PARALLEL=${parallel}" "-DCTEST_RANDOM=${random}") -endfunction() - -function(verify_ctest_hardware) - file(READ "${RunCMake_TEST_BINARY_DIR}/hwtests.txt" hwtests) - execute_process(COMMAND "${CTHWALLOC_COMMAND}" verify "${RunCMake_TEST_BINARY_DIR}/cthwalloc.log" "${CMAKE_CURRENT_LIST_DIR}/hwspec.json" "${hwtests}" - OUTPUT_VARIABLE output ERROR_QUIET RESULT_VARIABLE result) - if(result) - string(APPEND RunCMake_TEST_FAILED "${output}") - set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE) - endif() -endfunction() - -run_ctest_hardware(lotsoftests 10 1) -run_ctest_hardware(checkfree1 2 0) -run_ctest_hardware(checkfree2 1 0) -run_ctest_hardware(notenough1 1 0) -run_ctest_hardware(notenough2 1 0) -run_ctest_hardware(ensure_parallel 2 0) - -set(ENV{CTEST_RESOURCE_GROUP_COUNT} 2) -run_ctest_hardware(process_count 1 0) -unset(ENV{CTEST_RESOURCE_GROUP_COUNT}) diff --git a/Tests/RunCMake/CTestHardwareAllocation/checkfree1-ctest-s-hw-check.cmake b/Tests/RunCMake/CTestHardwareAllocation/checkfree1-ctest-s-hw-check.cmake deleted file mode 100644 index 94b1fa7..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/checkfree1-ctest-s-hw-check.cmake +++ /dev/null @@ -1 +0,0 @@ -verify_ctest_hardware() diff --git a/Tests/RunCMake/CTestHardwareAllocation/checkfree1.cmake b/Tests/RunCMake/CTestHardwareAllocation/checkfree1.cmake deleted file mode 100644 index 0e997b5..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/checkfree1.cmake +++ /dev/null @@ -1,7 +0,0 @@ -setup_hardware_tests() - -add_hardware_test(Test1 1 "widgets:8") -add_hardware_test(Test2 1 "fluxcapacitors:50;fluxcapacitors:50,widgets:8") -add_hardware_test(Test3 1 "fluxcapacitors:121") - -cleanup_hardware_tests() diff --git a/Tests/RunCMake/CTestHardwareAllocation/checkfree2-ctest-s-hw-check.cmake b/Tests/RunCMake/CTestHardwareAllocation/checkfree2-ctest-s-hw-check.cmake deleted file mode 100644 index 94b1fa7..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/checkfree2-ctest-s-hw-check.cmake +++ /dev/null @@ -1 +0,0 @@ -verify_ctest_hardware() diff --git a/Tests/RunCMake/CTestHardwareAllocation/checkfree2.cmake b/Tests/RunCMake/CTestHardwareAllocation/checkfree2.cmake deleted file mode 100644 index 3c2b666..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/checkfree2.cmake +++ /dev/null @@ -1,8 +0,0 @@ -setup_hardware_tests() - -# This test is an attack on the hardware scheduling algorithm. It has been -# carefully crafted to fool the algorithm into thinking there isn't sufficient -# hardware for it. -add_hardware_test(Test1 1 "widgets:2;4,widgets:4") - -cleanup_hardware_tests() diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-baddealloc-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-baddealloc-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-baddealloc-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-baddealloc.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-baddealloc.log deleted file mode 100644 index abd6bad..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-baddealloc.log +++ /dev/null @@ -1,2 +0,0 @@ -alloc widgets 0 1 -dealloc widgets 0 2 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest1-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest1-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest1-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest1.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest1.log deleted file mode 100644 index 605104b..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest1.log +++ /dev/null @@ -1 +0,0 @@ -begin test1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest2-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest2-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest2-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest2.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest2.log deleted file mode 100644 index 1ff1b0d..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest2.log +++ /dev/null @@ -1,2 +0,0 @@ -begin test1 -begin test1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest3-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest3-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest3-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest3.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest3.log deleted file mode 100644 index 1925e6a..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest3.log +++ /dev/null @@ -1,3 +0,0 @@ -begin test1 -end test1 -begin test1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest4-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest4-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest4-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest4.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest4.log deleted file mode 100644 index 3fe7da1..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest4.log +++ /dev/null @@ -1,3 +0,0 @@ -begin test1 -end test1 -end test1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest5-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest5-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest5-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest5.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest5.log deleted file mode 100644 index 3a2e7e3..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-badtest5.log +++ /dev/null @@ -1 +0,0 @@ -end test1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-good1.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-good1.log deleted file mode 100644 index 2cca0c3..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-good1.log +++ /dev/null @@ -1,14 +0,0 @@ -begin test1 -alloc widgets 3 4 -alloc widgets 4 1 -alloc transmogrifiers calvin 2 -alloc fluxcapacitors outatime 121 -begin test2 -alloc widgets 3 4 -dealloc widgets 3 4 -dealloc widgets 4 1 -dealloc transmogrifiers calvin 2 -dealloc fluxcapacitors outatime 121 -end test1 -dealloc widgets 3 4 -end test2 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-good2.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-good2.log deleted file mode 100644 index e69de29..0000000 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-leak-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-leak-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-leak-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-leak.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-leak.log deleted file mode 100644 index b900d86..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-leak.log +++ /dev/null @@ -1 +0,0 @@ -alloc widgets 0 1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nobegin-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nobegin-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nobegin-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nobegin.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nobegin.log deleted file mode 100644 index e69de29..0000000 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noend-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noend-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noend-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noend.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noend.log deleted file mode 100644 index 605104b..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noend.log +++ /dev/null @@ -1 +0,0 @@ -begin test1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noid-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noid-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noid-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noid.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noid.log deleted file mode 100644 index c718975..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-noid.log +++ /dev/null @@ -1,2 +0,0 @@ -alloc fluxcapacitors train 1 -dealloc fluxcapacitors train 1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nolog-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nolog-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nolog-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nores-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nores-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nores-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nores.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nores.log deleted file mode 100644 index a18202b..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-nores.log +++ /dev/null @@ -1,2 +0,0 @@ -alloc gpus 0 1 -dealloc gpus 0 1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-notenough-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-notenough-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-notenough-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-notenough.log b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-notenough.log deleted file mode 100644 index ac78d5a..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-verify-notenough.log +++ /dev/null @@ -1,2 +0,0 @@ -alloc widgets 0 8 -dealloc widgets 0 8 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-noproc-count-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-noproc-count-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-noproc-count-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badcount-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badcount-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badcount-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badres-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badres-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badres-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets1-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets1-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets1-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets2-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets2-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets2-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets3-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets3-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets3-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets4-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets4-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets4-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets5-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets5-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets5-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets6-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets6-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets6-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets7-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets7-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-badwidgets7-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-good1-check.cmake b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-good1-check.cmake deleted file mode 100644 index 949d2d7..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-good1-check.cmake +++ /dev/null @@ -1,20 +0,0 @@ -cthwalloc_verify_log( -[[begin test1 -alloc widgets 0 1 -dealloc widgets 0 1 -end test1 -begin cthwalloc-write-proc-good1 -alloc transmogrifiers calvin 1 -alloc widgets 0 2 -alloc widgets 0 1 -alloc widgets 2 2 -alloc widgets 0 1 -alloc widgets 2 2 -dealloc transmogrifiers calvin 1 -dealloc widgets 0 2 -dealloc widgets 0 1 -dealloc widgets 2 2 -dealloc widgets 0 1 -dealloc widgets 2 2 -end cthwalloc-write-proc-good1 -]]) diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-good2-check.cmake b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-good2-check.cmake deleted file mode 100644 index ca0c6b8..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-good2-check.cmake +++ /dev/null @@ -1,6 +0,0 @@ -cthwalloc_verify_log( -[[begin cthwalloc-write-proc-good2 -alloc widgets 3 8 -dealloc widgets 3 8 -end cthwalloc-write-proc-good2 -]]) diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nocount-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nocount-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nocount-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nores-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nores-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nores-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nowidgets-result.txt b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nowidgets-result.txt deleted file mode 100644 index d00491f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc-write-proc-nowidgets-result.txt +++ /dev/null @@ -1 +0,0 @@ -1 diff --git a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx b/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx deleted file mode 100644 index 27644af..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/cthwalloc.cxx +++ /dev/null @@ -1,399 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include "cmsys/Encoding.hxx" -#include "cmsys/FStream.hxx" - -#include "cmCTestMultiProcessHandler.h" -#include "cmCTestResourceAllocator.h" -#include "cmCTestResourceSpec.h" -#include "cmCTestTestHandler.h" -#include "cmFileLock.h" -#include "cmFileLockResult.h" -#include "cmStringAlgorithms.h" -#include "cmSystemTools.h" - -/* - * This helper program is used to verify that the CTest resource allocation - * feature is working correctly. It consists of two stages: - * - * 1) write - This stage receives the RESOURCE_GROUPS property of the test and - * compares it with the values passed in the CTEST_RESOURCE_GROUP_* - * environment variables. If it received all of the resources it expected, - * then it writes this information to a log file, which will be read in - * the verify stage. - * 2) verify - This stage compares the log file with the resource spec file to - * make sure that no resources were over-subscribed, deallocated without - * being allocated, or allocated without being deallocated. - */ - -static int usage(const char* argv0) -{ - std::cout << "Usage: " << argv0 << " (write|verify) " << std::endl; - return 1; -} - -static int usageWrite(const char* argv0) -{ - std::cout << "Usage: " << argv0 - << " write " - " []" - << std::endl; - return 1; -} - -static int usageVerify(const char* argv0) -{ - std::cout << "Usage: " << argv0 - << " verify []" - << std::endl; - return 1; -} - -static int doWrite(int argc, char const* const* argv) -{ - if (argc < 5 || argc > 6) { - return usageWrite(argv[0]); - } - std::string logFile = argv[2]; - std::string testName = argv[3]; - unsigned int sleepTime = std::atoi(argv[4]); - std::vector>> - resources; - if (argc == 6) { - // Parse RESOURCE_GROUPS property - std::string resourceGroupsProperty = argv[5]; - std::vector< - std::vector> - resourceGroups; - bool result = cmCTestTestHandler::ParseResourceGroupsProperty( - resourceGroupsProperty, resourceGroups); - (void)result; - assert(result); - - // Verify group count - const char* resourceGroupCountEnv = - cmSystemTools::GetEnv("CTEST_RESOURCE_GROUP_COUNT"); - if (!resourceGroupCountEnv) { - std::cout << "CTEST_RESOURCE_GROUP_COUNT should be defined" << std::endl; - return 1; - } - int resourceGroupCount = std::atoi(resourceGroupCountEnv); - if (resourceGroups.size() != std::size_t(resourceGroupCount)) { - std::cout - << "CTEST_RESOURCE_GROUP_COUNT does not match expected resource groups" - << std::endl - << "Expected: " << resourceGroups.size() << std::endl - << "Actual: " << resourceGroupCount << std::endl; - return 1; - } - - if (!cmSystemTools::Touch(logFile + ".lock", true)) { - std::cout << "Could not create lock file" << std::endl; - return 1; - } - cmFileLock lock; - auto lockResult = - lock.Lock(logFile + ".lock", static_cast(-1)); - if (!lockResult.IsOk()) { - std::cout << "Could not lock file" << std::endl; - return 1; - } - std::size_t i = 0; - cmsys::ofstream fout(logFile.c_str(), std::ios::app); - fout << "begin " << testName << std::endl; - for (auto& resourceGroup : resourceGroups) { - try { - // Build and verify set of expected resources - std::set expectedResources; - for (auto const& it : resourceGroup) { - expectedResources.insert(it.ResourceType); - } - - std::string prefix = "CTEST_RESOURCE_GROUP_"; - prefix += std::to_string(i); - const char* actualResourcesCStr = cmSystemTools::GetEnv(prefix); - if (!actualResourcesCStr) { - std::cout << prefix << " should be defined" << std::endl; - return 1; - } - - auto actualResourcesVec = - cmSystemTools::SplitString(actualResourcesCStr, ','); - std::set actualResources; - for (auto const& r : actualResourcesVec) { - if (!r.empty()) { - actualResources.insert(r); - } - } - - if (actualResources != expectedResources) { - std::cout << prefix << " did not list expected resources" - << std::endl; - return 1; - } - - // Verify that we got what we asked for and write it to the log - prefix += '_'; - std::map> - resEntry; - for (auto const& type : actualResources) { - auto it = resourceGroup.begin(); - - std::string varName = prefix; - varName += cmSystemTools::UpperCase(type); - const char* varVal = cmSystemTools::GetEnv(varName); - if (!varVal) { - std::cout << varName << " should be defined" << std::endl; - return 1; - } - - auto received = cmSystemTools::SplitString(varVal, ';'); - for (auto const& r : received) { - while (it->ResourceType != type || it->UnitsNeeded == 0) { - ++it; - if (it == resourceGroup.end()) { - std::cout << varName << " did not list expected resources" - << std::endl; - return 1; - } - } - auto split = cmSystemTools::SplitString(r, ','); - if (split.size() != 2) { - std::cout << varName << " was ill-formed" << std::endl; - return 1; - } - if (!cmHasLiteralPrefix(split[0], "id:")) { - std::cout << varName << " was ill-formed" << std::endl; - return 1; - } - auto id = split[0].substr(3); - if (!cmHasLiteralPrefix(split[1], "slots:")) { - std::cout << varName << " was ill-formed" << std::endl; - return 1; - } - auto slots = split[1].substr(6); - unsigned int amount = std::atoi(slots.c_str()); - if (amount != static_cast(it->SlotsNeeded)) { - std::cout << varName << " did not list expected resources" - << std::endl; - return 1; - } - --it->UnitsNeeded; - - fout << "alloc " << type << " " << id << " " << amount - << std::endl; - resEntry[type].push_back({ id, amount }); - } - - bool ended = false; - while (it->ResourceType != type || it->UnitsNeeded == 0) { - ++it; - if (it == resourceGroup.end()) { - ended = true; - break; - } - } - - if (!ended) { - std::cout << varName << " did not list expected resources" - << std::endl; - return 1; - } - } - resources.push_back(resEntry); - - ++i; - } catch (...) { - std::cout << "Unknown error while processing resources" << std::endl; - return 1; - } - } - - auto unlockResult = lock.Release(); - if (!unlockResult.IsOk()) { - std::cout << "Could not unlock file" << std::endl; - return 1; - } - } else { - if (cmSystemTools::GetEnv("CTEST_RESOURCE_GROUP_COUNT")) { - std::cout << "CTEST_RESOURCE_GROUP_COUNT should not be defined" - << std::endl; - return 1; - } - } - - std::this_thread::sleep_for(std::chrono::seconds(sleepTime)); - - if (argc == 6) { - if (!cmSystemTools::Touch(logFile + ".lock", true)) { - std::cout << "Could not create lock file" << std::endl; - return 1; - } - cmFileLock lock; - auto lockResult = - lock.Lock(logFile + ".lock", static_cast(-1)); - if (!lockResult.IsOk()) { - std::cout << "Could not lock file" << std::endl; - return 1; - } - cmsys::ofstream fout(logFile.c_str(), std::ios::app); - for (auto const& group : resources) { - for (auto const& it : group) { - for (auto const& it2 : it.second) { - fout << "dealloc " << it.first << " " << it2.Id << " " << it2.Slots - << std::endl; - } - } - } - - fout << "end " << testName << std::endl; - - auto unlockResult = lock.Release(); - if (!unlockResult.IsOk()) { - std::cout << "Could not unlock file" << std::endl; - return 1; - } - } - - return 0; -} - -static int doVerify(int argc, char const* const* argv) -{ - if (argc < 4 || argc > 5) { - return usageVerify(argv[0]); - } - std::string logFile = argv[2]; - std::string resFile = argv[3]; - std::string testNames; - if (argc == 5) { - testNames = argv[4]; - } - auto testNameList = cmExpandedList(testNames, false); - std::set testNameSet(testNameList.begin(), testNameList.end()); - - cmCTestResourceSpec spec; - if (!spec.ReadFromJSONFile(resFile)) { - std::cout << "Could not read resource spec " << resFile << std::endl; - return 1; - } - - cmCTestResourceAllocator allocator; - allocator.InitializeFromResourceSpec(spec); - - cmsys::ifstream fin(logFile.c_str(), std::ios::in); - if (!fin) { - std::cout << "Could not open log file " << logFile << std::endl; - return 1; - } - - std::string command; - std::string resourceName; - std::string resourceId; - std::string testName; - unsigned int amount; - std::set inProgressTests; - std::set completedTests; - try { - while (fin >> command) { - if (command == "begin") { - if (!(fin >> testName)) { - std::cout << "Could not read begin line" << std::endl; - return 1; - } - if (!testNameSet.count(testName) || inProgressTests.count(testName) || - completedTests.count(testName)) { - std::cout << "Could not begin test" << std::endl; - return 1; - } - inProgressTests.insert(testName); - } else if (command == "alloc") { - if (!(fin >> resourceName) || !(fin >> resourceId) || - !(fin >> amount)) { - std::cout << "Could not read alloc line" << std::endl; - return 1; - } - if (!allocator.AllocateResource(resourceName, resourceId, amount)) { - std::cout << "Could not allocate resources" << std::endl; - return 1; - } - } else if (command == "dealloc") { - if (!(fin >> resourceName) || !(fin >> resourceId) || - !(fin >> amount)) { - std::cout << "Could not read dealloc line" << std::endl; - return 1; - } - if (!allocator.DeallocateResource(resourceName, resourceId, amount)) { - std::cout << "Could not deallocate resources" << std::endl; - return 1; - } - } else if (command == "end") { - if (!(fin >> testName)) { - std::cout << "Could not read end line" << std::endl; - return 1; - } - if (!inProgressTests.erase(testName)) { - std::cout << "Could not end test" << std::endl; - return 1; - } - if (!completedTests.insert(testName).second) { - std::cout << "Could not end test" << std::endl; - return 1; - } - } - } - } catch (...) { - std::cout << "Unknown error while reading log file" << std::endl; - return 1; - } - - auto const& avail = allocator.GetResources(); - for (auto const& it : avail) { - for (auto const& it2 : it.second) { - if (it2.second.Locked != 0) { - std::cout << "Resource was not unlocked" << std::endl; - return 1; - } - } - } - - if (completedTests != testNameSet) { - std::cout << "Tests were not ended" << std::endl; - return 1; - } - - return 0; -} - -int main(int argc, char const* const* argv) -{ - cmsys::Encoding::CommandLineArguments args = - cmsys::Encoding::CommandLineArguments::Main(argc, argv); - argc = args.argc(); - argv = args.argv(); - - if (argc < 2) { - return usage(argv[0]); - } - - std::string argv1 = argv[1]; - if (argv1 == "write") { - return doWrite(argc, argv); - } - if (argv1 == "verify") { - return doVerify(argc, argv); - } - return usage(argv[0]); -} diff --git a/Tests/RunCMake/CTestHardwareAllocation/ensure_parallel-ctest-s-hw-check.cmake b/Tests/RunCMake/CTestHardwareAllocation/ensure_parallel-ctest-s-hw-check.cmake deleted file mode 100644 index e5f6828..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/ensure_parallel-ctest-s-hw-check.cmake +++ /dev/null @@ -1,16 +0,0 @@ -verify_ctest_hardware() - -set(expected_contents [[ -begin Test1 -alloc transmogrifiers calvin 2 -begin Test2 -alloc transmogrifiers hobbes 2 -dealloc transmogrifiers calvin 2 -end Test1 -dealloc transmogrifiers hobbes 2 -end Test2 -]]) -file(READ "${RunCMake_TEST_BINARY_DIR}/cthwalloc.log" actual_contents) -if(NOT actual_contents STREQUAL expected_contents) - string(APPEND RunCMake_TEST_FAILED "cthwalloc.log contents did not match expected\n") -endif() diff --git a/Tests/RunCMake/CTestHardwareAllocation/ensure_parallel.cmake b/Tests/RunCMake/CTestHardwareAllocation/ensure_parallel.cmake deleted file mode 100644 index 1dafb8f..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/ensure_parallel.cmake +++ /dev/null @@ -1,11 +0,0 @@ -setup_hardware_tests() - -add_hardware_test(Test1 4 "transmogrifiers:2") - -# Mitigate possible race conditions to ensure that the events are logged in the -# exact order we want -add_test(NAME Test2Sleep COMMAND "${CMAKE_COMMAND}" -E sleep 2) -add_hardware_test(Test2 4 "transmogrifiers:2") -set_property(TEST Test2 APPEND PROPERTY DEPENDS Test2Sleep) - -cleanup_hardware_tests() diff --git a/Tests/RunCMake/CTestHardwareAllocation/hwspec.json b/Tests/RunCMake/CTestHardwareAllocation/hwspec.json deleted file mode 100644 index c67fcca..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/hwspec.json +++ /dev/null @@ -1,55 +0,0 @@ -{ - "local": [ - { - "widgets": [ - { - "id": "0", - "slots": 4 - }, - { - "id": "1", - "slots": 2 - }, - { - "id": "2", - "slots": 4 - }, - { - "id": "3", - "slots": 8 - }, - { - "id": "4", - "slots": 1 - }, - { - "id": "5", - "slots": 1 - }, - { - "id": "6", - "slots": 1 - }, - { - "id": "7" - } - ], - "transmogrifiers": [ - { - "id": "calvin", - "slots": 2 - }, - { - "id": "hobbes", - "slots": 2 - } - ], - "fluxcapacitors": [ - { - "id": "outatime", - "slots": 121 - } - ] - } - ] -} diff --git a/Tests/RunCMake/CTestHardwareAllocation/lotsoftests-ctest-s-hw-check.cmake b/Tests/RunCMake/CTestHardwareAllocation/lotsoftests-ctest-s-hw-check.cmake deleted file mode 100644 index 94b1fa7..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/lotsoftests-ctest-s-hw-check.cmake +++ /dev/null @@ -1 +0,0 @@ -verify_ctest_hardware() diff --git a/Tests/RunCMake/CTestHardwareAllocation/lotsoftests.cmake b/Tests/RunCMake/CTestHardwareAllocation/lotsoftests.cmake deleted file mode 100644 index c684434..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/lotsoftests.cmake +++ /dev/null @@ -1,16 +0,0 @@ -setup_hardware_tests() - -add_hardware_test(Test1 2 "widgets:8;2,widgets:2") -add_hardware_test(Test2 5 "fluxcapacitors:40") -add_hardware_test(Test3 1 "10,widgets:1,fluxcapacitors:2") -add_hardware_test(Test4 4 "fluxcapacitors:121") - -foreach(i RANGE 5 50) - add_hardware_test(Test${i} 1 "2,widgets:1") -endforeach() - -foreach(i RANGE 51 100) - add_hardware_test(Test${i} 1 "2,transmogrifiers:2") -endforeach() - -cleanup_hardware_tests() diff --git a/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-check.cmake b/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-check.cmake deleted file mode 100644 index 9c730be..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-check.cmake +++ /dev/null @@ -1,3 +0,0 @@ -if(EXISTS "${RunCMake_TEST_BINARY_DIR}/cthwalloc.log") - set(RunCMake_TEST_FAILED "cthwalloc.log should not exist") -endif() diff --git a/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-result.txt b/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-result.txt deleted file mode 100644 index b57e2de..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-result.txt +++ /dev/null @@ -1 +0,0 @@ -(-1|255) diff --git a/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-stderr.txt b/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-stderr.txt deleted file mode 100644 index f1ea087..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw-stderr.txt +++ /dev/null @@ -1,4 +0,0 @@ -^Insufficient resources -CMake Error at [^ -]*/Tests/RunCMake/CTestHardwareAllocation/notenough1-ctest-s-hw/test\.cmake:[0-9]+ \(message\): - Tests did not pass$ diff --git a/Tests/RunCMake/CTestHardwareAllocation/notenough1.cmake b/Tests/RunCMake/CTestHardwareAllocation/notenough1.cmake deleted file mode 100644 index 3e1f620..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/notenough1.cmake +++ /dev/null @@ -1,5 +0,0 @@ -setup_hardware_tests() - -add_hardware_test(Test1 1 "fluxcapacitors:200") - -cleanup_hardware_tests() diff --git a/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-check.cmake b/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-check.cmake deleted file mode 100644 index 9c730be..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-check.cmake +++ /dev/null @@ -1,3 +0,0 @@ -if(EXISTS "${RunCMake_TEST_BINARY_DIR}/cthwalloc.log") - set(RunCMake_TEST_FAILED "cthwalloc.log should not exist") -endif() diff --git a/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-result.txt b/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-result.txt deleted file mode 100644 index b57e2de..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-result.txt +++ /dev/null @@ -1 +0,0 @@ -(-1|255) diff --git a/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-stderr.txt b/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-stderr.txt deleted file mode 100644 index bc03156..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw-stderr.txt +++ /dev/null @@ -1,4 +0,0 @@ -^Insufficient resources -CMake Error at [^ -]*/Tests/RunCMake/CTestHardwareAllocation/notenough2-ctest-s-hw/test\.cmake:[0-9]+ \(message\): - Tests did not pass$ diff --git a/Tests/RunCMake/CTestHardwareAllocation/notenough2.cmake b/Tests/RunCMake/CTestHardwareAllocation/notenough2.cmake deleted file mode 100644 index 8205c95..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/notenough2.cmake +++ /dev/null @@ -1,5 +0,0 @@ -setup_hardware_tests() - -add_hardware_test(Test1 1 "terminators:2") - -cleanup_hardware_tests() diff --git a/Tests/RunCMake/CTestHardwareAllocation/process_count-ctest-s-hw-check.cmake b/Tests/RunCMake/CTestHardwareAllocation/process_count-ctest-s-hw-check.cmake deleted file mode 100644 index 94b1fa7..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/process_count-ctest-s-hw-check.cmake +++ /dev/null @@ -1 +0,0 @@ -verify_ctest_hardware() diff --git a/Tests/RunCMake/CTestHardwareAllocation/process_count.cmake b/Tests/RunCMake/CTestHardwareAllocation/process_count.cmake deleted file mode 100644 index c969648..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/process_count.cmake +++ /dev/null @@ -1,5 +0,0 @@ -setup_hardware_tests() - -add_hardware_test(Test1 1 "widgets:1") - -cleanup_hardware_tests() diff --git a/Tests/RunCMake/CTestHardwareAllocation/test.cmake.in b/Tests/RunCMake/CTestHardwareAllocation/test.cmake.in deleted file mode 100644 index a4884dc..0000000 --- a/Tests/RunCMake/CTestHardwareAllocation/test.cmake.in +++ /dev/null @@ -1,23 +0,0 @@ -set(CTEST_SITE "test-site") -set(CTEST_BUILD_NAME "test-build-name") -set(CTEST_SOURCE_DIRECTORY "@RunCMake_BINARY_DIR@/@CASE_NAME@") -set(CTEST_BINARY_DIRECTORY "@RunCMake_BINARY_DIR@/@CASE_NAME@-build") -set(CTEST_CMAKE_GENERATOR "@RunCMake_GENERATOR@") -set(CTEST_CMAKE_GENERATOR_PLATFORM "@RunCMake_GENERATOR_PLATFORM@") -set(CTEST_CMAKE_GENERATOR_TOOLSET "@RunCMake_GENERATOR_TOOLSET@") -set(CTEST_BUILD_CONFIGURATION "$ENV{CMAKE_CONFIG_TYPE}") -set(CTEST_NIGHTLY_START_TIME "01:00:00 UTC") - -ctest_start(Experimental QUIET) -ctest_configure(OPTIONS - "-DCTEST_HARDWARE_ALLOC_ENABLED=${CTEST_HARDWARE_ALLOC_ENABLED};-DCTHWALLOC_COMMAND=${CTHWALLOC_COMMAND}" - ) -ctest_build() - -if(CTEST_HARDWARE_ALLOC_ENABLED) - set(hwspec RESOURCE_SPEC_FILE "@RunCMake_SOURCE_DIR@/hwspec.json") -endif() -ctest_test(${hwspec} RETURN_VALUE retval PARALLEL_LEVEL ${CTEST_PARALLEL} SCHEDULE_RANDOM ${CTEST_RANDOM}) -if(retval) - message(FATAL_ERROR "Tests did not pass") -endif() diff --git a/Tests/RunCMake/CTestResourceAllocation/CMakeLists.txt.in b/Tests/RunCMake/CTestResourceAllocation/CMakeLists.txt.in new file mode 100644 index 0000000..9984421 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/CMakeLists.txt.in @@ -0,0 +1,9 @@ +cmake_minimum_required(VERSION 3.15) +set(CASE_NAME "@CASE_NAME@") +if(CASE_NAME MATCHES "^(.*)-ctest-s") + set(projname "${CMAKE_MATCH_1}") + project(${projname} NONE) + include(CTest) + include("@RunCMake_SOURCE_DIR@/ResourceCommon.cmake") + include("@RunCMake_SOURCE_DIR@/${projname}.cmake") +endif() diff --git a/Tests/RunCMake/CTestResourceAllocation/ResourceCommon.cmake b/Tests/RunCMake/CTestResourceAllocation/ResourceCommon.cmake new file mode 100644 index 0000000..7d63299 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ResourceCommon.cmake @@ -0,0 +1,23 @@ +function(setup_resource_tests) + if(CTEST_RESOURCE_ALLOC_ENABLED) + add_test(NAME ResourceSetup COMMAND "${CMAKE_COMMAND}" -E remove -f "${CMAKE_BINARY_DIR}/ctresalloc.log") + endif() +endfunction() + +function(add_resource_test name sleep_time proc) + if(CTEST_RESOURCE_ALLOC_ENABLED) + add_test(NAME "${name}" COMMAND "${CTRESALLOC_COMMAND}" write "${CMAKE_BINARY_DIR}/ctresalloc.log" "${name}" "${sleep_time}" "${proc}") + set_property(TEST "${name}" PROPERTY DEPENDS ResourceSetup) + else() + add_test(NAME "${name}" COMMAND "${CTRESALLOC_COMMAND}" write "${CMAKE_BINARY_DIR}/ctresalloc.log" "${name}" "${sleep_time}") + endif() + set_property(TEST "${name}" PROPERTY RESOURCE_GROUPS "${proc}") + list(APPEND RESOURCE_TESTS "${name}") + set(RESOURCE_TESTS "${RESOURCE_TESTS}" PARENT_SCOPE) +endfunction() + +function(cleanup_resource_tests) + if(CTEST_RESOURCE_ALLOC_ENABLED) + file(WRITE "${CMAKE_BINARY_DIR}/restests.txt" "${RESOURCE_TESTS}") + endif() +endfunction() diff --git a/Tests/RunCMake/CTestResourceAllocation/RunCMakeTest.cmake b/Tests/RunCMake/CTestResourceAllocation/RunCMakeTest.cmake new file mode 100644 index 0000000..d52a63e --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/RunCMakeTest.cmake @@ -0,0 +1,167 @@ +include(RunCMake) +include(RunCTest) + +############################################################################### +# Test ctresalloc itself - we want to make sure it's not just rubber-stamping +# the test results +############################################################################### + +function(ctresalloc_verify_log expected_contents) + if(NOT EXISTS "${RunCMake_TEST_BINARY_DIR}/ctresalloc.log") + string(APPEND RunCMake_TEST_FAILED "Log file was not written\n") + set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE) + return() + endif() + file(READ "${RunCMake_TEST_BINARY_DIR}/ctresalloc.log" actual_contents) + if(NOT actual_contents STREQUAL expected_contents) + string(APPEND RunCMake_TEST_FAILED "Actual log did not match expected log\n") + set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE) + endif() +endfunction() + +function(run_ctresalloc_write_proc name proc) + file(REMOVE "${RunCMake_BINARY_DIR}/${name}-build/ctresalloc.log") + run_ctresalloc_write_proc_nodel("${name}" "${proc}" "${ARGN}") +endfunction() + +function(run_ctresalloc_write_proc_nodel name proc) + string(REPLACE ";" "\\;" proc "${proc}") + run_cmake_command(${name} "${CMAKE_COMMAND}" -E env "${ARGN}" "${CTRESALLOC_COMMAND}" write "${RunCMake_BINARY_DIR}/${name}-build/ctresalloc.log" "${name}" 0 "${proc}") +endfunction() + +function(run_ctresalloc_write_noproc name) + run_cmake_command(${name} "${CMAKE_COMMAND}" -E env "${ARGN}" "${CTRESALLOC_COMMAND}" write "${RunCMake_BINARY_DIR}/${name}-build/ctresalloc.log" "${name}" 0) +endfunction() + +function(run_ctresalloc_verify name tests) + string(REPLACE ";" "\\;" tests "${tests}") + run_cmake_command(${name} "${CTRESALLOC_COMMAND}" verify "${RunCMake_SOURCE_DIR}/${name}.log" "${CMAKE_CURRENT_LIST_DIR}/resspec.json" "${tests}") +endfunction() + +unset(ENV{CTEST_RESOURCE_GROUP_COUNT}) +set(RunCMake_TEST_NO_CLEAN 1) +file(REMOVE_RECURSE "${RunCMake_BINARY_DIR}/ctresalloc-write-proc-good1-build") +file(MAKE_DIRECTORY "${RunCMake_BINARY_DIR}/ctresalloc-write-proc-good1-build") +file(WRITE "${RunCMake_BINARY_DIR}/ctresalloc-write-proc-good1-build/ctresalloc.log" +[[begin test1 +alloc widgets 0 1 +dealloc widgets 0 1 +end test1 +]]) +run_ctresalloc_write_proc_nodel(ctresalloc-write-proc-good1 "1,widgets:2,transmogrifiers:1;2,widgets:1,widgets:2" + CTEST_RESOURCE_GROUP_COUNT=3 + CTEST_RESOURCE_GROUP_0=widgets,transmogrifiers + CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2 + CTEST_RESOURCE_GROUP_0_TRANSMOGRIFIERS=id:calvin,slots:1 + CTEST_RESOURCE_GROUP_1=widgets + "CTEST_RESOURCE_GROUP_1_WIDGETS=id:0,slots:1\\;id:2,slots:2" + CTEST_RESOURCE_GROUP_2=widgets + "CTEST_RESOURCE_GROUP_2_WIDGETS=id:0,slots:1\\;id:2,slots:2" + ) +set(RunCMake_TEST_NO_CLEAN 0) +run_ctresalloc_write_proc(ctresalloc-write-proc-good2 "widgets:8" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:8 + ) +run_ctresalloc_write_proc(ctresalloc-write-proc-nocount "widgets:8") +run_ctresalloc_write_proc(ctresalloc-write-proc-badcount "widgets:8" + CTEST_RESOURCE_GROUP_COUNT=2 + ) +run_ctresalloc_write_proc(ctresalloc-write-proc-nores "widgets:8" + CTEST_RESOURCE_GROUP_COUNT=1 + ) +run_ctresalloc_write_proc(ctresalloc-write-proc-badres "widgets:8" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets,transmogrifiers + ) +run_ctresalloc_write_proc(ctresalloc-write-proc-nowidgets "widgets:8" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + ) +run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets1 "widgets:8" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + CTEST_RESOURCE_GROUP_0_WIDGETS= + ) +run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets2 "widgets:8" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + "CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:8\\;id:0,slots:1" + ) +run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets3 "widgets:8" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + CTEST_RESOURCE_GROUP_0_WIDGETS=id:3,slots:7 + ) +run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets4 "widgets:8" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + CTEST_RESOURCE_GROUP_0_WIDGETS=invalid + ) +run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets5 "widgets:2,widgets:2" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + "CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2\\;id:0,slots:1" + ) +run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets6 "widgets:2" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + "CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2\\;id:0,slots:1" + ) +run_ctresalloc_write_proc(ctresalloc-write-proc-badwidgets7 "widgets:2,widgets:2" + CTEST_RESOURCE_GROUP_COUNT=1 + CTEST_RESOURCE_GROUP_0=widgets + CTEST_RESOURCE_GROUP_0_WIDGETS=id:0,slots:2 + ) + +run_ctresalloc_write_noproc(ctresalloc-write-noproc-good1) +run_ctresalloc_write_noproc(ctresalloc-write-noproc-count + CTEST_RESOURCE_GROUP_COUNT=1 + ) + +run_ctresalloc_verify(ctresalloc-verify-good1 "test1;test2") +run_ctresalloc_verify(ctresalloc-verify-good2 "") +run_ctresalloc_verify(ctresalloc-verify-nolog "") +run_ctresalloc_verify(ctresalloc-verify-nores "") +run_ctresalloc_verify(ctresalloc-verify-noid "") +run_ctresalloc_verify(ctresalloc-verify-notenough "") +run_ctresalloc_verify(ctresalloc-verify-baddealloc "") +run_ctresalloc_verify(ctresalloc-verify-leak "") +run_ctresalloc_verify(ctresalloc-verify-badtest1 "") +run_ctresalloc_verify(ctresalloc-verify-badtest2 "test1") +run_ctresalloc_verify(ctresalloc-verify-badtest3 "test1") +run_ctresalloc_verify(ctresalloc-verify-badtest4 "test1") +run_ctresalloc_verify(ctresalloc-verify-badtest5 "test1") +run_ctresalloc_verify(ctresalloc-verify-nobegin "test1") +run_ctresalloc_verify(ctresalloc-verify-noend "test1") + +############################################################################### +# Now test the resource allocation feature of CTest +############################################################################### + +function(run_ctest_resource name parallel random) + run_ctest("${name}-ctest-s-res" "-DCTEST_RESOURCE_ALLOC_ENABLED=1" "-DCTRESALLOC_COMMAND=${CTRESALLOC_COMMAND}" "-DCTEST_PARALLEL=${parallel}" "-DCTEST_RANDOM=${random}") + run_ctest("${name}-ctest-s-nores" "-DCTEST_RESOURCE_ALLOC_ENABLED=0" "-DCTRESALLOC_COMMAND=${CTRESALLOC_COMMAND}" "-DCTEST_PARALLEL=${parallel}" "-DCTEST_RANDOM=${random}") +endfunction() + +function(verify_ctest_resources) + file(READ "${RunCMake_TEST_BINARY_DIR}/restests.txt" restests) + execute_process(COMMAND "${CTRESALLOC_COMMAND}" verify "${RunCMake_TEST_BINARY_DIR}/ctresalloc.log" "${CMAKE_CURRENT_LIST_DIR}/resspec.json" "${restests}" + OUTPUT_VARIABLE output ERROR_QUIET RESULT_VARIABLE result) + if(result) + string(APPEND RunCMake_TEST_FAILED "${output}") + set(RunCMake_TEST_FAILED "${RunCMake_TEST_FAILED}" PARENT_SCOPE) + endif() +endfunction() + +run_ctest_resource(lotsoftests 10 1) +run_ctest_resource(checkfree1 2 0) +run_ctest_resource(checkfree2 1 0) +run_ctest_resource(notenough1 1 0) +run_ctest_resource(notenough2 1 0) +run_ctest_resource(ensure_parallel 2 0) + +set(ENV{CTEST_RESOURCE_GROUP_COUNT} 2) +run_ctest_resource(process_count 1 0) +unset(ENV{CTEST_RESOURCE_GROUP_COUNT}) diff --git a/Tests/RunCMake/CTestResourceAllocation/checkfree1-ctest-s-res-check.cmake b/Tests/RunCMake/CTestResourceAllocation/checkfree1-ctest-s-res-check.cmake new file mode 100644 index 0000000..ceda72e --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/checkfree1-ctest-s-res-check.cmake @@ -0,0 +1 @@ +verify_ctest_resources() diff --git a/Tests/RunCMake/CTestResourceAllocation/checkfree1.cmake b/Tests/RunCMake/CTestResourceAllocation/checkfree1.cmake new file mode 100644 index 0000000..45cbf20 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/checkfree1.cmake @@ -0,0 +1,7 @@ +setup_resource_tests() + +add_resource_test(Test1 1 "widgets:8") +add_resource_test(Test2 1 "fluxcapacitors:50;fluxcapacitors:50,widgets:8") +add_resource_test(Test3 1 "fluxcapacitors:121") + +cleanup_resource_tests() diff --git a/Tests/RunCMake/CTestResourceAllocation/checkfree2-ctest-s-res-check.cmake b/Tests/RunCMake/CTestResourceAllocation/checkfree2-ctest-s-res-check.cmake new file mode 100644 index 0000000..ceda72e --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/checkfree2-ctest-s-res-check.cmake @@ -0,0 +1 @@ +verify_ctest_resources() diff --git a/Tests/RunCMake/CTestResourceAllocation/checkfree2.cmake b/Tests/RunCMake/CTestResourceAllocation/checkfree2.cmake new file mode 100644 index 0000000..03b737c --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/checkfree2.cmake @@ -0,0 +1,8 @@ +setup_resource_tests() + +# This test is an attack on the resource scheduling algorithm. It has been +# carefully crafted to fool the algorithm into thinking there aren't sufficient +# resources for it. +add_resource_test(Test1 1 "widgets:2;4,widgets:4") + +cleanup_resource_tests() diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-baddealloc-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-baddealloc-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-baddealloc-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-baddealloc.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-baddealloc.log new file mode 100644 index 0000000..abd6bad --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-baddealloc.log @@ -0,0 +1,2 @@ +alloc widgets 0 1 +dealloc widgets 0 2 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest1-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest1-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest1-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest1.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest1.log new file mode 100644 index 0000000..605104b --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest1.log @@ -0,0 +1 @@ +begin test1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest2-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest2-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest2-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest2.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest2.log new file mode 100644 index 0000000..1ff1b0d --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest2.log @@ -0,0 +1,2 @@ +begin test1 +begin test1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest3-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest3-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest3-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest3.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest3.log new file mode 100644 index 0000000..1925e6a --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest3.log @@ -0,0 +1,3 @@ +begin test1 +end test1 +begin test1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest4-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest4-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest4-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest4.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest4.log new file mode 100644 index 0000000..3fe7da1 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest4.log @@ -0,0 +1,3 @@ +begin test1 +end test1 +end test1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest5-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest5-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest5-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest5.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest5.log new file mode 100644 index 0000000..3a2e7e3 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-badtest5.log @@ -0,0 +1 @@ +end test1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-good1.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-good1.log new file mode 100644 index 0000000..2cca0c3 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-good1.log @@ -0,0 +1,14 @@ +begin test1 +alloc widgets 3 4 +alloc widgets 4 1 +alloc transmogrifiers calvin 2 +alloc fluxcapacitors outatime 121 +begin test2 +alloc widgets 3 4 +dealloc widgets 3 4 +dealloc widgets 4 1 +dealloc transmogrifiers calvin 2 +dealloc fluxcapacitors outatime 121 +end test1 +dealloc widgets 3 4 +end test2 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-good2.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-good2.log new file mode 100644 index 0000000..e69de29 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-leak-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-leak-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-leak-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-leak.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-leak.log new file mode 100644 index 0000000..b900d86 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-leak.log @@ -0,0 +1 @@ +alloc widgets 0 1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nobegin-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nobegin-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nobegin-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nobegin.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nobegin.log new file mode 100644 index 0000000..e69de29 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noend-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noend-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noend-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noend.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noend.log new file mode 100644 index 0000000..605104b --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noend.log @@ -0,0 +1 @@ +begin test1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noid-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noid-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noid-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noid.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noid.log new file mode 100644 index 0000000..c718975 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-noid.log @@ -0,0 +1,2 @@ +alloc fluxcapacitors train 1 +dealloc fluxcapacitors train 1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nolog-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nolog-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nolog-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nores-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nores-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nores-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nores.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nores.log new file mode 100644 index 0000000..a18202b --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-nores.log @@ -0,0 +1,2 @@ +alloc gpus 0 1 +dealloc gpus 0 1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-notenough-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-notenough-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-notenough-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-notenough.log b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-notenough.log new file mode 100644 index 0000000..ac78d5a --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-verify-notenough.log @@ -0,0 +1,2 @@ +alloc widgets 0 8 +dealloc widgets 0 8 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-noproc-count-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-noproc-count-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-noproc-count-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badcount-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badcount-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badcount-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badres-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badres-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badres-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets1-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets1-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets1-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets2-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets2-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets2-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets3-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets3-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets3-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets4-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets4-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets4-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets5-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets5-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets5-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets6-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets6-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets6-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets7-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets7-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-badwidgets7-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-good1-check.cmake b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-good1-check.cmake new file mode 100644 index 0000000..40144c8 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-good1-check.cmake @@ -0,0 +1,20 @@ +ctresalloc_verify_log( +[[begin test1 +alloc widgets 0 1 +dealloc widgets 0 1 +end test1 +begin ctresalloc-write-proc-good1 +alloc transmogrifiers calvin 1 +alloc widgets 0 2 +alloc widgets 0 1 +alloc widgets 2 2 +alloc widgets 0 1 +alloc widgets 2 2 +dealloc transmogrifiers calvin 1 +dealloc widgets 0 2 +dealloc widgets 0 1 +dealloc widgets 2 2 +dealloc widgets 0 1 +dealloc widgets 2 2 +end ctresalloc-write-proc-good1 +]]) diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-good2-check.cmake b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-good2-check.cmake new file mode 100644 index 0000000..4545466 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-good2-check.cmake @@ -0,0 +1,6 @@ +ctresalloc_verify_log( +[[begin ctresalloc-write-proc-good2 +alloc widgets 3 8 +dealloc widgets 3 8 +end ctresalloc-write-proc-good2 +]]) diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nocount-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nocount-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nocount-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nores-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nores-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nores-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nowidgets-result.txt b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nowidgets-result.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc-write-proc-nowidgets-result.txt @@ -0,0 +1 @@ +1 diff --git a/Tests/RunCMake/CTestResourceAllocation/ctresalloc.cxx b/Tests/RunCMake/CTestResourceAllocation/ctresalloc.cxx new file mode 100644 index 0000000..27644af --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ctresalloc.cxx @@ -0,0 +1,399 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "cmsys/Encoding.hxx" +#include "cmsys/FStream.hxx" + +#include "cmCTestMultiProcessHandler.h" +#include "cmCTestResourceAllocator.h" +#include "cmCTestResourceSpec.h" +#include "cmCTestTestHandler.h" +#include "cmFileLock.h" +#include "cmFileLockResult.h" +#include "cmStringAlgorithms.h" +#include "cmSystemTools.h" + +/* + * This helper program is used to verify that the CTest resource allocation + * feature is working correctly. It consists of two stages: + * + * 1) write - This stage receives the RESOURCE_GROUPS property of the test and + * compares it with the values passed in the CTEST_RESOURCE_GROUP_* + * environment variables. If it received all of the resources it expected, + * then it writes this information to a log file, which will be read in + * the verify stage. + * 2) verify - This stage compares the log file with the resource spec file to + * make sure that no resources were over-subscribed, deallocated without + * being allocated, or allocated without being deallocated. + */ + +static int usage(const char* argv0) +{ + std::cout << "Usage: " << argv0 << " (write|verify) " << std::endl; + return 1; +} + +static int usageWrite(const char* argv0) +{ + std::cout << "Usage: " << argv0 + << " write " + " []" + << std::endl; + return 1; +} + +static int usageVerify(const char* argv0) +{ + std::cout << "Usage: " << argv0 + << " verify []" + << std::endl; + return 1; +} + +static int doWrite(int argc, char const* const* argv) +{ + if (argc < 5 || argc > 6) { + return usageWrite(argv[0]); + } + std::string logFile = argv[2]; + std::string testName = argv[3]; + unsigned int sleepTime = std::atoi(argv[4]); + std::vector>> + resources; + if (argc == 6) { + // Parse RESOURCE_GROUPS property + std::string resourceGroupsProperty = argv[5]; + std::vector< + std::vector> + resourceGroups; + bool result = cmCTestTestHandler::ParseResourceGroupsProperty( + resourceGroupsProperty, resourceGroups); + (void)result; + assert(result); + + // Verify group count + const char* resourceGroupCountEnv = + cmSystemTools::GetEnv("CTEST_RESOURCE_GROUP_COUNT"); + if (!resourceGroupCountEnv) { + std::cout << "CTEST_RESOURCE_GROUP_COUNT should be defined" << std::endl; + return 1; + } + int resourceGroupCount = std::atoi(resourceGroupCountEnv); + if (resourceGroups.size() != std::size_t(resourceGroupCount)) { + std::cout + << "CTEST_RESOURCE_GROUP_COUNT does not match expected resource groups" + << std::endl + << "Expected: " << resourceGroups.size() << std::endl + << "Actual: " << resourceGroupCount << std::endl; + return 1; + } + + if (!cmSystemTools::Touch(logFile + ".lock", true)) { + std::cout << "Could not create lock file" << std::endl; + return 1; + } + cmFileLock lock; + auto lockResult = + lock.Lock(logFile + ".lock", static_cast(-1)); + if (!lockResult.IsOk()) { + std::cout << "Could not lock file" << std::endl; + return 1; + } + std::size_t i = 0; + cmsys::ofstream fout(logFile.c_str(), std::ios::app); + fout << "begin " << testName << std::endl; + for (auto& resourceGroup : resourceGroups) { + try { + // Build and verify set of expected resources + std::set expectedResources; + for (auto const& it : resourceGroup) { + expectedResources.insert(it.ResourceType); + } + + std::string prefix = "CTEST_RESOURCE_GROUP_"; + prefix += std::to_string(i); + const char* actualResourcesCStr = cmSystemTools::GetEnv(prefix); + if (!actualResourcesCStr) { + std::cout << prefix << " should be defined" << std::endl; + return 1; + } + + auto actualResourcesVec = + cmSystemTools::SplitString(actualResourcesCStr, ','); + std::set actualResources; + for (auto const& r : actualResourcesVec) { + if (!r.empty()) { + actualResources.insert(r); + } + } + + if (actualResources != expectedResources) { + std::cout << prefix << " did not list expected resources" + << std::endl; + return 1; + } + + // Verify that we got what we asked for and write it to the log + prefix += '_'; + std::map> + resEntry; + for (auto const& type : actualResources) { + auto it = resourceGroup.begin(); + + std::string varName = prefix; + varName += cmSystemTools::UpperCase(type); + const char* varVal = cmSystemTools::GetEnv(varName); + if (!varVal) { + std::cout << varName << " should be defined" << std::endl; + return 1; + } + + auto received = cmSystemTools::SplitString(varVal, ';'); + for (auto const& r : received) { + while (it->ResourceType != type || it->UnitsNeeded == 0) { + ++it; + if (it == resourceGroup.end()) { + std::cout << varName << " did not list expected resources" + << std::endl; + return 1; + } + } + auto split = cmSystemTools::SplitString(r, ','); + if (split.size() != 2) { + std::cout << varName << " was ill-formed" << std::endl; + return 1; + } + if (!cmHasLiteralPrefix(split[0], "id:")) { + std::cout << varName << " was ill-formed" << std::endl; + return 1; + } + auto id = split[0].substr(3); + if (!cmHasLiteralPrefix(split[1], "slots:")) { + std::cout << varName << " was ill-formed" << std::endl; + return 1; + } + auto slots = split[1].substr(6); + unsigned int amount = std::atoi(slots.c_str()); + if (amount != static_cast(it->SlotsNeeded)) { + std::cout << varName << " did not list expected resources" + << std::endl; + return 1; + } + --it->UnitsNeeded; + + fout << "alloc " << type << " " << id << " " << amount + << std::endl; + resEntry[type].push_back({ id, amount }); + } + + bool ended = false; + while (it->ResourceType != type || it->UnitsNeeded == 0) { + ++it; + if (it == resourceGroup.end()) { + ended = true; + break; + } + } + + if (!ended) { + std::cout << varName << " did not list expected resources" + << std::endl; + return 1; + } + } + resources.push_back(resEntry); + + ++i; + } catch (...) { + std::cout << "Unknown error while processing resources" << std::endl; + return 1; + } + } + + auto unlockResult = lock.Release(); + if (!unlockResult.IsOk()) { + std::cout << "Could not unlock file" << std::endl; + return 1; + } + } else { + if (cmSystemTools::GetEnv("CTEST_RESOURCE_GROUP_COUNT")) { + std::cout << "CTEST_RESOURCE_GROUP_COUNT should not be defined" + << std::endl; + return 1; + } + } + + std::this_thread::sleep_for(std::chrono::seconds(sleepTime)); + + if (argc == 6) { + if (!cmSystemTools::Touch(logFile + ".lock", true)) { + std::cout << "Could not create lock file" << std::endl; + return 1; + } + cmFileLock lock; + auto lockResult = + lock.Lock(logFile + ".lock", static_cast(-1)); + if (!lockResult.IsOk()) { + std::cout << "Could not lock file" << std::endl; + return 1; + } + cmsys::ofstream fout(logFile.c_str(), std::ios::app); + for (auto const& group : resources) { + for (auto const& it : group) { + for (auto const& it2 : it.second) { + fout << "dealloc " << it.first << " " << it2.Id << " " << it2.Slots + << std::endl; + } + } + } + + fout << "end " << testName << std::endl; + + auto unlockResult = lock.Release(); + if (!unlockResult.IsOk()) { + std::cout << "Could not unlock file" << std::endl; + return 1; + } + } + + return 0; +} + +static int doVerify(int argc, char const* const* argv) +{ + if (argc < 4 || argc > 5) { + return usageVerify(argv[0]); + } + std::string logFile = argv[2]; + std::string resFile = argv[3]; + std::string testNames; + if (argc == 5) { + testNames = argv[4]; + } + auto testNameList = cmExpandedList(testNames, false); + std::set testNameSet(testNameList.begin(), testNameList.end()); + + cmCTestResourceSpec spec; + if (!spec.ReadFromJSONFile(resFile)) { + std::cout << "Could not read resource spec " << resFile << std::endl; + return 1; + } + + cmCTestResourceAllocator allocator; + allocator.InitializeFromResourceSpec(spec); + + cmsys::ifstream fin(logFile.c_str(), std::ios::in); + if (!fin) { + std::cout << "Could not open log file " << logFile << std::endl; + return 1; + } + + std::string command; + std::string resourceName; + std::string resourceId; + std::string testName; + unsigned int amount; + std::set inProgressTests; + std::set completedTests; + try { + while (fin >> command) { + if (command == "begin") { + if (!(fin >> testName)) { + std::cout << "Could not read begin line" << std::endl; + return 1; + } + if (!testNameSet.count(testName) || inProgressTests.count(testName) || + completedTests.count(testName)) { + std::cout << "Could not begin test" << std::endl; + return 1; + } + inProgressTests.insert(testName); + } else if (command == "alloc") { + if (!(fin >> resourceName) || !(fin >> resourceId) || + !(fin >> amount)) { + std::cout << "Could not read alloc line" << std::endl; + return 1; + } + if (!allocator.AllocateResource(resourceName, resourceId, amount)) { + std::cout << "Could not allocate resources" << std::endl; + return 1; + } + } else if (command == "dealloc") { + if (!(fin >> resourceName) || !(fin >> resourceId) || + !(fin >> amount)) { + std::cout << "Could not read dealloc line" << std::endl; + return 1; + } + if (!allocator.DeallocateResource(resourceName, resourceId, amount)) { + std::cout << "Could not deallocate resources" << std::endl; + return 1; + } + } else if (command == "end") { + if (!(fin >> testName)) { + std::cout << "Could not read end line" << std::endl; + return 1; + } + if (!inProgressTests.erase(testName)) { + std::cout << "Could not end test" << std::endl; + return 1; + } + if (!completedTests.insert(testName).second) { + std::cout << "Could not end test" << std::endl; + return 1; + } + } + } + } catch (...) { + std::cout << "Unknown error while reading log file" << std::endl; + return 1; + } + + auto const& avail = allocator.GetResources(); + for (auto const& it : avail) { + for (auto const& it2 : it.second) { + if (it2.second.Locked != 0) { + std::cout << "Resource was not unlocked" << std::endl; + return 1; + } + } + } + + if (completedTests != testNameSet) { + std::cout << "Tests were not ended" << std::endl; + return 1; + } + + return 0; +} + +int main(int argc, char const* const* argv) +{ + cmsys::Encoding::CommandLineArguments args = + cmsys::Encoding::CommandLineArguments::Main(argc, argv); + argc = args.argc(); + argv = args.argv(); + + if (argc < 2) { + return usage(argv[0]); + } + + std::string argv1 = argv[1]; + if (argv1 == "write") { + return doWrite(argc, argv); + } + if (argv1 == "verify") { + return doVerify(argc, argv); + } + return usage(argv[0]); +} diff --git a/Tests/RunCMake/CTestResourceAllocation/ensure_parallel-ctest-s-res-check.cmake b/Tests/RunCMake/CTestResourceAllocation/ensure_parallel-ctest-s-res-check.cmake new file mode 100644 index 0000000..d842a76 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ensure_parallel-ctest-s-res-check.cmake @@ -0,0 +1,16 @@ +verify_ctest_resources() + +set(expected_contents [[ +begin Test1 +alloc transmogrifiers calvin 2 +begin Test2 +alloc transmogrifiers hobbes 2 +dealloc transmogrifiers calvin 2 +end Test1 +dealloc transmogrifiers hobbes 2 +end Test2 +]]) +file(READ "${RunCMake_TEST_BINARY_DIR}/ctresalloc.log" actual_contents) +if(NOT actual_contents STREQUAL expected_contents) + string(APPEND RunCMake_TEST_FAILED "ctresalloc.log contents did not match expected\n") +endif() diff --git a/Tests/RunCMake/CTestResourceAllocation/ensure_parallel.cmake b/Tests/RunCMake/CTestResourceAllocation/ensure_parallel.cmake new file mode 100644 index 0000000..562d05a --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/ensure_parallel.cmake @@ -0,0 +1,11 @@ +setup_resource_tests() + +add_resource_test(Test1 4 "transmogrifiers:2") + +# Mitigate possible race conditions to ensure that the events are logged in the +# exact order we want +add_test(NAME Test2Sleep COMMAND "${CMAKE_COMMAND}" -E sleep 2) +add_resource_test(Test2 4 "transmogrifiers:2") +set_property(TEST Test2 APPEND PROPERTY DEPENDS Test2Sleep) + +cleanup_resource_tests() diff --git a/Tests/RunCMake/CTestResourceAllocation/lotsoftests-ctest-s-res-check.cmake b/Tests/RunCMake/CTestResourceAllocation/lotsoftests-ctest-s-res-check.cmake new file mode 100644 index 0000000..ceda72e --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/lotsoftests-ctest-s-res-check.cmake @@ -0,0 +1 @@ +verify_ctest_resources() diff --git a/Tests/RunCMake/CTestResourceAllocation/lotsoftests.cmake b/Tests/RunCMake/CTestResourceAllocation/lotsoftests.cmake new file mode 100644 index 0000000..4c0a7a5 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/lotsoftests.cmake @@ -0,0 +1,16 @@ +setup_resource_tests() + +add_resource_test(Test1 2 "widgets:8;2,widgets:2") +add_resource_test(Test2 5 "fluxcapacitors:40") +add_resource_test(Test3 1 "10,widgets:1,fluxcapacitors:2") +add_resource_test(Test4 4 "fluxcapacitors:121") + +foreach(i RANGE 5 50) + add_resource_test(Test${i} 1 "2,widgets:1") +endforeach() + +foreach(i RANGE 51 100) + add_resource_test(Test${i} 1 "2,transmogrifiers:2") +endforeach() + +cleanup_resource_tests() diff --git a/Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-check.cmake b/Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-check.cmake new file mode 100644 index 0000000..321e9a2 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-check.cmake @@ -0,0 +1,3 @@ +if(EXISTS "${RunCMake_TEST_BINARY_DIR}/ctresalloc.log") + set(RunCMake_TEST_FAILED "ctresalloc.log should not exist") +endif() diff --git a/Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-result.txt b/Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-result.txt new file mode 100644 index 0000000..b57e2de --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-result.txt @@ -0,0 +1 @@ +(-1|255) diff --git a/Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-stderr.txt b/Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-stderr.txt new file mode 100644 index 0000000..41df5af --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res-stderr.txt @@ -0,0 +1,4 @@ +^Insufficient resources +CMake Error at [^ +]*/Tests/RunCMake/CTestResourceAllocation/notenough1-ctest-s-res/test\.cmake:[0-9]+ \(message\): + Tests did not pass$ diff --git a/Tests/RunCMake/CTestResourceAllocation/notenough1.cmake b/Tests/RunCMake/CTestResourceAllocation/notenough1.cmake new file mode 100644 index 0000000..2908812 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/notenough1.cmake @@ -0,0 +1,5 @@ +setup_resource_tests() + +add_resource_test(Test1 1 "fluxcapacitors:200") + +cleanup_resource_tests() diff --git a/Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-check.cmake b/Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-check.cmake new file mode 100644 index 0000000..321e9a2 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-check.cmake @@ -0,0 +1,3 @@ +if(EXISTS "${RunCMake_TEST_BINARY_DIR}/ctresalloc.log") + set(RunCMake_TEST_FAILED "ctresalloc.log should not exist") +endif() diff --git a/Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-result.txt b/Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-result.txt new file mode 100644 index 0000000..b57e2de --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-result.txt @@ -0,0 +1 @@ +(-1|255) diff --git a/Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-stderr.txt b/Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-stderr.txt new file mode 100644 index 0000000..6c2f554 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res-stderr.txt @@ -0,0 +1,4 @@ +^Insufficient resources +CMake Error at [^ +]*/Tests/RunCMake/CTestResourceAllocation/notenough2-ctest-s-res/test\.cmake:[0-9]+ \(message\): + Tests did not pass$ diff --git a/Tests/RunCMake/CTestResourceAllocation/notenough2.cmake b/Tests/RunCMake/CTestResourceAllocation/notenough2.cmake new file mode 100644 index 0000000..d7600c8 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/notenough2.cmake @@ -0,0 +1,5 @@ +setup_resource_tests() + +add_resource_test(Test1 1 "terminators:2") + +cleanup_resource_tests() diff --git a/Tests/RunCMake/CTestResourceAllocation/process_count-ctest-s-res-check.cmake b/Tests/RunCMake/CTestResourceAllocation/process_count-ctest-s-res-check.cmake new file mode 100644 index 0000000..ceda72e --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/process_count-ctest-s-res-check.cmake @@ -0,0 +1 @@ +verify_ctest_resources() diff --git a/Tests/RunCMake/CTestResourceAllocation/process_count.cmake b/Tests/RunCMake/CTestResourceAllocation/process_count.cmake new file mode 100644 index 0000000..1457f89 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/process_count.cmake @@ -0,0 +1,5 @@ +setup_resource_tests() + +add_resource_test(Test1 1 "widgets:1") + +cleanup_resource_tests() diff --git a/Tests/RunCMake/CTestResourceAllocation/resspec.json b/Tests/RunCMake/CTestResourceAllocation/resspec.json new file mode 100644 index 0000000..c67fcca --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/resspec.json @@ -0,0 +1,55 @@ +{ + "local": [ + { + "widgets": [ + { + "id": "0", + "slots": 4 + }, + { + "id": "1", + "slots": 2 + }, + { + "id": "2", + "slots": 4 + }, + { + "id": "3", + "slots": 8 + }, + { + "id": "4", + "slots": 1 + }, + { + "id": "5", + "slots": 1 + }, + { + "id": "6", + "slots": 1 + }, + { + "id": "7" + } + ], + "transmogrifiers": [ + { + "id": "calvin", + "slots": 2 + }, + { + "id": "hobbes", + "slots": 2 + } + ], + "fluxcapacitors": [ + { + "id": "outatime", + "slots": 121 + } + ] + } + ] +} diff --git a/Tests/RunCMake/CTestResourceAllocation/test.cmake.in b/Tests/RunCMake/CTestResourceAllocation/test.cmake.in new file mode 100644 index 0000000..4b426f1 --- /dev/null +++ b/Tests/RunCMake/CTestResourceAllocation/test.cmake.in @@ -0,0 +1,23 @@ +set(CTEST_SITE "test-site") +set(CTEST_BUILD_NAME "test-build-name") +set(CTEST_SOURCE_DIRECTORY "@RunCMake_BINARY_DIR@/@CASE_NAME@") +set(CTEST_BINARY_DIRECTORY "@RunCMake_BINARY_DIR@/@CASE_NAME@-build") +set(CTEST_CMAKE_GENERATOR "@RunCMake_GENERATOR@") +set(CTEST_CMAKE_GENERATOR_PLATFORM "@RunCMake_GENERATOR_PLATFORM@") +set(CTEST_CMAKE_GENERATOR_TOOLSET "@RunCMake_GENERATOR_TOOLSET@") +set(CTEST_BUILD_CONFIGURATION "$ENV{CMAKE_CONFIG_TYPE}") +set(CTEST_NIGHTLY_START_TIME "01:00:00 UTC") + +ctest_start(Experimental QUIET) +ctest_configure(OPTIONS + "-DCTEST_RESOURCE_ALLOC_ENABLED=${CTEST_RESOURCE_ALLOC_ENABLED};-DCTRESALLOC_COMMAND=${CTRESALLOC_COMMAND}" + ) +ctest_build() + +if(CTEST_RESOURCE_ALLOC_ENABLED) + set(resspec RESOURCE_SPEC_FILE "@RunCMake_SOURCE_DIR@/resspec.json") +endif() +ctest_test(${resspec} RETURN_VALUE retval PARALLEL_LEVEL ${CTEST_PARALLEL} SCHEDULE_RANDOM ${CTEST_RANDOM}) +if(retval) + message(FATAL_ERROR "Tests did not pass") +endif() -- cgit v0.12 From c1435d98120dff203de01d75f8f91e99bc75fe2b Mon Sep 17 00:00:00 2001 From: Kyle Edwards Date: Tue, 5 Nov 2019 11:40:51 -0500 Subject: Help: Fix error in resource allocation example --- Help/manual/ctest.1.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Help/manual/ctest.1.rst b/Help/manual/ctest.1.rst index be1ec5d..dbefb91 100644 --- a/Help/manual/ctest.1.rst +++ b/Help/manual/ctest.1.rst @@ -1479,8 +1479,8 @@ The following variables are passed to the test process: * ``CTEST_RESOURCE_GROUP_2_CRYPTO_CHIPS=id:card0,slots:2`` In this example, group 0 gets 2 slots from GPU ``0``, group 1 gets 2 slots - from GPU ``2``, and group 2 gets 4 slots from GPU ``1`` and 2 slots from - cryptography chip ``card0``. + from GPU ``2``, and group 2 gets 4 slots from GPU ``1``, 1 slot from GPU + ``3``, and 2 slots from cryptography chip ``card0``. ```` is a number from zero to ``CTEST_RESOURCE_GROUP_COUNT`` minus one. ```` is the name of a resource type, converted to uppercase. -- cgit v0.12