AI: Refine utest for WebRTC AV1.

Author: ossrs-ai

trunk/src/app/srs_app_rtc_api.cpp

@@ -666,16 +666,16 @@ srs_error_t SrsGoApiRtcWhip::serve_http(ISrsHttpResponseWriter *w, ISrsHttpMessa
     string code_str;
     if (true) {
         srs_error_t err = srs_success;
-        
+
         err = serve_http_with(w, r);
         if (err == srs_success) {
             return err;
         }
 
         code = srs_error_code(err);
         code_str = srs_error_code_str(err);
-        srs_warn("WHIP: serve http for %s with err %d:%s, %s", 
-            r->url().c_str(), code, code_str.c_str(), srs_error_desc(err).c_str());
+        srs_warn("WHIP: serve http for %s with err %d:%s, %s",
+                 r->url().c_str(), code, code_str.c_str(), srs_error_desc(err).c_str());
         srs_freep(err);
     }
 

trunk/src/app/srs_app_rtc_source.cpp

@@ -3851,7 +3851,7 @@ srs_error_t SrsRtcFormat::on_rtp_packet(SrsRtcRecvTrack *track, bool is_audio)
             SrsAudioChannels channels = (SrsAudioChannels)audio_media->channel_;
 
             if ((err = stat_->on_audio_info(req_, codec_id, sample_rate, channels,
-                                             SrsAacObjectTypeReserved)) != srs_success) {
+                                            SrsAacObjectTypeReserved)) != srs_success) {
                 return srs_error_wrap(err, "stat audio info");
             }
             srs_trace("RTC: parsed %s codec, sample_rate=%dHz, channels=%d",

trunk/src/kernel/srs_kernel_error.hpp

@@ -111,10 +111,9 @@
     XX(ERROR_STREAM_DISPOSING, 1098, "StreamDisposing", "Stream is disposing")                                         \
     XX(ERROR_NOT_IMPLEMENTED, 1099, "NotImplemented", "Feature is not implemented")                                    \
     XX(ERROR_NOT_SUPPORTED, 1100, "NotSupported", "Feature is not supported")                                          \
-    XX(ERROR_SYSTEM_FILE_UNLINK, 1101, "FileUnlink", "Failed to unlink file") \
+    XX(ERROR_SYSTEM_FILE_UNLINK, 1101, "FileUnlink", "Failed to unlink file")                                          \
     XX(ERROR_SYSTEM_AUTH, 1102, "SystemAuth", "Failed to authenticate stream")
 
-
 /**************************************************/
 /* RTMP protocol error. */
 #define SRS_ERRNO_MAP_RTMP(XX)                                                                                         \
@@ -382,7 +381,7 @@
     XX(ERROR_RTSP_NO_TRACK, 5039, "RtspNoTrack", "Drop RTSP packet for track not found")                                                              \
     XX(ERROR_RTSP_TOKEN_NOT_NORMAL, 5040, "RtspToken", "Invalid RTSP token state not normal")                                                         \
     XX(ERROR_RTSP_REQUEST_HEADER_EOF, 5041, "RtspHeaderEof", "Invalid RTSP request for header EOF")                                                   \
-    XX(ERROR_RTSP_NEED_MORE_DATA, 5042, "RtspNeedMoreData", "Need more data to complete RTCP frame parsing") \
+    XX(ERROR_RTSP_NEED_MORE_DATA, 5042, "RtspNeedMoreData", "Need more data to complete RTCP frame parsing")                                          \
     XX(ERROR_RTC_INVALID_SDP, 5043, "RtcInvalidSdp", "Invalid SDP for RTC")
 
 /**************************************************/
@@ -492,7 +491,7 @@ class SrsCplxError
 //      }
 #define srs_error_new(code, fmt, ...) SrsCplxError::create(__FUNCTION__, __FILE__, __LINE__, code, fmt, ##__VA_ARGS__)
 
-// Wrap an existing error with additional context. The error code is 
+// Wrap an existing error with additional context. The error code is
 // preserved from the wrapped error.
 //
 // Example:
@@ -501,8 +500,8 @@ class SrsCplxError
 //      }
 #define srs_error_wrap(err, fmt, ...) SrsCplxError::wrap(__FUNCTION__, __FILE__, __LINE__, err, fmt, ##__VA_ARGS__)
 
-// Transform an error by wrapping it and changing its error code. Useful 
-// for converting internal errors to protocol-specific error codes (e.g., 
+// Transform an error by wrapping it and changing its error code. Useful
+// for converting internal errors to protocol-specific error codes (e.g.,
 // HTTP, RTMP). The wrapped error chain is preserved.
 //
 // Example:

trunk/src/utest/srs_utest_ai18.cpp

@@ -21,6 +21,7 @@ using namespace std;
 #include <srs_kernel_utility.hpp>
 #include <srs_protocol_utility.hpp>
 #include <srs_utest_ai23.hpp>
+#include <srs_utest_manual_mock.hpp>
 #include <sstream>
 
 // Mock ISrsSrtSocket implementation
@@ -193,10 +194,11 @@ VOID TEST(UdpListenerTest, ListenAndReceivePacket)
     dest_addr.sin_port = htons(port);
     dest_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
 
-    for (int i = 0; i < 3; i++) {
+    for (int i = 0; i < 10; i++) {
         int sent = srs_sendto(client_fd, (void *)test_data.c_str(), test_data.size(),
                               (sockaddr *)&dest_addr, sizeof(dest_addr), SRS_UTIME_NO_TIMEOUT);
         EXPECT_EQ(sent, (int)test_data.size());
+        srs_usleep(1 * SRS_UTIME_MILLISECONDS);
     }
 
     // Wait a bit for the listener to receive and process the packet
@@ -2186,39 +2188,8 @@ VOID TEST(ApiServerAsCandidatesTest, MajorUseScenario)
     EXPECT_TRUE(candidate_ips.find("192.168.1.100") != candidate_ips.end());
 }
 
-// Mock SrsProtocolUtility implementation
-MockProtocolUtility::MockProtocolUtility()
-{
-}
-
-MockProtocolUtility::~MockProtocolUtility()
-{
-    clear_ips();
-}
-
-vector<SrsIPAddress *> &MockProtocolUtility::local_ips()
-{
-    return mock_ips_;
-}
-
-void MockProtocolUtility::add_ip(string ip, string ifname, bool is_ipv4, bool is_loopback, bool is_internet)
-{
-    SrsIPAddress *addr = new SrsIPAddress();
-    addr->ip_ = ip;
-    addr->ifname_ = ifname;
-    addr->is_ipv4_ = is_ipv4;
-    addr->is_loopback_ = is_loopback;
-    addr->is_internet_ = is_internet;
-    mock_ips_.push_back(addr);
-}
-
-void MockProtocolUtility::clear_ips()
-{
-    for (size_t i = 0; i < mock_ips_.size(); i++) {
-        srs_freep(mock_ips_[i]);
-    }
-    mock_ips_.clear();
-}
+// Note: MockProtocolUtility has been merged into MockProtocolUtility
+// in srs_utest_manual_mock.hpp/cpp. All usages below now use MockProtocolUtility.
 
 // Mock ISrsAppConfig for discover_candidates implementation
 MockAppConfigForDiscoverCandidates::MockAppConfigForDiscoverCandidates()

trunk/src/utest/srs_utest_ai18.hpp

@@ -196,19 +196,8 @@ class MockHttpHooksForSrt : public ISrsHttpHooks
     void clear_calls();
 };
 
-// Mock SrsProtocolUtility for testing discover_candidates
-class MockProtocolUtility : public SrsProtocolUtility
-{
-public:
-    std::vector<SrsIPAddress *> mock_ips_;
-
-public:
-    MockProtocolUtility();
-    virtual ~MockProtocolUtility();
-    virtual std::vector<SrsIPAddress *> &local_ips();
-    void add_ip(std::string ip, std::string ifname, bool is_ipv4, bool is_loopback, bool is_internet);
-    void clear_ips();
-};
+// Note: MockProtocolUtility has been merged into MockProtocolUtility
+// in srs_utest_manual_mock.hpp. Use MockProtocolUtility instead.
 
 // Mock ISrsAppConfig for testing discover_candidates
 class MockAppConfigForDiscoverCandidates : public MockAppConfig

trunk/src/utest/srs_utest_manual_mock.cpp

@@ -306,6 +306,8 @@ ISrsRequest *MockRtcAsyncCallRequest::as_http()
 MockRtcSource::MockRtcSource()
 {
     on_rtp_count_ = 0;
+    rtp_audio_count_ = 0;
+    rtp_video_count_ = 0;
 }
 
 MockRtcSource::~MockRtcSource()
@@ -315,6 +317,14 @@ MockRtcSource::~MockRtcSource()
 srs_error_t MockRtcSource::on_rtp(SrsRtpPacket *pkt)
 {
     on_rtp_count_++;
+
+    // Count audio and video packets separately
+    if (pkt->frame_type_ == SrsFrameTypeAudio) {
+        rtp_audio_count_++;
+    } else if (pkt->frame_type_ == SrsFrameTypeVideo) {
+        rtp_video_count_++;
+    }
+
     return SrsRtcSource::on_rtp(pkt);
 }
 
@@ -2337,3 +2347,53 @@ void MockAudioTranscoder::aac_codec_header(uint8_t **data, int *len)
     *data = copy;
     *len = size;
 }
+
+// Mock ISrsProtocolUtility implementation
+MockProtocolUtility::MockProtocolUtility(std::string ip)
+{
+    mock_ip_ = ip;
+}
+
+MockProtocolUtility::~MockProtocolUtility()
+{
+    clear_ips();
+}
+
+std::vector<SrsIPAddress *> &MockProtocolUtility::local_ips()
+{
+    if (!ips_.empty()) {
+        return ips_;
+    }
+
+    // If mock_ip_ is set (via constructor), create a default IP address
+    if (!mock_ip_.empty()) {
+        SrsIPAddress *addr = new SrsIPAddress();
+        addr->ip_ = mock_ip_;
+        addr->is_ipv4_ = true;
+        addr->is_loopback_ = false; // Not loopback
+        addr->is_internet_ = true;  // Public IP
+        addr->ifname_ = "eth0";     // Interface name
+        ips_.push_back(addr);
+    }
+
+    return ips_;
+}
+
+void MockProtocolUtility::add_ip(std::string ip, std::string ifname, bool is_ipv4, bool is_loopback, bool is_internet)
+{
+    SrsIPAddress *addr = new SrsIPAddress();
+    addr->ip_ = ip;
+    addr->ifname_ = ifname;
+    addr->is_ipv4_ = is_ipv4;
+    addr->is_loopback_ = is_loopback;
+    addr->is_internet_ = is_internet;
+    ips_.push_back(addr);
+}
+
+void MockProtocolUtility::clear_ips()
+{
+    for (size_t i = 0; i < ips_.size(); i++) {
+        srs_freep(ips_[i]);
+    }
+    ips_.clear();
+}

trunk/src/utest/srs_utest_manual_mock.hpp

@@ -162,6 +162,8 @@ class MockRtcSource : public SrsRtcSource
 {
 public:
     int on_rtp_count_;
+    int rtp_audio_count_;
+    int rtp_video_count_;
 
 public:
     MockRtcSource();
@@ -1332,4 +1334,23 @@ class MockAudioTranscoder : public ISrsAudioTranscoder
     virtual void aac_codec_header(uint8_t **data, int *len);
 };
 
+// Mock ISrsProtocolUtility for testing RTC connections
+// This class merges functionality from MockProtocolUtility in srs_utest_ai18.hpp
+// It supports both simple single-IP usage (via constructor) and complex multi-IP usage (via add_ip)
+class MockProtocolUtility : public ISrsProtocolUtility
+{
+public:
+    std::vector<SrsIPAddress *> ips_;
+    std::string mock_ip_;
+
+public:
+    MockProtocolUtility(std::string ip = "");
+    virtual ~MockProtocolUtility();
+
+public:
+    virtual std::vector<SrsIPAddress *> &local_ips();
+    void add_ip(std::string ip, std::string ifname, bool is_ipv4, bool is_loopback, bool is_internet);
+    void clear_ips();
+};
+
 #endif

trunk/src/utest/srs_utest_workflow_rtc_conn.cpp

@@ -34,73 +34,6 @@
 #include <srs_utest_manual_mock.hpp>
 #include <srs_utest_manual_service.hpp>
 
-MockProtocolUtilityForRtcConn::MockProtocolUtilityForRtcConn(std::string ip)
-{
-    mock_ip_ = ip;
-}
-
-MockProtocolUtilityForRtcConn::~MockProtocolUtilityForRtcConn()
-{
-}
-
-std::vector<SrsIPAddress *> &MockProtocolUtilityForRtcConn::local_ips()
-{
-    if (!ips_.empty()) {
-        return ips_;
-    }
-
-    SrsIPAddress *addr = new SrsIPAddress();
-    addr->ip_ = mock_ip_;
-    addr->is_ipv4_ = true;
-    addr->is_loopback_ = false; // Not loopback
-    addr->is_internet_ = true;  // Public IP
-    addr->ifname_ = "eth0";     // Interface name
-    ips_.push_back(addr);
-
-    return ips_;
-}
-
-MockAppFactoryForRtcConn::MockAppFactoryForRtcConn()
-{
-    mock_protocol_utility_ = NULL;
-}
-
-MockAppFactoryForRtcConn::~MockAppFactoryForRtcConn()
-{
-}
-
-ISrsProtocolUtility *MockAppFactoryForRtcConn::create_protocol_utility()
-{
-    return mock_protocol_utility_;
-}
-
-ISrsRtcPublishStream *MockAppFactoryForRtcConn::create_rtc_publish_stream(ISrsExecRtcAsyncTask *exec, ISrsExpire *expire, ISrsRtcPacketReceiver *receiver, const SrsContextId &cid)
-{
-    SrsRtcPublishStream *publisher = new SrsRtcPublishStream(exec, expire, receiver, cid);
-    publisher->rtc_sources_ = rtc_sources_;
-    return publisher;
-}
-
-MockRtcSourceForRtcConn::MockRtcSourceForRtcConn()
-{
-    rtp_audio_count_ = 0;
-    rtp_video_count_ = 0;
-}
-
-MockRtcSourceForRtcConn::~MockRtcSourceForRtcConn()
-{
-}
-
-srs_error_t MockRtcSourceForRtcConn::on_rtp(SrsRtpPacket *pkt)
-{
-    if (pkt->frame_type_ == SrsFrameTypeAudio) {
-        rtp_audio_count_++;
-    } else if (pkt->frame_type_ == SrsFrameTypeVideo) {
-        rtp_video_count_++;
-    }
-    return srs_success;
-}
-
 // This test is used to verify the basic workflow of the RTC connection.
 // It's finished with the help of AI, but each step is manually designed
 // and verified. So this is not dominated by AI, but by humanbeing.
@@ -120,8 +53,8 @@ VOID TEST(BasicWorkflowRtcConnTest, ManuallyVerifyForPlayer)
     mock_config->rtc_dtls_role_ = "passive";
     mock_dtls_certificate->fingerprint_ = "test-fingerprint";
     mock_app_factory->rtc_sources_ = mock_rtc_sources.get();
-    mock_app_factory->mock_protocol_utility_ = new MockProtocolUtilityForRtcConn("192.168.1.100");
-    MockRtcSourceForRtcConn *mock_rtc_source = new MockRtcSourceForRtcConn();
+    mock_app_factory->mock_protocol_utility_ = new MockProtocolUtility("192.168.1.100");
+    MockRtcSource *mock_rtc_source = new MockRtcSource();
     mock_rtc_sources->mock_source_ = SrsSharedPtr<SrsRtcSource>(mock_rtc_source);
 
     // Create a real ISrsRtcConnection using _srs_app_factory_
@@ -271,8 +204,8 @@ VOID TEST(BasicWorkflowRtcConnTest, ManuallyVerifyForPublisher)
     mock_config->rtc_dtls_role_ = "passive";
     mock_dtls_certificate->fingerprint_ = "test-fingerprint";
     mock_app_factory->rtc_sources_ = mock_rtc_sources.get();
-    mock_app_factory->mock_protocol_utility_ = new MockProtocolUtilityForRtcConn("192.168.1.100");
-    MockRtcSourceForRtcConn *mock_rtc_source = new MockRtcSourceForRtcConn();
+    mock_app_factory->mock_protocol_utility_ = new MockProtocolUtility("192.168.1.100");
+    MockRtcSource *mock_rtc_source = new MockRtcSource();
     mock_rtc_sources->mock_source_ = SrsSharedPtr<SrsRtcSource>(mock_rtc_source);
 
     // Create a real ISrsRtcConnection using _srs_app_factory_