|
@@ -14,8 +14,11 @@
|
|
|
|
|
|
#define BUF_SIZE 0x100
|
|
|
|
|
|
+/* Declare a new mem test */
|
|
|
+#define MEM_TEST(_name, _flags) UNIT_TEST(_name, _flags, mem_test)
|
|
|
+
|
|
|
/* Test 'ms' command with bytes */
|
|
|
-static int dm_test_ms_b(struct unit_test_state *uts)
|
|
|
+static int mem_test_ms_b(struct unit_test_state *uts)
|
|
|
{
|
|
|
u8 *buf;
|
|
|
|
|
@@ -25,7 +28,7 @@ static int dm_test_ms_b(struct unit_test_state *uts)
|
|
|
buf[0x31] = 0x12;
|
|
|
buf[0xff] = 0x12;
|
|
|
buf[0x100] = 0x12;
|
|
|
- console_record_reset();
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
run_command("ms.b 1 ff 12", 0);
|
|
|
ut_assert_nextline("00000030: 00 12 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................");
|
|
|
ut_assert_nextline("--");
|
|
@@ -41,10 +44,10 @@ static int dm_test_ms_b(struct unit_test_state *uts)
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
-DM_TEST(dm_test_ms_b, 0);
|
|
|
+MEM_TEST(mem_test_ms_b, UT_TESTF_CONSOLE_REC);
|
|
|
|
|
|
/* Test 'ms' command with 16-bit values */
|
|
|
-static int dm_test_ms_w(struct unit_test_state *uts)
|
|
|
+static int mem_test_ms_w(struct unit_test_state *uts)
|
|
|
{
|
|
|
u16 *buf;
|
|
|
|
|
@@ -52,7 +55,7 @@ static int dm_test_ms_w(struct unit_test_state *uts)
|
|
|
memset(buf, '\0', BUF_SIZE);
|
|
|
buf[0x34 / 2] = 0x1234;
|
|
|
buf[BUF_SIZE / 2] = 0x1234;
|
|
|
- console_record_reset();
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
run_command("ms.w 0 80 1234", 0);
|
|
|
ut_assert_nextline("00000030: 0000 0000 1234 0000 0000 0000 0000 0000 ....4...........");
|
|
|
ut_assert_nextline("1 match");
|
|
@@ -66,10 +69,10 @@ static int dm_test_ms_w(struct unit_test_state *uts)
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
-DM_TEST(dm_test_ms_w, 0);
|
|
|
+MEM_TEST(mem_test_ms_w, UT_TESTF_CONSOLE_REC);
|
|
|
|
|
|
/* Test 'ms' command with 32-bit values */
|
|
|
-static int dm_test_ms_l(struct unit_test_state *uts)
|
|
|
+static int mem_test_ms_l(struct unit_test_state *uts)
|
|
|
{
|
|
|
u32 *buf;
|
|
|
|
|
@@ -77,7 +80,7 @@ static int dm_test_ms_l(struct unit_test_state *uts)
|
|
|
memset(buf, '\0', BUF_SIZE);
|
|
|
buf[0x38 / 4] = 0x12345678;
|
|
|
buf[BUF_SIZE / 4] = 0x12345678;
|
|
|
- console_record_reset();
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
run_command("ms 0 40 12345678", 0);
|
|
|
ut_assert_nextline("00000030: 00000000 00000000 12345678 00000000 ........xV4.....");
|
|
|
ut_assert_nextline("1 match");
|
|
@@ -87,7 +90,7 @@ static int dm_test_ms_l(struct unit_test_state *uts)
|
|
|
ut_asserteq(0x38, env_get_hex("memaddr", 0));
|
|
|
ut_asserteq(0x38 / 4, env_get_hex("mempos", 0));
|
|
|
|
|
|
- console_record_reset();
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
run_command("ms 0 80 12345679", 0);
|
|
|
ut_assert_nextline("0 matches");
|
|
|
ut_assert_console_end();
|
|
@@ -100,10 +103,10 @@ static int dm_test_ms_l(struct unit_test_state *uts)
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
-DM_TEST(dm_test_ms_l, 0);
|
|
|
+MEM_TEST(mem_test_ms_l, UT_TESTF_CONSOLE_REC);
|
|
|
|
|
|
/* Test 'ms' command with continuation */
|
|
|
-static int dm_test_ms_cont(struct unit_test_state *uts)
|
|
|
+static int mem_test_ms_cont(struct unit_test_state *uts)
|
|
|
{
|
|
|
char *const args[] = {"ms.b", "0", "100", "34"};
|
|
|
int repeatable;
|
|
@@ -114,7 +117,7 @@ static int dm_test_ms_cont(struct unit_test_state *uts)
|
|
|
memset(buf, '\0', BUF_SIZE);
|
|
|
for (i = 5; i < 0x33; i += 3)
|
|
|
buf[i] = 0x34;
|
|
|
- console_record_reset();
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
run_command("ms.b 0 100 34", 0);
|
|
|
ut_assert_nextlinen("00000000: 00 00 00 00 00 34 00 00 34 00 00 34 00 00 34 00");
|
|
|
ut_assert_nextline("--");
|
|
@@ -132,7 +135,7 @@ static int dm_test_ms_cont(struct unit_test_state *uts)
|
|
|
* run_command() ignoes the repeatable flag when using hush, so call
|
|
|
* cmd_process() directly
|
|
|
*/
|
|
|
- console_record_reset();
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
cmd_process(CMD_FLAG_REPEAT, 4, args, &repeatable, NULL);
|
|
|
ut_assert_nextlinen("00000020: 34 00 00 34 00 00 34 00 00 34 00 00 34 00 00 34");
|
|
|
ut_assert_nextline("--");
|
|
@@ -150,10 +153,54 @@ static int dm_test_ms_cont(struct unit_test_state *uts)
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
-DM_TEST(dm_test_ms_cont, 0);
|
|
|
+MEM_TEST(mem_test_ms_cont, UT_TESTF_CONSOLE_REC);
|
|
|
+
|
|
|
+/* Test that an 'ms' command with continuation stops at the end of the range */
|
|
|
+static int mem_test_ms_cont_end(struct unit_test_state *uts)
|
|
|
+{
|
|
|
+ char *const args[] = {"ms.b", "1", "ff", "12"};
|
|
|
+ int repeatable;
|
|
|
+ u8 *buf;
|
|
|
+
|
|
|
+ buf = map_sysmem(0, BUF_SIZE);
|
|
|
+ memset(buf, '\0', BUF_SIZE);
|
|
|
+ buf[0x0] = 0x12;
|
|
|
+ buf[0x31] = 0x12;
|
|
|
+ buf[0xff] = 0x12;
|
|
|
+ buf[0x100] = 0x12;
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
+ run_command("ms.b 1 ff 12", 0);
|
|
|
+ ut_assert_nextlinen("00000030");
|
|
|
+ ut_assert_nextlinen("--");
|
|
|
+ ut_assert_nextlinen("000000f0");
|
|
|
+ ut_assert_nextlinen("2 matches");
|
|
|
+ ut_assert_console_end();
|
|
|
+
|
|
|
+ /*
|
|
|
+ * run_command() ignoes the repeatable flag when using hush, so call
|
|
|
+ * cmd_process() directly.
|
|
|
+ *
|
|
|
+ * This should produce no matches.
|
|
|
+ */
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
+ cmd_process(CMD_FLAG_REPEAT, 4, args, &repeatable, NULL);
|
|
|
+ ut_assert_nextlinen("0 matches");
|
|
|
+ ut_assert_console_end();
|
|
|
+
|
|
|
+ /* One more time */
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
+ cmd_process(CMD_FLAG_REPEAT, 4, args, &repeatable, NULL);
|
|
|
+ ut_assert_nextlinen("0 matches");
|
|
|
+ ut_assert_console_end();
|
|
|
+
|
|
|
+ unmap_sysmem(buf);
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+MEM_TEST(mem_test_ms_cont_end, UT_TESTF_CONSOLE_REC);
|
|
|
|
|
|
/* Test 'ms' command with multiple values */
|
|
|
-static int dm_test_ms_mult(struct unit_test_state *uts)
|
|
|
+static int mem_test_ms_mult(struct unit_test_state *uts)
|
|
|
{
|
|
|
static const char str[] = "hello";
|
|
|
char *buf;
|
|
@@ -163,7 +210,7 @@ static int dm_test_ms_mult(struct unit_test_state *uts)
|
|
|
strcpy(buf + 0x1e, str);
|
|
|
strcpy(buf + 0x63, str);
|
|
|
strcpy(buf + BUF_SIZE - strlen(str) + 1, str);
|
|
|
- console_record_reset();
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
run_command("ms.b 0 100 68 65 6c 6c 6f", 0);
|
|
|
ut_assert_nextline("00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 68 65 ..............he");
|
|
|
ut_assert_nextline("00000020: 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 00 00 llo.............");
|
|
@@ -179,10 +226,10 @@ static int dm_test_ms_mult(struct unit_test_state *uts)
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
-DM_TEST(dm_test_ms_mult, 0);
|
|
|
+MEM_TEST(mem_test_ms_mult, UT_TESTF_CONSOLE_REC);
|
|
|
|
|
|
/* Test 'ms' command with string */
|
|
|
-static int dm_test_ms_s(struct unit_test_state *uts)
|
|
|
+static int mem_test_ms_s(struct unit_test_state *uts)
|
|
|
{
|
|
|
static const char str[] = "hello";
|
|
|
static const char str2[] = "hellothere";
|
|
@@ -193,7 +240,7 @@ static int dm_test_ms_s(struct unit_test_state *uts)
|
|
|
strcpy(buf + 0x1e, str);
|
|
|
strcpy(buf + 0x63, str);
|
|
|
strcpy(buf + 0xa1, str2);
|
|
|
- console_record_reset();
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
run_command("ms.s 0 100 hello", 0);
|
|
|
ut_assert_nextline("00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 68 65 ..............he");
|
|
|
ut_assert_nextline("00000020: 6c 6c 6f 00 00 00 00 00 00 00 00 00 00 00 00 00 llo.............");
|
|
@@ -208,7 +255,7 @@ static int dm_test_ms_s(struct unit_test_state *uts)
|
|
|
ut_asserteq(0xa1, env_get_hex("memaddr", 0));
|
|
|
ut_asserteq(0xa1, env_get_hex("mempos", 0));
|
|
|
|
|
|
- console_record_reset();
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
run_command("ms.s 0 100 hello there", 0);
|
|
|
ut_assert_nextline("000000a0: 00 68 65 6c 6c 6f 74 68 65 72 65 00 00 00 00 00 .hellothere.....");
|
|
|
ut_assert_nextline("1 match");
|
|
@@ -222,10 +269,10 @@ static int dm_test_ms_s(struct unit_test_state *uts)
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
-DM_TEST(dm_test_ms_s, 0);
|
|
|
+MEM_TEST(mem_test_ms_s, UT_TESTF_CONSOLE_REC);
|
|
|
|
|
|
/* Test 'ms' command with limit */
|
|
|
-static int dm_test_ms_limit(struct unit_test_state *uts)
|
|
|
+static int mem_test_ms_limit(struct unit_test_state *uts)
|
|
|
{
|
|
|
u8 *buf;
|
|
|
|
|
@@ -235,7 +282,7 @@ static int dm_test_ms_limit(struct unit_test_state *uts)
|
|
|
buf[0x31] = 0x12;
|
|
|
buf[0x62] = 0x12;
|
|
|
buf[0x76] = 0x12;
|
|
|
- console_record_reset();
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
run_command("ms.b -l2 1 ff 12", 0);
|
|
|
ut_assert_nextline("00000030: 00 12 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................");
|
|
|
ut_assert_nextline("--");
|
|
@@ -251,10 +298,10 @@ static int dm_test_ms_limit(struct unit_test_state *uts)
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
-DM_TEST(dm_test_ms_limit, 0);
|
|
|
+MEM_TEST(mem_test_ms_limit, UT_TESTF_CONSOLE_REC);
|
|
|
|
|
|
/* Test 'ms' command in quiet mode */
|
|
|
-static int dm_test_ms_quiet(struct unit_test_state *uts)
|
|
|
+static int mem_test_ms_quiet(struct unit_test_state *uts)
|
|
|
{
|
|
|
u8 *buf;
|
|
|
|
|
@@ -264,12 +311,15 @@ static int dm_test_ms_quiet(struct unit_test_state *uts)
|
|
|
buf[0x31] = 0x12;
|
|
|
buf[0x62] = 0x12;
|
|
|
buf[0x76] = 0x12;
|
|
|
- console_record_reset();
|
|
|
- run_command("ms.b -l2 1 ff 12", 0);
|
|
|
+ ut_assertok(console_record_reset_enable());
|
|
|
+ run_command("ms.b -q -l2 1 ff 12", 0);
|
|
|
ut_assert_console_end();
|
|
|
unmap_sysmem(buf);
|
|
|
|
|
|
+ ut_asserteq(2, env_get_hex("memmatches", 0));
|
|
|
+ ut_asserteq(0x62, env_get_hex("memaddr", 0));
|
|
|
+ ut_asserteq(0x61, env_get_hex("mempos", 0));
|
|
|
+
|
|
|
return 0;
|
|
|
}
|
|
|
-DM_TEST(dm_test_ms_quiet, 0);
|
|
|
-
|
|
|
+MEM_TEST(mem_test_ms_quiet, UT_TESTF_CONSOLE_REC);
|