Function Test_recv_buf_full

tests/test_connection.cpp:1112–1204

Coverage/stress test for a stalled receiver: the application stops draining its receive queue while the peer keeps blasting reliable data, under loss and reorder. This drives a code path almost nothing else in the suite reaches. Simulates an app stall (e.g. loading assets from disk) while the server is blasting reliable state data. The client never calls ReceiveMessagesOnConnection, so its appl

// server keeps advancing its stop_waiting.  Layering loss and reorder on the
// server->client path keeps the gap map churning throughout.
void Test_recv_buf_full()
{
	TEST_Printf( "***************************************************\n" );
	TEST_Printf( "Test: recv buffer full / stalled receiver under loss+reorder\n" );
	TEST_Printf( "***************************************************\n" );

	// Network loopback so packets go through the full SNP encode/decode path.
	HSteamNetConnection hServer, hClient;
	assert( SteamNetworkingSockets()->CreateSocketPair( &hServer, &hClient, true, nullptr, nullptr ) );
	SteamNetworkingSockets()->SetConnectionName( hServer, "Server" );
	SteamNetworkingSockets()->SetConnectionName( hClient, "Client" );

	// Small application receive queue on the client.  After this many messages
	// are queued without the app draining them, ReceivedMessage() returns false,
	// which propagates to bInhibitMarkReceived in the SNP decoder.
	SteamNetworkingUtils()->SetConnectionConfigValueInt32( hClient,
		k_ESteamNetworkingConfig_RecvBufferMessages, 32 );

	// Moderate send rate -- enough to fill the queue quickly but not so fast
	// that the service thread starves the client's keepalive sending.
	const int k_nSendRate = 256 * 1024;
	SteamNetworkingUtils()->SetConnectionConfigValueInt32( hServer,
		k_ESteamNetworkingConfig_SendRateMin, k_nSendRate );
	SteamNetworkingUtils()->SetConnectionConfigValueInt32( hServer,
		k_ESteamNetworkingConfig_SendRateMax, k_nSendRate );

	// Simulate real-world network conditions: packet loss and reordering on
	// the server->client path.  This creates non-trivial gap map state on the
	// client before and during the buffer-full condition, which may interact
	// with the stop_waiting/sentinel relationship differently.
	SteamNetworkingUtils()->SetConnectionConfigValueInt32( hClient,
		k_ESteamNetworkingConfig_FakePacketLoss_Recv, 5 );
	SteamNetworkingUtils()->SetConnectionConfigValueInt32( hClient,
		k_ESteamNetworkingConfig_FakePacketReorder_Recv, 10 );
	SteamNetworkingUtils()->SetConnectionConfigValueInt32( hClient,
		k_ESteamNetworkingConfig_FakePacketReorder_Time, 20 );

	// Let the connection settle so all handshake traffic is complete and acks
	// have drained before the burst begins.
	for ( int i = 0; i < 20; ++i )
	{
		TEST_PumpCallbacks();
		std::this_thread::sleep_for( std::chrono::milliseconds( 10 ) );
	}

	// Queue up a large initial burst of reliable data -- far more than the
	// client's RecvBufferMessages limit.  The server drains this at k_nSendRate.
	static const char kData[ 1000 ] = {};
	int nSent = 0;
	for ( int i = 0; i < 2000; ++i )
	{
		EResult r = SteamNetworkingSockets()->SendMessageToConnection(
			hServer, kData, sizeof(kData), k_nSteamNetworkingSend_Reliable, nullptr );
		if ( r == k_EResultOK )
			++nSent;
	}
	TEST_Printf( "Queued %d messages (~%d KB) for server to send\n", nSent, nSent * (int)sizeof(kData) / 1024 );