cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,39 @@
+#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

@@ -0,0 +1,52 @@
+#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

@@ -0,0 +1,58 @@
+#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

@@ -0,0 +1,114 @@
+#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

@@ -0,0 +1,152 @@
+#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

@@ -0,0 +1,206 @@
+#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);
+            }
+        }
+    }
+}