tsvesync 1.0.13 → 1.0.14

package/dist/src/lib/vesyncSwitchImpl.js

@@ -1,290 +0,0 @@
-"use strict";
-/**
- * VeSync Switch Implementations
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.switchModules = exports.VeSyncDimmerSwitch = exports.VeSyncWallSwitch = void 0;
-const vesyncSwitch_1 = require("./vesyncSwitch");
-const helpers_1 = require("./helpers");
-/**
- * Basic Wall Switch Implementation (ESWL01, ESWL03)
- */
-class VeSyncWallSwitch extends vesyncSwitch_1.VeSyncSwitch {
-    constructor(details, manager) {
-        super(details, manager);
-    }
-    /**
-     * Get wall switch details
-     */
-    async getDetails() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicedetail'),
-            uuid: this.cid,
-            method: 'devicedetail'
-        };
-        const [response] = await helpers_1.Helpers.callApi('/inwallswitch/v1/device/devicedetail', 'post', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0 && response?.result) {
-            const result = response.result;
-            this.deviceStatus = result.deviceStatus || this.deviceStatus;
-            this.details.active_time = result.activeTime || 0;
-            this.connectionStatus = result.connectionStatus || this.connectionStatus;
-        }
-    }
-    /**
-     * Get switch device configuration info
-     */
-    async getConfig() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicedetail'),
-            method: 'configurations',
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/inwallswitch/v1/device/configurations', 'post', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this.config = helpers_1.Helpers.buildConfigDict(response);
-        }
-    }
-    /**
-     * Turn off wall switch
-     */
-    async turnOff() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
-            status: 'off',
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/inwallswitch/v1/device/devicestatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this.deviceStatus = 'off';
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Turn on wall switch
-     */
-    async turnOn() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
-            status: 'on',
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/inwallswitch/v1/device/devicestatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this.deviceStatus = 'on';
-            return true;
-        }
-        return false;
-    }
-}
-exports.VeSyncWallSwitch = VeSyncWallSwitch;
-/**
- * Dimmer Switch Implementation (ESWD16)
- */
-class VeSyncDimmerSwitch extends vesyncSwitch_1.VeSyncSwitch {
-    constructor(details, manager) {
-        super(details, manager);
-        this._brightness = 0;
-        this._rgbValue = { red: 0, blue: 0, green: 0 };
-        this._rgbStatus = 'unknown';
-        this._indicatorLight = 'unknown';
-    }
-    /**
-     * Get dimmer switch details
-     */
-    async getDetails() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicedetail'),
-            uuid: this.cid,
-            method: 'devicedetail'
-        };
-        const [response] = await helpers_1.Helpers.callApi('/dimmer/v1/device/devicedetail', 'post', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0 && response?.result) {
-            const result = response.result;
-            this.deviceStatus = result.deviceStatus || this.deviceStatus;
-            this.details.active_time = result.activeTime || 0;
-            this.connectionStatus = result.connectionStatus || this.connectionStatus;
-            this._brightness = result.brightness || this._brightness;
-            this._rgbStatus = result.rgbStatus || this._rgbStatus;
-            this._indicatorLight = result.indicatorlightStatus || this._indicatorLight;
-            if (result.rgbValue) {
-                this._rgbValue = {
-                    red: result.rgbValue.red || 0,
-                    green: result.rgbValue.green || 0,
-                    blue: result.rgbValue.blue || 0
-                };
-            }
-        }
-    }
-    /**
-     * Get dimmer switch configuration info
-     */
-    async getConfig() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicedetail'),
-            method: 'configurations',
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/dimmer/v1/device/configurations', 'post', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this.config = helpers_1.Helpers.buildConfigDict(response);
-        }
-    }
-    /**
-     * Turn off dimmer switch
-     */
-    async turnOff() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
-            status: 'off',
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/dimmer/v1/device/devicestatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this.deviceStatus = 'off';
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Turn on dimmer switch
-     */
-    async turnOn() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
-            status: 'on',
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/dimmer/v1/device/devicestatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this.deviceStatus = 'on';
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Set brightness level
-     */
-    async setBrightness(brightness) {
-        if (!this.isDimmable()) {
-            return false;
-        }
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
-            brightness: brightness.toString(),
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/dimmer/v1/device/updatebrightness', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this._brightness = brightness;
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Set RGB indicator color
-     */
-    async rgbColorSet(red, green, blue) {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
-            rgbValue: {
-                red: Math.round(red),
-                green: Math.round(green),
-                blue: Math.round(blue)
-            },
-            status: 'on',
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/dimmer/v1/device/devicergbstatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this._rgbValue = { red, green, blue };
-            this._rgbStatus = 'on';
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Turn on RGB indicator
-     */
-    async rgbColorOn() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
-            status: 'on',
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/dimmer/v1/device/devicergbstatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this._rgbStatus = 'on';
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Turn off RGB indicator
-     */
-    async rgbColorOff() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
-            status: 'off',
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/dimmer/v1/device/devicergbstatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this._rgbStatus = 'off';
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Turn on indicator light
-     */
-    async indicatorLightOn() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
-            status: 'on',
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/dimmer/v1/device/indicatorlightstatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this._indicatorLight = 'on';
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Turn off indicator light
-     */
-    async indicatorLightOff() {
-        const body = {
-            ...helpers_1.Helpers.reqBody(this.manager, 'devicestatus'),
-            status: 'off',
-            uuid: this.cid
-        };
-        const [response] = await helpers_1.Helpers.callApi('/dimmer/v1/device/indicatorlightstatus', 'put', body, helpers_1.Helpers.reqHeaders(this.manager));
-        if (response?.code === 0) {
-            this._indicatorLight = 'off';
-            return true;
-        }
-        return false;
-    }
-    // Getters
-    get brightness() {
-        return this._brightness;
-    }
-    get indicatorLightStatus() {
-        return this._indicatorLight;
-    }
-    get rgbLightStatus() {
-        return this._rgbStatus;
-    }
-    get rgbLightValue() {
-        return { ...this._rgbValue };
-    }
-}
-exports.VeSyncDimmerSwitch = VeSyncDimmerSwitch;
-// Export the switch modules dictionary
-exports.switchModules = {
-    'ESWL01': VeSyncWallSwitch,
-    'ESWL03': VeSyncWallSwitch,
-    'ESWD16': VeSyncDimmerSwitch
-};

package/dist/test/testFeatures.d.ts

@@ -1,4 +0,0 @@
-/**
- * Test all device features using TSVeSync device classes
- */
-export {};

package/dist/test/testFeatures.js

@@ -1,394 +0,0 @@
-"use strict";
-/**
- * Test all device features using TSVeSync device classes
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const vesync_1 = require("../src/lib/vesync");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const yaml = __importStar(require("js-yaml"));
-const helpers_1 = require("../src/lib/helpers");
-// Configure logging
-const DEBUG = true;
-class DeviceFeatureTest {
-    constructor() {
-        this.deviceSpecs = new Map();
-        this.testSummary = new Map();
-        // Method name mapping from Python snake_case to TypeScript camelCase
-        this.methodNameMap = {
-            'change_fan_speed': 'changeFanSpeed',
-            'set_brightness': 'setBrightness',
-            'set_color_temp': 'setColorTemp',
-            'set_hsv': 'setHsv',
-            'set_timer': 'setTimer',
-            'set_mist_level': 'setMistLevel',
-            'set_warm_level': 'setWarmLevel',
-            'set_drying_mode_enabled': 'setDryingModeEnabled',
-            'change_mode': 'setMode',
-            'get_monthly_energy': 'getMonthlyEnergy',
-            'get_weekly_energy': 'getWeeklyEnergy',
-            'get_yearly_energy': 'getYearlyEnergy',
-            'rgb_color_set': 'rgbColorSet',
-            'rgb_color_on': 'rgbColorOn',
-            'rgb_color_off': 'rgbColorOff',
-            'set_temperature': 'setTemperature',
-            'set_cooking_time': 'setCookingTime',
-            'set_cooking_mode': 'setCookingMode',
-            'turn_on': 'turnOn',
-            'turn_off': 'turnOff',
-            'turn_on_nightlight': 'turnOnNightlight',
-            'turn_off_nightlight': 'turnOffNightlight',
-            'toggle': 'toggle',
-            'clear_timer': 'clearTimer',
-            'manual_mode': 'setMode',
-            'sleep_mode': 'setMode',
-            'turn_off_display': 'setDisplay',
-            'turn_on_display': 'setDisplay',
-            'update': 'update',
-            'auto_mode': 'setMode',
-            'set_auto_mode': 'setMode',
-            'set_manual_mode': 'setMode',
-            'automatic_stop_on': 'automaticStopOn',
-            'automatic_stop_off': 'automaticStopOff',
-            'set_humidity': 'setHumidity',
-            'indicator_light_on': 'indicatorLightOn',
-            'indicator_light_off': 'indicatorLightOff',
-            'enable_white_mode': 'enableWhiteMode',
-            'set_rgb': 'setRgb',
-            'set_mode': 'setMode',
-            'set_display': 'setDisplay',
-            'set_child_lock': 'setChildLock',
-            'set_night_light': 'setNightLight'
-        };
-        // Property name mapping from Python snake_case to TypeScript camelCase
-        this.propertyNameMap = {
-            'current_temperature': 'currentTemperature',
-            'cooking_status': 'cookingStatus',
-            'remaining_time': 'remainingTime',
-            'current_humidity': 'currentHumidity',
-            'water_lacks': 'waterLacks',
-            'voltage': 'voltage',
-            'power': 'power',
-            'filter_life': 'filterLife',
-            'screen_status': 'screenStatus',
-            'child_lock': 'childLock',
-            'air_quality': 'airQuality',
-            'mist_level': 'mistLevel',
-            'warm_level': 'warmLevel'
-        };
-        (0, helpers_1.setApiBaseUrl)('http://localhost:8000');
-        this.manager = new vesync_1.VeSync('test@example.com', 'test123', 'America/New_York', DEBUG);
-        // Load all YAML specs
-        const apiDir = path.join(__dirname, '..', 'api');
-        for (const deviceType of ['vesyncfan', 'vesyncbulb', 'vesyncoutlet', 'vesyncswitch']) {
-            const deviceDir = path.join(apiDir, deviceType);
-            if (fs.existsSync(deviceDir)) {
-                for (const file of fs.readdirSync(deviceDir)) {
-                    if (file.endsWith('.yaml')) {
-                        const model = path.basename(file, '.yaml');
-                        const spec = yaml.load(fs.readFileSync(path.join(deviceDir, file), 'utf8'));
-                        this.deviceSpecs.set(model, spec);
-                    }
-                }
-            }
-        }
-    }
-    getDeviceSpec(deviceType) {
-        return this.deviceSpecs.get(deviceType) || {};
-    }
-    logError(deviceName, methodName, error) {
-        const errorMsg = error?.message || error;
-        if (!this.testSummary.has(deviceName)) {
-            this.testSummary.set(deviceName, {
-                testedFeatures: new Set(),
-                failedFeatures: new Set(),
-                errors: new Map()
-            });
-        }
-        const summary = this.testSummary.get(deviceName);
-        if (!summary.errors.has(methodName)) {
-            summary.errors.set(methodName, []);
-        }
-        summary.errors.get(methodName).push(errorMsg);
-        console.error(`[${deviceName}] ${methodName}: ${errorMsg}`);
-    }
-    async testMethod(device, methodName, spec) {
-        const deviceName = `${device.deviceName} (${device.deviceType})`;
-        const summary = this.testSummary.get(deviceName);
-        summary.testedFeatures.add(methodName);
-        try {
-            // Convert method name from snake_case to camelCase
-            const camelCaseMethod = this.methodNameMap[methodName];
-            if (!camelCaseMethod) {
-                throw new Error(`No camelCase mapping found for method: ${methodName}`);
-            }
-            const method = device[camelCaseMethod];
-            if (!method) {
-                throw new Error(`Method ${camelCaseMethod} not found`);
-            }
-            // Handle special cases for method parameters
-            switch (methodName) {
-                case 'manual_mode':
-                case 'set_manual_mode':
-                    await method.call(device, 'manual');
-                    break;
-                case 'auto_mode':
-                case 'set_auto_mode':
-                    await method.call(device, 'auto');
-                    break;
-                case 'sleep_mode':
-                    await method.call(device, 'sleep');
-                    break;
-                case 'turn_on_display':
-                    await method.call(device, true);
-                    break;
-                case 'turn_off_display':
-                    await method.call(device, false);
-                    break;
-                case 'change_fan_speed':
-                    const speeds = device.deviceType.match(/Core|LAP|LTF|LV/) ? [1, 2, 3, 4, 5] : [1, 2, 3];
-                    for (const speed of speeds) {
-                        await method.call(device, speed);
-                    }
-                    break;
-                case 'set_warm_level':
-                    await method.call(device, 2);
-                    break;
-                case 'set_mist_level':
-                    await method.call(device, 2);
-                    break;
-                case 'set_brightness':
-                    for (const brightness of [25, 50, 75, 100]) {
-                        await method.call(device, brightness);
-                    }
-                    break;
-                case 'set_color_temp':
-                    for (const temp of [2700, 4000, 5500]) {
-                        await method.call(device, temp);
-                    }
-                    break;
-                case 'set_hsv':
-                    const colors = [
-                        [0, 100, 100], // Red
-                        [120, 100, 100], // Green
-                        [240, 100, 100] // Blue
-                    ];
-                    for (const [h, s, v] of colors) {
-                        await method.call(device, h, s, v);
-                    }
-                    break;
-                case 'set_timer':
-                    await method.call(device, 2); // 2 hours
-                    break;
-                case 'set_mode':
-                    for (const mode of ['auto', 'manual', 'sleep']) {
-                        await method.call(device, mode);
-                    }
-                    break;
-                case 'set_display':
-                case 'set_child_lock':
-                case 'set_night_light':
-                    for (const state of [true, false]) {
-                        await method.call(device, state);
-                    }
-                    break;
-                case 'set_humidity':
-                    for (const humidity of [30, 50, 80]) {
-                        await method.call(device, humidity);
-                    }
-                    break;
-                default:
-                    // For simple methods with no parameters
-                    await method.call(device);
-            }
-        }
-        catch (error) {
-            summary.failedFeatures.add(methodName);
-            this.logError(deviceName, methodName, error);
-            throw error;
-        }
-    }
-    async testDeviceFeatures(device) {
-        const deviceType = device.deviceType;
-        const spec = this.getDeviceSpec(deviceType);
-        if (!spec) {
-            console.error(`No YAML spec found for device type: ${deviceType}`);
-            return;
-        }
-        const deviceName = `${device.deviceName} (${deviceType})`;
-        this.testSummary.set(deviceName, {
-            testedFeatures: new Set(),
-            failedFeatures: new Set(),
-            errors: new Map()
-        });
-        // Test each method from the YAML spec
-        for (const methodName of Object.keys(spec)) {
-            await this.testMethod(device, methodName, spec[methodName]);
-        }
-        // Test device-specific properties
-        if (deviceType.match(/Core|LAP|LTF|LV/)) {
-            // Test air purifier properties
-            const properties = ['mode', 'speed', 'filterLife', 'screenStatus', 'childLock', 'airQuality'];
-            for (const prop of properties) {
-                const summary = this.testSummary.get(deviceName);
-                summary.testedFeatures.add(prop);
-                try {
-                    device[prop];
-                }
-                catch (error) {
-                    summary.failedFeatures.add(prop);
-                    this.logError(deviceName, prop, error);
-                }
-            }
-        }
-        if (deviceType.match(/Classic|Dual/)) {
-            // Test humidifier properties
-            const properties = ['mode', 'speed', 'humidity', 'mistLevel'];
-            for (const prop of properties) {
-                const summary = this.testSummary.get(deviceName);
-                summary.testedFeatures.add(prop);
-                try {
-                    device[prop];
-                }
-                catch (error) {
-                    summary.failedFeatures.add(prop);
-                    this.logError(deviceName, prop, error);
-                }
-            }
-        }
-        if (deviceType.match(/LUH|LEH/)) {
-            // Test warm humidifier properties
-            const properties = ['mode', 'speed', 'humidity', 'mistLevel', 'warmLevel'];
-            for (const prop of properties) {
-                const summary = this.testSummary.get(deviceName);
-                summary.testedFeatures.add(prop);
-                try {
-                    device[prop];
-                }
-                catch (error) {
-                    summary.failedFeatures.add(prop);
-                    this.logError(deviceName, prop, error);
-                }
-            }
-        }
-        // Test outlet properties
-        if (deviceType.match(/ESW|ESO/)) {
-            const properties = ['voltage', 'power'];
-            for (const prop of properties) {
-                const camelCaseProp = this.propertyNameMap[prop] || prop;
-                if (camelCaseProp in device) {
-                    const summary = this.testSummary.get(deviceName);
-                    summary.testedFeatures.add(prop);
-                    try {
-                        device[camelCaseProp];
-                    }
-                    catch (error) {
-                        summary.failedFeatures.add(prop);
-                        this.logError(deviceName, prop, error);
-                    }
-                }
-            }
-        }
-    }
-    displaySummary() {
-        console.log('\n=== Test Summary ===\n');
-        // First print all errors
-        console.log('=== All Errors Found ===');
-        let hasErrors = false;
-        for (const [deviceName, summary] of this.testSummary) {
-            if (summary.errors.size > 0) {
-                hasErrors = true;
-                console.log(`\nDevice: ${deviceName}`);
-                for (const [method, errors] of summary.errors) {
-                    console.log(`\nMethod: ${method}`);
-                    for (const error of errors) {
-                        console.log(`Error: ${error}`);
-                    }
-                }
-            }
-        }
-        if (!hasErrors) {
-            console.log('No errors found!');
-        }
-        // Then print feature summary
-        console.log('\n=== Feature Summary ===');
-        for (const [deviceName, summary] of this.testSummary) {
-            console.log(`\nDevice: ${deviceName}`);
-            console.log('Tested features:');
-            for (const feature of Array.from(summary.testedFeatures).sort()) {
-                const status = summary.failedFeatures.has(feature) ? '✗' : '✓';
-                console.log(`  ${status} ${feature}`);
-            }
-            if (summary.failedFeatures.size > 0) {
-                console.log('Failed features:');
-                for (const feature of Array.from(summary.failedFeatures).sort()) {
-                    console.log(`  ✗ ${feature}`);
-                }
-            }
-        }
-    }
-    async run() {
-        console.log('Using credentials:', {
-            username: this.manager.username,
-            password: '*'.repeat(this.manager.password.length)
-        });
-        console.log('\nTesting login...');
-        if (!await this.manager.login()) {
-            console.error('Login failed');
-            return;
-        }
-        console.log('\nTesting device discovery...');
-        await this.manager.getDevices();
-        if (this.manager.devices && this.manager.devices.length > 0) {
-            for (const device of this.manager.devices) {
-                await this.testDeviceFeatures(device);
-            }
-        }
-        else {
-            console.log('No devices found. Tests will be skipped.');
-        }
-        this.displaySummary();
-        console.log('\n✓ All tests completed');
-    }
-}
-// Run tests if this file is executed directly
-if (require.main === module) {
-    const test = new DeviceFeatureTest();
-    test.run().catch(error => {
-        console.error('Test failed:', error);
-        process.exit(1);
-    });
-}