SBS: Add more unit tests for battery_get_params

Currently, we test only BATT_FLAG_RESPONSIVE and BAD_ANY. This patch
adds test for the other flags. It also explicitly tests flag transitions (0
-> 1 and 1 -> 0), and reading voltages and currents.

BUG=None
BRANCH=None
TEST=run-battery_get_params_smart

Signed-off-by: Daisuke Nojiri <dnojiri@chromium.org>
Change-Id: Ia83d782c427aff1e12b71e0f1569e1e577648671
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/4137167
Code-Coverage: Zoss <zoss-cl-coverage@prod.google.com>
Reviewed-by: Paul Fagerburg <pfagerburg@chromium.org>
Commit-Queue: Paul Fagerburg <pfagerburg@chromium.org>
(cherry picked from commit 095a1ac65d1dd163623fa2081aaea4f844e3a78b)
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/4212308
Commit-Queue: Ivan Chen <yulunchen@google.com>
Reviewed-by: Owen Yang <owen.yang@ecs.corp-partner.google.com>
Reviewed-by: Shou-Chieh Hsu <shouchieh@chromium.org>
Tested-by: Owen Yang <owen.yang@ecs.corp-partner.google.com>

1 files changed, 155 insertions, 6 deletions

diff --git a/test/battery_get_params_smart.c b/test/battery_get_params_smart.c
index 42582df363..48273c4be0 100644
--- a/test/battery_get_params_smart.c
+++ b/test/battery_get_params_smart.c
@@ -18,6 +18,7 @@
 static int fail_on_first, fail_on_last;
 static int read_count, write_count;
 struct batt_params batt;
+static int cmd_to_fail;
 
 void battery_compensate_params(struct batt_params *batt)
 {
@@ -27,15 +28,21 @@ void board_battery_compensate_params(struct batt_params *batt)
 {
 }
 
-static void reset_and_fail_on(int first, int last)
+static void reset_counters(int first, int last)
 {
-	/* We're not initializing the fake battery, so everything reads zero */
-	memset(&batt, 0, sizeof(typeof(batt)));
 	read_count = write_count = 0;
 	fail_on_first = first;
 	fail_on_last = last;
 }
 
+static void reset_and_fail_on(int first, int last, int cmd)
+{
+	/* We're not initializing the fake battery, so everything reads zero */
+	memset(&batt, 0, sizeof(typeof(batt)));
+	cmd_to_fail = cmd;
+	reset_counters(first, last);
+}
+
 /* Mocked functions */
 int sb_read(int cmd, int *param)
 {
@@ -43,8 +50,12 @@ int sb_read(int cmd, int *param)
 	if (read_count >= fail_on_first && read_count <= fail_on_last)
 		return EC_ERROR_UNKNOWN;
 
+	if (cmd == cmd_to_fail)
+		return EC_ERROR_UNKNOWN;
+
 	return i2c_read16(I2C_PORT_BATTERY, BATTERY_ADDR_FLAGS, cmd, param);
 }
+
 int sb_write(int cmd, int param)
 {
 	write_count++;
@@ -57,15 +68,17 @@ static int test_param_failures(void)
 	int i, num_reads;
 
 	/* No failures */
-	reset_and_fail_on(0, 0);
+	reset_and_fail_on(0, 0, -1);
 	battery_get_params(&batt);
 	TEST_ASSERT(batt.flags & BATT_FLAG_RESPONSIVE);
 	TEST_ASSERT(!(batt.flags & BATT_FLAG_BAD_ANY));
+
+	/* Save the max number of reads. */
 	num_reads = read_count;
 
 	/* Just a single failure */
 	for (i = 1; i <= num_reads; i++) {
-		reset_and_fail_on(i, i);
+		reset_and_fail_on(i, i, -1);
 		battery_get_params(&batt);
 		TEST_ASSERT(batt.flags & BATT_FLAG_BAD_ANY);
 		TEST_ASSERT(batt.flags & BATT_FLAG_RESPONSIVE);
@@ -73,7 +86,7 @@ static int test_param_failures(void)
 
 	/* Once it fails, it keeps failing */
 	for (i = 1; i <= num_reads; i++) {
-		reset_and_fail_on(i, num_reads);
+		reset_and_fail_on(i, num_reads, -1);
 		battery_get_params(&batt);
 		TEST_ASSERT(batt.flags & BATT_FLAG_BAD_ANY);
 		if (i == 1)
@@ -86,9 +99,145 @@ static int test_param_failures(void)
 	return EC_SUCCESS;
 }
 
+/**
+ * Test if battery_get_params sets a flag properly for a SB command.
+ *
+ * @param cmd   SB command to fail.
+ * @param flag  Flag expected to be set when <cmd> fails.
+ * @return  EC_SUCCESS
+ */
+static int test_flag(int cmd, int flag)
+{
+	reset_and_fail_on(0, 0, cmd);
+	battery_get_params(&batt);
+	TEST_ASSERT(batt.flags & flag);
+	TEST_ASSERT(!((batt.flags & ~flag) & BATT_FLAG_BAD_ANY));
+	TEST_ASSERT(batt.flags & BATT_FLAG_RESPONSIVE);
+
+	/*
+	 * When SB_CHARGING_VOLTAGE, SB_CHARGING_CURRENT, or
+	 * SB_RELATIVE_STATE_OF_CHARGE fails, WANT_CHARGE should be cleared.
+	 */
+	switch (cmd) {
+	case SB_RELATIVE_STATE_OF_CHARGE:
+	case SB_CHARGING_VOLTAGE:
+	case SB_CHARGING_CURRENT:
+		TEST_ASSERT(!(batt.flags & BATT_FLAG_WANT_CHARGE));
+		TEST_ASSERT(batt.desired_voltage == 0);
+		TEST_ASSERT(batt.desired_current == 0);
+		break;
+	default:
+		TEST_ASSERT(batt.flags & BATT_FLAG_WANT_CHARGE);
+		TEST_ASSERT(batt.desired_voltage == 100);
+		TEST_ASSERT(batt.desired_current == 100);
+	}
+
+	/*
+	 * Failure is recovered. <flag> should be cleared. WANT_CHARGE should be
+	 * set.
+	 */
+	cmd_to_fail = -1;
+	battery_get_params(&batt);
+	TEST_ASSERT(!(batt.flags & flag));
+	TEST_ASSERT(batt.flags & BATT_FLAG_WANT_CHARGE);
+
+	return EC_SUCCESS;
+}
+
+static int test_flags(void)
+{
+	sb_write(SB_CHARGING_VOLTAGE, 100);
+	sb_write(SB_CHARGING_CURRENT, 100);
+	sb_write(SB_RELATIVE_STATE_OF_CHARGE, 50);
+
+	/* Test each command-flag pair. */
+	test_flag(SB_TEMPERATURE, BATT_FLAG_BAD_TEMPERATURE);
+	test_flag(SB_RELATIVE_STATE_OF_CHARGE, BATT_FLAG_BAD_STATE_OF_CHARGE);
+	test_flag(SB_VOLTAGE, BATT_FLAG_BAD_VOLTAGE);
+	test_flag(SB_CURRENT, BATT_FLAG_BAD_CURRENT);
+	test_flag(SB_AVERAGE_CURRENT, BATT_FLAG_BAD_AVERAGE_CURRENT);
+	test_flag(SB_CHARGING_VOLTAGE, BATT_FLAG_BAD_DESIRED_VOLTAGE);
+	test_flag(SB_CHARGING_CURRENT, BATT_FLAG_BAD_DESIRED_CURRENT);
+	test_flag(SB_REMAINING_CAPACITY, BATT_FLAG_BAD_REMAINING_CAPACITY);
+	test_flag(SB_FULL_CHARGE_CAPACITY, BATT_FLAG_BAD_FULL_CAPACITY);
+	test_flag(SB_BATTERY_STATUS, BATT_FLAG_BAD_STATUS);
+
+	/*
+	 * All reads succeed. BATT_FLAG_RESPONSIVE should be set. Then, all
+	 * reads fail. BATT_FLAG_RESPONSIVE should be cleared.
+	 */
+	reset_and_fail_on(0, 0, -1);
+	battery_get_params(&batt);
+	TEST_ASSERT(batt.flags & BATT_FLAG_RESPONSIVE);
+
+	reset_counters(1, read_count);
+	battery_get_params(&batt);
+	TEST_ASSERT(!(batt.flags & BATT_FLAG_RESPONSIVE));
+
+	/* Test WANT_CHARGE is explicitly cleared. */
+	reset_and_fail_on(0, 0, SB_RELATIVE_STATE_OF_CHARGE);
+	batt.flags |= BATT_FLAG_WANT_CHARGE;
+	battery_get_params(&batt);
+	TEST_ASSERT(!(batt.flags & BATT_FLAG_WANT_CHARGE));
+
+	return EC_SUCCESS;
+}
+
+static int test_full_state_of_charge(void)
+{
+	/*
+	 * When SoC is full, BATT_FLAG_WANT_CHARGE should be cleared and
+	 * desired voltage and current are also cleared.
+	 */
+	sb_write(SB_CHARGING_VOLTAGE, 100);
+	sb_write(SB_CHARGING_CURRENT, 100);
+	sb_write(SB_RELATIVE_STATE_OF_CHARGE, 100);
+
+	reset_and_fail_on(0, 0, -1);
+	battery_get_params(&batt);
+	TEST_ASSERT(!(batt.flags & BATT_FLAG_WANT_CHARGE));
+	TEST_ASSERT(batt.desired_voltage == 0);
+	TEST_ASSERT(batt.desired_current == 0);
+	TEST_ASSERT(batt.state_of_charge == 100);
+
+	return EC_SUCCESS;
+}
+
+static int test_voltage(void)
+{
+	sb_write(SB_VOLTAGE, 100);
+	reset_and_fail_on(0, 0, -1);
+
+	battery_get_params(&batt);
+	TEST_ASSERT(batt.voltage == 100);
+
+	return EC_SUCCESS;
+}
+
+static int test_current(void)
+{
+	/* Test positive (charge) current. */
+	sb_write(SB_CURRENT, 100);
+	reset_and_fail_on(0, 0, -1);
+	battery_get_params(&batt);
+	TEST_ASSERT(batt.current == 100);
+
+	/* Test negative (discharge) current. */
+	sb_write(SB_CURRENT, -100);
+	reset_and_fail_on(0, 0, -1);
+	battery_get_params(&batt);
+	TEST_ASSERT(batt.current == -100);
+
+	return EC_SUCCESS;
+}
+
 void run_test(int argc, const char **argv)
 {
 	RUN_TEST(test_param_failures);
+	RUN_TEST(test_flags);
+	RUN_TEST(test_full_state_of_charge);
+	RUN_TEST(test_voltage);
+	RUN_TEST(test_current);
 
 	test_print_result();
 }