test: Improve test_send_caps_error in usb_pe_drp

Better mock tx and rx messages, add sop type.

BUG=b:161835483 b:173791979
BRANCH=none
TEST=make run-usb_pe_drp

Signed-off-by: Edward Hill <ecgh@chromium.org>
Change-Id: If1f91b6385d6841d662a8a6262af6382645da92e
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/2553343
Reviewed-by: Diana Z <dzigterman@chromium.org>

5 files changed, 195 insertions, 136 deletions

diff --git a/common/mock/usb_prl_mock.c b/common/mock/usb_prl_mock.c
index 75c0976362..cb4b035ff4 100644
--- a/common/mock/usb_prl_mock.c
+++ b/common/mock/usb_prl_mock.c
@@ -2,7 +2,7 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
- * Fake Protocol Layer module.
+ * Mock Protocol Layer module.
  */
 #include <string.h>
 #include "common.h"
@@ -10,6 +10,9 @@
 #include "usb_pe_sm.h"
 #include "usb_prl_sm.h"
 #include "mock/usb_prl_mock.h"
+#include "task.h"
+#include "test_util.h"
+#include "timer.h"
 
 #ifndef TEST_BUILD
 #error "Mocks should only be in the test build."
@@ -21,10 +24,12 @@ struct extended_msg tx_emsg[CONFIG_USB_PD_PORT_MAX_COUNT];
 
 struct mock_prl_port_t {
 	enum pd_ctrl_msg_type last_ctrl_msg;
-	enum pd_data_msg_type last_data_msg_type;
+	enum pd_data_msg_type last_data_msg;
+	enum tcpm_transmit_type last_tx_type;
 	bool message_sent;
 	bool message_received;
-	int pe_error;
+	enum pe_error error;
+	enum tcpm_transmit_type error_tx_type;
 };
 
 struct mock_prl_port_t mock_prl_port[CONFIG_USB_PD_PORT_MAX_COUNT];
@@ -39,8 +44,10 @@ void mock_prl_reset(void)
 
 	memset(mock_prl_port, 0, sizeof(mock_prl_port));
 
-	for (port = 0 ; port < CONFIG_USB_PD_PORT_MAX_COUNT ; ++port)
-		mock_prl_port[port].pe_error = -1;
+	for (port = 0 ; port < CONFIG_USB_PD_PORT_MAX_COUNT ; ++port) {
+		mock_prl_port[port].last_tx_type = TCPC_TX_INVALID;
+		mock_prl_port[port].error_tx_type = TCPC_TX_INVALID;
+	}
 }
 
 void prl_end_ams(int port)
@@ -77,12 +84,16 @@ void prl_send_ctrl_msg(int port, enum tcpm_transmit_type type,
 	enum pd_ctrl_msg_type msg)
 {
 	mock_prl_port[port].last_ctrl_msg = msg;
+	mock_prl_port[port].last_data_msg = 0;
+	mock_prl_port[port].last_tx_type = type;
 }
 
 void prl_send_data_msg(int port, enum tcpm_transmit_type type,
 	enum pd_data_msg_type msg)
 {
-	mock_prl_port[port].last_data_msg_type = msg;
+	mock_prl_port[port].last_data_msg = msg;
+	mock_prl_port[port].last_ctrl_msg = 0;
+	mock_prl_port[port].last_tx_type = type;
 }
 
 void prl_send_ext_data_msg(int port, enum tcpm_transmit_type type,
@@ -94,45 +105,69 @@ void prl_set_rev(int port, enum tcpm_transmit_type partner,
 {}
 
 
-enum pd_ctrl_msg_type fake_prl_get_last_sent_ctrl_msg(int port)
+int mock_prl_wait_for_tx_msg(int port,
+			     enum tcpm_transmit_type tx_type,
+			     enum pd_ctrl_msg_type ctrl_msg,
+			     enum pd_data_msg_type data_msg,
+			     int timeout)
 {
-	enum pd_ctrl_msg_type last = mock_prl_port[port].last_ctrl_msg;
-
-	fake_prl_clear_last_sent_ctrl_msg(port);
-	return last;
+	uint64_t end_time = get_time().val + timeout;
+
+	while (get_time().val < end_time) {
+		if (mock_prl_port[port].last_tx_type != TCPC_TX_INVALID) {
+			TEST_EQ(mock_prl_port[port].last_tx_type,
+				tx_type, "%d");
+			TEST_EQ(mock_prl_port[port].last_ctrl_msg,
+				ctrl_msg, "%d");
+			TEST_EQ(mock_prl_port[port].last_data_msg,
+				data_msg, "%d");
+			mock_prl_clear_last_sent_msg(port);
+			return EC_SUCCESS;
+		}
+		task_wait_event(5 * MSEC);
+	}
+	TEST_ASSERT(0);
+	return EC_ERROR_UNKNOWN;
 }
 
-void fake_prl_clear_last_sent_ctrl_msg(int port)
+enum pd_ctrl_msg_type mock_prl_get_last_sent_ctrl_msg(int port)
 {
-	mock_prl_port[port].last_ctrl_msg = 0;
+	enum pd_ctrl_msg_type last = mock_prl_port[port].last_ctrl_msg;
+
+	mock_prl_clear_last_sent_msg(port);
+	return last;
 }
 
-enum pd_data_msg_type fake_prl_get_last_sent_data_msg_type(int port)
+enum pd_data_msg_type mock_prl_get_last_sent_data_msg(int port)
 {
-	enum pd_data_msg_type last = mock_prl_port[port].last_data_msg_type;
+	enum pd_data_msg_type last = mock_prl_port[port].last_data_msg;
 
-	fake_prl_clear_last_sent_data_msg(port);
+	mock_prl_clear_last_sent_msg(port);
 	return last;
 }
 
-void fake_prl_clear_last_sent_data_msg(int port)
+void mock_prl_clear_last_sent_msg(int port)
 {
-	mock_prl_port[port].last_data_msg_type = 0;
+	mock_prl_port[port].last_data_msg = 0;
+	mock_prl_port[port].last_ctrl_msg = 0;
+	mock_prl_port[port].last_tx_type = TCPC_TX_INVALID;
 }
 
-void fake_prl_message_sent(int port)
+void mock_prl_message_sent(int port)
 {
 	mock_prl_port[port].message_sent = 1;
 }
 
-void fake_prl_message_received(int port)
+void mock_prl_message_received(int port)
 {
 	mock_prl_port[port].message_received = 1;
 }
 
-void fake_prl_report_error(int port, enum pe_error e)
+void mock_prl_report_error(int port, enum pe_error e,
+			   enum tcpm_transmit_type tx_type)
 {
-	mock_prl_port[port].pe_error = e;
+	mock_prl_port[port].error = e;
+	mock_prl_port[port].error_tx_type = tx_type;
 }
 
 void prl_run(int port, int evt, int en)
@@ -147,11 +182,12 @@ void prl_run(int port, int evt, int en)
 		pe_message_received(port);
 		mock_prl_port[port].message_received = 0;
 	}
-	if (mock_prl_port[port].pe_error >= 0) {
-		ccprints("pe_error %d", mock_prl_port[port].pe_error);
+	if (mock_prl_port[port].error_tx_type != TCPC_TX_INVALID) {
+		ccprints("pe_error %d", mock_prl_port[port].error);
 		pe_report_error(port,
-				mock_prl_port[port].pe_error,
-				TCPC_TX_SOP);
-		mock_prl_port[port].pe_error = -1;
+				mock_prl_port[port].error,
+				mock_prl_port[port].error_tx_type);
+		mock_prl_port[port].error = 0;
+		mock_prl_port[port].error_tx_type = TCPC_TX_INVALID;
 	}
 }
diff --git a/include/mock/usb_prl_mock.h b/include/mock/usb_prl_mock.h
index 5479fbd164..052b3e7b76 100644
--- a/include/mock/usb_prl_mock.h
+++ b/include/mock/usb_prl_mock.h
@@ -12,18 +12,23 @@
 
 void mock_prl_reset(void);
 
-enum pd_ctrl_msg_type fake_prl_get_last_sent_ctrl_msg(int port);
+int mock_prl_wait_for_tx_msg(int port,
+			     enum tcpm_transmit_type tx_type,
+			     enum pd_ctrl_msg_type ctrl_msg,
+			     enum pd_data_msg_type data_msg,
+			     int timeout);
 
-void fake_prl_clear_last_sent_ctrl_msg(int port);
+enum pd_ctrl_msg_type mock_prl_get_last_sent_ctrl_msg(int port);
 
-enum pd_data_msg_type fake_prl_get_last_sent_data_msg_type(int port);
+enum pd_data_msg_type mock_prl_get_last_sent_data_msg(int port);
 
-void fake_prl_clear_last_sent_data_msg(int port);
+void mock_prl_clear_last_sent_msg(int port);
 
-void fake_prl_message_sent(int port);
+void mock_prl_message_sent(int port);
 
-void fake_prl_message_received(int port);
+void mock_prl_message_received(int port);
 
-void fake_prl_report_error(int port, enum pe_error e);
+void mock_prl_report_error(int port, enum pe_error e,
+			   enum tcpm_transmit_type tx_type);
 
 #endif /* __MOCK_DP_ALT_MODE_MOCK_H */
diff --git a/include/usb_prl_sm.h b/include/usb_prl_sm.h
index d5d133f250..6a143f9acc 100644
--- a/include/usb_prl_sm.h
+++ b/include/usb_prl_sm.h
@@ -123,28 +123,4 @@ void prl_hard_reset_complete(int port);
  */
 void prl_execute_hard_reset(int port);
 
-#ifdef TEST_BUILD
-/**
- * Fake to track the last sent control message
- */
-enum pd_ctrl_msg_type fake_prl_get_last_sent_ctrl_msg(int port);
-
-/**
- * Fake to set the last sent control message to an invalid value.
- */
-void fake_prl_clear_last_sent_ctrl_msg(int port);
-
-/**
- * Get the type of the last sent data message on the given port.
- */
-enum pd_data_msg_type fake_prl_get_last_sent_data_msg_type(int port);
-
-/**
- * Clear the last sent data message on the given port to an invalid value,
- * making it possible to check that two of the same message were sent in order.
- */
-void fake_prl_clear_last_sent_data_msg(int port);
-#endif
-
 #endif /* __CROS_EC_USB_PRL_H */
-
diff --git a/test/usb_pe_drp.c b/test/usb_pe_drp.c
index f5ced4c7b1..19bad83edf 100644
--- a/test/usb_pe_drp.c
+++ b/test/usb_pe_drp.c
@@ -49,92 +49,131 @@ void before_test(void)
 	task_wait_event(SECOND);
 }
 
+/*
+ * This assumes data messages only contain a single data object (uint32_t data).
+ * TODO: Add support for multiple data objects (when a test is added here that
+ * needs it).
+ */
+test_static void rx_message(enum pd_msg_type sop,
+			    enum pd_ctrl_msg_type ctrl_msg,
+			    enum pd_data_msg_type data_msg,
+			    enum pd_power_role prole,
+			    enum pd_data_role drole,
+			    uint32_t data)
+{
+	int type, cnt;
+
+	if (ctrl_msg != 0) {
+		type = ctrl_msg;
+		cnt = 0;
+	} else {
+		type = data_msg;
+		cnt = 1;
+	}
+	rx_emsg[PORT0].header = (PD_HEADER_SOP(sop)
+		| PD_HEADER(type, prole, drole, 0, cnt, PD_REV30, 0));
+	rx_emsg[PORT0].len = cnt * 4;
+	*(uint32_t *)rx_emsg[PORT0].buf = data;
+	mock_prl_message_received(PORT0);
+}
+
+
 test_static int test_send_caps_error(void)
 {
+	int i;
+
 	/* Enable PE as source, expect SOURCE_CAP. */
 	mock_pd_port[PORT0].power_role = PD_ROLE_SOURCE;
 	mock_tc_port[PORT0].pd_enable = 1;
 	mock_tc_port[PORT0].vconn_src = true;
-	task_wait_event(10 * MSEC);
-	TEST_EQ(fake_prl_get_last_sent_data_msg_type(PORT0),
-		PD_DATA_SOURCE_CAP, "%d");
-	fake_prl_message_sent(PORT0);
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+					 0, PD_DATA_SOURCE_CAP, 20 * MSEC),
+		EC_SUCCESS, "%d");
+	mock_prl_message_sent(PORT0);
 	task_wait_event(10 * MSEC);
 
 	/* REQUEST 5V, expect ACCEPT, PS_RDY. */
-	rx_emsg[PORT0].header = PD_HEADER(PD_DATA_REQUEST, PD_ROLE_SINK,
-			PD_ROLE_UFP, 0,
-			1, PD_REV30, 0);
-	rx_emsg[PORT0].len = 4;
-	*(uint32_t *)rx_emsg[PORT0].buf = RDO_FIXED(1, 500, 500, 0);
-	fake_prl_message_received(PORT0);
-	task_wait_event(10 * MSEC);
-	TEST_EQ(fake_prl_get_last_sent_ctrl_msg(PORT0),
-		PD_CTRL_ACCEPT, "%d");
-	fake_prl_message_sent(PORT0);
-	task_wait_event(10 * MSEC);
-	TEST_EQ(fake_prl_get_last_sent_ctrl_msg(PORT0),
-		PD_CTRL_PS_RDY, "%d");
-	fake_prl_message_sent(PORT0);
-	task_wait_event(30 * MSEC);
-
-	/* Expect VENDOR_DEF, reply NOT_SUPPORTED. */
-	TEST_EQ(fake_prl_get_last_sent_data_msg_type(PORT0),
-		PD_DATA_VENDOR_DEF, "%d");
-	fake_prl_message_sent(PORT0);
-	task_wait_event(10 * MSEC);
-	rx_emsg[PORT0].header = PD_HEADER(PD_CTRL_NOT_SUPPORTED, PD_ROLE_SINK,
-			PD_ROLE_UFP, 2,
-			0, PD_REV30, 0);
-	rx_emsg[PORT0].len = 0;
-	fake_prl_message_received(PORT0);
-	task_wait_event(30 * MSEC);
+	rx_message(PD_MSG_SOP, 0, PD_DATA_REQUEST,
+		   PD_ROLE_SINK, PD_ROLE_UFP, RDO_FIXED(1, 500, 500, 0));
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+					 PD_CTRL_ACCEPT, 0, 20 * MSEC),
+		EC_SUCCESS, "%d");
+	mock_prl_message_sent(PORT0);
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+					 PD_CTRL_PS_RDY, 0, 20 * MSEC),
+		EC_SUCCESS, "%d");
+	mock_prl_message_sent(PORT0);
+
+	/*
+	 * Expect VENDOR_DEF for cable identity, simulate no cable (so no
+	 * GoodCRC, so ERR_TCH_XMIT). Don't reply NOT_SUPPORTED, since the spec
+	 * says a cable never does that.
+	 * TODO: Add tests for cable replying to identity, and replying
+	 * NOT_SUPPORTED (since we should be robust to cables doing the wrong
+	 * thing).
+	 */
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP_PRIME,
+					 0, PD_DATA_VENDOR_DEF, 20 * MSEC),
+		EC_SUCCESS, "%d");
+	mock_prl_report_error(PORT0, ERR_TCH_XMIT, TCPC_TX_SOP_PRIME);
 
 	/* Expect GET_SOURCE_CAP, reply NOT_SUPPORTED. */
-	TEST_EQ(fake_prl_get_last_sent_ctrl_msg(PORT0),
-		PD_CTRL_GET_SOURCE_CAP, "%d");
-	fake_prl_message_sent(PORT0);
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+					 PD_CTRL_GET_SOURCE_CAP, 0, 20 * MSEC),
+		EC_SUCCESS, "%d");
+	mock_prl_message_sent(PORT0);
 	task_wait_event(10 * MSEC);
-	rx_emsg[PORT0].header = PD_HEADER(PD_CTRL_NOT_SUPPORTED, PD_ROLE_SINK,
-			PD_ROLE_UFP, 2,
-			0, PD_REV30, 0);
-	rx_emsg[PORT0].len = 0;
-	fake_prl_message_received(PORT0);
-	task_wait_event(200 * MSEC);
+	rx_message(PD_MSG_SOP, PD_CTRL_NOT_SUPPORTED, 0,
+		   PD_ROLE_SINK, PD_ROLE_UFP, 0);
 
 	/*
 	 * Expect GET_SINK_CAP, reply with a simple Sink Cap since sink partners
 	 * must support this message.
 	 */
-	TEST_EQ(fake_prl_get_last_sent_ctrl_msg(PORT0),
-		PD_CTRL_GET_SINK_CAP, "%d");
-	fake_prl_message_sent(PORT0);
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+					 PD_CTRL_GET_SINK_CAP, 0, 20 * MSEC),
+		EC_SUCCESS, "%d");
+	mock_prl_message_sent(PORT0);
+	task_wait_event(10 * MSEC);
+	rx_message(PD_MSG_SOP, 0, PD_DATA_SINK_CAP,
+		   PD_ROLE_SINK, PD_ROLE_UFP,
+		   PDO_FIXED(5000, 500, PDO_FIXED_COMM_CAP));
+
+	/*
+	 * Cable identity discovery is attempted 6 times total. 1 was done
+	 * above, so expect 5 more now.
+	 */
+	for (i = 0; i < 5; i++) {
+		TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP_PRIME,
+						 0, PD_DATA_VENDOR_DEF,
+						 60 * MSEC),
+			EC_SUCCESS, "%d");
+		mock_prl_report_error(PORT0, ERR_TCH_XMIT, TCPC_TX_SOP_PRIME);
+	}
+
+	/* Expect VENDOR_DEF for partner identity, reply NOT_SUPPORTED. */
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+					 0, PD_DATA_VENDOR_DEF, 20 * MSEC),
+		EC_SUCCESS, "%d");
+	mock_prl_message_sent(PORT0);
 	task_wait_event(10 * MSEC);
-	rx_emsg[PORT0].header = PD_HEADER(PD_DATA_SINK_CAP, PD_ROLE_SINK,
-			PD_ROLE_UFP, 2,
-			1, PD_REV30, 0);
-	rx_emsg[PORT0].len = 4;
-	*(uint32_t *)rx_emsg[PORT0].buf = PDO_FIXED(5000, 500,
-						    PDO_FIXED_COMM_CAP);
-	fake_prl_message_received(PORT0);
-	task_wait_event(200 * MSEC);
+	rx_message(PD_MSG_SOP, PD_CTRL_NOT_SUPPORTED, 0,
+		   PD_ROLE_SINK, PD_ROLE_UFP, 0);
+
+	task_wait_event(5 * SECOND);
 
 	/*
 	 * Now connected. Send GET_SOURCE_CAP, to check how error sending
 	 * SOURCE_CAP is handled.
 	 */
-	rx_emsg[PORT0].header = PD_HEADER(PD_CTRL_GET_SOURCE_CAP, PD_ROLE_SINK,
-			PD_ROLE_UFP, 3,
-			0, PD_REV30, 0);
-	rx_emsg[PORT0].len = 0;
-	fake_prl_message_received(PORT0);
-	task_wait_event(10 * MSEC);
-	TEST_EQ(fake_prl_get_last_sent_data_msg_type(PORT0),
-		PD_DATA_SOURCE_CAP, "%d");
+	rx_message(PD_MSG_SOP, PD_CTRL_GET_SOURCE_CAP, 0,
+		   PD_ROLE_SINK, PD_ROLE_UFP, 0);
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+					 0, PD_DATA_SOURCE_CAP, 20 * MSEC),
+		EC_SUCCESS, "%d");
 
 	/* Simulate error sending SOURCE_CAP. */
-	fake_prl_report_error(PORT0, ERR_TCH_XMIT);
-	task_wait_event(20 * MSEC);
+	mock_prl_report_error(PORT0, ERR_TCH_XMIT, TCPC_TX_SOP);
 
 	/*
 	 * Expect SOFT_RESET.
@@ -143,9 +182,11 @@ test_static int test_send_caps_error(void)
 	 * "The PE_SRC_Send_Soft_Reset state Shall be entered from any state
 	 * when ... A Message has not been sent after retries to the Sink"
 	 */
-	TEST_EQ(fake_prl_get_last_sent_ctrl_msg(PORT0),
-		PD_CTRL_SOFT_RESET, "%d");
-	fake_prl_message_sent(PORT0);
+	TEST_EQ(mock_prl_wait_for_tx_msg(PORT0, TCPC_TX_SOP,
+					 PD_CTRL_SOFT_RESET, 0, 20 * MSEC),
+		EC_SUCCESS, "%d");
+	mock_prl_message_sent(PORT0);
+
 	task_wait_event(5 * SECOND);
 
 	return EC_SUCCESS;
diff --git a/test/usb_pe_drp_old.c b/test/usb_pe_drp_old.c
index c6e55f47ca..1c5717a341 100644
--- a/test/usb_pe_drp_old.c
+++ b/test/usb_pe_drp_old.c
@@ -17,6 +17,7 @@
 #include "usb_prl_sm.h"
 #include "usb_sm_checks.h"
 #include "usb_tc_sm.h"
+#include "mock/usb_prl_mock.h"
 
 /**
  * STUB Section
@@ -146,7 +147,7 @@ static int test_pe_frs(void)
 	 * Make sure that we sent FR_Swap
 	 */
 	task_wait_event(10 * MSEC);
-	TEST_ASSERT(fake_prl_get_last_sent_ctrl_msg(PORT0) == PD_CTRL_FR_SWAP);
+	TEST_ASSERT(mock_prl_get_last_sent_ctrl_msg(PORT0) == PD_CTRL_FR_SWAP);
 	TEST_ASSERT(get_state_pe(PORT0) == PE_PRS_SNK_SRC_SEND_SWAP);
 	TEST_ASSERT(pe_chk_flag(PORT0, PE_FLAGS_FAST_ROLE_SWAP_PATH));
 	pe_set_flag(PORT0, PE_FLAGS_TX_COMPLETE);
@@ -179,7 +180,7 @@ static int test_pe_frs(void)
 	task_wait_event(PD_POWER_SUPPLY_TURN_ON_DELAY);
 	TEST_ASSERT(get_state_pe(PORT0) == PE_PRS_SNK_SRC_SOURCE_ON);
 	TEST_ASSERT(pe_chk_flag(PORT0, PE_FLAGS_FAST_ROLE_SWAP_PATH));
-	TEST_ASSERT(fake_prl_get_last_sent_ctrl_msg(PORT0) == PD_CTRL_PS_RDY);
+	TEST_ASSERT(mock_prl_get_last_sent_ctrl_msg(PORT0) == PD_CTRL_PS_RDY);
 
 	/*
 	 * Fake the Transmit complete and this will bring us to Source Startup
@@ -207,7 +208,7 @@ static int test_snk_give_source_cap(void)
 
 	TEST_ASSERT(!pe_chk_flag(PORT0, PE_FLAGS_MSG_RECEIVED));
 	TEST_ASSERT(!pe_chk_flag(PORT0, PE_FLAGS_TX_COMPLETE));
-	TEST_EQ(fake_prl_get_last_sent_data_msg_type(PORT0),
+	TEST_EQ(mock_prl_get_last_sent_data_msg(PORT0),
 		PD_DATA_SOURCE_CAP, "%d");
 	TEST_EQ(get_state_pe(PORT0), PE_DR_SNK_GIVE_SOURCE_CAP, "%d");
 
@@ -243,12 +244,12 @@ test_static int test_extended_message_not_supported(void)
 	*(uint16_t *)rx_emsg[PORT0].buf =
 		PD_EXT_HEADER(0, 0, ARRAY_SIZE(rx_emsg[PORT0].buf)) & ~BIT(15);
 	pe_set_flag(PORT0, PE_FLAGS_MSG_RECEIVED);
-	fake_prl_clear_last_sent_ctrl_msg(PORT0);
+	mock_prl_clear_last_sent_msg(PORT0);
 	task_wait_event(10 * MSEC);
 
 	pe_set_flag(PORT0, PE_FLAGS_TX_COMPLETE);
 	task_wait_event(10 * MSEC);
-	TEST_EQ(fake_prl_get_last_sent_ctrl_msg(PORT0), PD_CTRL_NOT_SUPPORTED,
+	TEST_EQ(mock_prl_get_last_sent_ctrl_msg(PORT0), PD_CTRL_NOT_SUPPORTED,
 			"%d");
 	/* At this point, the PE should again be running in PE_SRC_Ready. */
 
@@ -262,12 +263,12 @@ test_static int test_extended_message_not_supported(void)
 	*(uint16_t *)rx_emsg[PORT0].buf =
 		PD_EXT_HEADER(0, 0, PD_MAX_EXTENDED_MSG_CHUNK_LEN);
 	pe_set_flag(PORT0, PE_FLAGS_MSG_RECEIVED);
-	fake_prl_clear_last_sent_ctrl_msg(PORT0);
+	mock_prl_clear_last_sent_msg(PORT0);
 	task_wait_event(10 * MSEC);
 
 	pe_set_flag(PORT0, PE_FLAGS_TX_COMPLETE);
 	task_wait_event(10 * MSEC);
-	TEST_EQ(fake_prl_get_last_sent_ctrl_msg(PORT0), PD_CTRL_NOT_SUPPORTED,
+	TEST_EQ(mock_prl_get_last_sent_ctrl_msg(PORT0), PD_CTRL_NOT_SUPPORTED,
 			"%d");
 	/* At this point, the PE should again be running in PE_SRC_Ready. */
 
@@ -281,20 +282,20 @@ test_static int test_extended_message_not_supported(void)
 	*(uint16_t *)rx_emsg[PORT0].buf =
 		PD_EXT_HEADER(0, 0, ARRAY_SIZE(rx_emsg[PORT0].buf));
 	pe_set_flag(PORT0, PE_FLAGS_MSG_RECEIVED);
-	fake_prl_clear_last_sent_ctrl_msg(PORT0);
+	mock_prl_clear_last_sent_msg(PORT0);
 	task_wait_event(10 * MSEC);
 	/*
 	 * The PE should stay in PE_SRC_Chunk_Received for
 	 * tChunkingNotSupported.
 	 */
 	task_wait_event(10 * MSEC);
-	TEST_NE(fake_prl_get_last_sent_ctrl_msg(PORT0), PD_CTRL_NOT_SUPPORTED,
+	TEST_NE(mock_prl_get_last_sent_ctrl_msg(PORT0), PD_CTRL_NOT_SUPPORTED,
 			"%d");
 
 	task_wait_event(PD_T_CHUNKING_NOT_SUPPORTED);
 	pe_set_flag(PORT0, PE_FLAGS_TX_COMPLETE);
 	task_wait_event(10 * MSEC);
-	TEST_EQ(fake_prl_get_last_sent_ctrl_msg(PORT0), PD_CTRL_NOT_SUPPORTED,
+	TEST_EQ(mock_prl_get_last_sent_ctrl_msg(PORT0), PD_CTRL_NOT_SUPPORTED,
 			"%d");
 	/* At this point, the PE should again be running in PE_SRC_Ready. */
 
@@ -378,12 +379,12 @@ static int test_send_caps_error(void)
 	 *  1) The Protocol Layer indicates that the Message has not been sent
 	 *     and we are presently not Connected
 	 */
-	fake_prl_clear_last_sent_ctrl_msg(PORT0);
+	mock_prl_clear_last_sent_msg(PORT0);
 	pe_set_flag(PORT0, PE_FLAGS_PROTOCOL_ERROR);
 	pe_clr_flag(PORT0, PE_FLAGS_PD_CONNECTION);
 	set_state_pe(PORT0, PE_SRC_SEND_CAPABILITIES);
 	task_wait_event(10 * MSEC);
-	TEST_EQ(fake_prl_get_last_sent_ctrl_msg(PORT0), 0, "%d");
+	TEST_EQ(mock_prl_get_last_sent_ctrl_msg(PORT0), 0, "%d");
 	TEST_EQ(get_state_pe(PORT0), PE_SRC_DISCOVERY, "%d");
 
 	/*
@@ -391,12 +392,12 @@ static int test_send_caps_error(void)
 	 *  1) The Protocol Layer indicates that the Message has not been sent
 	 *     and we are already Connected
 	 */
-	fake_prl_clear_last_sent_ctrl_msg(PORT0);
+	mock_prl_clear_last_sent_msg(PORT0);
 	pe_set_flag(PORT0, PE_FLAGS_PROTOCOL_ERROR);
 	pe_set_flag(PORT0, PE_FLAGS_PD_CONNECTION);
 	set_state_pe(PORT0, PE_SRC_SEND_CAPABILITIES);
 	task_wait_event(10 * MSEC);
-	TEST_EQ(fake_prl_get_last_sent_ctrl_msg(PORT0),
+	TEST_EQ(mock_prl_get_last_sent_ctrl_msg(PORT0),
 		PD_CTRL_SOFT_RESET, "%d");
 	TEST_EQ(get_state_pe(PORT0), PE_SEND_SOFT_RESET, "%d");