Removes MAYBE_ from several test case names in JsepPeerConnectionP2PTestClient.

talk/app/webrtc/peerconnection_unittest.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 1154 matching lines @@
   ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
   receiving_client()->SetReceiveAudioVideo(true, false);
   LocalP2PTest();
   receiving_client()->SetReceiveAudioVideo(true, true);
   receiving_client()->Negotiate();
 }
 
 // This test sets up a call between two endpoints that are configured to use
 // DTLS key agreement. The offerer don't support SDES. As a result, DTLS is
 // negotiated and used for transport.
-TEST_F(MAYBE_JsepPeerConnectionP2PTestClient,
-       MAYBE_LocalP2PTestOfferDtlsButNotSdes) {
+TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, LocalP2PTestOfferDtlsButNotSdes) {
   MAYBE_SKIP_TEST(rtc::SSLStreamAdapter::HaveDtlsSrtp);
   FakeConstraints setup_constraints;
   setup_constraints.AddMandatory(MediaConstraintsInterface::kEnableDtlsSrtp,
                                  true);
   ASSERT_TRUE(CreateTestClients(&setup_constraints, &setup_constraints));
   receiving_client()->RemoveSdesCryptoFromReceivedSdp(true);
   LocalP2PTest();
   VerifyRenderedSize(640, 480);
 }
 
@@ skipping 59 matching lines @@
   constraint.SetOptionalMaxWidth(320);
   SetVideoConstraints(constraint, constraint);
   initializing_client()->AddMediaStream(true, true);
   initializing_client()->AddMediaStream(false, true);
   ASSERT_EQ(2u, initializing_client()->NumberOfLocalMediaStreams());
   LocalP2PTest();
   EXPECT_EQ(2u, receiving_client()->number_of_remote_streams());
 }
 
 // Test that we can receive the audio output level from a remote audio track.
-TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, MAYBE_GetAudioOutputLevelStats) {
+TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, GetAudioOutputLevelStats) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
 
   StreamCollectionInterface* remote_streams =
       initializing_client()->remote_streams();
   ASSERT_GT(remote_streams->count(), 0u);
   ASSERT_GT(remote_streams->at(0)->GetAudioTracks().size(), 0u);
   MediaStreamTrackInterface* remote_audio_track =
       remote_streams->at(0)->GetAudioTracks()[0];
 
   // Get the audio output level stats. Note that the level is not available
   // until a RTCP packet has been received.
   EXPECT_TRUE_WAIT(
       initializing_client()->GetAudioOutputLevelStats(remote_audio_track) > 0,
       kMaxWaitForStatsMs);
 }
 
 // Test that an audio input level is reported.
-TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, MAYBE_GetAudioInputLevelStats) {
+TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, GetAudioInputLevelStats) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
 
   // Get the audio input level stats.  The level should be available very
   // soon after the test starts.
   EXPECT_TRUE_WAIT(initializing_client()->GetAudioInputLevelStats() > 0,
       kMaxWaitForStatsMs);
 }
 
 // Test that we can get incoming byte counts from both audio and video tracks.
-TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, MAYBE_GetBytesReceivedStats) {
+TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, GetBytesReceivedStats) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
 
   StreamCollectionInterface* remote_streams =
       initializing_client()->remote_streams();
   ASSERT_GT(remote_streams->count(), 0u);
   ASSERT_GT(remote_streams->at(0)->GetAudioTracks().size(), 0u);
   MediaStreamTrackInterface* remote_audio_track =
       remote_streams->at(0)->GetAudioTracks()[0];
   EXPECT_TRUE_WAIT(
       initializing_client()->GetBytesReceivedStats(remote_audio_track) > 0,
       kMaxWaitForStatsMs);
 
   MediaStreamTrackInterface* remote_video_track =
       remote_streams->at(0)->GetVideoTracks()[0];
   EXPECT_TRUE_WAIT(
       initializing_client()->GetBytesReceivedStats(remote_video_track) > 0,
       kMaxWaitForStatsMs);
 }
 
 // Test that we can get outgoing byte counts from both audio and video tracks.
-TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, MAYBE_GetBytesSentStats) {
+TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, GetBytesSentStats) {
   ASSERT_TRUE(CreateTestClients());
   LocalP2PTest();
 
   StreamCollectionInterface* local_streams =
       initializing_client()->local_streams();
   ASSERT_GT(local_streams->count(), 0u);
   ASSERT_GT(local_streams->at(0)->GetAudioTracks().size(), 0u);
   MediaStreamTrackInterface* local_audio_track =
       local_streams->at(0)->GetAudioTracks()[0];
   EXPECT_TRUE_WAIT(
@@ skipping 32 matching lines @@
 
   EXPECT_EQ_WAIT(rtc::SrtpCryptoSuiteToName(kDefaultSrtpCryptoSuite),
                  initializing_client()->GetSrtpCipherStats(),
                  kMaxWaitForStatsMs);
   EXPECT_EQ(1,
             init_observer->GetEnumCounter(webrtc::kEnumCounterAudioSrtpCipher,
                                           kDefaultSrtpCryptoSuite));
 }
 
 // Test that DTLS 1.2 is used if both ends support it.
-TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, MAYBE_GetDtls12Both) {
+TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, GetDtls12Both) {
   PeerConnectionFactory::Options init_options;
   init_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
   PeerConnectionFactory::Options recv_options;
   recv_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
   ASSERT_TRUE(
       CreateTestClients(nullptr, &init_options, nullptr, &recv_options));
   rtc::scoped_refptr<webrtc::FakeMetricsObserver>
       init_observer = new rtc::RefCountedObject<webrtc::FakeMetricsObserver>();
   initializing_client()->pc()->RegisterUMAObserver(init_observer);
   LocalP2PTest();
@@ skipping 225 matching lines @@
       MediaConstraintsInterface::kEnableDtlsSrtp, true);
   ASSERT_TRUE(CreateTestClients(&constraints, &constraints));
   initializing_client()->CreateDataChannel();
   initializing_client()->Negotiate(false, false);
 }
 #endif
 
 // This test sets up a call between two parties with audio, and video.
 // During the call, the initializing side restart ice and the test verifies that
 // new ice candidates are generated and audio and video still can flow.
-TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, MAYBE_IceRestart) {
+TEST_F(MAYBE_JsepPeerConnectionP2PTestClient, IceRestart) {
   ASSERT_TRUE(CreateTestClients());
 
   // Negotiate and wait for ice completion and make sure audio and video plays.
   LocalP2PTest();
 
   // Create a SDP string of the first audio candidate for both clients.
   const webrtc::IceCandidateCollection* audio_candidates_initiator =
       initializing_client()->pc()->local_description()->candidates(0);
   const webrtc::IceCandidateCollection* audio_candidates_receiver =
       receiving_client()->pc()->local_description()->candidates(0);
@@ skipping 265 matching lines @@
   server.urls.push_back("stun:hostname");
   server.urls.push_back("turn:hostname");
   servers.push_back(server);
   EXPECT_TRUE(webrtc::ParseIceServers(servers, &stun_configurations_,
                                       &turn_configurations_));
   EXPECT_EQ(1U, stun_configurations_.size());
   EXPECT_EQ(1U, turn_configurations_.size());
 }
 
 #endif // if !defined(THREAD_SANITIZER)