alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2025-10-04 04:19:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(esp_partition): add error-returning variants for partition find APIs

Browse Source 
Add esp_partition_find_err() and esp_partition_find_first_err() to provide
error reporting while maintaining backward compatibility.

Closes https://github.com/espressif/esp-idf/issues/9281
This commit is contained in:
sonika.rathi
2025-09-22 12:03:58 +02:00
parent 9ef6d3eac4
commit 5b65634b49
4 changed files with 442 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
components/esp_partition/test/test_partition.c
View File

@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2016-2022 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2016-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -44,6 +44,150 @@ TEST_CASE("Can read partition table", "[partition]")
TEST_ASSERT_EQUAL(8, count);
}
TEST_CASE("Test esp_partition_find_err API", "[partition]")
{
// Test successful partition finding
esp_partition_iterator_t iter = NULL;
esp_err_t err = esp_partition_find_err(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_ANY, NULL, &iter);
TEST_ASSERT_EQUAL(ESP_OK, err);
TEST_ASSERT_NOT_NULL(iter);
const esp_partition_t *part = esp_partition_get(iter);
TEST_ASSERT_NOT_NULL(part);
TEST_ASSERT_EQUAL(ESP_PARTITION_TYPE_APP, part->type);
esp_partition_iterator_release(iter);
// Test partition not found (returns ESP_ERR_NOT_FOUND)
err = esp_partition_find_err(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, "nonexistent_partition", &iter);
TEST_ASSERT_EQUAL(ESP_ERR_NOT_FOUND, err);
TEST_ASSERT_NULL(iter);
// Test invalid argument - wrong type/subtype combination
err = esp_partition_find_err(ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_APP_FACTORY, NULL, &iter);
TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, err);
TEST_ASSERT_NULL(iter);
// Test NULL pointer argument
err = esp_partition_find_err(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_ANY, NULL, NULL);
TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, err);
TEST_ASSERT_NULL(iter);
// Test finding data partitions with error reporting
iter = NULL;
err = esp_partition_find_err(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, NULL, &iter);
TEST_ASSERT_EQUAL(ESP_OK, err);
TEST_ASSERT_NOT_NULL(iter);
int data_count = 0;
for (; iter != NULL; iter = esp_partition_next(iter)) {
const esp_partition_t *data_part = esp_partition_get(iter);
TEST_ASSERT_NOT_NULL(data_part);
TEST_ASSERT_EQUAL(ESP_PARTITION_TYPE_DATA, data_part->type);
data_count++;
}
esp_partition_iterator_release(iter);
TEST_ASSERT_TRUE(data_count > 0);
}
TEST_CASE("Test esp_partition_find_first_err API", "[partition]")
{
// Test successful partition finding
const esp_partition_t *part = NULL;
esp_err_t err = esp_partition_find_first_err(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_ANY, NULL, &part);
TEST_ASSERT_EQUAL(ESP_OK, err);
TEST_ASSERT_NOT_NULL(part);
TEST_ASSERT_EQUAL(ESP_PARTITION_TYPE_APP, part->type);
TEST_ASSERT_EQUAL(0x20000, part->address);
TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_FACTORY, part->subtype);
// Test finding specific factory partition
part = NULL;
err = esp_partition_find_first_err(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_APP_FACTORY, NULL, &part);
TEST_ASSERT_EQUAL(ESP_OK, err);
TEST_ASSERT_NOT_NULL(part);
TEST_ASSERT_EQUAL(ESP_PARTITION_SUBTYPE_APP_FACTORY, part->subtype);
// Test partition not found (returns ESP_ERR_NOT_FOUND)
err = esp_partition_find_first_err(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, "nonexistent_partition", &part);
TEST_ASSERT_EQUAL(ESP_ERR_NOT_FOUND, err);
TEST_ASSERT_NULL(part);
// Test invalid argument - wrong type/subtype combination
err = esp_partition_find_first_err(ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_APP_FACTORY, NULL, &part);
TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, err);
TEST_ASSERT_NULL(part);
// Test NULL pointer argument
err = esp_partition_find_first_err(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_ANY, NULL, NULL);
TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, err);
// Test finding data partitions
part = NULL;
err = esp_partition_find_first_err(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, NULL, &part);
TEST_ASSERT_EQUAL(ESP_OK, err);
TEST_ASSERT_NOT_NULL(part);
TEST_ASSERT_EQUAL(ESP_PARTITION_TYPE_DATA, part->type);
// Compare with legacy API to ensure consistency
const esp_partition_t *legacy_part = esp_partition_find_first(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_ANY, NULL);
part = NULL;
err = esp_partition_find_first_err(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_ANY, NULL, &part);
TEST_ASSERT_EQUAL(ESP_OK, err);
TEST_ASSERT_EQUAL(legacy_part, part); // Should return the same partition
}
TEST_CASE("Test esp_partition_verify_err API", "[partition]")
{
// Test successful partition verification
const esp_partition_t *app_part = esp_partition_find_first(ESP_PARTITION_TYPE_APP, ESP_PARTITION_SUBTYPE_ANY, NULL);
TEST_ASSERT_NOT_NULL(app_part);
const esp_partition_t *verified_part = NULL;
esp_err_t err = esp_partition_verify_err(app_part, &verified_part);
TEST_ASSERT_EQUAL(ESP_OK, err);
TEST_ASSERT_NOT_NULL(verified_part);
TEST_ASSERT_EQUAL(app_part, verified_part); // Should return the same partition pointer
// Test both parameters NULL
err = esp_partition_verify_err(NULL, NULL);
TEST_ASSERT_EQUAL(ESP_ERR_INVALID_ARG, err);
// Test with wrong address (should not match)
esp_partition_t app_copy = *app_part;
app_copy.address = 0xFFFFFFFF;
err = esp_partition_verify_err(&app_copy, &verified_part);
TEST_ASSERT_EQUAL(ESP_ERR_NOT_FOUND, err);
TEST_ASSERT_NULL(verified_part);
// Test with wrong type (should not match)
app_copy = *app_part;
app_copy.type = ESP_PARTITION_TYPE_DATA;
err = esp_partition_verify_err(&app_copy, &verified_part);
TEST_ASSERT_EQUAL(ESP_ERR_NOT_FOUND, err);
TEST_ASSERT_NULL(verified_part);
// Test with different readonly flag (should not match)
app_copy = *app_part;
app_copy.readonly = !app_part->readonly;
err = esp_partition_verify_err(&app_copy, &verified_part);
TEST_ASSERT_EQUAL(ESP_ERR_NOT_FOUND, err);
TEST_ASSERT_NULL(verified_part);
// Test output parameter is properly initialized
verified_part = (const esp_partition_t *)0xDEADBEEF;
err = esp_partition_verify_err(&app_copy, &verified_part);
TEST_ASSERT_EQUAL(ESP_ERR_NOT_FOUND, err);
TEST_ASSERT_NULL(verified_part); // Should be set to NULL
// Compare with legacy API for consistency
const esp_partition_t *legacy_verified = esp_partition_verify(app_part);
verified_part = NULL;
err = esp_partition_verify_err(app_part, &verified_part);
TEST_ASSERT_EQUAL(ESP_OK, err);
TEST_ASSERT_EQUAL(legacy_verified, verified_part);
}
TEST_CASE("Can write, read, mmap partition", "[partition][ignore]")
{
const esp_partition_t *p = get_test_data_partition();