diff options
Diffstat (limited to 'test/mfs/source/test/mfs_test_sequence_002.c')
| -rw-r--r-- | test/mfs/source/test/mfs_test_sequence_002.c | 506 |
1 files changed, 459 insertions, 47 deletions
diff --git a/test/mfs/source/test/mfs_test_sequence_002.c b/test/mfs/source/test/mfs_test_sequence_002.c index 735b359df..c75858ea2 100644 --- a/test/mfs/source/test/mfs_test_sequence_002.c +++ b/test/mfs/source/test/mfs_test_sequence_002.c @@ -21,17 +21,18 @@ * @file mfs_test_sequence_002.c
* @brief Test Sequence 002 code.
*
- * @page mfs_test_sequence_002 [2] API Invalid Cases tests
+ * @page mfs_test_sequence_002 [2] Transaction Mode tests
*
* File: @ref mfs_test_sequence_002.c
*
* <h2>Description</h2>
- * This test sequence tests the error coded returned by the various
- * APIs when called when the system is not initialized.
+ * This sequence tests the MFS behavior when used in transaction mode,
+ * correct cases and expected error cases are tested.
*
* <h2>Test Cases</h2>
* - @subpage mfs_test_002_001
* - @subpage mfs_test_002_002
+ * - @subpage mfs_test_002_003
* .
*/
@@ -39,6 +40,7 @@ * Shared code.
****************************************************************************/
+#include <string.h>
#include "hal_mfs.h"
/****************************************************************************
@@ -46,91 +48,277 @@ ****************************************************************************/
/**
- * @page mfs_test_002_001 [2.1] Initialization error from APIs
+ * @page mfs_test_002_001 [2.1] Committing a transaction
*
* <h2>Description</h2>
- * The API functions are invoked without prior initialization.
+ * A set of new/existing records are written/erased within a
+ * transaction then the transaction is committed, the state is checked
+ * afterward.
*
* <h2>Test Steps</h2>
- * - [2.1.1] The function mfsErase() is called, MFS_ERR_INV_STATE is
- * expected.
- * - [2.1.2] The function mfsWriteRecord() is called, MFS_ERR_INV_STATE
+ * - [2.1.1] Records 1, 2 and 3 are created, MFS_NO_ERROR is expected.
+ * - [2.1.2] Presence of records 1, 2 and 3 is verified, MFS_NO_ERROR
* is expected.
- * - [2.1.3] The function mfsEraseRecord() is called, MFS_ERR_INV_STATE
- * is expected.
- * - [2.1.4] The function mfsReadRecord() is called, MFS_ERR_INV_STATE
- * is expected.
- * - [2.1.5] The function mfsPerformGarbageCollection() is called,
- * MFS_ERR_INV_STATE is expected.
+ * - [2.1.3] Starting a transaction with sufficient pre-allocated
+ * space, MFS_NO_ERROR is expected.
+ * - [2.1.4] Atomically erasing record 1, updating record 2, reading
+ * record 3.
+ * - [2.1.5] Committing the transaction, MFS_NO_ERROR is expected.
+ * - [2.1.6] Testing outcome, records 1 must not be present, record 2
+ * must contain the new value and record 3 must be unchanged.
+ * - [2.1.7] Re-mounting the manage storage, MFS_NO_ERROR is expected.
+ * - [2.1.8] Testing outcome again after re-start.
+ * - [2.1.9] Performing a garbage collection, the result must not
+ * change.
+ * - [2.1.10] Testing outcome again after garbage collection.
* .
*/
+static void mfs_test_002_001_setup(void) {
+ bank_erase(MFS_BANK_0);
+ bank_erase(MFS_BANK_1);
+ mfsStart(&mfs1, &mfscfg1);
+}
+
+static void mfs_test_002_001_teardown(void) {
+ mfsStop(&mfs1);
+}
+
static void mfs_test_002_001_execute(void) {
+ uint32_t current_counter;
+ uint32_t used_space;
- /* [2.1.1] The function mfsErase() is called, MFS_ERR_INV_STATE is
+ /* [2.1.1] Records 1, 2 and 3 are created, MFS_NO_ERROR is
expected.*/
test_set_step(1);
{
- mfs_error_t err = mfsErase(&mfs1);
- test_assert(err == MFS_ERR_INV_STATE, "mfsErase() returned wrong status");
+ mfs_error_t err;
+
+ err = mfsWriteRecord(&mfs1, 1, sizeof mfs_pattern16, mfs_pattern16);
+ test_assert(err == MFS_NO_ERROR, "error creating record 1");
+ err = mfsWriteRecord(&mfs1, 2, sizeof mfs_pattern16, mfs_pattern16);
+ test_assert(err == MFS_NO_ERROR, "error creating record 2");
+ err = mfsWriteRecord(&mfs1, 3, sizeof mfs_pattern16, mfs_pattern16);
+ test_assert(err == MFS_NO_ERROR, "error creating record 3");
}
+ test_end_step(1);
- /* [2.1.2] The function mfsWriteRecord() is called, MFS_ERR_INV_STATE
+ /* [2.1.2] Presence of records 1, 2 and 3 is verified, MFS_NO_ERROR
is expected.*/
test_set_step(2);
{
- mfs_error_t err = mfsWriteRecord(&mfs1, 1, 16, mfs_buffer);
- test_assert(err == MFS_ERR_INV_STATE, "mfsWriteRecord() returned wrong status");
+ mfs_error_t err;
+ size_t size;
+
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 1, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 2, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 3, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
}
+ test_end_step(2);
- /* [2.1.3] The function mfsEraseRecord() is called, MFS_ERR_INV_STATE
- is expected.*/
+ /* [2.1.3] Starting a transaction with sufficient pre-allocated
+ space, MFS_NO_ERROR is expected.*/
test_set_step(3);
{
- mfs_error_t err = mfsEraseRecord(&mfs1, 1);
- test_assert(err == MFS_ERR_INV_STATE, "mfsEraseRecord() returned wrong status");
+ mfs_error_t err;
+
+ err = mfsStartTransaction(&mfs1, 1024U);
+ test_assert(err == MFS_NO_ERROR, "error starting transaction");
}
+ test_end_step(3);
- /* [2.1.4] The function mfsReadRecord() is called, MFS_ERR_INV_STATE
- is expected.*/
+ /* [2.1.4] Atomically erasing record 1, updating record 2, reading
+ record 3.*/
test_set_step(4);
{
- size_t size = sizeof mfs_buffer;
- mfs_error_t err = mfsReadRecord(&mfs1, 1, &size, mfs_buffer);
- test_assert(err == MFS_ERR_INV_STATE, "mfsReadRecord() returned wrong status");
+ mfs_error_t err;
+ size_t size;
+
+ err = mfsEraseRecord(&mfs1, 1);
+ test_assert(err == MFS_NO_ERROR, "error erasing record 1");
+ err = mfsWriteRecord(&mfs1, 2, sizeof mfs_pattern32, mfs_pattern32);
+ test_assert(err == MFS_NO_ERROR, "error writing record 2");
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 3, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ test_assert(size == sizeof mfs_pattern16, "unexpected record length");
+ test_assert(memcmp(mfs_pattern16, mfs_buffer, size) == 0, "wrong record content");
}
+ test_end_step(4);
- /* [2.1.5] The function mfsPerformGarbageCollection() is called,
- MFS_ERR_INV_STATE is expected.*/
+ /* [2.1.5] Committing the transaction, MFS_NO_ERROR is expected.*/
test_set_step(5);
{
- mfs_error_t err = mfsPerformGarbageCollection(&mfs1);
- test_assert(err == MFS_ERR_INV_STATE, "mfsPerformGarbageCollection() returned wrong status");
+ mfs_error_t err;
+
+ err = mfsCommitTransaction(&mfs1);
+ test_assert(err == MFS_NO_ERROR, "error committing transaction");
+
+ /* Saving some internal state for successive checks.*/
+ current_counter = mfs1.current_counter;
+ used_space = mfs1.used_space;
+ }
+ test_end_step(5);
+
+ /* [2.1.6] Testing outcome, records 1 must not be present, record 2
+ must contain the new value and record 3 must be unchanged.*/
+ test_set_step(6);
+ {
+ mfs_error_t err;
+ size_t size;
+
+ /* Record 1 must not be present.*/
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 1, &size, mfs_buffer);
+ test_assert(err == MFS_ERR_NOT_FOUND, "record found");
+
+ /* Record 2 must contain the new value.*/
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 2, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ test_assert(size == sizeof mfs_pattern32, "unexpected record length");
+ test_assert(memcmp(mfs_pattern32, mfs_buffer, size) == 0, "wrong record content");
+
+ /* Record 3 must be unchanged.*/
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 3, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ test_assert(size == sizeof mfs_pattern16, "unexpected record length");
+ test_assert(memcmp(mfs_pattern16, mfs_buffer, size) == 0, "wrong record content");
+
+ /* Checking internal data.*/
+ test_assert(MFS_BANK_0 == mfs1.current_bank, "internal data mismatch");
+ test_assert(current_counter == mfs1.current_counter, "internal data mismatch");
+ test_assert(used_space == mfs1.used_space, "internal data mismatch");
+ }
+ test_end_step(6);
+
+ /* [2.1.7] Re-mounting the manage storage, MFS_NO_ERROR is
+ expected.*/
+ test_set_step(7);
+ {
+ mfs_error_t err;
+
+ err = mfsStart(&mfs1, &mfscfg1);
+ test_assert(err == MFS_NO_ERROR, "re-start failed");
+ }
+ test_end_step(7);
+
+ /* [2.1.8] Testing outcome again after re-start.*/
+ test_set_step(8);
+ {
+ mfs_error_t err;
+ size_t size;
+
+ /* Record 1 must not be present.*/
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 1, &size, mfs_buffer);
+ test_assert(err == MFS_ERR_NOT_FOUND, "record found");
+
+ /* Record 2 must contain the new value.*/
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 2, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ test_assert(size == sizeof mfs_pattern32, "unexpected record length");
+ test_assert(memcmp(mfs_pattern32, mfs_buffer, size) == 0, "wrong record content");
+
+ /* Record 3 must be unchanged.*/
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 3, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ test_assert(size == sizeof mfs_pattern16, "unexpected record length");
+ test_assert(memcmp(mfs_pattern16, mfs_buffer, size) == 0, "wrong record content");
+
+ /* Checking internal data.*/
+ test_assert(MFS_BANK_0 == mfs1.current_bank, "internal data mismatch");
+ test_assert(current_counter == mfs1.current_counter, "internal data mismatch");
+ test_assert(used_space == mfs1.used_space, "internal data mismatch");
+ }
+ test_end_step(8);
+
+ /* [2.1.9] Performing a garbage collection, the result must not
+ change.*/
+ test_set_step(9);
+ {
+ mfs_error_t err;
+
+ err = mfsPerformGarbageCollection(&mfs1);
+ test_assert(err == MFS_NO_ERROR, "garbage collection failed");
+ }
+ test_end_step(9);
+
+ /* [2.1.10] Testing outcome again after garbage collection.*/
+ test_set_step(10);
+ {
+ mfs_error_t err;
+ size_t size;
+
+ /* Record 1 must not be present.*/
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 1, &size, mfs_buffer);
+ test_assert(err == MFS_ERR_NOT_FOUND, "record found");
+
+ /* Record 2 must contain the new value.*/
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 2, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ test_assert(size == sizeof mfs_pattern32, "unexpected record length");
+ test_assert(memcmp(mfs_pattern32, mfs_buffer, size) == 0, "wrong record content");
+
+ /* Record 3 must be unchanged.*/
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 3, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ test_assert(size == sizeof mfs_pattern16, "unexpected record length");
+ test_assert(memcmp(mfs_pattern16, mfs_buffer, size) == 0, "wrong record content");
+
+ /* Checking internal data.*/
+ test_assert(MFS_BANK_1 == mfs1.current_bank, "internal data mismatch");
+ test_assert(current_counter == mfs1.current_counter - 1, "internal data mismatch");
+ test_assert(used_space == mfs1.used_space, "internal data mismatch");
}
+ test_end_step(10);
}
static const testcase_t mfs_test_002_001 = {
- "Initialization error from APIs",
- NULL,
- NULL,
+ "Committing a transaction",
+ mfs_test_002_001_setup,
+ mfs_test_002_001_teardown,
mfs_test_002_001_execute
};
/**
- * @page mfs_test_002_002 [2.2] Erasing non existing record
+ * @page mfs_test_002_002 [2.2] Rolling back a transaction
*
* <h2>Description</h2>
- * An erase operation is attempted on an non-existing record.
+ * A set of new/existing records are written/erased within a
+ * transaction then the transaction is rolled back, the state is
+ * checked afterward.
*
* <h2>Test Steps</h2>
- * - [2.2.1] Record one is erased, the error MFS_ERR_NOT_FOUND is
- * expected.
+ * - [2.2.1] Records 1, 2 and 3 are created, MFS_NO_ERROR is expected.
+ * - [2.2.2] Presence of records 1, 2 and 3 is verified, MFS_NO_ERROR
+ * is expected.
+ * - [2.2.3] Starting a transaction with sufficient pre-allocated
+ * space, MFS_NO_ERROR is expected..
+ * - [2.2.4] Atomically erasing record 1, updating record 2, reading
+ * record 3.
+ * - [2.2.5] Rolling back the transaction, MFS_NO_ERROR is expected.
+ * - [2.2.6] State must not have changed, records 1, 2 and 3 must still
+ * be there unchanged.
* .
*/
static void mfs_test_002_002_setup(void) {
+ bank_erase(MFS_BANK_0);
+ bank_erase(MFS_BANK_1);
mfsStart(&mfs1, &mfscfg1);
- mfsErase(&mfs1);
}
static void mfs_test_002_002_teardown(void) {
@@ -138,26 +326,249 @@ static void mfs_test_002_002_teardown(void) { }
static void mfs_test_002_002_execute(void) {
+ uint32_t current_counter;
+ uint32_t used_space;
- /* [2.2.1] Record one is erased, the error MFS_ERR_NOT_FOUND is
+ /* [2.2.1] Records 1, 2 and 3 are created, MFS_NO_ERROR is
expected.*/
test_set_step(1);
{
mfs_error_t err;
+ err = mfsWriteRecord(&mfs1, 1, sizeof mfs_pattern16, mfs_pattern16);
+ test_assert(err == MFS_NO_ERROR, "error creating record 1");
+ err = mfsWriteRecord(&mfs1, 2, sizeof mfs_pattern16, mfs_pattern16);
+ test_assert(err == MFS_NO_ERROR, "error creating record 2");
+ err = mfsWriteRecord(&mfs1, 3, sizeof mfs_pattern16, mfs_pattern16);
+ test_assert(err == MFS_NO_ERROR, "error creating record 3");
+ }
+ test_end_step(1);
+
+ /* [2.2.2] Presence of records 1, 2 and 3 is verified, MFS_NO_ERROR
+ is expected.*/
+ test_set_step(2);
+ {
+ mfs_error_t err;
+ size_t size;
+
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 1, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 2, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 3, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ }
+ test_end_step(2);
+
+ /* [2.2.3] Starting a transaction with sufficient pre-allocated
+ space, MFS_NO_ERROR is expected..*/
+ test_set_step(3);
+ {
+ mfs_error_t err;
+
+ err = mfsStartTransaction(&mfs1, 1024U);
+ test_assert(err == MFS_NO_ERROR, "error starting transaction");
+ }
+ test_end_step(3);
+
+ /* [2.2.4] Atomically erasing record 1, updating record 2, reading
+ record 3.*/
+ test_set_step(4);
+ {
+ mfs_error_t err;
+ size_t size;
+
err = mfsEraseRecord(&mfs1, 1);
- test_assert(err != MFS_NO_ERROR, "record was present");
- test_assert(err == MFS_ERR_NOT_FOUND, "invalid error code");
+ test_assert(err == MFS_NO_ERROR, "error erasing record 1");
+ err = mfsWriteRecord(&mfs1, 2, sizeof mfs_pattern32, mfs_pattern32);
+ test_assert(err == MFS_NO_ERROR, "error writing record 2");
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 3, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ test_assert(size == sizeof mfs_pattern16, "unexpected record length");
+ test_assert(memcmp(mfs_pattern16, mfs_buffer, size) == 0, "wrong record content");
+
+ /* Saving some internal state for successive checks.*/
+ current_counter = mfs1.current_counter;
+ used_space = mfs1.used_space;
+ }
+ test_end_step(4);
+
+ /* [2.2.5] Rolling back the transaction, MFS_NO_ERROR is expected.*/
+ test_set_step(5);
+ {
+ mfs_error_t err;
+
+ err = mfsRollbackTransaction(&mfs1);
+ test_assert(err == MFS_NO_ERROR, "error rolling back transaction");
+ }
+ test_end_step(5);
+
+ /* [2.2.6] State must not have changed, records 1, 2 and 3 must still
+ be there unchanged.*/
+ test_set_step(6);
+ {
+ mfs_error_t err;
+ size_t size;
+
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 1, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ test_assert(size == sizeof mfs_pattern16, "size changed");
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 2, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ test_assert(size == sizeof mfs_pattern16, "size changed");
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 3, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR, "record not found");
+ test_assert(size == sizeof mfs_pattern16, "size changed");
+
+ /* Checking internal data.*/
+ test_assert(MFS_BANK_1 == mfs1.current_bank, "internal data mismatch");
+ test_assert(current_counter == mfs1.current_counter - 1, "internal data mismatch");
+ test_assert(used_space == mfs1.used_space, "internal data mismatch");
}
+ test_end_step(6);
}
static const testcase_t mfs_test_002_002 = {
- "Erasing non existing record",
+ "Rolling back a transaction",
mfs_test_002_002_setup,
mfs_test_002_002_teardown,
mfs_test_002_002_execute
};
+/**
+ * @page mfs_test_002_003 [2.3] Transaction triggering an early garbage collect
+ *
+ * <h2>Description</h2>
+ * A transaction is started with sufficient space but not contiguous, a
+ * garbage collection is triggered.
+ *
+ * <h2>Test Steps</h2>
+ * - [2.3.1] Filling up the storage by writing records with increasing
+ * IDs, MFS_NO_ERROR is expected.
+ * - [2.3.2] Erasing one record, MFS_NO_ERROR is expected.
+ * - [2.3.3] Starting a transaction with the whole remaining space,
+ * MFS_ERR_OUT_OF_MEM is expected.
+ * - [2.3.4] Starting a transaction with insufficient space for one
+ * more header, MFS_ERR_OUT_OF_MEM is expected.
+ * - [2.3.5] Starting a transaction with just enough space for one more
+ * header, MFS_NO_ERROR is expected.
+ * - [2.3.6] Rolling back, MFS_NO_ERROR is expected.
+ * .
+ */
+
+static void mfs_test_002_003_setup(void) {
+ bank_erase(MFS_BANK_0);
+ bank_erase(MFS_BANK_1);
+ mfsStart(&mfs1, &mfscfg1);
+}
+
+static void mfs_test_002_003_teardown(void) {
+ mfsStop(&mfs1);
+}
+
+static void mfs_test_002_003_execute(void) {
+
+ /* [2.3.1] Filling up the storage by writing records with increasing
+ IDs, MFS_NO_ERROR is expected.*/
+ test_set_step(1);
+ {
+ mfs_id_t id;
+ mfs_id_t id_max = (mfscfg1.bank_size - sizeof (mfs_bank_header_t)) /
+ (sizeof (mfs_data_header_t) + sizeof mfs_pattern512);
+
+ for (id = 1; id <= id_max; id++) {
+ mfs_error_t err;
+ size_t size;
+
+ err = mfsWriteRecord(&mfs1, id, sizeof mfs_pattern512, mfs_pattern512);
+ test_assert(err == MFS_NO_ERROR, "error creating the record");
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, id, &size, mfs_buffer);
+ test_assert(err == MFS_NO_ERROR,
+ "record not found");
+ test_assert(size == sizeof mfs_pattern512,
+ "unexpected record length");
+ test_assert(memcmp(mfs_pattern512, mfs_buffer, size) == 0,
+ "wrong record content");
+ }
+ }
+ test_end_step(1);
+
+ /* [2.3.2] Erasing one record, MFS_NO_ERROR is expected.*/
+ test_set_step(2);
+ {
+ mfs_error_t err;
+ size_t size;
+
+ err = mfsEraseRecord(&mfs1, 1);
+ test_assert(err == MFS_NO_ERROR, "error erasing the record");
+ size = sizeof mfs_buffer;
+ err = mfsReadRecord(&mfs1, 1, &size, mfs_buffer);
+ test_assert(err == MFS_ERR_NOT_FOUND, "record not erased");
+ }
+ test_end_step(2);
+
+ /* [2.3.3] Starting a transaction with the whole remaining space,
+ MFS_ERR_OUT_OF_MEM is expected.*/
+ test_set_step(3);
+ {
+ mfs_error_t err;
+ size_t size = mfs1.config->bank_size - mfs1.used_space;
+
+ err = mfsStartTransaction(&mfs1, size);
+ test_assert(err == MFS_ERR_OUT_OF_MEM, "invalid error code");
+ }
+ test_end_step(3);
+
+ /* [2.3.4] Starting a transaction with insufficient space for one
+ more header, MFS_ERR_OUT_OF_MEM is expected.*/
+ test_set_step(4);
+ {
+ mfs_error_t err;
+ size_t size = ((mfs1.config->bank_size - mfs1.used_space) - sizeof (mfs_data_header_t)) + 1;
+
+ err = mfsStartTransaction(&mfs1, size);
+ test_assert(err == MFS_ERR_OUT_OF_MEM, "invalid error code");
+ }
+ test_end_step(4);
+
+ /* [2.3.5] Starting a transaction with just enough space for one more
+ header, MFS_NO_ERROR is expected.*/
+ test_set_step(5);
+ {
+ mfs_error_t err;
+ size_t size = (mfs1.config->bank_size - mfs1.used_space) - sizeof (mfs_data_header_t);
+
+ err = mfsStartTransaction(&mfs1, size);
+ test_assert(err == MFS_NO_ERROR, "error starting transaction");
+ }
+ test_end_step(5);
+
+ /* [2.3.6] Rolling back, MFS_NO_ERROR is expected.*/
+ test_set_step(6);
+ {
+ mfs_error_t err;
+
+ err = mfsRollbackTransaction(&mfs1);
+ test_assert(err == MFS_NO_ERROR, "error rolling back transaction");
+ }
+ test_end_step(6);
+}
+
+static const testcase_t mfs_test_002_003 = {
+ "Transaction triggering an early garbage collect",
+ mfs_test_002_003_setup,
+ mfs_test_002_003_teardown,
+ mfs_test_002_003_execute
+};
+
/****************************************************************************
* Exported data.
****************************************************************************/
@@ -168,13 +579,14 @@ static const testcase_t mfs_test_002_002 = { const testcase_t * const mfs_test_sequence_002_array[] = {
&mfs_test_002_001,
&mfs_test_002_002,
+ &mfs_test_002_003,
NULL
};
/**
- * @brief API Invalid Cases tests.
+ * @brief Transaction Mode tests.
*/
const testsequence_t mfs_test_sequence_002 = {
- "API Invalid Cases tests",
+ "Transaction Mode tests",
mfs_test_sequence_002_array
};
|