// SPDX-License-Identifier: MIT
#include "hardware.h"
#include "fan.h"
#include "cpu.h"
#include "power.h"
#include <QTest>
#include <QTemporaryDir>
#include <QDir>
#include <QFile>

class HardwareTest : public QObject {
    Q_OBJECT
    void put(const QString &path, const QByteArray &value) {
        QVERIFY(QDir().mkpath(QFileInfo(path).absolutePath()));
        QFile file(path); QVERIFY(file.open(QIODevice::WriteOnly)); QCOMPARE(file.write(value), value.size());
    }
private Q_SLOTS:
    void coreGroupFrequencies() {
        QTemporaryDir root;
        const QString base = root.path() + "/devices/system/cpu/cpufreq/";
        for (int i = 0; i < 3; ++i) {
            const auto policy = base + "policy" + QString::number(i) + "/";
            put(policy + "related_cpus", QByteArray::number(i));
            put(policy + "scaling_cur_freq", QByteArray::number((i + 1) * 1000000));
        }
        // No core-type metadata: retain the original combined reading.
        auto sensors = frequencySensors(root.path());
        QCOMPARE(sensors.size(), 1);
        QCOMPARE(sensors[0].id, QString("cpu"));
        QVERIFY(sensors[0].primary);
        QCOMPARE(sensorValue(sensors[0]), std::optional<double>(2000));
        put(root.path() + "/bus/event_source/devices/cpu_core/cpus", "2");
        put(root.path() + "/bus/event_source/devices/cpu_atom/cpus", "0-1");
        sensors = frequencySensors(root.path());
        QCOMPARE(sensors.size(), 5);
        QCOMPARE(sensors[0].id, QString("cpu/p"));
        QCOMPARE(sensors[1].id, QString("cpu/e"));
        QCOMPARE(sensors[2].id, QString("cpu"));
        QVERIFY(sensors[0].primary && sensors[1].primary && !sensors[2].primary);
        QCOMPARE(sensorValue(sensors[0]), std::optional<double>(3000));
        QCOMPARE(sensorValue(sensors[1]), std::optional<double>(1500));
        QCOMPARE(sensorValue(sensors[2]), std::optional<double>(2000));
        QCOMPARE(sensors[3].id, QString("cpu/p/max"));
        QCOMPARE(sensors[4].id, QString("cpu/e/max"));
        QVERIFY(!sensors[3].primary && !sensors[4].primary);
        QCOMPARE(sensorValue(sensors[3]), std::optional<double>(3000));
        QCOMPARE(sensorValue(sensors[4]), std::optional<double>(2000));
        put(base + "policy0/scaling_cur_freq", "4000000");
        QCOMPARE(sensorValue(sensors[4]), std::optional<double>(4000));
        put(base + "policy0/scaling_cur_freq", "1000000");
        QCOMPARE(sensorValue(sensors[4]), std::optional<double>(2000)); // Not a historical peak.
        // Missing readings aren't zeroes, and membership isn't guessed by speed.
        put(base + "policy0/scaling_cur_freq", "unavailable");
        QCOMPARE(sensorValue(sensors[1]), std::optional<double>(2000));
        QCOMPARE(sensorValue(sensors[4]), std::optional<double>(2000));
        put(base + "policy1/scaling_cur_freq", "unavailable");
        QVERIFY(!sensorValue(sensors[1]));
        QVERIFY(!sensorValue(sensors[4]));
        QCOMPARE(sensorValue(sensors[2]), std::optional<double>(3000));
        put(base + "policy2/related_cpus", "1 2");
        sensors = frequencySensors(root.path());
        QCOMPARE(sensors.size(), 1); // A policy spanning types cannot be split.
        QVERIFY(sensors[0].primary);
    }

    void energyCounters() {
        EnergyCounter counter;
        const quint64 range = 262143328850ULL;
        QVERIFY(!counter.sample(1000000, range, 0, 3000));
        QCOMPARE(counter.sample(6000000, range, 1000, 3000), std::optional<double>(5));
        QCOMPARE(counter.sample(16000000, range, 3000, 3000), std::optional<double>(5));
        QVERIFY(!counter.sample(100, range, 4000, 3000)); // Reset, not a wrap.
        QCOMPARE(counter.sample(100, range, 5000, 3000), std::optional<double>(0));
        QVERIFY(!counter.sample(200, range, 10000, 3000)); // Long gaps establish a new baseline.
        QCOMPARE(counter.sample(1000200, range, 11000, 3000), std::optional<double>(1));
        EnergyCounter wrapped;
        QVERIFY(!wrapped.sample(range - 3000000, range, 0, 3000));
        QCOMPARE(wrapped.sample(2000000, range, 1000, 3000), std::optional<double>(5));
        QVERIFY(!wrapped.sample(100, 100000000, 2000, 3000)); // Changed range.
        QVERIFY(!wrapped.sample(100, 0, 3000, 3000));
        QVERIFY(!wrapped.sample(range + 1, range, 4000, 3000));
        EnergyCounter large;
        const quint64 base = 1ULL << 60;
        QVERIFY(!large.sample(base, base * 2, 0, 3000));
        QCOMPARE(large.sample(base + 1000, base * 2, 1000, 3000), std::optional<double>(.001));
    }
    void powerDiscoveryAndSampling() {
        QTemporaryDir root;
        const QString rapl = root.path() + "/class/powercap/intel-rapl:0/";
        const QString mmio = root.path() + "/class/powercap/intel-rapl-mmio:0/";
        for (const auto &path : {rapl, mmio}) {
            put(path + "name", "package-0"); put(path + "energy_uj", "1000000");
            put(path + "max_energy_range_uj", "262143328850");
        }
        const QString fan = root.path() + "/class/hwmon/hwmon9/";
        put(fan + "name", "power_meter"); put(fan + "power1_input", "250000"); put(fan + "power1_average", "500000");
        const QString acpiFan = root.path() + "/class/hwmon/hwmon10/";
        put(acpiFan + "name", "acpi_fan"); put(acpiFan + "power1_input", "0");
        PowerMonitor monitor(root.path()); QCOMPARE(monitor.sensors().size(), 2);
        QCOMPARE(monitor.sensors()[0].name, QString("CPU package"));
        QCOMPARE(monitor.sensors()[0].path, rapl + "energy_uj");
        const QString cpu = monitor.sensors()[0].id, fanId = monitor.sensors()[1].id;
        auto values = monitor.sample(1000, 0);
        QVERIFY(!values.contains(cpu)); QCOMPARE(values.value(fanId), .25);
        put(rapl + "energy_uj", "6000000");
        values = monitor.sample(1000, 1000); QCOMPARE(values.value(cpu), 5.);
        put(rapl + "energy_uj", "unavailable"); QVERIFY(!monitor.sample(1000, 2000).contains(cpu));
        put(rapl + "energy_uj", "11000000"); QVERIFY(!monitor.sample(1000, 3000).contains(cpu));
        put(rapl + "energy_uj", "16000000"); QCOMPARE(monitor.sample(1000, 4000).value(cpu), 5.);
        monitor.reset(); QVERIFY(!monitor.sample(1000, 5000).contains(cpu));
        put(fan + "power1_input", "0"); QCOMPARE(monitor.sample(1000, 6000).value(fanId), 0.);
        QTemporaryDir fallback;
        const QString fallbackZone = fallback.path() + "/class/powercap/intel-rapl-mmio:0/";
        put(fallbackZone + "name", "package-0"); put(fallbackZone + "energy_uj", "0");
        PowerMonitor mmioOnly(fallback.path()); QCOMPARE(mmioOnly.sensors().size(), 1);
        QCOMPARE(mmioOnly.sensors()[0].id, cpu);
        QVERIFY(mmioOnly.sample(1000, 0).isEmpty()); // Missing range is not a zero reading.
    }
    void platformPowerIsExcluded() {
        for (const auto &prefix : {"intel-rapl:", "intel-rapl-mmio:"}) {
            QTemporaryDir root;
            const QStringList names{"package-0", "core", "uncore", "dram", "psys", "psys-0"};
            for (int i = 0; i < names.size(); ++i) {
                const QString path = root.path() + "/class/powercap/" + prefix + QString::number(i) + "/";
                put(path + "name", names[i].toUtf8()); put(path + "energy_uj", "0");
                put(path + "max_energy_range_uj", "1000000");
            }
            PowerMonitor monitor(root.path());
            QStringList discovered;
            for (const auto &sensor : monitor.sensors()) discovered.append(sensor.name);
            QCOMPARE(discovered, QStringList({"CPU package", "CPU cores", "Uncore", "Memory (RAPL)"}));
            QVERIFY(monitor.sample(1000, 0).isEmpty());
            QCOMPARE(monitor.sample(1000, 1000).size(), 4);
        }
    }
    void modelGate() {
        QTemporaryDir root;
        QVERIFY(!compatibilityError(root.path()).isEmpty());
        put(root.path() + "/class/dmi/id/sys_vendor", "Framework\n");
        put(root.path() + "/class/dmi/id/product_name", "Laptop 13\n");
        QVERIFY(!compatibilityError(root.path()).isEmpty());
        put(root.path() + "/class/dmi/id/product_name", "Laptop 13 Pro (Intel Core Ultra Series 3)\n");
        QVERIFY(compatibilityError(root.path()).isEmpty());
    }
    void missingReadingsAreNotZero() {
        QTemporaryDir root;
        QVERIFY(!readNumber(root.filePath("absent")));
        put(root.filePath("value"), "invalid\n"); QVERIFY(!readNumber(root.filePath("value")));
        put(root.filePath("value"), "0\n"); QCOMPARE(*readNumber(root.filePath("value")), 0.);
    }
    void batteryUnits() {
        QTemporaryDir root; const QString battery = root.path() + "/class/power_supply/BAT1/";
        put(battery + "type", "Battery"); put(battery + "current_now", "2000000");
        put(battery + "voltage_now", "16000000"); put(battery + "capacity", "60");
        QCOMPARE(batteryStatus(root.path())["watts"].toDouble(), 32.);
        put(battery + "power_now", "12300000");
        QCOMPARE(batteryStatus(root.path())["watts"].toDouble(), 12.3);
        QCOMPARE(batteryRate({{"watts", 12.3}, {"state", "Discharging"}}), std::optional<double>(-12.3));
        QCOMPARE(batteryRate({{"watts", 12.3}, {"state", "Charging"}}), std::optional<double>(12.3));
        QCOMPARE(batteryRate({{"watts", 0}, {"state", "Full"}}), std::optional<double>(0));
        QVERIFY(!batteryRate({{"watts", 12.3}, {"state", "Unknown"}}));
        put(battery + "charge_full", "4500000"); put(battery + "charge_full_design", "5000000");
        put(battery + "voltage_min_design", "16000000");
        put(battery + "charge_now", "3000000");
        QCOMPARE(batteryStatus(root.path())["remainingMWh"].toDouble(), 48000.);
        QCOMPARE(batteryStatus(root.path())["fullMWh"].toDouble(), 72000.);
        QCOMPARE(batteryStatus(root.path())["health"].toDouble(), 90.);
        QVERIFY(batteryStatus(root.path())["capacityEstimated"].toBool());
        put(battery + "energy_full", "75000000"); put(battery + "energy_full_design", "75000000");
        put(battery + "energy_now", "56250000");
        QCOMPARE(batteryStatus(root.path())["remainingMWh"].toDouble(), 56250.);
        QCOMPARE(batteryStatus(root.path())["fullMWh"].toDouble(), 75000.);
        QCOMPARE(batteryStatus(root.path())["health"].toDouble(), 100.);
        QVERIFY(!batteryStatus(root.path()).contains("capacityEstimated"));
    }
    void mainTemperatureSensors() {
        QTemporaryDir root;
        const QList<QPair<QString, QString>> fixtures{{"nvme", "Composite"}, {"nvme", "Sensor 1"},
            {"cros_ec", "peci-temp"}, {"cros_ec", "cpu_f75303@4d"}, {"coretemp", "Core 0"}, {"spd5118", ""}};
        for (int i = 0; i < fixtures.size(); ++i) {
            const QString dir = root.path() + "/class/hwmon/hwmon" + QString::number(i) + "/";
            put(dir + "name", fixtures[i].first.toUtf8()); put(dir + "temp1_label", fixtures[i].second.toUtf8());
            put(dir + "temp1_input", "45000");
        }
        const auto sensors = temperatureSensors(root.path()); QCOMPARE(sensors.size(), 6);
        for (const auto &sensor : sensors) {
            const bool main = sensor.name == "NVMe (composite)" || sensor.name == "CPU (PECI)"
                || sensor.name == "Memory (SPD)";
            QCOMPARE(sensor.primary, main); QCOMPARE(sensorValue(sensor), std::optional<double>(45.));
        }
    }
    void fanValidationAndCurve() {
        QVERIFY(validateFan({{"mode", "auto"}}).isEmpty());
        QVERIFY(validateFan({{"mode", "manual"}, {"duty", 0}}).isEmpty());
        QVERIFY(!validateFan({{"mode", "manual"}, {"duty", -1}}).isEmpty());
        QVERIFY(validateFan({{"mode", "curve"}, {"curve", QVariantList{0, 0, 20, 100}}}).isEmpty());
        QCOMPARE(curveDuty(40, {0, 0, 20, 100}), 0.);
        QVERIFY(!validateFan({{"mode", "curve"}, {"curve", QVariantList{30, 70, 40, 100}}}).isEmpty());
        QVERIFY(!validateFan({{"mode", "curve"}, {"curve", QVariantList{30, 40, 70, 90}}}).isEmpty());
        QVERIFY(validateFan({{"mode", "curve"}, {"curve", QVariantList{30, 40, 70, 100}}}).isEmpty());
        QCOMPARE(curveDuty(55, {30, 40, 70, 100}), 40.);
        QCOMPARE(curveDuty(62.5, {30, 40, 70, 100}), 55.);
        QCOMPARE(curveDuty(100, {30, 40, 70, 100}), 100.);
        QCOMPARE(curveDuty(60, {30, 40, 70, 100}, {40, 60, 75, 85}), 40.);
        QCOMPARE(curveDuty(67.5, {30, 40, 70, 100}, {40, 60, 75, 85}), 55.);
        QVariantMap config{{"mode", "curve"}, {"curve", QVariantList{30, 40, 70, 100}}, {"temperatures", QVariantList{40, 60, 75, 85}}};
        QVERIFY(validateFan(config).isEmpty());
        config["temperatures"] = QVariantList{40, 60, 60, 85}; QVERIFY(!validateFan(config).isEmpty());
        config["temperatures"] = QVariantList{40, 60, 75, 90}; QVERIFY(!validateFan(config).isEmpty());
    }
    void cpuRangeAndApply() {
        QTemporaryDir root; const QString policy = root.path() + "/devices/system/cpu/cpufreq/policy0/";
        put(policy + "cpuinfo_min_freq", "400000"); put(policy + "cpuinfo_max_freq", "4800000");
        put(policy + "scaling_min_freq", "400000"); put(policy + "scaling_max_freq", "3000000");
        QVERIFY(!setCpuLimits(3500, 3000, root.path()).isEmpty());
        QCOMPARE(readText(policy + "scaling_max_freq"), QString("3000000"));
        QVERIFY(setCpuLimits(1000, 4000, root.path()).isEmpty());
        QCOMPARE(readText(policy + "scaling_min_freq"), QString("1000000"));
        QCOMPARE(readText(policy + "scaling_max_freq"), QString("4000000"));
    }
    void hybridCpuProfiles() {
        QTemporaryDir root;
        const QString base = root.path() + "/devices/system/cpu/cpufreq/";
        for (int i = 0; i < 2; ++i) {
            const QString p = base + "policy" + QString::number(i) + "/";
            put(p + "cpuinfo_min_freq", "400000"); put(p + "cpuinfo_max_freq", i ? "3300000" : "4800000");
            put(p + "scaling_min_freq", "400000"); put(p + "scaling_max_freq", "3000000");
            put(p + "scaling_driver", "intel_pstate");
            put(p + "scaling_governor", "powersave"); put(p + "energy_performance_preference", "balance_power");
            put(p + "scaling_available_governors", "powersave performance");
            put(p + "energy_performance_available_preferences", "performance balance_performance balance_power power");
        }
        QVariantMap profile{{"frequencyOverride", true}, {"minimum", 1000}, {"maximum", 4500}, {"governor", "powersave"}, {"preference", "balance_power"}};
        QCOMPARE(cpuLimits(root.path())["high"].toInt(), 4800);
        QCOMPARE(cpuLimits(root.path())["capped"].toInt(), 2);
        QVERIFY(applyCpuProfile(profile, root.path()).isEmpty());
        QCOMPARE(readText(base + "policy0/scaling_max_freq"), QString("4500000"));
        QCOMPARE(readText(base + "policy1/scaling_max_freq"), QString("3300000"));
        QCOMPARE(cpuLimits(root.path())["capped"].toInt(), 1); // An E-core at its own ceiling isn't capped.
        QCOMPARE(readText(base + "policy1/energy_performance_preference"), QString("balance_power"));
        profile["minimum"] = 4000;
        QVERIFY(applyCpuProfile(profile, root.path()).isEmpty());
        QCOMPARE(readText(base + "policy1/scaling_min_freq"), QString("3300000"));
        profile["governor"] = "performance";
        QVERIFY(applyCpuProfile(profile, root.path()).isEmpty());
        QCOMPARE(readText(base + "policy0/scaling_governor"), QString("powersave"));
        profile["preference"] = "performance";
        QVERIFY(applyCpuProfile(profile, root.path()).isEmpty());
        profile["maximum"] = 99999;
        QVERIFY(!applyCpuProfile(profile, root.path()).isEmpty());
    }
    void independentCpuOverrides() {
        QTemporaryDir root; const QString p = root.path() + "/devices/system/cpu/cpufreq/policy0/";
        const QVariantMap automatic{{"frequencyOverride", false}, {"governor", "auto"}, {"preference", "auto"}};
        QVERIFY(applyCpuProfile(automatic, root.path()).isEmpty()); // No CPU files are required for a no-op.
        put(p + "scaling_driver", "intel_pstate"); put(p + "scaling_governor", "powersave");
        put(p + "energy_performance_preference", "balance_power");
        put(p + "scaling_available_governors", "powersave performance");
        put(p + "energy_performance_available_preferences", "performance balance_power balance_performance power");
        put(p + "scaling_min_freq", "555000"); put(p + "scaling_max_freq", "2345000");
        put(p + "cpuinfo_min_freq", "400000"); put(p + "cpuinfo_max_freq", "4800000");
        auto profile = automatic; profile["governor"] = "performance";
        QVERIFY(applyCpuProfile(profile, root.path()).isEmpty());
        QCOMPARE(readText(p + "scaling_governor"), QString("powersave"));
        QCOMPARE(readText(p + "energy_performance_preference"), QString("balance_power"));
        put(p + "energy_performance_preference", "performance");
        QVERIFY(applyCpuProfile(profile, root.path()).isEmpty());
        QCOMPARE(readText(p + "scaling_governor"), QString("performance"));
        // Simulate another controller switching governor/EPP after a power-profile change.
        put(p + "scaling_governor", "powersave"); put(p + "energy_performance_preference", "power");
        QVERIFY(applyCpuProfile(profile, root.path()).isEmpty());
        QCOMPARE(readText(p + "scaling_governor"), QString("powersave"));
        QCOMPARE(readText(p + "energy_performance_preference"), QString("power"));
        QCOMPARE(readText(p + "scaling_min_freq"), QString("555000"));
        QCOMPARE(readText(p + "scaling_max_freq"), QString("2345000"));
        profile = automatic; profile["preference"] = "balance_power";
        put(p + "scaling_governor", "performance");
        QVERIFY(!applyCpuProfile(profile, root.path()).isEmpty()); // Auto governor must not be silently changed.
        QCOMPARE(readText(p + "scaling_governor"), QString("performance"));
        QCOMPARE(readText(p + "energy_performance_preference"), QString("power"));
        profile = automatic; profile["frequencyOverride"] = true; profile["minimum"] = 1000; profile["maximum"] = 4000;
        QVERIFY(applyCpuProfile(profile, root.path()).isEmpty());
        QCOMPARE(readText(p + "scaling_governor"), QString("performance"));
        QCOMPARE(readText(p + "energy_performance_preference"), QString("power"));
        QCOMPARE(readText(p + "scaling_max_freq"), QString("4000000"));
        QVERIFY(applyCpuProfile(automatic, root.path()).isEmpty());
        QCOMPARE(readText(p + "scaling_max_freq"), QString("4000000")); // Releasing control is not a reset.
    }
    void cpuConfigMigration() {
        const QVariantMap profile{{"minimum", 1000}, {"maximum", 3000}, {"governor", "performance"}, {"preference", "performance"}};
        QVariantMap old{{"enabled", false}, {"separate", true}, {"battery", profile}, {"ac", profile}};
        auto config = normalizeCpuConfig(old); QVERIFY(!config.contains("enabled")); QVERIFY(!hasCpuOverrides(config));
        QCOMPARE(config["battery"].toMap()["governor"].toString(), QString("auto"));
        old["enabled"] = true; config = normalizeCpuConfig(old); QVERIFY(hasCpuOverrides(config));
        QVERIFY(config["battery"].toMap()["frequencyOverride"].toBool());
        QCOMPARE(normalizeCpuConfig(config), config);
    }
    void independentCoreGroups() {
        QTemporaryDir root;
        put(root.path() + "/bus/event_source/devices/cpu_core/cpus", "0");
        put(root.path() + "/bus/event_source/devices/cpu_atom/cpus", "1-2");
        const QString base = root.path() + "/devices/system/cpu/cpufreq/";
        for (int i = 0; i < 3; ++i) {
            const auto path = base + "policy" + QString::number(i) + "/";
            put(path + "related_cpus", QByteArray::number(i));
            put(path + "cpuinfo_min_freq", "400000"); put(path + "cpuinfo_max_freq", i == 0 ? "4800000" : i == 1 ? "3700000" : "3300000");
            put(path + "scaling_min_freq", "400000"); put(path + "scaling_max_freq", "3000000");
        }
        QCOMPARE(cpuPolicyGroups(root.path())["e"].size(), 2);
        QVariantMap bounds{{"p", QVariantMap{{"frequencyOverride", true}, {"minimum", 1000}, {"maximum", 4500}}},
            {"e", QVariantMap{{"frequencyOverride", false}, {"minimum", 400}, {"maximum", 3500}}}};
        QVariantMap profile{{"bounds", bounds}, {"governor", "auto"}, {"preference", "auto"}};
        QVERIFY(applyCpuProfile(profile, root.path()).isEmpty());
        QCOMPARE(readText(base + "policy0/scaling_max_freq"), QString("4500000"));
        QCOMPARE(readText(base + "policy1/scaling_max_freq"), QString("3000000"));
        bounds["p"] = QVariantMap{{"frequencyOverride", false}};
        bounds["e"] = QVariantMap{{"frequencyOverride", true}, {"minimum", 500}, {"maximum", 3500}};
        profile["bounds"] = bounds;
        QVERIFY(applyCpuProfile(profile, root.path()).isEmpty());
        QCOMPARE(readText(base + "policy0/scaling_max_freq"), QString("4500000"));
        QCOMPARE(readText(base + "policy1/scaling_max_freq"), QString("3500000"));
        QCOMPARE(readText(base + "policy2/scaling_max_freq"), QString("3300000"));
        QVERIFY(hasCpuOverrides({{"battery", profile}}));
        QCOMPARE(normalizeCpuConfig({{"battery", profile}})["battery"].toMap()["bounds"], QVariant(bounds));
        put(base + "policy1/related_cpus", "0 1");
        QVERIFY(cpuPolicyGroups(root.path()).isEmpty());
        QVERIFY(!applyCpuProfile(profile, root.path()).isEmpty());
    }
    void powerSourceAndProfileSelection() {
        QTemporaryDir root;
        QVERIFY(!onAcPower(root.path()).has_value());
        const QString ac = root.path() + "/class/power_supply/ACAD/";
        put(ac + "type", "Mains"); put(ac + "online", "0");
        QCOMPARE(onAcPower(root.path()), std::optional<bool>(false));
        put(ac + "online", "1");
        QCOMPARE(onAcPower(root.path()), std::optional<bool>(true));
        const QVariantMap battery{{"maximum", 2500}}, plugged{{"maximum", 4500}};
        QVariantMap config{{"enabled", true}, {"separate", true}, {"battery", battery}, {"ac", plugged}};
        QCOMPARE(cpuProfile(config, false), battery); QCOMPARE(cpuProfile(config, true), plugged);
        config["separate"] = false;
        QCOMPARE(cpuProfile(config, true), battery);
    }
    void fanRefusesMissingOrHotSensors() {
        QTemporaryDir root; const QString ec = root.path() + "/class/hwmon/hwmon7/";
        put(ec + "name", "cros_ec"); put(ec + "pwm1_enable", "2"); put(ec + "pwm1", "0"); put(ec + "fan1_fault", "0");
        const QVariantMap config{{"mode", "manual"}, {"duty", 50}};
        double last = -1;
        QVERIFY(!updateFan({{"mode", "auto"}}, last, root.path()).isEmpty());
        QVERIFY(!updateFan(config, last, root.path()).isEmpty());
        QCOMPARE(readText(ec + "pwm1_enable"), QString("2"));
        for (int i = 1; i <= 5; ++i) {
            const QString stem = ec + "temp" + QString::number(i);
            put(stem + "_input", "40000"); put(stem + "_fault", "0"); put(stem + "_crit", "90000");
        }
        QVERIFY(updateFan(config, last, root.path()).isEmpty());
        QCOMPARE(readText(ec + "pwm1_enable"), QString("1"));
        QCOMPARE(last, 50.);
        put(ec + "temp3_input", "89000");
        QVERIFY(!updateFan(config, last, root.path()).isEmpty());
        put(ec + "temp3_input", "40000"); put(ec + "temp1_fault", "1");
        QVERIFY(!updateFan(config, last, root.path()).isEmpty());
    }
};
QTEST_GUILESS_MAIN(HardwareTest)
#include "test-hardware.moc"