From 861b29db617996e0c4d45e579b108897467fdd8f Mon Sep 17 00:00:00 2001 From: Haesu Gwon Date: Tue, 18 Oct 2022 16:04:51 +0900 Subject: [PATCH] [WebRTC][Non-ACR] Code clean Remove useless code and add debug info Change-Id: I955bf6920c4bb5841d18299bc0bf8ba5bea78da6 --- .../testcase/TSMediaFileSource.cs | 5 - .../TSMediaPacketBufferStatusChangedEventArgs.cs | 46 ++- .../testcase/TSMediaPacketSource.cs | 15 +- .../testcase/TSMediaPacketSourceConfiguration.cs | 18 +- .../testcase/TSMediaStreamTrack.cs | 456 ++++++++++++++------- .../testcase/TSWebRTC.Events.DataChannel.cs | 28 +- .../testcase/TSWebRTC.Events.FrameEncoded.cs | 53 ++- .../testcase/TSWebRTC.Events.IceCandidate.cs | 27 +- .../TSWebRTC.Events.IceConnectionStateChanged.cs | 49 ++- .../TSWebRTC.Events.IceGatheringStateChanged.cs | 27 ++ .../testcase/TSWebRTC.Events.NegotiationNeeded.cs | 15 +- .../TSWebRTC.Events.PeerConnectionStateChanged.cs | 37 +- .../TSWebRTC.Events.SignalingStateChanged.cs | 27 ++ .../testcase/TSWebRTC.Events.StateChanged.cs | 25 ++ .../testcase/TSWebRTC.Events.TrackAdded.cs | 24 +- .../Tizen.WebRTC.Tests/testcase/TSWebRTC.cs | 25 +- .../testcase/TSWebRTC.statistics.cs | 3 +- .../testcase/TSWebRTCDataChannel.Events.cs | 64 ++- .../testcase/TSWebRTCDataChannel.cs | 64 ++- .../testcase/TSWebRTCDataChannelEventArgs.cs | 36 +- .../TSWebRTCDataChannelMessageReceivedEventArgs.cs | 92 +++-- .../testcase/TSWebRTCFrameEncodedEventArgs.cs | 100 +++-- .../testcase/TSWebRTCIceCandidateEventArgs.cs | 29 +- .../TSWebRTCIceConnectionStateChangedEventArgs.cs | 27 ++ .../TSWebRTCIceGatheringStateChangedEventArgs.cs | 25 ++ .../TSWebRTCPeerConnectionStateChangedEventArgs.cs | 27 ++ .../TSWebRTCSignalingStateChangedEventArgs.cs | 49 ++- .../testcase/TSWebRTCStateChangedEventArgs.cs | 54 ++- .../testcase/TSWebRTCTrackAddedEventArgs.cs | 53 ++- .../testcase/support/TestBase.cs | 26 ++ 30 files changed, 1140 insertions(+), 386 deletions(-) diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaFileSource.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaFileSource.cs index 6d8a71e..b162325 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaFileSource.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaFileSource.cs @@ -268,16 +268,11 @@ namespace Tizen.Multimedia.Remoting.Tests { public async Task SetTransceiverDirection_THROWS_IF_INVALID_STATE() { using (var offerClient = new WebRTC()) - using (var answerClient = new WebRTC()) { var source = new MediaFileSource(Mp4VideoFilePath); offerClient.AddSource(source); - await offerClient.StartAsync(); - await answerClient.StartAsync(); - - await ConnectPeerAsync(offerClient, answerClient); Assert.That(() => source.SetTransceiverDirection(MediaType.Video, TransceiverDirection.SendRecv), Throws.InvalidOperationException, "Should return InvalidOperationException"); diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketBufferStatusChangedEventArgs.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketBufferStatusChangedEventArgs.cs index 39d81a3..df95de1 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketBufferStatusChangedEventArgs.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketBufferStatusChangedEventArgs.cs @@ -15,6 +15,7 @@ */ using NUnit.Framework; +using System; using System.Threading.Tasks; namespace Tizen.Multimedia.Remoting.Tests @@ -38,7 +39,8 @@ namespace Tizen.Multimedia.Remoting.Tests { var mediaPacketSource = new MediaPacketSource( new VideoMediaFormat(MediaFormatVideoMimeType.H264SP, 640, 480)); - mediaPacketSource.VideoConfiguration.BufferStatusChanged += (s, e) => + + EventHandler eventHandler = (s, e) => { Assert.IsInstanceOf(e.SourceId, "Should be uint"); Assert.That(e.SourceId > 0, "Should return valid sourceId"); @@ -50,9 +52,17 @@ namespace Tizen.Multimedia.Remoting.Tests } }; - webRtc.AddSource(mediaPacketSource); + mediaPacketSource.VideoConfiguration.BufferStatusChanged += eventHandler; - await webRtc.StartAsync(); + try + { + webRtc.AddSource(mediaPacketSource); + await webRtc.StartAsync(); + } + finally + { + mediaPacketSource.VideoConfiguration.BufferStatusChanged -= eventHandler; + } } } @@ -71,7 +81,8 @@ namespace Tizen.Multimedia.Remoting.Tests { var mediaPacketSource = new MediaPacketSource( new VideoMediaFormat(MediaFormatVideoMimeType.H264SP, 640, 480)); - mediaPacketSource.VideoConfiguration.BufferStatusChanged += (s, e) => + + EventHandler eventHandler = (s, e) => { Assert.IsInstanceOf(e.Status, "Should be uint"); Assert.That(e.Status == MediaPacketBufferStatus.Underrun, "Should return valid status"); @@ -83,9 +94,17 @@ namespace Tizen.Multimedia.Remoting.Tests } }; - webRtc.AddSource(mediaPacketSource); + mediaPacketSource.VideoConfiguration.BufferStatusChanged += eventHandler; - await webRtc.StartAsync(); + try + { + webRtc.AddSource(mediaPacketSource); + await webRtc.StartAsync(); + } + finally + { + mediaPacketSource.VideoConfiguration.BufferStatusChanged -= eventHandler; + } } } @@ -104,7 +123,8 @@ namespace Tizen.Multimedia.Remoting.Tests { var mediaPacketSource = new MediaPacketSource( new VideoMediaFormat(MediaFormatVideoMimeType.H264SP, 640, 480)); - mediaPacketSource.VideoConfiguration.BufferStatusChanged += (s, e) => + + EventHandler eventHandler = (s, e) => { Assert.AreEqual($"Source ID={e.SourceId}, Buffer status={e.Status}", e.ToString(), "Should be same string"); @@ -116,9 +136,17 @@ namespace Tizen.Multimedia.Remoting.Tests } }; - webRtc.AddSource(mediaPacketSource); + mediaPacketSource.VideoConfiguration.BufferStatusChanged += eventHandler; - await webRtc.StartAsync(); + try + { + webRtc.AddSource(mediaPacketSource); + await webRtc.StartAsync(); + } + finally + { + mediaPacketSource.VideoConfiguration.BufferStatusChanged -= eventHandler; + } } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketSource.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketSource.cs index 14c717a..f5a8308 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketSource.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketSource.cs @@ -190,7 +190,8 @@ namespace Tizen.Multimedia.Remoting.Tests { { var mediaPacketSource = new MediaPacketSource( new VideoMediaFormat(MediaFormatVideoMimeType.H264SP, 640, 480)); - mediaPacketSource.VideoConfiguration.BufferStatusChanged += (s, e) => + + EventHandler eventHandler = (s, e) => { if (needToPush && e.Status == MediaPacketBufferStatus.Underrun) { @@ -200,9 +201,17 @@ namespace Tizen.Multimedia.Remoting.Tests { } }; - webRtc.AddSource(mediaPacketSource); + mediaPacketSource.VideoConfiguration.BufferStatusChanged += eventHandler; - await webRtc.StartAsync(); + try + { + webRtc.AddSource(mediaPacketSource); + await webRtc.StartAsync(); + } + finally + { + mediaPacketSource.VideoConfiguration.BufferStatusChanged -= eventHandler; + } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketSourceConfiguration.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketSourceConfiguration.cs index 4ddbc0f..93b9153 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketSourceConfiguration.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaPacketSourceConfiguration.cs @@ -15,6 +15,7 @@ */ using NUnit.Framework; +using System; using System.Threading.Tasks; namespace Tizen.Multimedia.Remoting.Tests @@ -39,7 +40,8 @@ namespace Tizen.Multimedia.Remoting.Tests { var mediaPacketSource = new MediaPacketSource( new VideoMediaFormat(MediaFormatVideoMimeType.H264SP, 640, 480)); - mediaPacketSource.VideoConfiguration.BufferStatusChanged += (s, e) => + + EventHandler eventHandler = (s, e) => { if (needToPush && e.Status == MediaPacketBufferStatus.Underrun) { @@ -50,11 +52,19 @@ namespace Tizen.Multimedia.Remoting.Tests } }; - webRtc.AddSource(mediaPacketSource); + mediaPacketSource.VideoConfiguration.BufferStatusChanged += eventHandler; - await webRtc.StartAsync(); + try + { + webRtc.AddSource(mediaPacketSource); + await webRtc.StartAsync(); - Assert.That(await tcsBufferStateChanged.Task, "Event should be raised"); + Assert.That(await tcsBufferStateChanged.Task, "Event should be raised"); + } + finally + { + mediaPacketSource.VideoConfiguration.BufferStatusChanged -= eventHandler; + } } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaStreamTrack.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaStreamTrack.cs index 907bbe4..3188295 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaStreamTrack.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSMediaStreamTrack.cs @@ -52,21 +52,31 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => + EventHandler eventHandler = (s, e) => { Assert.That(e.MediaStreamTrack.Type == MediaType.Audio, "Should return same value"); tcsAnswerTrackAdded.TrySetResult(true); }; - _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); + _answerClient.TrackAdded += eventHandler; - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); + + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await ConnectPeerAsync(_offerClient, _answerClient); + await ConnectPeerAsync(_offerClient, _answerClient); - await tcsAnswerTrackAdded.Task; + await tcsAnswerTrackAdded.Task; + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -82,7 +92,7 @@ namespace Tizen.Multimedia.Remoting.Tests var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => + EventHandler eventHandler = (s, e) => { Assert.DoesNotThrow(() => e.MediaStreamTrack.Display = new Display(answerWindow), "Should not throw exception"); @@ -90,14 +100,24 @@ namespace Tizen.Multimedia.Remoting.Tests tcsAnswerTrackAdded.TrySetResult(true); }; - _offerClient.AddSource(new MediaTestSource(MediaType.Video)); + _answerClient.TrackAdded += eventHandler; - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Video)); + + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await ConnectPeerAsync(_offerClient, _answerClient); + await ConnectPeerAsync(_offerClient, _answerClient); - await tcsAnswerTrackAdded.Task; + await tcsAnswerTrackAdded.Task; + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -111,24 +131,34 @@ namespace Tizen.Multimedia.Remoting.Tests { var window = CreateWindow(); - var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => + EventHandler eventHandler = (s, e) => { Assert.That(() => e.MediaStreamTrack.Display = new Display(window), Throws.InvalidOperationException, "Should throw InvalidOperationException"); - tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + tcsAnswerTrackAdded.TrySetResult(true); }; - _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); + _answerClient.TrackAdded += eventHandler; - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); - await ConnectPeerAsync(_offerClient, _answerClient); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await tcsAnswerTrackAdded.Task; + await ConnectPeerAsync(_offerClient, _answerClient); + + await tcsAnswerTrackAdded.Task; + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -144,19 +174,31 @@ namespace Tizen.Multimedia.Remoting.Tests var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + EventHandler eventHandler = (s, e) => + tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + + _answerClient.TrackAdded += eventHandler; + + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Video)); - _offerClient.AddSource(new MediaTestSource(MediaType.Video)); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await ConnectPeerAsync(_offerClient, _answerClient); - await ConnectPeerAsync(_offerClient, _answerClient); + var mediaStreamTrack = await tcsAnswerTrackAdded.Task; - var mediaStreamTrack = await tcsAnswerTrackAdded.Task; + Assert.That(() => mediaStreamTrack.Display = new Display(window), Throws.InvalidOperationException, + "Should throw InvalidOperationException"); - Assert.That(() => mediaStreamTrack.Display = new Display(window), Throws.InvalidOperationException, - "Should throw InvalidOperationException"); + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -172,27 +214,39 @@ namespace Tizen.Multimedia.Remoting.Tests var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => + EventHandler eventHandler = (s, e) => { e.MediaStreamTrack.Display = new Display(answerWindow); tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); }; - _offerClient.AddSource(new MediaTestSource(MediaType.Video)); + _answerClient.TrackAdded += eventHandler; - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Video)); - await ConnectPeerAsync(_offerClient, _answerClient); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - var track = await tcsAnswerTrackAdded.Task; + await ConnectPeerAsync(_offerClient, _answerClient); - Assert.That(() => track.DisplayMode = WebRTCDisplayMode.OriginSize, Throws.Nothing, - "Should not throw exception"); + var track = await tcsAnswerTrackAdded.Task; + await Task.Delay(1000); - Assert.That(() => track.DisplayMode, Is.EqualTo(WebRTCDisplayMode.OriginSize), - "Should not throw exception"); + Assert.That(() => track.DisplayMode = WebRTCDisplayMode.OriginSize, Throws.Nothing, + "Should not throw exception"); + + Assert.That(() => track.DisplayMode, Is.EqualTo(WebRTCDisplayMode.OriginSize), + "Should not throw exception"); + + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -204,32 +258,43 @@ namespace Tizen.Multimedia.Remoting.Tests [Property("AUTHOR", "Haesu Gwon, haesu.gwon@samsung.com")] public async Task DisplayVisible_READ_WRITE() { - var offerWindow = CreateWindow(); var answerWindow = CreateWindow(); var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => + EventHandler eventHandler = (s, e) => { e.MediaStreamTrack.Display = new Display(answerWindow); tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); }; - _offerClient.AddSource(new MediaTestSource(MediaType.Video)); + _answerClient.TrackAdded += eventHandler; + + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Video)); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await ConnectPeerAsync(_offerClient, _answerClient); + await ConnectPeerAsync(_offerClient, _answerClient); - var track = await tcsAnswerTrackAdded.Task; + var track = await tcsAnswerTrackAdded.Task; + await Task.Delay(1000); - Assert.That(() => track.DisplayVisible = true, Throws.Nothing, - "Should not throw exception"); + Assert.That(() => track.DisplayVisible = true, Throws.Nothing, + "Should not throw exception"); - Assert.That(() => track.DisplayVisible, Is.EqualTo(true), - "Should not throw exception"); + Assert.That(() => track.DisplayVisible, Is.EqualTo(true), + "Should not throw exception"); + + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -243,19 +308,31 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + EventHandler eventHandler = (s, e) => + tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + + _answerClient.TrackAdded += eventHandler; - _offerClient.AddSource(new MediaTestSource(MediaType.Video)); + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Video)); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await ConnectPeerAsync(_offerClient, _answerClient); + await ConnectPeerAsync(_offerClient, _answerClient); - var track = await tcsAnswerTrackAdded.Task; + var track = await tcsAnswerTrackAdded.Task; + + Assert.That(() => track.DisplayMode = WebRTCDisplayMode.OriginSize, Throws.InvalidOperationException, + "Should throw InvalidOperationException"); - Assert.That(() => track.DisplayMode = WebRTCDisplayMode.OriginSize, Throws.InvalidOperationException, - "Should throw InvalidOperationException"); + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -271,23 +348,31 @@ namespace Tizen.Multimedia.Remoting.Tests var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => - { - e.MediaStreamTrack.Display = new Display(window); + EventHandler eventHandler = (s, e) => tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); - }; - _offerClient.AddSource(new MediaTestSource(MediaType.Video)); + _answerClient.TrackAdded += eventHandler; + + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Video)); + + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await ConnectPeerAsync(_offerClient, _answerClient); - await ConnectPeerAsync(_offerClient, _answerClient); + var track = await tcsAnswerTrackAdded.Task; - var track = await tcsAnswerTrackAdded.Task; + Assert.That(() => track.DisplayMode = (WebRTCDisplayMode)4, Throws.ArgumentException, + "Should throw ArgumentException"); - Assert.That(() => track.DisplayMode = (WebRTCDisplayMode)4, Throws.ArgumentException, - "Should throw ArgumentException"); + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -301,19 +386,31 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + EventHandler eventHandler = (s, e) => + tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + + _answerClient.TrackAdded += eventHandler; - _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await ConnectPeerAsync(_offerClient, _answerClient); + await ConnectPeerAsync(_offerClient, _answerClient); - var track = await tcsAnswerTrackAdded.Task; + var track = await tcsAnswerTrackAdded.Task; - Assert.That(() => track.DisplayMode = WebRTCDisplayMode.OriginSize, Throws.InvalidOperationException, - "Should throw InvalidOperationException"); + Assert.That(() => track.DisplayMode = WebRTCDisplayMode.OriginSize, Throws.InvalidOperationException, + "Should throw InvalidOperationException"); + + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -327,19 +424,31 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + EventHandler eventHandler = (s, e) => + tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); - _offerClient.AddSource(new MediaTestSource(MediaType.Video)); + _answerClient.TrackAdded += eventHandler; + + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Video)); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await ConnectPeerAsync(_offerClient, _answerClient); + await ConnectPeerAsync(_offerClient, _answerClient); - var track = await tcsAnswerTrackAdded.Task; + var track = await tcsAnswerTrackAdded.Task; - Assert.That(() => track.DisplayVisible = true, Throws.InvalidOperationException, - "Should throw InvalidOperationException"); + Assert.That(() => track.DisplayVisible = true, Throws.InvalidOperationException, + "Should throw InvalidOperationException"); + + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -353,19 +462,31 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + EventHandler eventHandler = (s, e) => + tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + + _answerClient.TrackAdded += eventHandler; - _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); + + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await ConnectPeerAsync(_offerClient, _answerClient); - await ConnectPeerAsync(_offerClient, _answerClient); + var track = await tcsAnswerTrackAdded.Task; - var track = await tcsAnswerTrackAdded.Task; + Assert.That(() => track.DisplayVisible = true, Throws.InvalidOperationException, + "Should throw InvalidOperationException"); - Assert.That(() => track.DisplayVisible = true, Throws.InvalidOperationException, - "Should throw InvalidOperationException"); + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -379,7 +500,7 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => + EventHandler eventHandler = (s, e) => { var policy = new AudioStreamPolicy(AudioStreamType.Media); Assert.That(() => e.MediaStreamTrack.ApplyAudioStreamPolicy(policy), Throws.Nothing, @@ -388,14 +509,24 @@ namespace Tizen.Multimedia.Remoting.Tests tcsAnswerTrackAdded.TrySetResult(true); }; - _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); + _answerClient.TrackAdded += eventHandler; - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); - await ConnectPeerAsync(_offerClient, _answerClient); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - Assert.That(await tcsAnswerTrackAdded.Task, "Event shoud be raised"); + await ConnectPeerAsync(_offerClient, _answerClient); + + Assert.That(await tcsAnswerTrackAdded.Task, "Event shoud be raised"); + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -409,20 +540,32 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + EventHandler eventHandler = (s, e) => + tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + + _answerClient.TrackAdded += eventHandler; + + try + { + _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); - _offerClient.AddSource(new MediaTestSource(MediaType.Audio)); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await ConnectPeerAsync(_offerClient, _answerClient); - await ConnectPeerAsync(_offerClient, _answerClient); + var track = await tcsAnswerTrackAdded.Task; - var track = await tcsAnswerTrackAdded.Task; + var policy = new AudioStreamPolicy(AudioStreamType.Media); + Assert.That(() => track.ApplyAudioStreamPolicy(policy), Throws.InvalidOperationException, + "InvalidOperationException should be thrown"); - var policy = new AudioStreamPolicy(AudioStreamType.Media); - Assert.That(() => track.ApplyAudioStreamPolicy(policy), Throws.InvalidOperationException, - "InvalidOperationException should be thrown"); + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -436,7 +579,7 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => + EventHandler eventHandler = (s, e) => { var policy = new AudioStreamPolicy(AudioStreamType.Media); @@ -453,21 +596,34 @@ namespace Tizen.Multimedia.Remoting.Tests tcsAnswerTrackAdded.TrySetResult(false); }; - _answerClient.AudioFrameEncoded += (s, e) => Log.Info(WebRTCTestLog.Tag, "Enter"); + _answerClient.TrackAdded += eventHandler; + + try + { + _answerClient.AudioFrameEncoded += (s, e) => + Log.Info(WebRTCTestLog.Tag, "Enter"); + + var offerSource = new MediaTestSource(MediaType.Audio); - var offerSource = new MediaTestSource(MediaType.Audio); + _offerClient.AddSource(offerSource); - _offerClient.AddSource(offerSource); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await ConnectPeerAsync(_offerClient, _answerClient); - await ConnectPeerAsync(_offerClient, _answerClient); + Assert.That(await tcsAnswerTrackAdded.Task, Is.EqualTo(true), + "InvalidOperationException should be thrown"); - Assert.That(await tcsAnswerTrackAdded.Task, Is.EqualTo(true), - "InvalidOperationException should be thrown"); + await StopAsync(_answerClient); + await StopAsync(_offerClient); - offerSource.Pause = true; + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -481,7 +637,7 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => + EventHandler eventHandler = (s, e) => { var policy = new AudioStreamPolicy(AudioStreamType.Media); policy.Dispose(); @@ -499,21 +655,34 @@ namespace Tizen.Multimedia.Remoting.Tests tcsAnswerTrackAdded.TrySetResult(false); }; - _answerClient.AudioFrameEncoded += (s, e) => Log.Info(WebRTCTestLog.Tag, "Enter"); + _answerClient.TrackAdded += eventHandler; + + try + { + _answerClient.AudioFrameEncoded += (s, e) => + Log.Info(WebRTCTestLog.Tag, "Enter"); + + var offerSource = new MediaTestSource(MediaType.Audio); - var offerSource = new MediaTestSource(MediaType.Audio); + _offerClient.AddSource(offerSource); - _offerClient.AddSource(offerSource); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await ConnectPeerAsync(_offerClient, _answerClient); - await ConnectPeerAsync(_offerClient, _answerClient); + Assert.That(await tcsAnswerTrackAdded.Task, Is.EqualTo(true), + "ObjectDisposedException should be thrown"); - Assert.That(await tcsAnswerTrackAdded.Task, Is.EqualTo(true), - "ObjectDisposedException should be thrown"); + await StopAsync(_answerClient); + await StopAsync(_offerClient); - offerSource.Pause = true; + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } [Test] @@ -527,7 +696,7 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.TrackAdded += (s, e) => + EventHandler eventHandler = (s, e) => { try { @@ -542,21 +711,34 @@ namespace Tizen.Multimedia.Remoting.Tests tcsAnswerTrackAdded.TrySetResult(false); }; - _answerClient.AudioFrameEncoded += (s, e) => Log.Info(WebRTCTestLog.Tag, "Enter"); + _answerClient.TrackAdded += eventHandler; + + try + { + _answerClient.AudioFrameEncoded += (s, e) => + Log.Info(WebRTCTestLog.Tag, "Enter"); - var offerSource = new MediaTestSource(MediaType.Audio); + var offerSource = new MediaTestSource(MediaType.Audio); - _offerClient.AddSource(offerSource); + _offerClient.AddSource(offerSource); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await ConnectPeerAsync(_offerClient, _answerClient); + await ConnectPeerAsync(_offerClient, _answerClient); - Assert.That(await tcsAnswerTrackAdded.Task, Is.EqualTo(true), - "ObjectDisposedException should be thrown"); + Assert.That(await tcsAnswerTrackAdded.Task, Is.EqualTo(true), + "ObjectDisposedException should be thrown"); - offerSource.Pause = true; + await StopAsync(_answerClient); + await StopAsync(_offerClient); + + await Task.Delay(1000); + } + finally + { + _answerClient.TrackAdded -= eventHandler; + } } } } \ No newline at end of file diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.DataChannel.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.DataChannel.cs index b026197..b9260db 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.DataChannel.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.DataChannel.cs @@ -15,6 +15,7 @@ */ using NUnit.Framework; +using System; using System.Threading.Tasks; namespace Tizen.Multimedia.Remoting.Tests @@ -42,17 +43,30 @@ namespace Tizen.Multimedia.Remoting.Tests var offerDataChannel = new WebRTCDataChannel(offerClient, "offerClient"); - answerClient.DataChannel += (s, e) => tcsAnswerDataChannel.TrySetResult(true); - answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(true); + EventHandler eventHandler = (s, e) => + tcsAnswerDataChannel.TrySetResult(true); + EventHandler eventHandler2 = (s, e) => + tcsAnswerTrackAdded.TrySetResult(true); - await offerClient.StartAsync(); - await answerClient.StartAsync(); + answerClient.DataChannel += eventHandler; + answerClient.TrackAdded += eventHandler2; - await ConnectPeerAsync(offerClient, answerClient); + try + { + await offerClient.StartAsync(); + await answerClient.StartAsync(); - Assert.That(await tcsAnswerDataChannel.Task, "Event should be raised."); + await ConnectPeerAsync(offerClient, answerClient); - await tcsAnswerTrackAdded.Task; + Assert.That(await tcsAnswerDataChannel.Task, "Event should be raised."); + + await tcsAnswerTrackAdded.Task; + } + finally + { + answerClient.DataChannel -= eventHandler; + answerClient.TrackAdded -= eventHandler2; + } } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.FrameEncoded.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.FrameEncoded.cs index a18edad..00d0a47 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.FrameEncoded.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.FrameEncoded.cs @@ -1,3 +1,4 @@ +using System; /* * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved * @@ -58,19 +59,30 @@ namespace Tizen.Multimedia.Remoting.Tests [Property("AUTHOR", "Haesu Gwon, haesu.gwon@samsung.com")] public async Task AudioFrameEncoded_CHECK_EVENT() { - _answerClient.AudioFrameEncoded += (s, e) => _tcsAnswerAudioFrameEncoded.TrySetResult(true); + EventHandler eventHandler = (s, e) => + _tcsAnswerAudioFrameEncoded.TrySetResult(true); - var offerSource = new MediaTestSource(MediaType.Audio); - _offerClient.AddSource(offerSource); + _answerClient.AudioFrameEncoded += eventHandler; + + try + { + var offerSource = new MediaTestSource(MediaType.Audio); + _offerClient.AddSource(offerSource); - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await ConnectPeerAsync(_offerClient, _answerClient); + await ConnectPeerAsync(_offerClient, _answerClient); - Assert.That(await _tcsAnswerAudioFrameEncoded.Task, "Event should be raised"); + Assert.That(await _tcsAnswerAudioFrameEncoded.Task, "Event should be raised"); - offerSource.Pause = true; + await StopAsync(_answerClient); + await StopAsync(_offerClient); + } + finally + { + _answerClient.AudioFrameEncoded -= eventHandler; + } } [Test] @@ -82,19 +94,30 @@ namespace Tizen.Multimedia.Remoting.Tests [Property("AUTHOR", "Haesu Gwon, haesu.gwon@samsung.com")] public async Task VideoFrameEncoded_CHECK_EVENT() { + EventHandler eventHandler = (s, e) => + _tcsAnswerVideoFrameEncoded.TrySetResult(true); + + _answerClient.VideoFrameEncoded += eventHandler; + var offerSource = new MediaTestSource(MediaType.Video); _offerClient.AddSource(offerSource); - _answerClient.VideoFrameEncoded += (s, e) => _tcsAnswerVideoFrameEncoded.TrySetResult(true); - - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + try + { + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await ConnectPeerAsync(_offerClient, _answerClient); + await ConnectPeerAsync(_offerClient, _answerClient); - Assert.That(await _tcsAnswerVideoFrameEncoded.Task, "Event should be raised"); + Assert.That(await _tcsAnswerVideoFrameEncoded.Task, "Event should be raised"); - offerSource.Pause = true; + await StopAsync(_answerClient); + await StopAsync(_offerClient); + } + finally + { + _answerClient.VideoFrameEncoded -= eventHandler; + } } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceCandidate.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceCandidate.cs index 2fc5ec2..73d8cd2 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceCandidate.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceCandidate.cs @@ -53,6 +53,9 @@ namespace Tizen.Multimedia.Remoting.Tests [TearDown] public void Destroy() { + UnregisterEvents(_offerClient, true); + UnregisterEvents(_answerClient, false); + _offerClient?.Dispose(); _answerClient?.Dispose(); } @@ -86,6 +89,28 @@ namespace Tizen.Multimedia.Remoting.Tests } } + private void UnregisterEvents(WebRTC webRtc, bool isOffer) + { + if (webRtc == null) + { + return; + } + + if (isOffer) + { + webRtc.StateChanged -= OfferStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= OfferIceGatheringStateChangeEventHandler; + webRtc.IceCandidate -= OfferIceCandidateEventHandler; + } + else + { + webRtc.StateChanged -= AnswerStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= AnswerIceGatheringStateChangeEventHandler; + webRtc.IceCandidate -= AnswerIceCandidateEventHandler; + webRtc.TrackAdded -= AnswerTrackAddedEventHandler; + } + } + private void OfferStateChangeEventHandler(object s, WebRTCStateChangedEventArgs e) { if (e.Current == WebRTCState.Playing) @@ -175,7 +200,7 @@ namespace Tizen.Multimedia.Remoting.Tests await Task.WhenAll(_tcsOfferStatePlaying.Task, _tcsAnswerStatePlaying.Task); - await _tcsAnswerTrackAdded.Task.ConfigureAwait(false); + await _tcsAnswerTrackAdded.Task; } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceConnectionStateChanged.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceConnectionStateChanged.cs index 80b986f..cdbe07e 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceConnectionStateChanged.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceConnectionStateChanged.cs @@ -28,7 +28,7 @@ namespace Tizen.Multimedia.Remoting.Tests TaskCompletionSource _tcsOfferStatePlaying, _tcsAnswerStatePlaying; TaskCompletionSource _tcsOfferIceGatheringStateCompleted, _tcsAnswerIceGatheringStateCompleted; - TaskCompletionSource _tcsOfferIceConnectionStateCompleted, _tcsAnswerIceConnectionStateCompleted; + TaskCompletionSource _tcsOfferIceConnectionState, _tcsAnswerIceConnectionState; TaskCompletionSource _tcsAnswerTrackAdded; List _offerIceCandidate, _answerIceCandidate; @@ -54,6 +54,9 @@ namespace Tizen.Multimedia.Remoting.Tests [TearDown] public void Destroy() { + UnregisterEvents(_offerClient, true); + UnregisterEvents(_answerClient, false); + _offerClient?.Dispose(); _answerClient?.Dispose(); } @@ -64,8 +67,8 @@ namespace Tizen.Multimedia.Remoting.Tests _tcsAnswerStatePlaying = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); _tcsOfferIceGatheringStateCompleted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); _tcsAnswerIceGatheringStateCompleted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _tcsOfferIceConnectionStateCompleted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _tcsAnswerIceConnectionStateCompleted = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + _tcsOfferIceConnectionState = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + _tcsAnswerIceConnectionState = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); _tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); _offerIceCandidate = new List(); @@ -91,6 +94,30 @@ namespace Tizen.Multimedia.Remoting.Tests } } + private void UnregisterEvents(WebRTC webRtc, bool isOffer) + { + if (webRtc == null) + { + return; + } + + if (isOffer) + { + webRtc.StateChanged -= OfferStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= OfferIceGatheringStateChangeEventHandler; + webRtc.IceConnectionStateChanged -= OfferIceConnectionStateChangeEventHandler; + webRtc.IceCandidate -= OfferIceCandidateEventHandler; + } + else + { + webRtc.StateChanged -= AnswerStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= AnswerIceGatheringStateChangeEventHandler; + webRtc.IceConnectionStateChanged -= AnswerIceConnectionStateChangeEventHandler; + webRtc.IceCandidate -= AnswerIceCandidateEventHandler; + webRtc.TrackAdded -= AnswerTrackAddedEventHandler; + } + } + private void OfferStateChangeEventHandler(object s, WebRTCStateChangedEventArgs e) { if (e.Current == WebRTCState.Playing) @@ -112,7 +139,7 @@ namespace Tizen.Multimedia.Remoting.Tests { if (e.State == WebRTCIceConnectionState.Completed) { - _tcsOfferIceConnectionStateCompleted.TrySetResult(true); + _tcsOfferIceConnectionState.TrySetResult(true); } } @@ -145,7 +172,7 @@ namespace Tizen.Multimedia.Remoting.Tests { if (e.State == WebRTCIceConnectionState.Completed) { - _tcsAnswerIceConnectionStateCompleted.TrySetResult(true); + _tcsAnswerIceConnectionState.TrySetResult(true); } } @@ -188,7 +215,7 @@ namespace Tizen.Multimedia.Remoting.Tests _offerClient.AddIceCandidates(_answerIceCandidate); _answerClient.AddIceCandidates(_offerIceCandidate); - var results = await Task.WhenAll(_tcsOfferIceConnectionStateCompleted.Task, _tcsAnswerIceConnectionStateCompleted.Task); + var results = await Task.WhenAll(_tcsOfferIceConnectionState.Task, _tcsAnswerIceConnectionState.Task); foreach (var result in results) { Assert.That(result, "IceConnectionStateChanged event should be raised"); @@ -226,10 +253,14 @@ namespace Tizen.Multimedia.Remoting.Tests _offerClient.AddIceCandidates(_answerIceCandidate); _answerClient.AddIceCandidates(_offerIceCandidate); - await Task.WhenAll(_tcsOfferIceConnectionStateCompleted.Task, _tcsAnswerIceConnectionStateCompleted.Task); + await Task.WhenAll(_tcsOfferIceConnectionState.Task, _tcsAnswerIceConnectionState.Task); - Assert.That(_offerClient.IceConnectionState == WebRTCIceConnectionState.Completed, "Should be Completed state"); - Assert.That(_answerClient.IceConnectionState == WebRTCIceConnectionState.Completed, "Should be Completed state"); + Assert.That(_offerClient.IceConnectionState == WebRTCIceConnectionState.Connected || + _offerClient.IceConnectionState == WebRTCIceConnectionState.Completed, + "Should be Connected or Completed state"); + Assert.That(_answerClient.IceConnectionState == WebRTCIceConnectionState.Connected || + _answerClient.IceConnectionState == WebRTCIceConnectionState.Completed, + "Should be Connected or Completed state"); await _tcsAnswerTrackAdded.Task; } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceGatheringStateChanged.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceGatheringStateChanged.cs index 0efa291..d437c85 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceGatheringStateChanged.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.IceGatheringStateChanged.cs @@ -53,6 +53,9 @@ namespace Tizen.Multimedia.Remoting.Tests [TearDown] public void Destroy() { + UnregisterEvents(_offerClient, true); + UnregisterEvents(_answerClient, false); + _offerClient?.Dispose(); _answerClient?.Dispose(); } @@ -90,6 +93,30 @@ namespace Tizen.Multimedia.Remoting.Tests } } + private void UnregisterEvents(WebRTC webRtc, bool isOffer) + { + if (webRtc == null) + { + return; + } + + if (isOffer) + { + webRtc.StateChanged -= OfferStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= OfferIceGatheringStateChangeEventHandler; + webRtc.IceConnectionStateChanged -= OfferIceConnectionStateChangeEventHandler; + webRtc.IceCandidate -= OfferIceCandidateEventHandler; + } + else + { + webRtc.StateChanged -= AnswerStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= AnswerIceGatheringStateChangeEventHandler; + webRtc.IceConnectionStateChanged -= AnswerIceConnectionStateChangeEventHandler; + webRtc.IceCandidate -= AnswerIceCandidateEventHandler; + webRtc.TrackAdded -= AnswerTrackAddedEventHandler; + } + } + private void OfferStateChangeEventHandler(object s, WebRTCStateChangedEventArgs e) { if (e.Current == WebRTCState.Playing) diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.NegotiationNeeded.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.NegotiationNeeded.cs index efe0f9a..9f29421 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.NegotiationNeeded.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.NegotiationNeeded.cs @@ -38,13 +38,18 @@ namespace Tizen.Multimedia.Remoting.Tests { webRtc.NegotiationNeeded += EventWaiter; - webRtc.AddSource(new MediaTestSource(MediaType.Video)); + try + { + webRtc.AddSource(new MediaTestSource(MediaType.Video)); - webRtc.Start(); + webRtc.Start(); - Assert.That(await EventWaiter.IsRaisedAsync(), "Event should be raised."); - - webRtc.NegotiationNeeded -= EventWaiter; + Assert.That(await EventWaiter.IsRaisedAsync(), "Event should be raised."); + } + finally + { + webRtc.NegotiationNeeded -= EventWaiter; + } } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.PeerConnectionStateChanged.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.PeerConnectionStateChanged.cs index 2a1aa03..4369365 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.PeerConnectionStateChanged.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.PeerConnectionStateChanged.cs @@ -54,6 +54,9 @@ namespace Tizen.Multimedia.Remoting.Tests [TearDown] public void Destroy() { + UnregisterEvents(_offerClient, true); + UnregisterEvents(_answerClient, false); + _offerClient?.Dispose(); _answerClient?.Dispose(); } @@ -93,6 +96,30 @@ namespace Tizen.Multimedia.Remoting.Tests } } + private void UnregisterEvents(WebRTC webRtc, bool isOffer) + { + if (webRtc == null) + { + return; + } + + if (isOffer) + { + webRtc.StateChanged -= OfferStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= OfferIceGatheringStateChangeEventHandler; + webRtc.PeerConnectionStateChanged -= OfferPeerConnectionStateChangeEventHandler; + webRtc.IceCandidate -= OfferIceCandidateEventHandler; + } + else + { + webRtc.StateChanged -= AnswerStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= AnswerIceGatheringStateChangeEventHandler; + webRtc.PeerConnectionStateChanged -= AnswerPeerConnectionStateChangeEventHandler; + webRtc.IceCandidate -= AnswerIceCandidateEventHandler; + webRtc.TrackAdded -= AnswerTrackAddedEventHandler; + } + } + private void OfferStateChangeEventHandler(object s, WebRTCStateChangedEventArgs e) { if (e.Current == WebRTCState.Playing) @@ -201,11 +228,6 @@ namespace Tizen.Multimedia.Remoting.Tests _offerClient.AddIceCandidates(_answerIceCandidate); _answerClient.AddIceCandidates(_offerIceCandidate); - await Task.WhenAll(_tcsOfferPeerConnectionStateConnecting.Task, _tcsAnswerPeerConnectionStateConnecting.Task); - - Assert.That(_offerClient.PeerConnectionState == WebRTCPeerConnectionState.Connecting, "Should be Connecting state"); - Assert.That(_answerClient.PeerConnectionState == WebRTCPeerConnectionState.Connecting, "Should be Connecting state"); - await Task.WhenAll(_tcsOfferPeerConnectionStateConnected.Task, _tcsAnswerPeerConnectionStateConnected.Task); Assert.That(_offerClient.PeerConnectionState == WebRTCPeerConnectionState.Connected, "Should be Connected state"); @@ -243,11 +265,6 @@ namespace Tizen.Multimedia.Remoting.Tests _offerClient.AddIceCandidates(_answerIceCandidate); _answerClient.AddIceCandidates(_offerIceCandidate); - await Task.WhenAll(_tcsOfferPeerConnectionStateConnecting.Task, _tcsAnswerPeerConnectionStateConnecting.Task); - - Assert.That(_offerClient.PeerConnectionState == WebRTCPeerConnectionState.Connecting, "Should be Connecting state"); - Assert.That(_answerClient.PeerConnectionState == WebRTCPeerConnectionState.Connecting, "Should be Connecting state"); - await Task.WhenAll(_tcsOfferPeerConnectionStateConnected.Task, _tcsAnswerPeerConnectionStateConnected.Task); Assert.That(_offerClient.PeerConnectionState == WebRTCPeerConnectionState.Connected, "Should be Connected state"); diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.SignalingStateChanged.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.SignalingStateChanged.cs index 6ee211e..e3e9024 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.SignalingStateChanged.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.SignalingStateChanged.cs @@ -54,6 +54,9 @@ namespace Tizen.Multimedia.Remoting.Tests [TearDown] public void Destroy() { + UnregisterEvents(_offerClient, true); + UnregisterEvents(_answerClient, false); + _offerClient?.Dispose(); _answerClient?.Dispose(); } @@ -93,6 +96,30 @@ namespace Tizen.Multimedia.Remoting.Tests } } + private void UnregisterEvents(WebRTC webRtc, bool isOffer) + { + if (webRtc == null) + { + return; + } + + if (isOffer) + { + webRtc.StateChanged -= OfferStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= OfferIceGatheringStateChangeEventHandler; + webRtc.SignalingStateChanged -= OfferSignalingStateChangeEventHandler; + webRtc.IceCandidate -= OfferIceCandidateEventHandler; + } + else + { + webRtc.StateChanged -= AnswerStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= AnswerIceGatheringStateChangeEventHandler; + webRtc.SignalingStateChanged -= AnswerSignalingStateChangeEventHandler; + webRtc.IceCandidate -= AnswerIceCandidateEventHandler; + webRtc.TrackAdded -= AnswerTrackAddedEventHandler; + } + } + private void OfferStateChangeEventHandler(object s, WebRTCStateChangedEventArgs e) { if (e.Current == WebRTCState.Playing) diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.StateChanged.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.StateChanged.cs index 9135a5d..579e0b8 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.StateChanged.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.StateChanged.cs @@ -53,6 +53,9 @@ namespace Tizen.Multimedia.Remoting.Tests [TearDown] public void Destroy() { + UnregisterEvents(_offerClient, true); + UnregisterEvents(_answerClient, false); + _offerClient?.Dispose(); _answerClient?.Dispose(); } @@ -88,6 +91,28 @@ namespace Tizen.Multimedia.Remoting.Tests } } + private void UnregisterEvents(WebRTC webRtc, bool isOffer) + { + if (webRtc == null) + { + return; + } + + if (isOffer) + { + webRtc.StateChanged -= OfferStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= OfferIceGatheringStateChangeEventHandler; + webRtc.IceCandidate -= OfferIceCandidateEventHandler; + } + else + { + webRtc.StateChanged -= AnswerStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= AnswerIceGatheringStateChangeEventHandler; + webRtc.IceCandidate -= AnswerIceCandidateEventHandler; + webRtc.TrackAdded -= AnswerTrackAddedEventHandler; + } + } + private void OfferStateChangeEventHandler(object s, WebRTCStateChangedEventArgs e) { if (e.Current == WebRTCState.Negotiating) diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.TrackAdded.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.TrackAdded.cs index 8bc03ca..2dc98f6 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.TrackAdded.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.Events.TrackAdded.cs @@ -15,6 +15,7 @@ */ using NUnit.Framework; +using System; using System.Threading.Tasks; namespace Tizen.Multimedia.Remoting.Tests @@ -37,19 +38,26 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - offerClient.AddSource(new MediaTestSource(MediaType.Video)); + EventHandler eventHandler = (s, e) => + tcsAnswerTrackAdded.TrySetResult(true); + + answerClient.TrackAdded += eventHandler; - answerClient.TrackAdded += (s, e) => + try { - tcsAnswerTrackAdded.TrySetResult(true); - }; + offerClient.AddSource(new MediaTestSource(MediaType.Video)); - await offerClient.StartAsync(); - await answerClient.StartAsync(); + await offerClient.StartAsync(); + await answerClient.StartAsync(); - await ConnectPeerAsync(offerClient, answerClient); + await ConnectPeerAsync(offerClient, answerClient); - Assert.That(await tcsAnswerTrackAdded.Task, "TrackAdded event Should be raised"); + Assert.That(await tcsAnswerTrackAdded.Task, "TrackAdded event Should be raised"); + } + finally + { + answerClient.TrackAdded -= eventHandler; + } } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.cs index 26382cb..079c9c3 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.cs @@ -232,10 +232,10 @@ namespace Tizen.Multimedia.Remoting.Tests { _webRtc.AddSource(new MediaTestSource(MediaType.Video)); await _webRtc.StartAsync(); - var offer = _webRtc.CreateOfferAsync(); + var offer = await _webRtc.CreateOfferAsync(); Assert.That(offer != null, "Should not null"); - Assert.That(offer.Result.Contains("offer"), "Should be offer sdp"); + Assert.That(offer.Contains("offer"), "Should be offer sdp"); } [Test] @@ -338,14 +338,14 @@ namespace Tizen.Multimedia.Remoting.Tests { _webRtc.AddSource(new MediaTestSource(MediaType.Video)); await _webRtc.StartAsync(); - var offer = await _webRtc.CreateOfferAsync(); - using (var eventWaiter = EventAwaiter.Create()) { _webRtc.SignalingStateChanged += eventWaiter; try { + var offer = await _webRtc.CreateOfferAsync(); + Assert.That(() => _webRtc.SetLocalDescription(offer), Throws.Nothing, "Should not throw exception"); @@ -437,14 +437,19 @@ namespace Tizen.Multimedia.Remoting.Tests { answerClient.SignalingStateChanged += eventWaiter; - var offer = await _webRtc.CreateOfferAsync(); - - Assert.That(() => answerClient.SetRemoteDescription(offer), Throws.Nothing, - "Should not throw exception"); + try + { + var offer = await _webRtc.CreateOfferAsync(); - await eventWaiter.IsRaisedAsync(); + Assert.That(() => answerClient.SetRemoteDescription(offer), Throws.Nothing, + "Should not throw exception"); - answerClient.SignalingStateChanged -= eventWaiter; + await eventWaiter.IsRaisedAsync(); + } + finally + { + answerClient.SignalingStateChanged -= eventWaiter; + } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.statistics.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.statistics.cs index a6d8c0b..18cc74b 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.statistics.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTC.statistics.cs @@ -16,7 +16,6 @@ using NUnit.Framework; using System; -using System.Collections.Generic; using System.Threading.Tasks; namespace Tizen.Multimedia.Remoting.Tests { @@ -76,7 +75,7 @@ namespace Tizen.Multimedia.Remoting.Tests { [Property("AUTHOR", "Haesu Gwon, haesu.gwon@samsung.com")] public async Task GetStatistics_THROWS_IF_ALREADY_DISPOSED() { - using (var offerClient = new WebRTC()) + var offerClient = new WebRTC(); using (var answerClient = new WebRTC()) { offerClient.AddSource(new MediaTestSource(MediaType.Video)); diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannel.Events.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannel.Events.cs index 6e1d5c3..886edff 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannel.Events.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannel.Events.cs @@ -15,7 +15,6 @@ */ using NUnit.Framework; using System; -using System.Collections.Generic; using System.Threading.Tasks; namespace Tizen.Multimedia.Remoting.Tests { @@ -47,6 +46,11 @@ namespace Tizen.Multimedia.Remoting.Tests { [TearDown] public void Destroy() { + if (_answerClient != null) + { + _answerClient.TrackAdded -= AnswerTrackAddedEventHandler; + } + _offerDataChannel?.Dispose(); _offerClient?.Dispose(); _answerClient?.Dispose(); @@ -87,14 +91,21 @@ namespace Tizen.Multimedia.Remoting.Tests { { _offerDataChannel.Opened += OfferDataChannelOpendEventHandler; - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + try + { + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await ConnectPeerAsync(_offerClient, _answerClient); + await ConnectPeerAsync(_offerClient, _answerClient); - Assert.That(await _tcsOfferDataChannelOpened.Task, "Event should be raised"); + Assert.That(await _tcsOfferDataChannelOpened.Task, "Event should be raised"); - await _tcsAnswerTrackAdded.Task; + await _tcsAnswerTrackAdded.Task; + } + finally + { + _offerDataChannel.Opened -= OfferDataChannelOpendEventHandler; + } } [Test] @@ -118,6 +129,7 @@ namespace Tizen.Multimedia.Remoting.Tests { await _tcsAnswerTrackAdded.Task; + _offerDataChannel.Opened -= OfferDataChannelOpendEventHandler; _offerDataChannel.Dispose(); Assert.That(await _tcsOfferDataChannelClosed.Task, "Event should be raised"); @@ -137,19 +149,13 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsDataChannel = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); var tcsDataChannelMessageReceived = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.DataChannel += (s, e) => + EventHandler eventHandler = (s, e) => { // DataChannel from peer tcsDataChannel.TrySetResult(e.DataChannel); }; - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); - - await ConnectPeerAsync(_offerClient, _answerClient); - - var answerDataChannel = await tcsDataChannel.Task; - answerDataChannel.MessageReceived += (s, e) => + EventHandler eventHandler2 = (s, e) => { if (e.Message.Equals(greetingMessage)) { @@ -157,11 +163,24 @@ namespace Tizen.Multimedia.Remoting.Tests { } }; + _answerClient.DataChannel += eventHandler; + + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); + + await ConnectPeerAsync(_offerClient, _answerClient); + + var answerDataChannel = await tcsDataChannel.Task; + answerDataChannel.MessageReceived += eventHandler2; + await _tcsAnswerTrackAdded.Task; _offerDataChannel.Send(greetingMessage); Assert.That(await tcsDataChannelMessageReceived.Task, "Event should be raised"); + + _answerClient.DataChannel -= eventHandler; + answerDataChannel.MessageReceived -= eventHandler2; } [Test] @@ -178,12 +197,19 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsDataChannel = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); var tcsDataChannelBufferedAmountLow = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.DataChannel += (s, e) => + EventHandler eventHandler = (s, e) => { // DataChannel from peer tcsDataChannel.TrySetResult(e.DataChannel); }; + EventHandler eventHandler2 = (s, e) => + { + tcsDataChannelBufferedAmountLow.TrySetResult(true); + }; + + _answerClient.DataChannel += eventHandler; + await _offerClient.StartAsync(); await _answerClient.StartAsync(); @@ -194,14 +220,14 @@ namespace Tizen.Multimedia.Remoting.Tests { await _tcsAnswerTrackAdded.Task; _offerDataChannel.BufferedAmountLowThreshold = 10; - _offerDataChannel.BufferedAmountLow += (s, e) => - { - tcsDataChannelBufferedAmountLow.TrySetResult(true); - }; + _offerDataChannel.BufferedAmountLow += eventHandler2; _offerDataChannel.Send(greetingMessage); Assert.That(await tcsDataChannelBufferedAmountLow.Task, "Event should be raised"); + + _answerClient.DataChannel -= eventHandler; + _offerDataChannel.BufferedAmountLow -= eventHandler2; } } } \ No newline at end of file diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannel.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannel.cs index b0dd356..6b7cee1 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannel.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannel.cs @@ -134,21 +134,32 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsOfferDataChannel = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(true); - answerClient.DataChannel += (s, e) => tcsOfferDataChannel.TrySetResult(true); + EventHandler eventHandler = (s, e) => tcsAnswerTrackAdded.TrySetResult(true); + EventHandler eventHandler2 = (s, e) => tcsOfferDataChannel.TrySetResult(true); - offerClient.AddSource(new MediaTestSource(MediaType.Video)); - using (var offerDataChannel = new WebRTCDataChannel(offerClient, "offerDataChannel")) + answerClient.TrackAdded += eventHandler; + answerClient.DataChannel += eventHandler2; + + try { - await offerClient.StartAsync(); - await answerClient.StartAsync(); + offerClient.AddSource(new MediaTestSource(MediaType.Video)); + using (var offerDataChannel = new WebRTCDataChannel(offerClient, "offerDataChannel")) + { + await offerClient.StartAsync(); + await answerClient.StartAsync(); - await ConnectPeerAsync(offerClient, answerClient); + await ConnectPeerAsync(offerClient, answerClient); - await Task.WhenAll(tcsOfferDataChannel.Task, tcsAnswerTrackAdded.Task); + await Task.WhenAll(tcsOfferDataChannel.Task, tcsAnswerTrackAdded.Task); - Assert.That(() => offerDataChannel.Send("test"), Throws.Nothing, - "Should not throw exception"); + Assert.That(() => offerDataChannel.Send("test"), Throws.Nothing, + "Should not throw exception"); + } + } + finally + { + answerClient.TrackAdded -= eventHandler; + answerClient.DataChannel -= eventHandler2; } } } @@ -188,22 +199,33 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsOfferDataChannel = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(true); - answerClient.DataChannel += (s, e) => tcsOfferDataChannel.TrySetResult(true); + EventHandler eventHandler = (s, e) => tcsAnswerTrackAdded.TrySetResult(true); + EventHandler eventHandler2 = (s, e) => tcsOfferDataChannel.TrySetResult(true); - offerClient.AddSource(new MediaTestSource(MediaType.Video)); - using (var offerDataChannel = new WebRTCDataChannel(offerClient, "offerDataChannel")) + answerClient.TrackAdded += eventHandler; + answerClient.DataChannel += eventHandler2; + + try { - await offerClient.StartAsync(); - await answerClient.StartAsync(); + offerClient.AddSource(new MediaTestSource(MediaType.Video)); + using (var offerDataChannel = new WebRTCDataChannel(offerClient, "offerDataChannel")) + { + await offerClient.StartAsync(); + await answerClient.StartAsync(); - await ConnectPeerAsync(offerClient, answerClient); + await ConnectPeerAsync(offerClient, answerClient); - await Task.WhenAll(tcsOfferDataChannel.Task, tcsAnswerTrackAdded.Task); + await Task.WhenAll(tcsOfferDataChannel.Task, tcsAnswerTrackAdded.Task); - var data = new byte[10]; - Assert.That(() => offerDataChannel.Send(data), Throws.Nothing, - "Should not throw exception"); + var data = new byte[10]; + Assert.That(() => offerDataChannel.Send(data), Throws.Nothing, + "Should not throw exception"); + } + } + finally + { + answerClient.TrackAdded -= eventHandler; + answerClient.DataChannel -= eventHandler2; } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannelEventArgs.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannelEventArgs.cs index d5b10f8..6aaff9d 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannelEventArgs.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannelEventArgs.cs @@ -14,6 +14,7 @@ * limitations under the License */ using NUnit.Framework; +using System; using System.Threading.Tasks; namespace Tizen.Multimedia.Remoting.Tests { @@ -34,27 +35,40 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsOfferDataChannel = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + EventHandler eventHandler = (s, e) => + tcsOfferDataChannel.TrySetResult(e.DataChannel); + EventHandler eventHandler2 = (s, e) => + tcsAnswerTrackAdded.TrySetResult(true); + using (var offerClient = new WebRTC()) using (var answerClient = new WebRTC()) { - answerClient.DataChannel += (s, e) => tcsOfferDataChannel.TrySetResult(e.DataChannel); - answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(true); + answerClient.DataChannel += eventHandler; + answerClient.TrackAdded += eventHandler2; - using (var offerDataChannel = new WebRTCDataChannel(offerClient, "offerDataChannel")) + try { - offerClient.AddSource(new MediaTestSource(MediaType.Video)); + using (var offerDataChannel = new WebRTCDataChannel(offerClient, "offerDataChannel")) + { + offerClient.AddSource(new MediaTestSource(MediaType.Video)); - await offerClient.StartAsync(); - await answerClient.StartAsync(); + await offerClient.StartAsync(); + await answerClient.StartAsync(); - await ConnectPeerAsync(offerClient, answerClient); + await ConnectPeerAsync(offerClient, answerClient); - var dataChannel = await tcsOfferDataChannel.Task; + var dataChannel = await tcsOfferDataChannel.Task; - await tcsAnswerTrackAdded.Task; + await tcsAnswerTrackAdded.Task; - Assert.IsNotNull(dataChannel, "DataChannel should not be null."); - Assert.IsInstanceOf(dataChannel, "Should return WebRTCDataChannel instance."); + Assert.IsNotNull(dataChannel, "DataChannel should not be null."); + Assert.IsInstanceOf(dataChannel, "Should return WebRTCDataChannel instance."); + } + } + finally + { + answerClient.DataChannel -= eventHandler; + answerClient.TrackAdded -= eventHandler2; } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannelMessageReceivedEventArgs.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannelMessageReceivedEventArgs.cs index c8dcc13..35bc49a 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannelMessageReceivedEventArgs.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCDataChannelMessageReceivedEventArgs.cs @@ -14,6 +14,7 @@ * limitations under the License */ using NUnit.Framework; +using System; using System.Threading.Tasks; namespace Tizen.Multimedia.Remoting.Tests { @@ -47,6 +48,12 @@ namespace Tizen.Multimedia.Remoting.Tests { [TearDown] public void Destroy() { + if (_answerClient != null) + { + _answerClient.TrackAdded -= AnswerTrackAddedEventHandler; + _answerClient.DataChannel -= AnswerDataChannelEventHandler; + } + _offerDataChannel?.Dispose(); _offerClient?.Dispose(); _answerClient?.Dispose(); @@ -95,13 +102,20 @@ namespace Tizen.Multimedia.Remoting.Tests { var receivedDataChannel = await _tcsOfferDataChannel.Task; receivedDataChannel.MessageReceived += AnswerDataChannelMessageReceivedEventHandler; - await _tcsAnswerTrackAdded.Task; + try + { + await _tcsAnswerTrackAdded.Task; - _offerDataChannel.Send(_greetingMessage); + _offerDataChannel.Send(_greetingMessage); - var dataChannelMessage = await _tcsOfferDataChannelMessageReceived.Task; + var dataChannelMessage = await _tcsOfferDataChannelMessageReceived.Task; - Assert.That(dataChannelMessage.Type == DataChannelType.Strings, "Should return same value"); + Assert.That(dataChannelMessage.Type == DataChannelType.Strings, "Should return same value"); + } + finally + { + receivedDataChannel.MessageReceived -= AnswerDataChannelMessageReceivedEventHandler; + } } [Test] @@ -121,14 +135,21 @@ namespace Tizen.Multimedia.Remoting.Tests { var receivedDataChannel = await _tcsOfferDataChannel.Task; receivedDataChannel.MessageReceived += AnswerDataChannelMessageReceivedEventHandler; - await _tcsAnswerTrackAdded.Task; + try + { + await _tcsAnswerTrackAdded.Task; - var data = new byte[] {1, 2}; - _offerDataChannel.Send(data); + var data = new byte[] {1, 2}; + _offerDataChannel.Send(data); - var dataChannelMessage = await _tcsOfferDataChannelMessageReceived.Task; + var dataChannelMessage = await _tcsOfferDataChannelMessageReceived.Task; - Assert.That(dataChannelMessage.Type == DataChannelType.Bytes, "Should return same value"); + Assert.That(dataChannelMessage.Type == DataChannelType.Bytes, "Should return same value"); + } + finally + { + receivedDataChannel.MessageReceived -= AnswerDataChannelMessageReceivedEventHandler; + } } [Test] @@ -148,14 +169,21 @@ namespace Tizen.Multimedia.Remoting.Tests { var receivedDataChannel = await _tcsOfferDataChannel.Task; receivedDataChannel.MessageReceived += AnswerDataChannelMessageReceivedEventHandler; - await _tcsAnswerTrackAdded.Task; + try + { + await _tcsAnswerTrackAdded.Task; - _offerDataChannel.Send(_greetingMessage); + _offerDataChannel.Send(_greetingMessage); - var dataChannelMessage = await _tcsOfferDataChannelMessageReceived.Task; + var dataChannelMessage = await _tcsOfferDataChannelMessageReceived.Task; - Assert.That(dataChannelMessage.Message, Is.EqualTo(_greetingMessage), - "Should return same value"); + Assert.That(dataChannelMessage.Message, Is.EqualTo(_greetingMessage), + "Should return same value"); + } + finally + { + receivedDataChannel.MessageReceived -= AnswerDataChannelMessageReceivedEventHandler; + } } [Test] @@ -175,15 +203,22 @@ namespace Tizen.Multimedia.Remoting.Tests { var receivedDataChannel = await _tcsOfferDataChannel.Task; receivedDataChannel.MessageReceived += AnswerDataChannelMessageReceivedEventHandler; - await _tcsAnswerTrackAdded.Task; + try + { + await _tcsAnswerTrackAdded.Task; - var data = new byte[5] {1, 2, 3, 4, 5}; - _offerDataChannel.Send(data); + var data = new byte[5] {1, 2, 3, 4, 5}; + _offerDataChannel.Send(data); - var dataChannelMessage = await _tcsOfferDataChannelMessageReceived.Task; + var dataChannelMessage = await _tcsOfferDataChannelMessageReceived.Task; - Assert.That(dataChannelMessage.Data, Is.EqualTo(data), - "Should return same value"); + Assert.That(dataChannelMessage.Data, Is.EqualTo(data), + "Should return same value"); + } + finally + { + receivedDataChannel.MessageReceived -= AnswerDataChannelMessageReceivedEventHandler; + } } [Test] @@ -203,14 +238,21 @@ namespace Tizen.Multimedia.Remoting.Tests { var receivedDataChannel = await _tcsOfferDataChannel.Task; receivedDataChannel.MessageReceived += AnswerDataChannelMessageReceivedEventHandler; - await _tcsAnswerTrackAdded.Task; + try + { + await _tcsAnswerTrackAdded.Task; - _offerDataChannel.Send(_greetingMessage); + _offerDataChannel.Send(_greetingMessage); - var dataChannelMessage = await _tcsOfferDataChannelMessageReceived.Task; + var dataChannelMessage = await _tcsOfferDataChannelMessageReceived.Task; - Assert.AreEqual($"Channel type={dataChannelMessage.Type}, Message={dataChannelMessage.Message}", - dataChannelMessage.ToString(), "Should return same value"); + Assert.AreEqual($"Channel type={dataChannelMessage.Type}, Message={dataChannelMessage.Message}", + dataChannelMessage.ToString(), "Should return same value"); + } + finally + { + receivedDataChannel.MessageReceived -= AnswerDataChannelMessageReceivedEventHandler; + } } } } \ No newline at end of file diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCFrameEncodedEventArgs.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCFrameEncodedEventArgs.cs index b628fd5..28a2c7b 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCFrameEncodedEventArgs.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCFrameEncodedEventArgs.cs @@ -1,3 +1,4 @@ +using System; /* * Copyright (c) 2021 Samsung Electronics Co., Ltd All Rights Reserved * @@ -23,7 +24,6 @@ namespace Tizen.Multimedia.Remoting.Tests { public class WebRTCFrameEncodedEventArgsTests : TestBase { private WebRTC _offerClient, _answerClient; - private WebRTCDataChannel _offerDataChannel; TaskCompletionSource _tcsAnswerTrackAdded; @@ -34,8 +34,6 @@ namespace Tizen.Multimedia.Remoting.Tests { _offerClient = new WebRTC(); _answerClient = new WebRTC(); - _offerDataChannel = new WebRTCDataChannel(_offerClient, "offerDataChannel"); - _tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); _answerClient.TrackAdded += AnswerTrackAddedEventHandler; @@ -46,7 +44,11 @@ namespace Tizen.Multimedia.Remoting.Tests { [TearDown] public void Destroy() { - _offerDataChannel?.Dispose(); + if (_answerClient != null) + { + _answerClient.TrackAdded -= AnswerTrackAddedEventHandler; + } + _offerClient?.Dispose(); _answerClient?.Dispose(); } @@ -65,13 +67,9 @@ namespace Tizen.Multimedia.Remoting.Tests { [Property("AUTHOR", "Haesu Gwon, haesu.gwon@samsung.com")] public async Task MediaStreamTrack_READ_ONLY() { - var offerSource = new MediaTestSource(MediaType.Video); - - _offerClient.AddSource(offerSource); - var tcsAnswerVideoFrameEncoded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.VideoFrameEncoded += (s, e) => + EventHandler eventHandler = (s, e) => { Assert.IsNotNull(e.MediaStreamTrack, "MediaStreamTrack should not be null."); Assert.IsInstanceOf(e.MediaStreamTrack, @@ -80,16 +78,28 @@ namespace Tizen.Multimedia.Remoting.Tests { tcsAnswerVideoFrameEncoded.TrySetResult(true); }; - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + var offerSource = new MediaTestSource(MediaType.Video); - await ConnectPeerAsync(_offerClient, _answerClient); + _offerClient.AddSource(offerSource); - await _tcsAnswerTrackAdded.Task; + _answerClient.VideoFrameEncoded += eventHandler; - await tcsAnswerVideoFrameEncoded.Task; + try + { + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); + + await ConnectPeerAsync(_offerClient, _answerClient); - offerSource.Pause = true; + await Task.WhenAll(_tcsAnswerTrackAdded.Task, tcsAnswerVideoFrameEncoded.Task); + + await StopAsync(_answerClient); + await StopAsync(_offerClient); + } + finally + { + _answerClient.VideoFrameEncoded -= eventHandler; + } } [Test] @@ -101,13 +111,9 @@ namespace Tizen.Multimedia.Remoting.Tests { [Property("AUTHOR", "Haesu Gwon, haesu.gwon@samsung.com")] public async Task Packet_READ_ONLY() { - var offerSource = new MediaTestSource(MediaType.Video); - - _offerClient.AddSource(offerSource); - var tcsAnswerVideoFrameEncoded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.VideoFrameEncoded += (s, e) => + EventHandler eventHandler = (s, e) => { Assert.IsNotNull(e.Packet, "Packet should not be null."); Assert.IsInstanceOf(e.Packet, "Should return MediaPacket instance."); @@ -115,16 +121,28 @@ namespace Tizen.Multimedia.Remoting.Tests { tcsAnswerVideoFrameEncoded.TrySetResult(true); }; - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + var offerSource = new MediaTestSource(MediaType.Video); + + _offerClient.AddSource(offerSource); + + _answerClient.VideoFrameEncoded += eventHandler; - await ConnectPeerAsync(_offerClient, _answerClient); + try + { + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await _tcsAnswerTrackAdded.Task; + await ConnectPeerAsync(_offerClient, _answerClient); - await tcsAnswerVideoFrameEncoded.Task; + await Task.WhenAll(_tcsAnswerTrackAdded.Task, tcsAnswerVideoFrameEncoded.Task); - offerSource.Pause = true; + await StopAsync(_answerClient); + await StopAsync(_offerClient); + } + finally + { + _answerClient.VideoFrameEncoded -= eventHandler; + } } [Test] @@ -136,13 +154,9 @@ namespace Tizen.Multimedia.Remoting.Tests { [Property("AUTHOR", "Haesu Gwon, haesu.gwon@samsung.com")] public async Task ToString_CHECK_VALUE() { - var offerSource = new MediaTestSource(MediaType.Video); - - _offerClient.AddSource(offerSource); - var tcsAnswerVideoFrameEncoded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - _answerClient.VideoFrameEncoded += (s, e) => + EventHandler eventHandler = (s, e) => { Assert.AreEqual($"MediaType={e.MediaStreamTrack.Type}", e.ToString(), "Should be the same value"); @@ -150,16 +164,28 @@ namespace Tizen.Multimedia.Remoting.Tests { tcsAnswerVideoFrameEncoded.TrySetResult(true); }; - await _offerClient.StartAsync(); - await _answerClient.StartAsync(); + var offerSource = new MediaTestSource(MediaType.Video); + + _offerClient.AddSource(offerSource); + + _answerClient.VideoFrameEncoded += eventHandler; - await ConnectPeerAsync(_offerClient, _answerClient); + try + { + await _offerClient.StartAsync(); + await _answerClient.StartAsync(); - await _tcsAnswerTrackAdded.Task; + await ConnectPeerAsync(_offerClient, _answerClient); - await tcsAnswerVideoFrameEncoded.Task; + await Task.WhenAll(_tcsAnswerTrackAdded.Task, tcsAnswerVideoFrameEncoded.Task); - offerSource.Pause = true; + await StopAsync(_answerClient); + await StopAsync(_offerClient); + } + finally + { + _answerClient.VideoFrameEncoded -= eventHandler; + } } } } \ No newline at end of file diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceCandidateEventArgs.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceCandidateEventArgs.cs index 8e27a64..4d80aa8 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceCandidateEventArgs.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceCandidateEventArgs.cs @@ -24,7 +24,6 @@ namespace Tizen.Multimedia.Remoting.Tests { public class WebRTCIceCandidateEventArgsTests : TestBase { private WebRTC _offerClient, _answerClient; - private WebRTCDataChannel _offerDataChannel; TaskCompletionSource _tcsOfferStatePlaying, _tcsAnswerStatePlaying; TaskCompletionSource _tcsOfferIceGatheringStateCompleted, _tcsAnswerIceGatheringStateCompleted; @@ -40,8 +39,6 @@ namespace Tizen.Multimedia.Remoting.Tests { _offerClient.AddSource(new MediaTestSource(MediaType.Video)); - _offerDataChannel = new WebRTCDataChannel(_offerClient, "offerDataChannel"); - Initialize(); RegisterEvents(_offerClient, true); @@ -54,7 +51,9 @@ namespace Tizen.Multimedia.Remoting.Tests { [TearDown] public void Destroy() { - _offerDataChannel?.Dispose(); + UnregisterEvents(_offerClient, true); + UnregisterEvents(_answerClient, false); + _offerClient?.Dispose(); _answerClient?.Dispose(); } @@ -88,6 +87,28 @@ namespace Tizen.Multimedia.Remoting.Tests { } } + private void UnregisterEvents(WebRTC webRtc, bool isOffer) + { + if (webRtc == null) + { + return; + } + + if (isOffer) + { + webRtc.StateChanged -= OfferStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= OfferIceGatheringStateChangeEventHandler; + webRtc.IceCandidate -= OfferIceCandidateEventHandler; + } + else + { + webRtc.StateChanged -= AnswerStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= AnswerIceGatheringStateChangeEventHandler; + webRtc.IceCandidate -= AnswerIceCandidateEventHandler; + webRtc.TrackAdded -= AnswerTrackAddedEventHandler; + } + } + private void OfferStateChangeEventHandler(object s, WebRTCStateChangedEventArgs e) { if (e.Current == WebRTCState.Playing) diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceConnectionStateChangedEventArgs.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceConnectionStateChangedEventArgs.cs index 641aed1..43048c4 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceConnectionStateChangedEventArgs.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceConnectionStateChangedEventArgs.cs @@ -52,6 +52,9 @@ namespace Tizen.Multimedia.Remoting.Tests { [TearDown] public void Destroy() { + UnregisterEvents(_offerClient, true); + UnregisterEvents(_answerClient, false); + _offerClient?.Dispose(); _answerClient?.Dispose(); } @@ -89,6 +92,30 @@ namespace Tizen.Multimedia.Remoting.Tests { } } + private void UnregisterEvents(WebRTC webRtc, bool isOffer) + { + if (webRtc == null) + { + return; + } + + if (isOffer) + { + webRtc.StateChanged -= OfferStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= OfferIceGatheringStateChangeEventHandler; + webRtc.IceCandidate -= OfferIceCandidateEventHandler; + webRtc.IceConnectionStateChanged -= OfferIceConnectionStateChangeEventHandler; + } + else + { + webRtc.StateChanged -= AnswerStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= AnswerIceGatheringStateChangeEventHandler; + webRtc.IceCandidate -= AnswerIceCandidateEventHandler; + webRtc.IceConnectionStateChanged -= AnswerIceConnectionStateChangeEventHandler; + webRtc.TrackAdded -= AnswerTrackAddedEventHandler; + } + } + private void OfferStateChangeEventHandler(object s, WebRTCStateChangedEventArgs e) { if (e.Current == WebRTCState.Playing) diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceGatheringStateChangedEventArgs.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceGatheringStateChangedEventArgs.cs index e7ff678..160d79a 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceGatheringStateChangedEventArgs.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCIceGatheringStateChangedEventArgs.cs @@ -52,6 +52,9 @@ namespace Tizen.Multimedia.Remoting.Tests { [TearDown] public void Destroy() { + UnregisterEvents(_offerClient, true); + UnregisterEvents(_answerClient, false); + _offerClient?.Dispose(); _answerClient?.Dispose(); } @@ -87,6 +90,28 @@ namespace Tizen.Multimedia.Remoting.Tests { } } + private void UnregisterEvents(WebRTC webRtc, bool isOffer) + { + if (webRtc == null) + { + return; + } + + if (isOffer) + { + webRtc.StateChanged -= OfferStateChangeEventHandler; + webRtc.IceCandidate -= OfferIceCandidateEventHandler; + webRtc.IceGatheringStateChanged -= OfferIceGatheringStateChangeEventHandler; + } + else + { + webRtc.StateChanged -= AnswerStateChangeEventHandler; + webRtc.IceCandidate -= AnswerIceCandidateEventHandler; + webRtc.IceGatheringStateChanged -= AnswerIceGatheringStateChangeEventHandler; + webRtc.TrackAdded -= AnswerTrackAddedEventHandler; + } + } + private void OfferStateChangeEventHandler(object s, WebRTCStateChangedEventArgs e) { if (e.Current == WebRTCState.Playing) diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCPeerConnectionStateChangedEventArgs.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCPeerConnectionStateChangedEventArgs.cs index ee07687..672fbf1 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCPeerConnectionStateChangedEventArgs.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCPeerConnectionStateChangedEventArgs.cs @@ -52,6 +52,9 @@ namespace Tizen.Multimedia.Remoting.Tests { [TearDown] public void Destroy() { + UnregisterEvents(_offerClient, true); + UnregisterEvents(_answerClient, false); + _offerClient?.Dispose(); _answerClient?.Dispose(); } @@ -89,6 +92,30 @@ namespace Tizen.Multimedia.Remoting.Tests { } } + private void UnregisterEvents(WebRTC webRtc, bool isOffer) + { + if (webRtc == null) + { + return; + } + + if (isOffer) + { + webRtc.StateChanged -= OfferStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= OfferIceGatheringStateChangeEventHandler; + webRtc.IceCandidate -= OfferIceCandidateEventHandler; + webRtc.PeerConnectionStateChanged -= OfferPeerConnectionStateChangeEventHandler; + } + else + { + webRtc.StateChanged -= AnswerStateChangeEventHandler; + webRtc.IceGatheringStateChanged -= AnswerIceGatheringStateChangeEventHandler; + webRtc.IceCandidate -= AnswerIceCandidateEventHandler; + webRtc.PeerConnectionStateChanged -= AnswerPeerConnectionStateChangeEventHandler; + webRtc.TrackAdded -= AnswerTrackAddedEventHandler; + } + } + private void OfferStateChangeEventHandler(object s, WebRTCStateChangedEventArgs e) { if (e.Current == WebRTCState.Playing) diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCSignalingStateChangedEventArgs.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCSignalingStateChangedEventArgs.cs index 6779aef..34aad86 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCSignalingStateChangedEventArgs.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCSignalingStateChangedEventArgs.cs @@ -14,6 +14,7 @@ * limitations under the License */ using NUnit.Framework; +using System; using System.Threading.Tasks; namespace Tizen.Multimedia.Remoting.Tests { @@ -33,20 +34,30 @@ namespace Tizen.Multimedia.Remoting.Tests { { var tcsOfferSignalingState = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + EventHandler eventHandler = (s, e) => + tcsOfferSignalingState.TrySetResult(e.State); + using (var webRtc = new WebRTC()) { - webRtc.SignalingStateChanged += (s, e) => tcsOfferSignalingState.TrySetResult(e.State); + webRtc.SignalingStateChanged += eventHandler; - await webRtc.StartAsync(); + try + { + await webRtc.StartAsync(); - var sdpOffer = await webRtc.CreateOfferAsync(); - webRtc.SetLocalDescription(sdpOffer); + var sdpOffer = await webRtc.CreateOfferAsync(); + webRtc.SetLocalDescription(sdpOffer); - var state = await tcsOfferSignalingState.Task; + var state = await tcsOfferSignalingState.Task; - Assert.IsNotNull(state, "state should not be null."); - Assert.IsInstanceOf(state, "Should return WebRTCSignalingState instance."); - Assert.That(state == WebRTCSignalingState.HaveLocalOffer, "Should return same value"); + Assert.IsNotNull(state, "state should not be null."); + Assert.IsInstanceOf(state, "Should return WebRTCSignalingState instance."); + Assert.That(state == WebRTCSignalingState.HaveLocalOffer, "Should return same value"); + } + finally + { + webRtc.SignalingStateChanged -= eventHandler; + } } } @@ -62,18 +73,28 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsOfferSignalingState = new TaskCompletionSource( TaskCreationOptions.RunContinuationsAsynchronously); + EventHandler eventHandler = (s, e) => + tcsOfferSignalingState.TrySetResult(e); + using (var webRtc = new WebRTC()) { - webRtc.SignalingStateChanged += (s, e) => tcsOfferSignalingState.TrySetResult(e); + webRtc.SignalingStateChanged += eventHandler; - await webRtc.StartAsync(); + try + { + await webRtc.StartAsync(); - var sdpOffer = await webRtc.CreateOfferAsync(); - webRtc.SetLocalDescription(sdpOffer); + var sdpOffer = await webRtc.CreateOfferAsync(); + webRtc.SetLocalDescription(sdpOffer); - var args = await tcsOfferSignalingState.Task; + var args = await tcsOfferSignalingState.Task; - Assert.AreEqual($"State={args.State}", args.ToString(), "Should be the same string"); + Assert.AreEqual($"State={args.State}", args.ToString(), "Should be the same string"); + } + finally + { + webRtc.SignalingStateChanged -= eventHandler; + } } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCStateChangedEventArgs.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCStateChangedEventArgs.cs index 1d520ca..363ddab 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCStateChangedEventArgs.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCStateChangedEventArgs.cs @@ -15,6 +15,7 @@ */ using NUnit.Framework; +using System; using System.Threading.Tasks; namespace Tizen.Multimedia.Remoting.Tests @@ -34,15 +35,24 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsOfferStateNegotiating = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + EventHandler eventHandler = (s, e) => tcsOfferStateNegotiating.TrySetResult(e); + using (var webRtc = new WebRTC()) { - webRtc.StateChanged += (s, e) => tcsOfferStateNegotiating.TrySetResult(e); + webRtc.StateChanged += eventHandler; - await webRtc.StartAsync(); + try + { + await webRtc.StartAsync(); - var result = await tcsOfferStateNegotiating.Task; + var result = await tcsOfferStateNegotiating.Task; - Assert.That(result.Previous == WebRTCState.Idle, "Should return proper state"); + Assert.That(result.Previous == WebRTCState.Idle, "Should return proper state"); + } + finally + { + webRtc.StateChanged -= eventHandler; + } } } @@ -57,15 +67,24 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsOfferStateNegotiating = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + EventHandler eventHandler = (s, e) => tcsOfferStateNegotiating.TrySetResult(e); + using (var webRtc = new WebRTC()) { - webRtc.StateChanged += (s, e) => tcsOfferStateNegotiating.TrySetResult(e); + webRtc.StateChanged += eventHandler; - await webRtc.StartAsync(); + try + { + await webRtc.StartAsync(); - var result = await tcsOfferStateNegotiating.Task; + var result = await tcsOfferStateNegotiating.Task; - Assert.That(result.Current == WebRTCState.Negotiating, "Should return proper state"); + Assert.That(result.Current == WebRTCState.Negotiating, "Should return proper state"); + } + finally + { + webRtc.StateChanged -= eventHandler; + } } } @@ -80,16 +99,25 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsOfferStateNegotiating = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + EventHandler eventHandler = (s, e) => tcsOfferStateNegotiating.TrySetResult(e); + using (var webRtc = new WebRTC()) { - webRtc.StateChanged += (s, e) => tcsOfferStateNegotiating.TrySetResult(e); + webRtc.StateChanged += eventHandler; - await webRtc.StartAsync(); + try + { + await webRtc.StartAsync(); - var result = await tcsOfferStateNegotiating.Task; + var result = await tcsOfferStateNegotiating.Task; - Assert.AreEqual($"Previous state={result.Previous}, Current state={result.Current}", - result.ToString(), "Should be the same string"); + Assert.AreEqual($"Previous state={result.Previous}, Current state={result.Current}", + result.ToString(), "Should be the same string"); + } + finally + { + webRtc.StateChanged -= eventHandler; + } } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCTrackAddedEventArgs.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCTrackAddedEventArgs.cs index 4a86074..0fe2b7b 100755 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCTrackAddedEventArgs.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/TSWebRTCTrackAddedEventArgs.cs @@ -15,6 +15,7 @@ */ using NUnit.Framework; +using System; using System.Threading.Tasks; namespace Tizen.Multimedia.Remoting.Tests @@ -34,23 +35,32 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + EventHandler eventHandler = (s, e) => tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + using (var offerClient = new WebRTC()) using (var answerClient = new WebRTC()) { - answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(e.MediaStreamTrack); + answerClient.TrackAdded += eventHandler; - offerClient.AddSource(new MediaTestSource(MediaType.Video)); + try + { + offerClient.AddSource(new MediaTestSource(MediaType.Video)); - await offerClient.StartAsync(); - await answerClient.StartAsync(); + await offerClient.StartAsync(); + await answerClient.StartAsync(); - await ConnectPeerAsync(offerClient, answerClient); + await ConnectPeerAsync(offerClient, answerClient); - var track = await tcsAnswerTrackAdded.Task; + var track = await tcsAnswerTrackAdded.Task; - Assert.IsNotNull(track, "Should not null"); - Assert.IsInstanceOf(track, "Should be MediaStreamTrack instance"); - Assert.That(track.Type == MediaType.Video, "Should return proper value"); + Assert.IsNotNull(track, "Should not null"); + Assert.IsInstanceOf(track, "Should be MediaStreamTrack instance"); + Assert.That(track.Type == MediaType.Video, "Should return proper value"); + } + finally + { + answerClient.TrackAdded -= eventHandler; + } } } @@ -65,22 +75,31 @@ namespace Tizen.Multimedia.Remoting.Tests { var tcsAnswerTrackAdded = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + EventHandler eventHandler = (s, e) => tcsAnswerTrackAdded.TrySetResult(e); + using (var offerClient = new WebRTC()) using (var answerClient = new WebRTC()) { - answerClient.TrackAdded += (s, e) => tcsAnswerTrackAdded.TrySetResult(e); + answerClient.TrackAdded += eventHandler; - offerClient.AddSource(new MediaTestSource(MediaType.Video)); + try + { + offerClient.AddSource(new MediaTestSource(MediaType.Video)); - await offerClient.StartAsync(); - await answerClient.StartAsync(); + await offerClient.StartAsync(); + await answerClient.StartAsync(); - await ConnectPeerAsync(offerClient, answerClient); + await ConnectPeerAsync(offerClient, answerClient); - var result = await tcsAnswerTrackAdded.Task; + var result = await tcsAnswerTrackAdded.Task; - Assert.AreEqual($"MediaType={result.MediaStreamTrack.Type}", result.ToString(), - "Should be the same string"); + Assert.AreEqual($"MediaType={result.MediaStreamTrack.Type}", result.ToString(), + "Should be the same string"); + } + finally + { + answerClient.TrackAdded -= eventHandler; + } } } } diff --git a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/support/TestBase.cs b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/support/TestBase.cs index 0a2ad27..63c5239 100644 --- a/tct-suite-vs/Tizen.WebRTC.Tests/testcase/support/TestBase.cs +++ b/tct-suite-vs/Tizen.WebRTC.Tests/testcase/support/TestBase.cs @@ -134,6 +134,32 @@ namespace Tizen.Multimedia.Remoting.Tests await Task.WhenAll(tcsOfferStatePlaying.Task, tcsAnswerStatePlaying.Task); } + protected async Task StopAsync(WebRTC webRtc) + { + var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + EventHandler stateChangedEventHandler = (s, e) => + { + if (e.Current == WebRTCState.Idle) + { + tcs.TrySetResult(true); + } + }; + + try + { + webRtc.StateChanged += stateChangedEventHandler; + + webRtc.Stop(); + + await tcs.Task; + } + finally + { + webRtc.StateChanged -= stateChangedEventHandler; + } + } + internal static Window CreateWindow() { var w = new Window(""); -- 2.7.4