Import of the watch repository from Pebble

tests/fw/mfg/test_mfg_serials.c

@@ -0,0 +1,219 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mfg/mfg_serials.h"
+#include "console/prompt_commands.h"
+
+#include "clar.h"
+
+#include "stubs_passert.h"
+#include "stubs_logging.h"
+#include "stubs_prompt.h"
+#include "fake_otp.h"
+
+#include <signal.h>
+
+extern void command_hwver_write(const char*);
+extern void command_pcba_serial_write(const char*);
+
+// Tests
+/////////////////////////////////////////////
+
+void test_mfg_serials__initialize(void) {
+  fake_otp_reset();
+}
+
+void test_mfg_serials__cleanup(void) {
+}
+
+void test_mfg_serials__hw_version(void) {
+  const char* hw_version;
+
+  // Initially, bunch of XXs:
+  hw_version = mfg_get_hw_version();
+  cl_assert(strcmp(hw_version, "XXXXXXXX") == 0);
+
+  // Test writing & reading back:
+  const char* written_hw_version1 = "ABCDEFG";
+  command_hwver_write(written_hw_version1);
+  hw_version = mfg_get_hw_version();
+  cl_assert(strcmp(written_hw_version1, hw_version) == 0);
+
+#if (BOARD_SILK_BB || BOARD_CALCULUS)
+  // Write a second time, too long.
+  const char* written_hw_version2_long = "abcdefghijkxyz";
+  command_hwver_write(written_hw_version2_long);
+  hw_version = mfg_get_hw_version();
+  cl_assert_equal_s(written_hw_version1, hw_version);
+
+  // Write second time
+  const char* written_hw_version2 = "HIJKLMN";
+  command_hwver_write(written_hw_version2);
+  hw_version = mfg_get_hw_version();
+  cl_assert_equal_s(written_hw_version2, hw_version);
+
+  // Write third time
+  const char* written_hw_version3 = "OPQRSTU";
+  command_hwver_write(written_hw_version3);
+  hw_version = mfg_get_hw_version();
+  cl_assert_equal_s(written_hw_version3, hw_version);
+
+  // Write fourth time
+  const char* written_hw_version4 = "VWXYZ12";
+  command_hwver_write(written_hw_version4);
+  hw_version = mfg_get_hw_version();
+  cl_assert_equal_s(written_hw_version4, hw_version);
+
+  // Write fifth time
+  const char* written_hw_version5 = "3456789";
+  command_hwver_write(written_hw_version5);
+  hw_version = mfg_get_hw_version();
+  cl_assert_equal_s(written_hw_version5, hw_version);
+#endif // BOARD_SILK || BOARD_CALCULUS
+}
+
+void test_mfg_serials__serial_number_console(void) {
+  const char* serial;
+
+  // Initially, bunch of XXs:
+  serial = mfg_get_serial_number();
+  cl_assert_equal_s(serial, "XXXXXXXXXXXX");
+
+  // Test writing & reading back:
+  const char* written_serial1 = "ABCDEFGHIJKL";
+  command_serial_write(written_serial1);
+  serial = mfg_get_serial_number();
+  cl_assert_equal_s(written_serial1, serial);
+}
+
+void test_mfg_serials__pcba_serial_number(void) {
+  const char* pcba_serial;
+
+  // Initially, bunch of XXs:
+  pcba_serial = mfg_get_pcba_serial_number();
+  cl_assert_equal_s(pcba_serial, "XXXXXXXXXXXX");
+
+  // Test writing & reading back:
+  const char* written_pcba_serial1 = "01234567901";
+  command_pcba_serial_write(written_pcba_serial1);
+  pcba_serial = mfg_get_pcba_serial_number();
+  cl_assert_equal_s(written_pcba_serial1, pcba_serial);
+
+  // Write second time, but too long
+  const char* written_pcba_serial2_long = "abcdefghijkxyz";
+  command_pcba_serial_write(written_pcba_serial2_long);
+  pcba_serial = mfg_get_pcba_serial_number();
+  cl_assert_equal_s(written_pcba_serial1, pcba_serial);
+
+  // Write second time
+  const char* written_pcba_serial2 = "abcdefghijkx";
+  command_pcba_serial_write(written_pcba_serial2);
+  pcba_serial = mfg_get_pcba_serial_number();
+  cl_assert_equal_s(written_pcba_serial2, pcba_serial);
+
+  // Write third time
+  const char* written_pcba_serial3 = "asdfghjklq";
+  command_pcba_serial_write(written_pcba_serial3);
+  pcba_serial = mfg_get_pcba_serial_number();
+  cl_assert_equal_s(written_pcba_serial3, pcba_serial);
+
+  // No more space: Reading should return the last successfully written value.
+  const char *pcba_serial4 = "XXXXXXXXXXXX";
+  command_pcba_serial_write(pcba_serial4);
+  pcba_serial = mfg_get_pcba_serial_number();
+  cl_assert_equal_s(written_pcba_serial3, pcba_serial);
+}
+
+void test_mfg_serials__serial_number_fails(void) {
+  const char * sn;
+  uint8_t index;
+  MfgSerialsResult r;
+
+  // Initially, return bunch of XXs:
+  sn = mfg_get_serial_number();
+  cl_assert_equal_s(sn, "XXXXXXXXXXXX");
+
+  // String too long:
+  const char *long_sn = "ABCDEFGHIJKLM";
+  r = mfg_write_serial_number(long_sn, strlen(long_sn), &index);
+  sn = mfg_get_serial_number();
+  cl_assert_equal_i(index, 0);
+  cl_assert_equal_i(r, MfgSerialsResultFailIncorrectLength);
+  cl_assert_equal_s(sn, "XXXXXXXXXXXX");
+
+  // String too short:
+  const char *short_sn = "ABCDEFGHIJK";
+  r = mfg_write_serial_number(short_sn, strlen(short_sn), &index);
+  sn = mfg_get_serial_number();
+  cl_assert_equal_i(index, 0);
+  cl_assert_equal_i(r, MfgSerialsResultFailIncorrectLength);
+  cl_assert_equal_s(sn, "XXXXXXXXXXXX");
+}
+
+void test_mfg_serials__serial_numbers(void) {
+  const char * sn;
+  uint8_t index;
+  MfgSerialsResult r;
+
+  // Initially, return bunch of XXs:
+  sn = mfg_get_serial_number();
+  cl_assert_equal_s(sn, "XXXXXXXXXXXX");
+
+  // First time:
+  const char *first_sn = "ABCDEFGHIJKL";
+  r = mfg_write_serial_number(first_sn, strlen(first_sn), &index);
+  sn = mfg_get_serial_number();
+  cl_assert_equal_i(index, 0);
+  cl_assert_equal_i(r, MfgSerialsResultSuccess);
+  cl_assert_equal_s(sn, first_sn);
+
+  // Second time:
+  const char *second_sn = "012345678901";
+  r = mfg_write_serial_number(second_sn, strlen(second_sn), &index);
+  sn = mfg_get_serial_number();
+  cl_assert_equal_i(index, 3); // SERIAL2 lives at index 3
+  cl_assert_equal_i(r, MfgSerialsResultSuccess);
+  cl_assert_equal_s(sn, second_sn);
+
+  // Third time:
+  const char *third_sn = "!@#$%^&*()-=";
+  r = mfg_write_serial_number(third_sn, strlen(third_sn), &index);
+  sn = mfg_get_serial_number();
+  cl_assert_equal_i(r, MfgSerialsResultSuccess);
+  cl_assert_equal_s(sn, third_sn);
+  cl_assert_equal_i(index, 4); // SERIAL3 lives at index 4
+
+  // Fourth time:
+  const char *fourth_sn = "mnbvcxzlkjhg";
+  r = mfg_write_serial_number(fourth_sn, strlen(fourth_sn), &index);
+  sn = mfg_get_serial_number();
+  cl_assert_equal_i(r, MfgSerialsResultSuccess);
+  cl_assert_equal_s(sn, fourth_sn);
+  cl_assert_equal_i(index, 5); // SERIAL4 lives at index 5
+
+  // Fifth time:
+  const char *fifth_sn = "7ujn8ikm9olm";
+  r = mfg_write_serial_number(fifth_sn, strlen(fifth_sn), &index);
+  sn = mfg_get_serial_number();
+  cl_assert_equal_i(r, MfgSerialsResultSuccess);
+  cl_assert_equal_s(sn, fifth_sn);
+  cl_assert_equal_i(index, 6); // SERIAL5 lives at index 6
+
+  // No more space:
+  const char *sixth_sn = "XXXXXXXXXXXX";
+  r = mfg_write_serial_number(sixth_sn, strlen(sixth_sn), &index);
+  cl_assert(r == MfgSerialsResultFailNoMoreSpace);
+}