Remove unnecessary test fixture in codec_unittest.cc

webrtc/media/base/codec_unittest.cc

 /*
  *  Copyright (c) 2009 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/media/base/codec.h"
 
 using cricket::AudioCodec;
 using cricket::Codec;
 using cricket::DataCodec;
 using cricket::FeedbackParam;
 using cricket::VideoCodec;
 using cricket::kCodecParamAssociatedPayloadType;
 using cricket::kCodecParamMaxBitrate;
 using cricket::kCodecParamMinBitrate;
 
-class CodecTest : public testing::Test {
- public:
-  CodecTest() {}
-};
-
-TEST_F(CodecTest, TestCodecOperators) {
+TEST(CodecTest, TestCodecOperators) {
   Codec c0(96, "D", 1000);
   c0.SetParam("a", 1);
 
   Codec c1 = c0;
   EXPECT_TRUE(c1 == c0);
 
   int param_value0;
   int param_value1;
   EXPECT_TRUE(c0.GetParam("a", &param_value0));
   EXPECT_TRUE(c1.GetParam("a", &param_value1));
@@ skipping 12 matching lines @@
 
   c1 = c0;
   c1.SetParam("a", 2);
   EXPECT_TRUE(c0 != c1);
 
   Codec c5;
   Codec c6(0, "", 0);
   EXPECT_TRUE(c5 == c6);
 }
 
-TEST_F(CodecTest, TestAudioCodecOperators) {
+TEST(CodecTest, TestAudioCodecOperators) {
   AudioCodec c0(96, "A", 44100, 20000, 2);
   AudioCodec c1(95, "A", 44100, 20000, 2);
   AudioCodec c2(96, "x", 44100, 20000, 2);
   AudioCodec c3(96, "A", 48000, 20000, 2);
   AudioCodec c4(96, "A", 44100, 10000, 2);
   AudioCodec c5(96, "A", 44100, 20000, 1);
   EXPECT_TRUE(c0 != c1);
   EXPECT_TRUE(c0 != c2);
   EXPECT_TRUE(c0 != c3);
   EXPECT_TRUE(c0 != c4);
@@ skipping 16 matching lines @@
   c13.params["x"] = "abc";
   EXPECT_TRUE(c10 != c0);
   EXPECT_TRUE(c11 != c0);
   EXPECT_TRUE(c11 != c10);
   EXPECT_TRUE(c12 != c0);
   EXPECT_TRUE(c12 != c10);
   EXPECT_TRUE(c12 != c11);
   EXPECT_TRUE(c13 == c10);
 }
 
-TEST_F(CodecTest, TestAudioCodecMatches) {
+TEST(CodecTest, TestAudioCodecMatches) {
   // Test a codec with a static payload type.
   AudioCodec c0(95, "A", 44100, 20000, 1);
   EXPECT_TRUE(c0.Matches(AudioCodec(95, "", 44100, 20000, 1)));
   EXPECT_TRUE(c0.Matches(AudioCodec(95, "", 44100, 20000, 0)));
   EXPECT_TRUE(c0.Matches(AudioCodec(95, "", 44100, 0, 0)));
   EXPECT_TRUE(c0.Matches(AudioCodec(95, "", 0, 0, 0)));
   EXPECT_FALSE(c0.Matches(AudioCodec(96, "", 44100, 20000, 1)));
   EXPECT_FALSE(c0.Matches(AudioCodec(95, "", 55100, 20000, 1)));
   EXPECT_FALSE(c0.Matches(AudioCodec(95, "", 44100, 30000, 1)));
   EXPECT_FALSE(c0.Matches(AudioCodec(95, "", 44100, 20000, 2)));
@@ skipping 19 matching lines @@
   // Backward compatibility with clients that might send "-1" (for default).
   EXPECT_TRUE(c2.Matches(AudioCodec(97, "A", 16000, -1, 1)));
 
   // Stereo doesn't match channels = 0.
   AudioCodec c3(96, "A", 44100, 20000, 2);
   EXPECT_TRUE(c3.Matches(AudioCodec(96, "A", 44100, 20000, 2)));
   EXPECT_FALSE(c3.Matches(AudioCodec(96, "A", 44100, 20000, 1)));
   EXPECT_FALSE(c3.Matches(AudioCodec(96, "A", 44100, 20000, 0)));
 }
 
-TEST_F(CodecTest, TestVideoCodecOperators) {
+TEST(CodecTest, TestVideoCodecOperators) {
   VideoCodec c0(96, "V");
   VideoCodec c1(95, "V");
   VideoCodec c2(96, "x");
 
   EXPECT_TRUE(c0 != c1);
   EXPECT_TRUE(c0 != c2);
 
   VideoCodec c7;
   VideoCodec c8(0, "");
   VideoCodec c9 = c0;
@@ skipping 11 matching lines @@
   c13.params["x"] = "abc";
   EXPECT_TRUE(c10 != c0);
   EXPECT_TRUE(c11 != c0);
   EXPECT_TRUE(c11 != c10);
   EXPECT_TRUE(c12 != c0);
   EXPECT_TRUE(c12 != c10);
   EXPECT_TRUE(c12 != c11);
   EXPECT_TRUE(c13 == c10);
 }
 
-TEST_F(CodecTest, TestVideoCodecMatches) {
+TEST(CodecTest, TestVideoCodecMatches) {
   // Test a codec with a static payload type.
   VideoCodec c0(95, "V");
   EXPECT_TRUE(c0.Matches(VideoCodec(95, "")));
   EXPECT_FALSE(c0.Matches(VideoCodec(96, "")));
 
   // Test a codec with a dynamic payload type.
   VideoCodec c1(96, "V");
   EXPECT_TRUE(c1.Matches(VideoCodec(96, "V")));
   EXPECT_TRUE(c1.Matches(VideoCodec(97, "V")));
   EXPECT_TRUE(c1.Matches(VideoCodec(96, "v")));
   EXPECT_TRUE(c1.Matches(VideoCodec(97, "v")));
   EXPECT_FALSE(c1.Matches(VideoCodec(96, "")));
   EXPECT_FALSE(c1.Matches(VideoCodec(95, "V")));
 }
 
-TEST_F(CodecTest, TestDataCodecMatches) {
+TEST(CodecTest, TestDataCodecMatches) {
   // Test a codec with a static payload type.
   DataCodec c0(95, "D");
   EXPECT_TRUE(c0.Matches(DataCodec(95, "")));
   EXPECT_FALSE(c0.Matches(DataCodec(96, "")));
 
   // Test a codec with a dynamic payload type.
   DataCodec c1(96, "D");
   EXPECT_TRUE(c1.Matches(DataCodec(96, "D")));
   EXPECT_TRUE(c1.Matches(DataCodec(97, "D")));
   EXPECT_TRUE(c1.Matches(DataCodec(96, "d")));
   EXPECT_TRUE(c1.Matches(DataCodec(97, "d")));
   EXPECT_FALSE(c1.Matches(DataCodec(96, "")));
   EXPECT_FALSE(c1.Matches(DataCodec(95, "D")));
 }
 
-TEST_F(CodecTest, TestSetParamGetParamAndRemoveParam) {
+TEST(CodecTest, TestSetParamGetParamAndRemoveParam) {
   AudioCodec codec;
   codec.SetParam("a", "1");
   codec.SetParam("b", "x");
 
   int int_value = 0;
   EXPECT_TRUE(codec.GetParam("a", &int_value));
   EXPECT_EQ(1, int_value);
   EXPECT_FALSE(codec.GetParam("b", &int_value));
   EXPECT_FALSE(codec.GetParam("c", &int_value));
 
   std::string str_value;
   EXPECT_TRUE(codec.GetParam("a", &str_value));
   EXPECT_EQ("1", str_value);
   EXPECT_TRUE(codec.GetParam("b", &str_value));
   EXPECT_EQ("x", str_value);
   EXPECT_FALSE(codec.GetParam("c", &str_value));
   EXPECT_TRUE(codec.RemoveParam("a"));
   EXPECT_FALSE(codec.RemoveParam("c"));
 }
 
-TEST_F(CodecTest, TestIntersectFeedbackParams) {
+TEST(CodecTest, TestIntersectFeedbackParams) {
   const FeedbackParam a1("a", "1");
   const FeedbackParam b2("b", "2");
   const FeedbackParam b3("b", "3");
   const FeedbackParam c3("c", "3");
   Codec c1;
   c1.AddFeedbackParam(a1); // Only match with c2.
   c1.AddFeedbackParam(b2); // Same param different values.
   c1.AddFeedbackParam(c3); // Not in c2.
   Codec c2;
   c2.AddFeedbackParam(a1);
   c2.AddFeedbackParam(b3);
 
   c1.IntersectFeedbackParams(c2);
   EXPECT_TRUE(c1.HasFeedbackParam(a1));
   EXPECT_FALSE(c1.HasFeedbackParam(b2));
   EXPECT_FALSE(c1.HasFeedbackParam(c3));
 }
 
-TEST_F(CodecTest, TestGetCodecType) {
+TEST(CodecTest, TestGetCodecType) {
   // Codec type comparison should be case insenstive on names.
   const VideoCodec codec(96, "V");
   const VideoCodec rtx_codec(96, "rTx");
   const VideoCodec ulpfec_codec(96, "ulpFeC");
   const VideoCodec red_codec(96, "ReD");
   EXPECT_EQ(VideoCodec::CODEC_VIDEO, codec.GetCodecType());
   EXPECT_EQ(VideoCodec::CODEC_RTX, rtx_codec.GetCodecType());
   EXPECT_EQ(VideoCodec::CODEC_ULPFEC, ulpfec_codec.GetCodecType());
   EXPECT_EQ(VideoCodec::CODEC_RED, red_codec.GetCodecType());
 }
 
-TEST_F(CodecTest, TestCreateRtxCodec) {
+TEST(CodecTest, TestCreateRtxCodec) {
   VideoCodec rtx_codec = VideoCodec::CreateRtxCodec(96, 120);
   EXPECT_EQ(96, rtx_codec.id);
   EXPECT_EQ(VideoCodec::CODEC_RTX, rtx_codec.GetCodecType());
   int associated_payload_type;
   ASSERT_TRUE(rtx_codec.GetParam(kCodecParamAssociatedPayloadType,
                                  &associated_payload_type));
   EXPECT_EQ(120, associated_payload_type);
 }
 
-TEST_F(CodecTest, TestValidateCodecFormat) {
+TEST(CodecTest, TestValidateCodecFormat) {
   const VideoCodec codec(96, "V");
   ASSERT_TRUE(codec.ValidateCodecFormat());
 
   // Accept 0-127 as payload types.
   VideoCodec low_payload_type = codec;
   low_payload_type.id = 0;
   VideoCodec high_payload_type = codec;
   high_payload_type.id = 127;
   ASSERT_TRUE(low_payload_type.ValidateCodecFormat());
   EXPECT_TRUE(high_payload_type.ValidateCodecFormat());
@@ skipping 20 matching lines @@
   equal_bitrates.params[kCodecParamMaxBitrate] = "100";
   EXPECT_TRUE(equal_bitrates.ValidateCodecFormat());
 
   // Accept min bitrate < max bitrate.
   VideoCodec different_bitrates = codec;
   different_bitrates.params[kCodecParamMinBitrate] = "99";
   different_bitrates.params[kCodecParamMaxBitrate] = "100";
   EXPECT_TRUE(different_bitrates.ValidateCodecFormat());
 }
 
-TEST_F(CodecTest, TestToCodecParameters) {
+TEST(CodecTest, TestToCodecParameters) {
   const VideoCodec v(96, "V");
   webrtc::RtpCodecParameters codec_params_1 = v.ToCodecParameters();
   EXPECT_EQ(96, codec_params_1.payload_type);
   EXPECT_EQ("V", codec_params_1.mime_type);
   EXPECT_EQ(cricket::kVideoCodecClockrate, codec_params_1.clock_rate);
   EXPECT_EQ(1, codec_params_1.channels);
 
   const AudioCodec a(97, "A", 44100, 20000, 2);
   webrtc::RtpCodecParameters codec_params_2 = a.ToCodecParameters();
   EXPECT_EQ(97, codec_params_2.payload_type);
   EXPECT_EQ("A", codec_params_2.mime_type);
   EXPECT_EQ(44100, codec_params_2.clock_rate);
   EXPECT_EQ(2, codec_params_2.channels);
 }