snapshot of https://github.com/pion/webrtc.git (main, 2026-09-15; blobs > 131072B omitted)

2026-09-15 20:06:07 +05:00
commit 8acb1a3a29
394 changed files with 78746 additions and 0 deletions
--- a/icecandidate_test.go
+++ b/icecandidate_test.go
@@ -0,0 +1,367 @@
+// SPDX-FileCopyrightText: 2026 The Pion community <https://pion.ly>
+// SPDX-License-Identifier: MIT
+
+package webrtc
+
+import (
+	"testing"
+
+	"github.com/pion/ice/v4"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestICECandidate_Convert(t *testing.T) {
+	testCases := []struct {
+		native ICECandidate
+
+		expectedType           ice.CandidateType
+		expectedNetwork        string
+		expectedAddress        string
+		expectedPort           int
+		expectedComponent      uint16
+		expectedRelatedAddress *ice.CandidateRelatedAddress
+	}{
+		{
+			ICECandidate{
+				Foundation: "foundation",
+				Priority:   128,
+				Address:    "1.0.0.1",
+				Protocol:   ICEProtocolUDP,
+				Port:       1234,
+				Typ:        ICECandidateTypeHost,
+				Component:  1,
+			},
+
+			ice.CandidateTypeHost,
+			"udp",
+			"1.0.0.1",
+			1234,
+			1,
+			nil,
+		},
+		{
+			ICECandidate{
+				Foundation:     "foundation",
+				Priority:       128,
+				Address:        "::1",
+				Protocol:       ICEProtocolUDP,
+				Port:           1234,
+				Typ:            ICECandidateTypeSrflx,
+				Component:      1,
+				RelatedAddress: "1.0.0.1",
+				RelatedPort:    4321,
+			},
+
+			ice.CandidateTypeServerReflexive,
+			"udp",
+			"::1",
+			1234,
+			1,
+			&ice.CandidateRelatedAddress{
+				Address: "1.0.0.1",
+				Port:    4321,
+			},
+		},
+		{
+			ICECandidate{
+				Foundation:     "foundation",
+				Priority:       128,
+				Address:        "::1",
+				Protocol:       ICEProtocolUDP,
+				Port:           1234,
+				Typ:            ICECandidateTypePrflx,
+				Component:      1,
+				RelatedAddress: "1.0.0.1",
+				RelatedPort:    4321,
+			},
+
+			ice.CandidateTypePeerReflexive,
+			"udp",
+			"::1",
+			1234,
+			1,
+			&ice.CandidateRelatedAddress{
+				Address: "1.0.0.1",
+				Port:    4321,
+			},
+		},
+	}
+
+	for i, testCase := range testCases {
+		var expectedICE ice.Candidate
+		var err error
+		switch testCase.expectedType { // nolint:exhaustive
+		case ice.CandidateTypeHost:
+			config := ice.CandidateHostConfig{
+				Network:    testCase.expectedNetwork,
+				Address:    testCase.expectedAddress,
+				Port:       testCase.expectedPort,
+				Component:  testCase.expectedComponent,
+				Foundation: "foundation",
+				Priority:   128,
+			}
+			expectedICE, err = ice.NewCandidateHost(&config)
+		case ice.CandidateTypeServerReflexive:
+			config := ice.CandidateServerReflexiveConfig{
+				Network:    testCase.expectedNetwork,
+				Address:    testCase.expectedAddress,
+				Port:       testCase.expectedPort,
+				Component:  testCase.expectedComponent,
+				Foundation: "foundation",
+				Priority:   128,
+				RelAddr:    testCase.expectedRelatedAddress.Address,
+				RelPort:    testCase.expectedRelatedAddress.Port,
+			}
+			expectedICE, err = ice.NewCandidateServerReflexive(&config)
+		case ice.CandidateTypePeerReflexive:
+			config := ice.CandidatePeerReflexiveConfig{
+				Network:    testCase.expectedNetwork,
+				Address:    testCase.expectedAddress,
+				Port:       testCase.expectedPort,
+				Component:  testCase.expectedComponent,
+				Foundation: "foundation",
+				Priority:   128,
+				RelAddr:    testCase.expectedRelatedAddress.Address,
+				RelPort:    testCase.expectedRelatedAddress.Port,
+			}
+			expectedICE, err = ice.NewCandidatePeerReflexive(&config)
+		}
+		assert.NoError(t, err)
+
+		// first copy the candidate ID so it matches the new one
+		testCase.native.statsID = expectedICE.ID()
+		actualICE, err := testCase.native.ToICE()
+		assert.NoError(t, err)
+
+		assert.Equal(t, expectedICE, actualICE, "testCase: %d ice not equal %v", i, actualICE)
+	}
+}
+
+func TestConvertTypeFromICE(t *testing.T) {
+	t.Run("host", func(t *testing.T) {
+		ct, err := convertTypeFromICE(ice.CandidateTypeHost)
+		assert.NoError(t, err, "failed coverting ice.CandidateTypeHost")
+		assert.Equal(t, ICECandidateTypeHost, ct, "should be converted to ICECandidateTypeHost")
+	})
+	t.Run("srflx", func(t *testing.T) {
+		ct, err := convertTypeFromICE(ice.CandidateTypeServerReflexive)
+		assert.NoError(t, err, "failed coverting ice.CandidateTypeServerReflexive")
+		assert.Equal(t, ICECandidateTypeSrflx, ct, "should be converted to ICECandidateTypeSrflx")
+	})
+	t.Run("prflx", func(t *testing.T) {
+		ct, err := convertTypeFromICE(ice.CandidateTypePeerReflexive)
+		assert.NoError(t, err, "failed coverting ice.CandidateTypePeerReflexive")
+		assert.Equal(t, ICECandidateTypePrflx, ct, "should be converted to ICECandidateTypePrflx")
+	})
+}
+
+func TestNewIdentifiedICECandidateFromICE(t *testing.T) {
+	config := ice.CandidateHostConfig{
+		Network:    "udp",
+		Address:    "::1",
+		Port:       1234,
+		Component:  1,
+		Foundation: "foundation",
+		Priority:   128,
+	}
+	ice, err := ice.NewCandidateHost(&config)
+	assert.NoError(t, err)
+
+	ct, err := newICECandidateFromICE(ice, "1", 2)
+	assert.NoError(t, err)
+
+	assert.Equal(t, "1", ct.SDPMid)
+	assert.Equal(t, uint16(2), ct.SDPMLineIndex)
+}
+
+func TestNewIdentifiedICECandidatesFromICE(t *testing.T) {
+	ic, err := ice.NewCandidateHost(&ice.CandidateHostConfig{
+		Network:    "udp",
+		Address:    "::1",
+		Port:       1234,
+		Component:  1,
+		Foundation: "foundation",
+		Priority:   128,
+	})
+
+	assert.NoError(t, err)
+
+	candidates := []ice.Candidate{ic, ic, ic}
+
+	sdpMid := "1"
+	sdpMLineIndex := uint16(2)
+
+	results, err := newICECandidatesFromICE(candidates, sdpMid, sdpMLineIndex)
+
+	assert.NoError(t, err)
+
+	assert.Equal(t, 3, len(results))
+
+	for _, result := range results {
+		assert.Equal(t, sdpMid, result.SDPMid)
+		assert.Equal(t, sdpMLineIndex, result.SDPMLineIndex)
+	}
+}
+
+func TestICECandidate_ToJSON(t *testing.T) {
+	candidate := ICECandidate{
+		Foundation: "foundation",
+		Priority:   128,
+		Address:    "1.0.0.1",
+		Protocol:   ICEProtocolUDP,
+		Port:       1234,
+		Typ:        ICECandidateTypeHost,
+		Component:  1,
+	}
+
+	candidateInit := candidate.ToJSON()
+
+	assert.Equal(t, uint16(0), *candidateInit.SDPMLineIndex)
+	assert.Equal(t, "candidate:foundation 1 udp 128 1.0.0.1 1234 typ host", candidateInit.Candidate)
+}
+
+func TestICECandidateZeroSDPid(t *testing.T) {
+	candidate := ICECandidate{}
+
+	assert.Equal(t, candidate.SDPMid, "")
+	assert.Equal(t, candidate.SDPMLineIndex, uint16(0))
+}
+
+func TestICECandidateString(t *testing.T) {
+	candidate := ICECandidate{
+		Foundation: "foundation",
+		Priority:   128,
+		Address:    "1.0.0.1",
+		Protocol:   ICEProtocolUDP,
+		Port:       1234,
+		Typ:        ICECandidateTypeHost,
+		Component:  1,
+	}
+	iceCandidateConfig := ice.CandidateHostConfig{
+		Network:    "udp",
+		Address:    "1.0.0.1",
+		Port:       1234,
+		Component:  1,
+		Foundation: "foundation",
+		Priority:   128,
+	}
+	iceCandidate, err := ice.NewCandidateHost(&iceCandidateConfig)
+	assert.NoError(t, err)
+
+	assert.Equal(t, candidate.String(), iceCandidate.String())
+}
+
+func TestICECandidateSDPMid_ToJSON(t *testing.T) {
+	candidate := ICECandidate{}
+
+	candidate.SDPMid = "0"
+	candidate.SDPMLineIndex = 1
+
+	assert.Equal(t, candidate.SDPMid, "0")
+	assert.Equal(t, candidate.SDPMLineIndex, uint16(1))
+}
+
+func TestICECandidateExtensions_ToJSON(t *testing.T) {
+	candidates := []struct {
+		candidate  string
+		extensions []ice.CandidateExtension
+	}{
+		{
+			"2637185494 1 udp 2121932543 192.168.1.4 50723 typ host generation 1 ufrag Jzd0 network-id 1",
+			[]ice.CandidateExtension{
+				{
+					Key:   "generation",
+					Value: "1",
+				},
+				{
+					Key:   "ufrag",
+					Value: "Jzd0",
+				},
+				{
+					Key:   "network-id",
+					Value: "1",
+				},
+			},
+		},
+		{
+			"1052353102 1 tcp 2128609279 192.168.0.196 0 typ host tcptype active ufrag Jzd0 network-id 1",
+			[]ice.CandidateExtension{
+				{
+					Key:   "tcptype",
+					Value: "active",
+				},
+				{
+					Key:   "ufrag",
+					Value: "Jzd0",
+				},
+				{
+					Key:   "network-id",
+					Value: "1",
+				},
+			},
+		},
+		{
+			"1052353102 1 tcp 2128609279 192.168.0.196 0 typ host tcptype active ufrag Jzd0 network-id 1 empty-ext ",
+			[]ice.CandidateExtension{
+				{
+					Key:   "tcptype",
+					Value: "active",
+				},
+				{
+					Key:   "ufrag",
+					Value: "Jzd0",
+				},
+				{
+					Key:   "network-id",
+					Value: "1",
+				},
+				{
+					Key:   "empty-ext",
+					Value: "",
+				},
+			},
+		},
+		{
+			"1052353102 1 tcp 2128609279 192.168.0.196 0 typ host tcptype active ufrag Jzd0 empty-ext  network-id 1",
+			[]ice.CandidateExtension{
+				{
+					Key:   "tcptype",
+					Value: "active",
+				},
+				{
+					Key:   "ufrag",
+					Value: "Jzd0",
+				},
+				{
+					Key:   "empty-ext",
+					Value: "",
+				},
+				{
+					Key:   "network-id",
+					Value: "1",
+				},
+			},
+		},
+	}
+
+	for _, cand := range candidates {
+		candidate, err := ice.UnmarshalCandidate(cand.candidate)
+		assert.NoError(t, err)
+
+		sdpMid := "1"
+		sdpMLineIndex := uint16(2)
+
+		iceCandidate, err := newICECandidateFromICE(candidate, sdpMid, sdpMLineIndex)
+		assert.NoError(t, err)
+
+		candidateInit := iceCandidate.ToJSON()
+
+		assert.Equal(t, sdpMLineIndex, *candidateInit.SDPMLineIndex)
+		assert.Equal(t, "candidate:"+cand.candidate, candidateInit.Candidate)
+
+		iceBack, err := iceCandidate.ToICE()
+
+		assert.NoError(t, err)
+		assert.Equal(t, cand.extensions, iceBack.Extensions())
+	}
+}