facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/ext/facter/facter/lib/tests/facts/posix/collection.cc

@@ -1,39 +0,0 @@
-#include <catch.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/resolver.hpp>
-#include <facter/facts/array_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include "../../fixtures.hpp"
-#include <sstream>
-
-using namespace std;
-using namespace facter::facts;
-using namespace facter::testing;
-
-SCENARIO("resolving external executable facts into a collection") {
-    collection_fixture facts;
-    REQUIRE(facts.size() == 0u);
-    GIVEN("an absolute path") {
-        facts.add_external_facts({
-            LIBFACTER_TESTS_DIRECTORY "/fixtures/facts/external/posix/execution",
-        });
-        THEN("facts should resolve") {
-            REQUIRE(facts.size() == 4u);
-            REQUIRE(facts.get<string_value>("exe_fact1"));
-            REQUIRE(facts.get<string_value>("exe_fact2"));
-            REQUIRE_FALSE(facts.get<string_value>("exe_fact3"));
-            REQUIRE(facts.get<string_value>("exe_fact4"));
-            REQUIRE(facts.get<string_value>("foo"));
-        }
-    }
-    GIVEN("a relative path") {
-        test_with_relative_path fixture("foo", "bar", "#! /usr/bin/env sh\necho local_exec_fact=value");
-        facts.add_external_facts({ "foo" });
-        THEN("facts should resolve") {
-            REQUIRE(facts.size() == 1u);
-            REQUIRE(facts.get<string_value>("local_exec_fact"));
-            REQUIRE(facts.get<string_value>("local_exec_fact")->value() == "value");
-        }
-    }
-}

data/ext/facter/facter/lib/tests/facts/posix/uptime_resolver.cc

@@ -1,52 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/posix/uptime_resolver.hpp>
-#include <map>
-
-using namespace std;
-using namespace facter::facts;
-
-SCENARIO("parsing uptime formats") {
-    WHEN("given an uptime to parse") {
-        static const map<string, int> test_cases = {
-            {"  4:42pm  up 1 min(s),  0 users,  load average: 0.95, 0.25, 0.09",                                         1*60},
-            {"13:16  up 58 mins,  2 users,  load average: 0.00, 0.02, 0.05",                                            58*60},
-            {"13:18  up 1 hr,  1 user,  load average: 0.58, 0.23, 0.14",                                      1*60*60        },
-            {" 10:14pm  up 3 hr(s),  0 users,  load average: 0.00, 0.00, 0.00",                               3*60*60        },
-            {"14:18  up 2 hrs,  0 users,  load average: 0.33, 0.27, 0.29",                                    2*60*60        },
-            {"  9:01pm  up  1:47,  0 users,  load average: 0.00, 0.00, 0.00",                                 1*60*60 + 47*60},
-            {"13:19  up  1:01,  1 user,  load average: 0.10, 0.26, 0.21",                                     1*60*60 +  1*60},
-            {"10:49  up 22:31,  0 users,  load average: 0.26, 0.34, 0.27",                                   22*60*60 + 31*60},
-            {"12:18  up 1 day,  0 users,  load average: 0.74, 0.20, 0.10",                      1*24*60*60                   },
-            {"  2:48pm  up 1 day(s),  0 users,  load average: 0.21, 0.20, 0.17",                1*24*60*60                   },
-            {"12:18  up 2 days,  0 users,  load average: 0.50, 0.27, 0.16",                     2*24*60*60                   },
-            {"  1:56pm  up 25 day(s),  2 users,  load average: 0.59, 0.56, 0.50",              25*24*60*60                   },
-            {"  1:29pm  up 485 days,  0 users,  load average: 0.00, 0.01, 0.01",              485*24*60*60                   },
-            {" 18:11:24  up 69 days, 0 min,  0 users,  load average: 0.00, 0.00, 0.00",        69*24*60*60                   },
-            {"12:19  up 1 day, 1 min,  0 users,  load average: 0.07, 0.16, 0.13",               1*24*60*60            +  1*60},
-            {"  3:23pm  up 25 day(s), 27 min(s),  2 users,  load average: 0.49, 0.45, 0.46",   25*24*60*60            + 27*60},
-            {"  02:42PM   up 1 day, 39 mins,  0 users,  load average: 1.49, 1.74, 1.80",        1*24*60*60            + 39*60},
-            {" 18:13:13  up 245 days, 44 min,  1 user,  load average: 0.00, 0.00, 0.00",      245*24*60*60            + 44*60},
-            {"  6:09pm  up 350 days, 2 min,  1 user,  load average: 0.02, 0.03, 0.00",        350*24*60*60            +  2*60},
-            {"  1:07pm  up 174 day(s), 16 hr(s),  0 users,  load average: 0.05, 0.04, 0.03",  174*24*60*60 + 16*60*60        },
-            {"  02:34PM   up 621 days, 18 hrs,  0 users,  load average: 2.67, 2.52, 2.56",    621*24*60*60 + 18*60*60        },
-            {"  3:30am  up 108 days, 1 hr,  31 users,  load average: 0.39, 0.40, 0.41",       108*24*60*60 +  1*60*60        },
-            {"13:18  up 1 day, 1 hr,  0 users,  load average: 0.78, 0.33, 0.18",                1*24*60*60 +  1*60*60        },
-            {"14:18  up 1 day, 2 hrs,  0 users,  load average: 1.17, 0.48, 0.41",               1*24*60*60 +  2*60*60        },
-            {"15:56  up 152 days, 17 hrs,  0 users,  load average: 0.01, 0.06, 0.07",         152*24*60*60 + 17*60*60        },
-            {"  5:37pm  up 25 days, 21:00,  0 users,  load average: 0.01, 0.02, 0.00",         25*24*60*60 + 21*60*60        },
-            {"  8:59pm  up 94 day(s),  3:17,  46 users,  load average: 0.66, 0.67, 0.70",      94*24*60*60 +  3*60*60 + 17*60},
-            {"  3:01pm  up 4496 day(s), 21:19,  32 users,  load average: 0.61, 0.62, 0.62",  4496*24*60*60 + 21*60*60 + 19*60},
-            {"  02:42PM   up 41 days,   2:38,  0 users,  load average: 0.38, 0.70, 0.55",      41*24*60*60 +  2*60*60 + 38*60},
-            {" 18:13:29  up 25 days, 21:36,  0 users,  load average: 0.00, 0.00, 0.00",        25*24*60*60 + 21*60*60 + 36*60},
-            {" 13:36:05 up 118 days,  1:15,  1 user,  load average: 0.00, 0.00, 0.00",        118*24*60*60 +  1*60*60 + 15*60},
-            {"10:27am  up 1 day  7:26,  1 user,  load average: 0.00, 0.00, 0.00",               1*24*60*60 +  7*60*60 + 26*60},
-            {"22:45pm up 0:-6, 1 user, load average: 0.00, 0.00, 0.00",                                                  6*60},
-            {"22:45pm up 1 day 0:-6, 1 user, load average: 0.00, 0.00, 0.00",                   1*24*60*60 +             6*60}
-        };
-        THEN("it parses each format correctly") {
-            for (auto const& t : test_cases) {
-                REQUIRE(posix::uptime_resolver::parse_uptime(t.first) == t.second);
-            }
-        }
-    }
-}

data/ext/facter/facter/lib/tests/facts/resolvers/augeas_resolver.cc

@@ -1,58 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/augeas_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include "../../collection_fixture.hpp"
-
-using namespace std;
-using namespace facter::facts;
-using namespace facter::facts::resolvers;
-using namespace facter::testing;
-
-struct empty_augeas_resolver : augeas_resolver
-{
- protected:
-    virtual string get_version() override
-    {
-        return {};
-    }
-};
-
-struct fixed_augeas_resolver : augeas_resolver
-{
- protected:
-    virtual string get_version() override
-    {
-        return "foo";
-    }
-};
-
-SCENARIO("using the augeas resolver") {
-    collection_fixture facts;
-    WHEN("no version is returned") {
-        facts.add(make_shared<empty_augeas_resolver>());
-        THEN("the fact is not present") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    WHEN("an augeas version is returned") {
-        facts.add(make_shared<fixed_augeas_resolver>());
-        THEN("a structured fact is returned") {
-            REQUIRE(facts.size() == 2u);
-            auto augeas = facts.get<map_value>(fact::augeas);
-            REQUIRE(augeas);
-            REQUIRE(augeas->size() == 1u);
-            auto version = augeas->get<string_value>("version");
-            REQUIRE(version);
-            REQUIRE(version->value() == "foo");
-        }
-        THEN("flat facts are added") {
-            REQUIRE(facts.size() == 2u);
-            auto augeasversion = facts.get<string_value>(fact::augeasversion);
-            REQUIRE(augeasversion);
-            REQUIRE(augeasversion->value() == "foo");
-        }
-    }
-}

data/ext/facter/facter/lib/tests/facts/resolvers/disk_resolver.cc

@@ -1,114 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/disk_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include "../../collection_fixture.hpp"
-
-using namespace std;
-using namespace facter::facts;
-using namespace facter::facts::resolvers;
-using namespace facter::testing;
-
-struct test_disk_resolver : disk_resolver
-{
-    void add_disk(string name, string vendor, string model, string product, uint64_t size)
-    {
-        disk d;
-        d.name = move(name);
-        d.vendor = move(vendor);
-        d.model = move(model);
-        d.product = move(product);
-        d.size = size;
-        disks.emplace_back(move(d));
-    }
-
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.disks = move(disks);
-        return result;
-    }
-
- private:
-    vector<disk> disks;
-};
-
-SCENARIO("using the disk resolver") {
-    collection_fixture facts;
-    auto resolver = make_shared<test_disk_resolver>();
-    facts.add(resolver);
-    GIVEN("no disks present") {
-        THEN("facts should not be added") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    GIVEN("five present disks") {
-        const unsigned int count = 5;
-        for (unsigned int i = 0; i < count; ++i) {
-            string num = to_string(i);
-            resolver->add_disk("disk" + num, "vendor" + num, "model" + num, "product" + num, 12345 + i);
-        }
-        THEN("a structured fact should be added") {
-            auto disks = facts.get<map_value>(fact::disks);
-            REQUIRE(disks);
-            REQUIRE(disks->size() == count);
-
-            for (unsigned int i = 0; i < count; ++i) {
-                string num = to_string(i);
-
-                auto disk = disks->get<map_value>("disk" + num);
-                REQUIRE(disk);
-                REQUIRE(disk->size() == 5u);
-
-                auto model = disk->get<string_value>("model");
-                REQUIRE(model);
-                REQUIRE(model->value() == "model" + num);
-
-                auto product = disk->get<string_value>("product");
-                REQUIRE(product);
-                REQUIRE(product->value() == "product" + num);
-
-                auto size = disk->get<string_value>("size");
-                REQUIRE(size);
-                REQUIRE(size->value() == "12.06 KiB");
-
-                auto size_bytes = disk->get<integer_value>("size_bytes");
-                REQUIRE(size_bytes);
-                REQUIRE(size_bytes->value() == 12345 + i);
-
-                auto vendor = disk->get<string_value>("vendor");
-                REQUIRE(vendor);
-                REQUIRE(vendor->value() == "vendor" + num);
-            }
-        }
-        THEN("flat facts should be added") {
-            string names;
-            for (unsigned int i = 0; i < count; ++i) {
-                string num = to_string(i);
-
-                auto model = facts.get<string_value>("blockdevice_disk" + num + "_model");
-                REQUIRE(model);
-                REQUIRE(model->value() == "model" + num);
-
-                auto size = facts.get<integer_value>("blockdevice_disk" + num + "_size");
-                REQUIRE(size);
-                REQUIRE(size->value() == 12345 + i);
-
-                auto vendor = facts.get<string_value>("blockdevice_disk" + num + "_vendor");
-                REQUIRE(vendor);
-                REQUIRE(vendor->value() == "vendor" + num);
-
-                if (names.size() > 0u) {
-                    names += ",";
-                }
-                names += "disk" + num;
-            }
-            auto devices = facts.get<string_value>(fact::block_devices);
-            REQUIRE(devices);
-            REQUIRE(devices->value() == names);
-        }
-    }
-}

data/ext/facter/facter/lib/tests/facts/resolvers/dmi_resolver.cc

@@ -1,152 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/dmi_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include "../../collection_fixture.hpp"
-
-using namespace std;
-using namespace facter::facts;
-using namespace facter::facts::resolvers;
-using namespace facter::testing;
-
-struct empty_dmi_resolver : dmi_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        return {};
-    }
-};
-
-struct test_dmi_resolver : dmi_resolver
-{
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.bios_vendor = fact::bios_vendor;
-        result.bios_version = fact::bios_version;
-        result.bios_release_date = fact::bios_release_date;
-        result.board_asset_tag = fact::board_asset_tag;
-        result.board_manufacturer = fact::board_manufacturer;
-        result.board_product_name = fact::board_product_name;
-        result.board_serial_number = fact::board_serial_number;
-        result.chassis_asset_tag = fact::chassis_asset_tag;
-        result.manufacturer = fact::manufacturer;
-        result.product_name = fact::product_name;
-        result.serial_number = fact::serial_number;
-        result.uuid = fact::uuid;
-        result.chassis_type = fact::chassis_type;
-        return result;
-    }
-};
-
-SCENARIO("using the DMI resolver") {
-    collection_fixture facts;
-    WHEN("data is not present") {
-        facts.add(make_shared<empty_dmi_resolver>());
-        THEN("facts should not be added") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    WHEN("data is present") {
-        facts.add(make_shared<test_dmi_resolver>());
-        THEN("a structured fact is added") {
-            auto dmi = facts.get<map_value>(fact::dmi);
-            REQUIRE(dmi);
-            REQUIRE(dmi->size() == 5u);
-
-            auto bios = dmi->get<map_value>("bios");
-            REQUIRE(bios);
-            REQUIRE(bios->size() == 3u);
-
-            auto value = bios->get<string_value>("release_date");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::bios_release_date));
-
-            value = bios->get<string_value>("vendor");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::bios_vendor));
-
-            value = bios->get<string_value>("version");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::bios_version));
-
-            auto board = dmi->get<map_value>("board");
-            REQUIRE(board);
-            REQUIRE(board->size() == 4u);
-
-            value = board->get<string_value>("asset_tag");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::board_asset_tag));
-
-            value = board->get<string_value>("manufacturer");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::board_manufacturer));
-
-            value = board->get<string_value>("product");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::board_product_name));
-
-            value = board->get<string_value>("serial_number");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::board_serial_number));
-
-            auto chassis = dmi->get<map_value>("chassis");
-            REQUIRE(chassis);
-            REQUIRE(chassis->size() == 2u);
-
-            value = chassis->get<string_value>("asset_tag");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::chassis_asset_tag));
-
-            value = chassis->get<string_value>("type");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::chassis_type));
-
-            value = dmi->get<string_value>("manufacturer");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::manufacturer));
-
-            auto product = dmi->get<map_value>("product");
-            REQUIRE(product);
-            REQUIRE(product->size() == 3u);
-
-            value = product->get<string_value>("name");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::product_name));
-
-            value = product->get<string_value>("serial_number");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::serial_number));
-
-            value = product->get<string_value>("uuid");
-            REQUIRE(value);
-            REQUIRE(value->value() == string(fact::uuid));
-        }
-        THEN("flat facts are added") {
-            static vector<string> const names = {
-                fact::bios_vendor,
-                fact::bios_version,
-                fact::bios_release_date,
-                fact::board_asset_tag,
-                fact::board_manufacturer,
-                fact::board_product_name,
-                fact::board_serial_number,
-                fact::chassis_asset_tag,
-                fact::manufacturer,
-                fact::product_name,
-                fact::serial_number,
-                fact::uuid,
-                fact::chassis_type,
-            };
-            for (auto const& name : names) {
-                auto fact = facts.get<string_value>(name);
-                REQUIRE(fact);
-                REQUIRE(fact->value() == name);
-            }
-        }
-    }
-}

data/ext/facter/facter/lib/tests/facts/resolvers/filesystem_resolver.cc

@@ -1,206 +0,0 @@
-#include <catch.hpp>
-#include <internal/facts/resolvers/filesystem_resolver.hpp>
-#include <facter/facts/collection.hpp>
-#include <facter/facts/fact.hpp>
-#include <facter/facts/scalar_value.hpp>
-#include <facter/facts/map_value.hpp>
-#include <facter/facts/array_value.hpp>
-#include "../../collection_fixture.hpp"
-
-using namespace std;
-using namespace facter::facts;
-using namespace facter::facts::resolvers;
-using namespace facter::testing;
-
-struct test_filesystem_resolver : filesystem_resolver
-{
-    void add_mountpoint(string name, string device, string filesystem, uint64_t size, uint64_t available, vector<string> options)
-    {
-        mountpoint mp;
-        mp.name = move(name);
-        mp.device = move(device);
-        mp.filesystem = move(filesystem);
-        mp.size = size;
-        mp.available = available;
-        mp.options = move(options);
-        mountpoints.emplace_back(move(mp));
-    }
-
-    void add_filesystem(string filesystem)
-    {
-        filesystems.emplace(move(filesystem));
-    }
-
-    void add_partition(string name, string filesystem, uint64_t size, string uuid, string partuuid, string label, string partlabel, string mount, string backing_file)
-    {
-        partition p;
-        p.name = move(name);
-        p.filesystem = move(filesystem);
-        p.size = size;
-        p.uuid = move(uuid);
-        p.partition_uuid = move(partuuid);
-        p.label = move(label);
-        p.partition_label = move(partlabel);
-        p.mount = move(mount);
-        p.backing_file = move(backing_file);
-        partitions.emplace_back(move(p));
-    }
-
- protected:
-    virtual data collect_data(collection& facts) override
-    {
-        data result;
-        result.mountpoints = move(mountpoints);
-        result.filesystems = move(filesystems);
-        result.partitions = move(partitions);
-        return result;
-    }
-
-    vector<mountpoint> mountpoints;
-    set<string> filesystems;
-    vector<partition> partitions;
-};
-
-SCENARIO("using the file system resolver") {
-    collection_fixture facts;
-    auto resolver = make_shared<test_filesystem_resolver>();
-    facts.add(resolver);
-
-    WHEN("data is not present") {
-        THEN("facts should not be added") {
-            REQUIRE(facts.size() == 0u);
-        }
-    }
-    WHEN("mount point data is present") {
-        const unsigned int count = 5;
-        for (unsigned int i = 0; i < count; ++i) {
-            string num = to_string(i);
-            resolver->add_mountpoint("mount" + num, "device" + num, "filesystem" + num, 12345, 1000, {"option1" + num, "option2" + num, "option3" + num});
-        }
-        THEN("a structured fact is added") {
-            REQUIRE(facts.size() == 1u);
-            auto mountpoints = facts.get<map_value>(fact::mountpoints);
-            REQUIRE(mountpoints);
-            REQUIRE(mountpoints->size() == 5u);
-            for (unsigned int i = 0; i < count; ++i) {
-                string num = to_string(i);
-
-                auto mountpoint = mountpoints->get<map_value>("mount" + num);
-                REQUIRE(mountpoint);
-                REQUIRE(mountpoint->size() == 10u);
-
-                auto available = mountpoint->get<string_value>("available");
-                REQUIRE(available);
-                REQUIRE(available->value() == "1000 bytes");
-
-                auto available_bytes = mountpoint->get<integer_value>("available_bytes");
-                REQUIRE(available_bytes);
-                REQUIRE(available_bytes->value() == 1000);
-
-                auto capacity = mountpoint->get<string_value>("capacity");
-                REQUIRE(capacity);
-                REQUIRE(capacity->value() == "91.90%");
-
-                auto device = mountpoint->get<string_value>("device");
-                REQUIRE(device);
-                REQUIRE(device->value() == "device" + num);
-
-                auto filesystem = mountpoint->get<string_value>("filesystem");
-                REQUIRE(filesystem);
-                REQUIRE(filesystem->value() == "filesystem" + num);
-
-                auto options = mountpoint->get<array_value>("options");
-                REQUIRE(options);
-                REQUIRE(options->size() == 3u);
-                REQUIRE(options->get<string_value>(0)->value() == "option1" + num);
-                REQUIRE(options->get<string_value>(1)->value() == "option2" + num);
-                REQUIRE(options->get<string_value>(2)->value() == "option3" + num);
-
-                auto size = mountpoint->get<string_value>("size");
-                REQUIRE(size);
-                REQUIRE(size->value() == "12.06 KiB");
-
-                auto size_bytes = mountpoint->get<integer_value>("size_bytes");
-                REQUIRE(size_bytes);
-                REQUIRE(size_bytes->value() == 12345);
-
-                auto used = mountpoint->get<string_value>("used");
-                REQUIRE(used);
-                REQUIRE(used->value() == "11.08 KiB");
-
-                auto used_bytes = mountpoint->get<integer_value>("used_bytes");
-                REQUIRE(used_bytes);
-                REQUIRE(used_bytes->value() == 12345 - 1000);
-            }
-        }
-    }
-    WHEN("file system data is present") {
-        resolver->add_filesystem("foo");
-        resolver->add_filesystem("bar");
-        resolver->add_filesystem("baz");
-
-        THEN("a flat fact is added") {
-            REQUIRE(facts.size() == 1u);
-            auto filesystems = facts.get<string_value>(fact::filesystems);
-            REQUIRE(filesystems);
-            REQUIRE(filesystems->value() == "bar,baz,foo");
-        }
-    }
-    WHEN("partition data is present") {
-        const unsigned int count = 5;
-        for (unsigned int i = 0; i < count; ++i) {
-            string num = to_string(i);
-            resolver->add_partition("partition" + num, "filesystem" + num, 12345 + i, "uuid" + num, "partuuid" + num, "label" + num, "partlabel" + num, "mount" + num, "file" + num);
-        }
-        THEN("a structured fact is added") {
-            REQUIRE(facts.size() == 1u);
-
-            auto partitions = facts.get<map_value>(fact::partitions);
-            REQUIRE(partitions);
-
-            for (unsigned int i = 0; i < count; ++i) {
-                string num = to_string(i);
-
-                auto partition = partitions->get<map_value>("partition" + num);
-                REQUIRE(partition);
-                REQUIRE(partition->size() == 9u);
-
-                auto filesystem = partition->get<string_value>("filesystem");
-                REQUIRE(filesystem);
-                REQUIRE(filesystem->value() == "filesystem" + num);
-
-                auto label = partition->get<string_value>("label");
-                REQUIRE(label);
-                REQUIRE(label->value() == "label" + num);
-
-                auto partlabel = partition->get<string_value>("partlabel");
-                REQUIRE(partlabel);
-                REQUIRE(partlabel->value() == "partlabel" + num);
-
-                auto mount = partition->get<string_value>("mount");
-                REQUIRE(mount);
-                REQUIRE(mount->value() == "mount" + num);
-
-                auto partuuid = partition->get<string_value>("partuuid");
-                REQUIRE(partuuid);
-                REQUIRE(partuuid->value() == "partuuid" + num);
-
-                auto uuid = partition->get<string_value>("uuid");
-                REQUIRE(uuid);
-                REQUIRE(uuid->value() == "uuid" + num);
-
-                auto size_bytes = partition->get<integer_value>("size_bytes");
-                REQUIRE(size_bytes);
-                REQUIRE(size_bytes->value() == 12345 + i);
-
-                auto size = partition->get<string_value>("size");
-                REQUIRE(size);
-                REQUIRE(size->value() == "12.06 KiB");
-
-                auto file = partition->get<string_value>("backing_file");
-                REQUIRE(file);
-                REQUIRE(file->value() == "file" + num);
-            }
-        }
-    }
-}