mirror of
https://github.com/Next-Flip/Momentum-Firmware.git
synced 2026-04-24 03:29:57 -07:00
Merge branch 'feat/nfc-type-4-final' into mntm-dev
This commit is contained in:
WillyJL
211
applications/debug/unit_tests/tests/args/args_test.c
Normal file
211
applications/debug/unit_tests/tests/args/args_test.c
Normal file
@@ -0,0 +1,211 @@
|
||||
|
||||
#include "../test.h" // IWYU pragma: keep
|
||||
#include <toolbox/args.h>
|
||||
|
||||
const uint32_t one_ms = 1;
|
||||
const uint32_t one_s = 1000 * one_ms;
|
||||
const uint32_t one_m = 60 * one_s;
|
||||
const uint32_t one_h = 60 * one_m;
|
||||
|
||||
MU_TEST(args_read_duration_default_values_test) {
|
||||
FuriString* args_string;
|
||||
uint32_t value = 0;
|
||||
|
||||
// Check default == NULL (ms)
|
||||
args_string = furi_string_alloc_set_str("1");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, one_ms);
|
||||
furi_string_free(args_string);
|
||||
value = 0;
|
||||
|
||||
// Check default == ms
|
||||
args_string = furi_string_alloc_set_str("1");
|
||||
mu_check(args_read_duration(args_string, &value, "ms"));
|
||||
mu_assert_int_eq(value, one_ms);
|
||||
furi_string_free(args_string);
|
||||
value = 0;
|
||||
|
||||
// Check default == s
|
||||
args_string = furi_string_alloc_set_str("1");
|
||||
mu_check(args_read_duration(args_string, &value, "s"));
|
||||
mu_assert_int_eq(value, one_s);
|
||||
furi_string_free(args_string);
|
||||
value = 0;
|
||||
|
||||
// Check default == m
|
||||
args_string = furi_string_alloc_set_str("1");
|
||||
mu_check(args_read_duration(args_string, &value, "m"));
|
||||
mu_assert_int_eq(value, one_m);
|
||||
furi_string_free(args_string);
|
||||
value = 0;
|
||||
|
||||
// Check default == h
|
||||
args_string = furi_string_alloc_set_str("1");
|
||||
mu_check(args_read_duration(args_string, &value, "h"));
|
||||
mu_assert_int_eq(value, one_h);
|
||||
furi_string_free(args_string);
|
||||
value = 0;
|
||||
}
|
||||
|
||||
MU_TEST(args_read_duration_suffix_values_test) {
|
||||
FuriString* args_string;
|
||||
uint32_t value = 0;
|
||||
|
||||
// Check ms
|
||||
args_string = furi_string_alloc_set_str("1ms");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, one_ms);
|
||||
furi_string_free(args_string);
|
||||
value = 0;
|
||||
|
||||
// Check s
|
||||
args_string = furi_string_alloc_set_str("1s");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, one_s);
|
||||
furi_string_free(args_string);
|
||||
value = 0;
|
||||
|
||||
// Check m
|
||||
args_string = furi_string_alloc_set_str("1m");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, one_m);
|
||||
furi_string_free(args_string);
|
||||
value = 0;
|
||||
|
||||
// Check h
|
||||
args_string = furi_string_alloc_set_str("1h");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, one_h);
|
||||
furi_string_free(args_string);
|
||||
value = 0;
|
||||
}
|
||||
|
||||
MU_TEST(args_read_duration_values_test) {
|
||||
FuriString* args_string;
|
||||
uint32_t value = 0;
|
||||
|
||||
// Check for ms
|
||||
args_string = furi_string_alloc_set_str("4294967295ms");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 4294967295U);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check for s
|
||||
args_string = furi_string_alloc_set_str("4294967s");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 4294967U * one_s);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check for m
|
||||
args_string = furi_string_alloc_set_str("71582m");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 71582U * one_m);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check for h
|
||||
args_string = furi_string_alloc_set_str("1193h");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 1193U * one_h);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check for ms in float
|
||||
args_string = furi_string_alloc_set_str("4.2ms");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 4);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check for s in float
|
||||
args_string = furi_string_alloc_set_str("1.5s");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, (uint32_t)(1.5 * one_s));
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check for m in float
|
||||
args_string = furi_string_alloc_set_str("1.5m");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, (uint32_t)(1.5 * one_m));
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check for h in float
|
||||
args_string = furi_string_alloc_set_str("1.5h");
|
||||
mu_check(args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, (uint32_t)(1.5 * one_h));
|
||||
furi_string_free(args_string);
|
||||
}
|
||||
|
||||
MU_TEST(args_read_duration_errors_test) {
|
||||
FuriString* args_string;
|
||||
uint32_t value = 0;
|
||||
|
||||
// Check wrong suffix
|
||||
args_string = furi_string_alloc_set_str("1x");
|
||||
mu_check(!args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 0);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check wrong suffix
|
||||
args_string = furi_string_alloc_set_str("1xs");
|
||||
mu_check(!args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 0);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check negative value
|
||||
args_string = furi_string_alloc_set_str("-1s");
|
||||
mu_check(!args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 0);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check wrong values
|
||||
|
||||
// Check only suffix
|
||||
args_string = furi_string_alloc_set_str("s");
|
||||
mu_check(!args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 0);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check doubled point
|
||||
args_string = furi_string_alloc_set_str("0.1.1");
|
||||
mu_check(!args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 0);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check overflow values
|
||||
|
||||
// Check for ms
|
||||
args_string = furi_string_alloc_set_str("4294967296ms");
|
||||
mu_check(!args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 0);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check for s
|
||||
args_string = furi_string_alloc_set_str("4294968s");
|
||||
mu_check(!args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 0);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check for m
|
||||
args_string = furi_string_alloc_set_str("71583m");
|
||||
mu_check(!args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 0);
|
||||
furi_string_free(args_string);
|
||||
|
||||
// Check for h
|
||||
args_string = furi_string_alloc_set_str("1194h");
|
||||
mu_check(!args_read_duration(args_string, &value, NULL));
|
||||
mu_assert_int_eq(value, 0);
|
||||
furi_string_free(args_string);
|
||||
}
|
||||
|
||||
MU_TEST_SUITE(toolbox_args_read_duration_suite) {
|
||||
MU_RUN_TEST(args_read_duration_default_values_test);
|
||||
MU_RUN_TEST(args_read_duration_suffix_values_test);
|
||||
MU_RUN_TEST(args_read_duration_values_test);
|
||||
MU_RUN_TEST(args_read_duration_errors_test);
|
||||
}
|
||||
|
||||
int run_minunit_test_toolbox_args(void) {
|
||||
MU_RUN_SUITE(toolbox_args_read_duration_suite);
|
||||
return MU_EXIT_CODE;
|
||||
}
|
||||
|
||||
TEST_API_DEFINE(run_minunit_test_toolbox_args)
|
||||
@@ -4,10 +4,23 @@
|
||||
|
||||
#include <bt/bt_service/bt_keys_storage.h>
|
||||
#include <storage/storage.h>
|
||||
#include <toolbox/saved_struct.h>
|
||||
|
||||
#define BT_TEST_KEY_STORAGE_FILE_PATH EXT_PATH("unit_tests/bt_test.keys")
|
||||
#define BT_TEST_MIGRATION_FILE_PATH EXT_PATH("unit_tests/bt_migration_test.keys")
|
||||
#define BT_TEST_NVM_RAM_BUFF_SIZE (507 * 4) // The same as in ble NVM storage
|
||||
|
||||
// Identity root key
|
||||
static const uint8_t gap_legacy_irk[16] =
|
||||
{0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0};
|
||||
// Encryption root key
|
||||
static const uint8_t gap_legacy_erk[16] =
|
||||
{0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21, 0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21};
|
||||
|
||||
// Test constants for migration (matching bt_keys_storage.c)
|
||||
#define BT_KEYS_STORAGE_MAGIC_TEST (0x18)
|
||||
#define BT_KEYS_STORAGE_VERSION_1_TEST (1)
|
||||
|
||||
typedef struct {
|
||||
Storage* storage;
|
||||
BtKeysStorage* bt_keys_storage;
|
||||
@@ -88,6 +101,134 @@ static void bt_test_keys_remove_test_file(void) {
|
||||
"Can't remove test file");
|
||||
}
|
||||
|
||||
// Helper function to create a version 0 file manually
|
||||
static bool
|
||||
bt_test_create_v0_file(const char* file_path, const uint8_t* nvm_data, size_t nvm_size) {
|
||||
// Version 0 files use saved_struct format with magic 0x18, version 0, containing only BLE pairing data
|
||||
return saved_struct_save(
|
||||
file_path,
|
||||
nvm_data,
|
||||
nvm_size,
|
||||
BT_KEYS_STORAGE_MAGIC_TEST,
|
||||
0); // Version 0
|
||||
}
|
||||
|
||||
// Helper function to verify file format version
|
||||
static bool bt_test_verify_file_version(const char* file_path, uint32_t expected_version) {
|
||||
uint8_t magic, version;
|
||||
size_t size;
|
||||
|
||||
if(!saved_struct_get_metadata(file_path, &magic, &version, &size)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return (magic == BT_KEYS_STORAGE_MAGIC_TEST && version == expected_version);
|
||||
}
|
||||
|
||||
// Test migration from version 0 to version 1, including root key preservation
|
||||
static void bt_test_migration_v0_to_v1(void) {
|
||||
// Create test NVM data
|
||||
const size_t test_nvm_size = 100;
|
||||
uint8_t test_nvm_data[test_nvm_size];
|
||||
for(size_t i = 0; i < test_nvm_size; i++) {
|
||||
test_nvm_data[i] = (uint8_t)(i & 0xFF);
|
||||
}
|
||||
|
||||
// Create a version 0 file
|
||||
mu_assert(
|
||||
bt_test_create_v0_file(BT_TEST_MIGRATION_FILE_PATH, test_nvm_data, test_nvm_size),
|
||||
"Failed to create version 0 test file");
|
||||
|
||||
// Create BT keys storage and load the v0 file (should trigger migration)
|
||||
BtKeysStorage* migration_storage = bt_keys_storage_alloc(BT_TEST_MIGRATION_FILE_PATH);
|
||||
uint8_t loaded_buffer[BT_TEST_NVM_RAM_BUFF_SIZE];
|
||||
memset(loaded_buffer, 0, sizeof(loaded_buffer));
|
||||
bt_keys_storage_set_ram_params(migration_storage, loaded_buffer, sizeof(loaded_buffer));
|
||||
|
||||
// Load should succeed and migrate v0 to v1
|
||||
mu_assert(bt_keys_storage_load(migration_storage), "Failed to load and migrate v0 file");
|
||||
|
||||
// Verify the file is now version 1
|
||||
mu_assert(
|
||||
bt_test_verify_file_version(BT_TEST_MIGRATION_FILE_PATH, BT_KEYS_STORAGE_VERSION_1_TEST),
|
||||
"File was not migrated to version 1");
|
||||
|
||||
// Verify the NVM data was preserved during migration
|
||||
mu_assert(
|
||||
memcmp(test_nvm_data, loaded_buffer, test_nvm_size) == 0,
|
||||
"NVM data was corrupted during migration");
|
||||
|
||||
// Verify that legacy root keys are used after migration
|
||||
const GapRootSecurityKeys* migrated_keys = bt_keys_storage_get_root_keys(migration_storage);
|
||||
mu_assert(
|
||||
memcmp(migrated_keys->irk, gap_legacy_irk, sizeof(gap_legacy_irk)) == 0,
|
||||
"IRK not set to legacy after migration");
|
||||
mu_assert(
|
||||
memcmp(migrated_keys->erk, gap_legacy_erk, sizeof(gap_legacy_erk)) == 0,
|
||||
"ERK not set to legacy after migration");
|
||||
|
||||
bt_keys_storage_free(migration_storage);
|
||||
storage_simply_remove(bt_test->storage, BT_TEST_MIGRATION_FILE_PATH);
|
||||
}
|
||||
|
||||
// Test that migration preserves existing pairing data and root keys are not changed on reload
|
||||
static void bt_test_migration_preserves_pairings_and_keys(void) {
|
||||
const size_t pairing_data_size = 200;
|
||||
uint8_t pairing_data[pairing_data_size];
|
||||
for(size_t i = 0; i < pairing_data_size; i++) {
|
||||
pairing_data[i] = (uint8_t)((i * 7 + 42) & 0xFF);
|
||||
}
|
||||
mu_assert(
|
||||
bt_test_create_v0_file(BT_TEST_MIGRATION_FILE_PATH, pairing_data, pairing_data_size),
|
||||
"Failed to create v0 file with pairing data");
|
||||
|
||||
GapRootSecurityKeys keys_after_first_load;
|
||||
for(int iteration = 0; iteration < 2; iteration++) {
|
||||
BtKeysStorage* storage = bt_keys_storage_alloc(BT_TEST_MIGRATION_FILE_PATH);
|
||||
uint8_t buffer[BT_TEST_NVM_RAM_BUFF_SIZE];
|
||||
memset(buffer, 0, sizeof(buffer));
|
||||
bt_keys_storage_set_ram_params(storage, buffer, sizeof(buffer));
|
||||
mu_assert(bt_keys_storage_load(storage), "Failed to load on iteration");
|
||||
mu_assert(
|
||||
memcmp(pairing_data, buffer, pairing_data_size) == 0,
|
||||
"Pairing data corrupted on iteration");
|
||||
const GapRootSecurityKeys* keys = bt_keys_storage_get_root_keys(storage);
|
||||
if(iteration == 0)
|
||||
memcpy(&keys_after_first_load, keys, sizeof(GapRootSecurityKeys));
|
||||
else
|
||||
mu_assert(
|
||||
memcmp(&keys_after_first_load, keys, sizeof(GapRootSecurityKeys)) == 0,
|
||||
"Root keys changed after reload");
|
||||
bt_keys_storage_free(storage);
|
||||
}
|
||||
storage_simply_remove(bt_test->storage, BT_TEST_MIGRATION_FILE_PATH);
|
||||
}
|
||||
|
||||
// Test that delete operation generates new secure keys in v1 and does not match legacy
|
||||
static void bt_test_delete_generates_new_keys_and_not_legacy(void) {
|
||||
BtKeysStorage* storage = bt_keys_storage_alloc(BT_TEST_MIGRATION_FILE_PATH);
|
||||
uint8_t buffer[BT_TEST_NVM_RAM_BUFF_SIZE];
|
||||
memset(buffer, 0x55, sizeof(buffer));
|
||||
bt_keys_storage_set_ram_params(storage, buffer, sizeof(buffer));
|
||||
mu_assert(bt_keys_storage_update(storage, buffer, 100), "Failed to create initial v1 file");
|
||||
const GapRootSecurityKeys* original_keys = bt_keys_storage_get_root_keys(storage);
|
||||
uint8_t original_keys_copy[sizeof(GapRootSecurityKeys)];
|
||||
memcpy(original_keys_copy, original_keys, sizeof(original_keys_copy));
|
||||
bt_keys_storage_delete(storage);
|
||||
const GapRootSecurityKeys* new_keys = bt_keys_storage_get_root_keys(storage);
|
||||
mu_assert(
|
||||
memcmp(original_keys_copy, new_keys, sizeof(original_keys_copy)) != 0,
|
||||
"Root keys were not regenerated after delete");
|
||||
mu_assert(
|
||||
memcmp(new_keys->irk, gap_legacy_irk, sizeof(gap_legacy_irk)) != 0,
|
||||
"IRK after delete should not match legacy");
|
||||
mu_assert(
|
||||
memcmp(new_keys->erk, gap_legacy_erk, sizeof(gap_legacy_erk)) != 0,
|
||||
"ERK after delete should not match legacy");
|
||||
bt_keys_storage_free(storage);
|
||||
storage_simply_remove(bt_test->storage, BT_TEST_MIGRATION_FILE_PATH);
|
||||
}
|
||||
|
||||
MU_TEST(bt_test_keys_storage_serial_profile) {
|
||||
furi_check(bt_test);
|
||||
|
||||
@@ -96,10 +237,28 @@ MU_TEST(bt_test_keys_storage_serial_profile) {
|
||||
bt_test_keys_remove_test_file();
|
||||
}
|
||||
|
||||
MU_TEST(bt_test_migration_v0_to_v1_test) {
|
||||
furi_check(bt_test);
|
||||
bt_test_migration_v0_to_v1();
|
||||
}
|
||||
|
||||
MU_TEST(bt_test_migration_preserves_pairings_and_keys_test) {
|
||||
furi_check(bt_test);
|
||||
bt_test_migration_preserves_pairings_and_keys();
|
||||
}
|
||||
|
||||
MU_TEST(bt_test_delete_generates_new_keys_and_not_legacy_test) {
|
||||
furi_check(bt_test);
|
||||
bt_test_delete_generates_new_keys_and_not_legacy();
|
||||
}
|
||||
|
||||
MU_TEST_SUITE(test_bt) {
|
||||
bt_test_alloc();
|
||||
|
||||
MU_RUN_TEST(bt_test_keys_storage_serial_profile);
|
||||
MU_RUN_TEST(bt_test_migration_v0_to_v1_test);
|
||||
MU_RUN_TEST(bt_test_migration_preserves_pairings_and_keys_test);
|
||||
MU_RUN_TEST(bt_test_delete_generates_new_keys_and_not_legacy_test);
|
||||
|
||||
bt_test_free();
|
||||
}
|
||||
|
||||
@@ -389,8 +389,8 @@ void minunit_printf_warning(const char* format, ...);
|
||||
__func__, \
|
||||
__FILE__, \
|
||||
__LINE__, \
|
||||
minunit_tmp_e, \
|
||||
minunit_tmp_r, \
|
||||
minunit_tmp_e, \
|
||||
minunit_tmp_m); \
|
||||
minunit_status = 1; \
|
||||
return; \
|
||||
|
||||
@@ -268,9 +268,9 @@ static void mf_ultralight_reader_test(const char* path) {
|
||||
nfc_listener_stop(mfu_listener);
|
||||
nfc_listener_free(mfu_listener);
|
||||
|
||||
mu_assert(
|
||||
mf_ultralight_is_equal(mfu_data, nfc_device_get_data(nfc_device, NfcProtocolMfUltralight)),
|
||||
"Data not matches");
|
||||
MfUltralightData* mfu_other_data =
|
||||
(MfUltralightData*)nfc_device_get_data(nfc_device, NfcProtocolMfUltralight);
|
||||
mu_assert(mf_ultralight_is_equal(mfu_data, mfu_other_data), "Data mismatch");
|
||||
|
||||
mf_ultralight_free(mfu_data);
|
||||
nfc_device_free(nfc_device);
|
||||
|
||||
165
applications/debug/unit_tests/tests/notification/notes_test.c
Normal file
165
applications/debug/unit_tests/tests/notification/notes_test.c
Normal file
@@ -0,0 +1,165 @@
|
||||
#include "../test.h" // IWYU pragma: keep
|
||||
#include <float_tools.h>
|
||||
#include <notification/notification_messages_notes.h>
|
||||
|
||||
void frequency_assert(const char* note_name, const NotificationMessage* message) {
|
||||
double a = notification_messages_notes_frequency_from_name(note_name);
|
||||
double b = message->data.sound.frequency;
|
||||
const double epsilon = message->data.sound.frequency > 5000 ? 0.02f : 0.01f;
|
||||
mu_assert_double_between(b - epsilon, b + epsilon, a);
|
||||
}
|
||||
|
||||
MU_TEST(notification_messages_notes_frequency_from_name_test) {
|
||||
// Upper case
|
||||
mu_check(float_is_equal(
|
||||
notification_messages_notes_frequency_from_name("C0"),
|
||||
notification_messages_notes_frequency_from_name("c0")));
|
||||
|
||||
// Mixed case
|
||||
mu_check(float_is_equal(
|
||||
notification_messages_notes_frequency_from_name("Cs0"),
|
||||
notification_messages_notes_frequency_from_name("cs0")));
|
||||
|
||||
// Check errors
|
||||
mu_check(
|
||||
float_is_equal(notification_messages_notes_frequency_from_name("0"), 0.0)); // Without note
|
||||
mu_check(float_is_equal(
|
||||
notification_messages_notes_frequency_from_name("C"), 0.0)); // Without octave
|
||||
mu_check(float_is_equal(
|
||||
notification_messages_notes_frequency_from_name("C9"), 0.0)); // Unsupported octave
|
||||
mu_check(float_is_equal(
|
||||
notification_messages_notes_frequency_from_name("C10"), 0.0)); // Unsupported octave
|
||||
mu_check(float_is_equal(
|
||||
notification_messages_notes_frequency_from_name("X0"), 0.0)); // Unknown note
|
||||
mu_check(float_is_equal(
|
||||
notification_messages_notes_frequency_from_name("CCC0"), 0.0)); // Note name overflow
|
||||
|
||||
// Notes and structures
|
||||
frequency_assert("c0", &message_note_c0);
|
||||
frequency_assert("cs0", &message_note_cs0);
|
||||
frequency_assert("d0", &message_note_d0);
|
||||
frequency_assert("ds0", &message_note_ds0);
|
||||
frequency_assert("e0", &message_note_e0);
|
||||
frequency_assert("f0", &message_note_f0);
|
||||
frequency_assert("fs0", &message_note_fs0);
|
||||
frequency_assert("g0", &message_note_g0);
|
||||
frequency_assert("gs0", &message_note_gs0);
|
||||
frequency_assert("a0", &message_note_a0);
|
||||
frequency_assert("as0", &message_note_as0);
|
||||
frequency_assert("b0", &message_note_b0);
|
||||
|
||||
frequency_assert("c1", &message_note_c1);
|
||||
frequency_assert("cs1", &message_note_cs1);
|
||||
frequency_assert("d1", &message_note_d1);
|
||||
frequency_assert("ds1", &message_note_ds1);
|
||||
frequency_assert("e1", &message_note_e1);
|
||||
frequency_assert("f1", &message_note_f1);
|
||||
frequency_assert("fs1", &message_note_fs1);
|
||||
frequency_assert("g1", &message_note_g1);
|
||||
frequency_assert("gs1", &message_note_gs1);
|
||||
frequency_assert("a1", &message_note_a1);
|
||||
frequency_assert("as1", &message_note_as1);
|
||||
frequency_assert("b1", &message_note_b1);
|
||||
|
||||
frequency_assert("c2", &message_note_c2);
|
||||
frequency_assert("cs2", &message_note_cs2);
|
||||
frequency_assert("d2", &message_note_d2);
|
||||
frequency_assert("ds2", &message_note_ds2);
|
||||
frequency_assert("e2", &message_note_e2);
|
||||
frequency_assert("f2", &message_note_f2);
|
||||
frequency_assert("fs2", &message_note_fs2);
|
||||
frequency_assert("g2", &message_note_g2);
|
||||
frequency_assert("gs2", &message_note_gs2);
|
||||
frequency_assert("a2", &message_note_a2);
|
||||
frequency_assert("as2", &message_note_as2);
|
||||
frequency_assert("b2", &message_note_b2);
|
||||
|
||||
frequency_assert("c3", &message_note_c3);
|
||||
frequency_assert("cs3", &message_note_cs3);
|
||||
frequency_assert("d3", &message_note_d3);
|
||||
frequency_assert("ds3", &message_note_ds3);
|
||||
frequency_assert("e3", &message_note_e3);
|
||||
frequency_assert("f3", &message_note_f3);
|
||||
frequency_assert("fs3", &message_note_fs3);
|
||||
frequency_assert("g3", &message_note_g3);
|
||||
frequency_assert("gs3", &message_note_gs3);
|
||||
frequency_assert("a3", &message_note_a3);
|
||||
frequency_assert("as3", &message_note_as3);
|
||||
frequency_assert("b3", &message_note_b3);
|
||||
|
||||
frequency_assert("c4", &message_note_c4);
|
||||
frequency_assert("cs4", &message_note_cs4);
|
||||
frequency_assert("d4", &message_note_d4);
|
||||
frequency_assert("ds4", &message_note_ds4);
|
||||
frequency_assert("e4", &message_note_e4);
|
||||
frequency_assert("f4", &message_note_f4);
|
||||
frequency_assert("fs4", &message_note_fs4);
|
||||
frequency_assert("g4", &message_note_g4);
|
||||
frequency_assert("gs4", &message_note_gs4);
|
||||
frequency_assert("a4", &message_note_a4);
|
||||
frequency_assert("as4", &message_note_as4);
|
||||
frequency_assert("b4", &message_note_b4);
|
||||
|
||||
frequency_assert("c5", &message_note_c5);
|
||||
frequency_assert("cs5", &message_note_cs5);
|
||||
frequency_assert("d5", &message_note_d5);
|
||||
frequency_assert("ds5", &message_note_ds5);
|
||||
frequency_assert("e5", &message_note_e5);
|
||||
frequency_assert("f5", &message_note_f5);
|
||||
frequency_assert("fs5", &message_note_fs5);
|
||||
frequency_assert("g5", &message_note_g5);
|
||||
frequency_assert("gs5", &message_note_gs5);
|
||||
frequency_assert("a5", &message_note_a5);
|
||||
frequency_assert("as5", &message_note_as5);
|
||||
frequency_assert("b5", &message_note_b5);
|
||||
|
||||
frequency_assert("c6", &message_note_c6);
|
||||
frequency_assert("cs6", &message_note_cs6);
|
||||
frequency_assert("d6", &message_note_d6);
|
||||
frequency_assert("ds6", &message_note_ds6);
|
||||
frequency_assert("e6", &message_note_e6);
|
||||
frequency_assert("f6", &message_note_f6);
|
||||
frequency_assert("fs6", &message_note_fs6);
|
||||
frequency_assert("g6", &message_note_g6);
|
||||
frequency_assert("gs6", &message_note_gs6);
|
||||
frequency_assert("a6", &message_note_a6);
|
||||
frequency_assert("as6", &message_note_as6);
|
||||
frequency_assert("b6", &message_note_b6);
|
||||
|
||||
frequency_assert("c7", &message_note_c7);
|
||||
frequency_assert("cs7", &message_note_cs7);
|
||||
frequency_assert("d7", &message_note_d7);
|
||||
frequency_assert("ds7", &message_note_ds7);
|
||||
frequency_assert("e7", &message_note_e7);
|
||||
frequency_assert("f7", &message_note_f7);
|
||||
frequency_assert("fs7", &message_note_fs7);
|
||||
frequency_assert("g7", &message_note_g7);
|
||||
frequency_assert("gs7", &message_note_gs7);
|
||||
frequency_assert("a7", &message_note_a7);
|
||||
frequency_assert("as7", &message_note_as7);
|
||||
frequency_assert("b7", &message_note_b7);
|
||||
|
||||
frequency_assert("c8", &message_note_c8);
|
||||
frequency_assert("cs8", &message_note_cs8);
|
||||
frequency_assert("d8", &message_note_d8);
|
||||
frequency_assert("ds8", &message_note_ds8);
|
||||
frequency_assert("e8", &message_note_e8);
|
||||
frequency_assert("f8", &message_note_f8);
|
||||
frequency_assert("fs8", &message_note_fs8);
|
||||
frequency_assert("g8", &message_note_g8);
|
||||
frequency_assert("gs8", &message_note_gs8);
|
||||
frequency_assert("a8", &message_note_a8);
|
||||
frequency_assert("as8", &message_note_as8);
|
||||
frequency_assert("b8", &message_note_b8);
|
||||
}
|
||||
|
||||
MU_TEST_SUITE(notes_suite) {
|
||||
MU_RUN_TEST(notification_messages_notes_frequency_from_name_test);
|
||||
}
|
||||
|
||||
int run_minunit_test_notes(void) {
|
||||
MU_RUN_SUITE(notes_suite);
|
||||
return MU_EXIT_CODE;
|
||||
}
|
||||
|
||||
TEST_API_DEFINE(run_minunit_test_notes)
|
||||
@@ -17,7 +17,7 @@
|
||||
#define NICE_FLOR_S_DIR_NAME EXT_PATH("subghz/assets/nice_flor_s")
|
||||
#define ALUTECH_AT_4N_DIR_NAME EXT_PATH("subghz/assets/alutech_at_4n")
|
||||
#define TEST_RANDOM_DIR_NAME EXT_PATH("unit_tests/subghz/test_random_raw.sub")
|
||||
#define TEST_RANDOM_COUNT_PARSE 329
|
||||
#define TEST_RANDOM_COUNT_PARSE 328
|
||||
#define TEST_TIMEOUT 10000
|
||||
|
||||
static SubGhzEnvironment* environment_handler;
|
||||
@@ -670,6 +670,62 @@ MU_TEST(subghz_decoder_dickert_test) {
|
||||
"Test decoder " SUBGHZ_PROTOCOL_DICKERT_MAHS_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_decoder_legrand_test) {
|
||||
mu_assert(
|
||||
subghz_decoder_test(
|
||||
EXT_PATH("unit_tests/subghz/legrand_raw.sub"), SUBGHZ_PROTOCOL_LEGRAND_NAME),
|
||||
"Test decoder " SUBGHZ_PROTOCOL_LEGRAND_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_decoder_marantec24_test) {
|
||||
mu_assert(
|
||||
subghz_decoder_test(
|
||||
EXT_PATH("unit_tests/subghz/marantec24_raw.sub"), SUBGHZ_PROTOCOL_MARANTEC24_NAME),
|
||||
"Test decoder " SUBGHZ_PROTOCOL_MARANTEC24_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_decoder_roger_test) {
|
||||
mu_assert(
|
||||
subghz_decoder_test(
|
||||
EXT_PATH("unit_tests/subghz/roger_raw.sub"), SUBGHZ_PROTOCOL_ROGER_NAME),
|
||||
"Test decoder " SUBGHZ_PROTOCOL_ROGER_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_decoder_feron_test) {
|
||||
mu_assert(
|
||||
subghz_decoder_test(
|
||||
EXT_PATH("unit_tests/subghz/feron_raw.sub"), SUBGHZ_PROTOCOL_FERON_NAME),
|
||||
"Test decoder " SUBGHZ_PROTOCOL_FERON_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_decoder_gangqi_test) {
|
||||
mu_assert(
|
||||
subghz_decoder_test(
|
||||
EXT_PATH("unit_tests/subghz/gangqi_raw.sub"), SUBGHZ_PROTOCOL_GANGQI_NAME),
|
||||
"Test decoder " SUBGHZ_PROTOCOL_GANGQI_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_decoder_hollarm_test) {
|
||||
mu_assert(
|
||||
subghz_decoder_test(
|
||||
EXT_PATH("unit_tests/subghz/hollarm_raw.sub"), SUBGHZ_PROTOCOL_HOLLARM_NAME),
|
||||
"Test decoder " SUBGHZ_PROTOCOL_HOLLARM_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_decoder_reversrb2_test) {
|
||||
mu_assert(
|
||||
subghz_decoder_test(
|
||||
EXT_PATH("unit_tests/subghz/revers_rb2_raw.sub"), SUBGHZ_PROTOCOL_REVERSRB2_NAME),
|
||||
"Test decoder " SUBGHZ_PROTOCOL_REVERSRB2_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_decoder_hay21_test) {
|
||||
mu_assert(
|
||||
subghz_decoder_test(
|
||||
EXT_PATH("unit_tests/subghz/hay21_raw.sub"), SUBGHZ_PROTOCOL_HAY21_NAME),
|
||||
"Test decoder " SUBGHZ_PROTOCOL_HAY21_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_decoder_solight_te44_test) {
|
||||
mu_assert(
|
||||
subghz_decoder_test(
|
||||
@@ -868,6 +924,48 @@ MU_TEST(subghz_encoder_dickert_test) {
|
||||
"Test encoder " SUBGHZ_PROTOCOL_DICKERT_MAHS_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_encoder_legrand_test) {
|
||||
mu_assert(
|
||||
subghz_encoder_test(EXT_PATH("unit_tests/subghz/legrand.sub")),
|
||||
"Test encoder " SUBGHZ_PROTOCOL_LEGRAND_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_encoder_feron_test) {
|
||||
mu_assert(
|
||||
subghz_encoder_test(EXT_PATH("unit_tests/subghz/feron.sub")),
|
||||
"Test encoder " SUBGHZ_PROTOCOL_FERON_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_encoder_gangqi_test) {
|
||||
mu_assert(
|
||||
subghz_encoder_test(EXT_PATH("unit_tests/subghz/gangqi.sub")),
|
||||
"Test encoder " SUBGHZ_PROTOCOL_GANGQI_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_encoder_hollarm_test) {
|
||||
mu_assert(
|
||||
subghz_encoder_test(EXT_PATH("unit_tests/subghz/hollarm.sub")),
|
||||
"Test encoder " SUBGHZ_PROTOCOL_HOLLARM_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_encoder_reversrb2_test) {
|
||||
mu_assert(
|
||||
subghz_encoder_test(EXT_PATH("unit_tests/subghz/revers_rb2.sub")),
|
||||
"Test encoder " SUBGHZ_PROTOCOL_REVERSRB2_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_encoder_roger_test) {
|
||||
mu_assert(
|
||||
subghz_encoder_test(EXT_PATH("unit_tests/subghz/roger.sub")),
|
||||
"Test encoder " SUBGHZ_PROTOCOL_ROGER_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_encoder_marantec24_test) {
|
||||
mu_assert(
|
||||
subghz_encoder_test(EXT_PATH("unit_tests/subghz/marantec24.sub")),
|
||||
"Test encoder " SUBGHZ_PROTOCOL_MARANTEC24_NAME " error\r\n");
|
||||
}
|
||||
|
||||
MU_TEST(subghz_random_test) {
|
||||
mu_assert(subghz_decode_random_test(TEST_RANDOM_DIR_NAME), "Random test error\r\n");
|
||||
}
|
||||
@@ -920,10 +1018,18 @@ MU_TEST_SUITE(subghz) {
|
||||
MU_RUN_TEST(subghz_decoder_kinggates_stylo4k_test);
|
||||
MU_RUN_TEST(subghz_decoder_mastercode_test);
|
||||
MU_RUN_TEST(subghz_decoder_dickert_test);
|
||||
MU_RUN_TEST(subghz_decoder_solight_te44_test);
|
||||
MU_RUN_TEST(subghz_decoder_bresser_3ch_v1_test);
|
||||
MU_RUN_TEST(subghz_decoder_bresser_3ch_v0_test);
|
||||
MU_RUN_TEST(subghz_decoder_vauno_en8822c_test);
|
||||
MU_RUN_TEST(subghz_decoder_roger_test);
|
||||
MU_RUN_TEST(subghz_decoder_hollarm_test);
|
||||
MU_RUN_TEST(subghz_decoder_reversrb2_test);
|
||||
MU_RUN_TEST(subghz_decoder_gangqi_test);
|
||||
MU_RUN_TEST(subghz_decoder_hay21_test);
|
||||
MU_RUN_TEST(subghz_decoder_feron_test);
|
||||
MU_RUN_TEST(subghz_decoder_legrand_test);
|
||||
MU_RUN_TEST(subghz_decoder_marantec24_test);
|
||||
// MU_RUN_TEST(subghz_decoder_solight_te44_test);
|
||||
// MU_RUN_TEST(subghz_decoder_bresser_3ch_v1_test);
|
||||
// MU_RUN_TEST(subghz_decoder_bresser_3ch_v0_test);
|
||||
// MU_RUN_TEST(subghz_decoder_vauno_en8822c_test);
|
||||
|
||||
MU_RUN_TEST(subghz_encoder_princeton_test);
|
||||
MU_RUN_TEST(subghz_encoder_came_test);
|
||||
@@ -953,6 +1059,13 @@ MU_TEST_SUITE(subghz) {
|
||||
MU_RUN_TEST(subghz_encoder_mastercode_test);
|
||||
MU_RUN_TEST(subghz_decoder_acurite_592txr_test);
|
||||
MU_RUN_TEST(subghz_encoder_dickert_test);
|
||||
MU_RUN_TEST(subghz_encoder_feron_test);
|
||||
MU_RUN_TEST(subghz_encoder_roger_test);
|
||||
MU_RUN_TEST(subghz_encoder_gangqi_test);
|
||||
MU_RUN_TEST(subghz_encoder_marantec24_test);
|
||||
MU_RUN_TEST(subghz_encoder_hollarm_test);
|
||||
MU_RUN_TEST(subghz_encoder_reversrb2_test);
|
||||
MU_RUN_TEST(subghz_encoder_legrand_test);
|
||||
|
||||
MU_RUN_TEST(subghz_random_test);
|
||||
subghz_test_deinit();
|
||||
|
||||
Reference in New Issue
Block a user