diff --git a/test/frame_generator_capturer_unittest.cc b/test/frame_generator_capturer_unittest.cc
index 7400bbb79b..a76cb95d44 100644
--- a/test/frame_generator_capturer_unittest.cc
+++ b/test/frame_generator_capturer_unittest.cc
@@ -22,8 +22,8 @@ using ::testing::Property;
 class MockVideoSinkInterfaceVideoFrame
     : public rtc::VideoSinkInterface<VideoFrame> {
  public:
-  MOCK_METHOD1(OnFrame, void(const VideoFrame& frame));
-  MOCK_METHOD0(OnDiscardedFrame, void());
+  MOCK_METHOD(void, OnFrame, (const VideoFrame& frame), (override));
+  MOCK_METHOD(void, OnDiscardedFrame, (), (override));
 };
 }  // namespace
 TEST(FrameGeneratorCapturerTest, CreateFromConfig) {
diff --git a/test/mock_audio_decoder.h b/test/mock_audio_decoder.h
index 7c6db5acc2..8f44bf891d 100644
--- a/test/mock_audio_decoder.h
+++ b/test/mock_audio_decoder.h
@@ -20,16 +20,18 @@ class MockAudioDecoder : public AudioDecoder {
  public:
   MockAudioDecoder();
   ~MockAudioDecoder();
-  MOCK_METHOD0(Die, void());
-  MOCK_METHOD5(DecodeInternal,
-               int(const uint8_t*, size_t, int, int16_t*, SpeechType*));
-  MOCK_CONST_METHOD0(HasDecodePlc, bool());
-  MOCK_METHOD2(DecodePlc, size_t(size_t, int16_t*));
-  MOCK_METHOD0(Reset, void());
-  MOCK_METHOD0(ErrorCode, int());
-  MOCK_CONST_METHOD2(PacketDuration, int(const uint8_t*, size_t));
-  MOCK_CONST_METHOD0(Channels, size_t());
-  MOCK_CONST_METHOD0(SampleRateHz, int());
+  MOCK_METHOD(void, Die, ());
+  MOCK_METHOD(int,
+              DecodeInternal,
+              (const uint8_t*, size_t, int, int16_t*, SpeechType*),
+              (override));
+  MOCK_METHOD(bool, HasDecodePlc, (), (const, override));
+  MOCK_METHOD(size_t, DecodePlc, (size_t, int16_t*), (override));
+  MOCK_METHOD(void, Reset, (), (override));
+  MOCK_METHOD(int, ErrorCode, (), (override));
+  MOCK_METHOD(int, PacketDuration, (const uint8_t*, size_t), (const, override));
+  MOCK_METHOD(size_t, Channels, (), (const, override));
+  MOCK_METHOD(int, SampleRateHz, (), (const, override));
 };
 
 }  // namespace webrtc
diff --git a/test/mock_audio_decoder_factory.h b/test/mock_audio_decoder_factory.h
index cdf2919543..cdb03d3f38 100644
--- a/test/mock_audio_decoder_factory.h
+++ b/test/mock_audio_decoder_factory.h
@@ -24,19 +24,23 @@ namespace webrtc {
 
 class MockAudioDecoderFactory : public AudioDecoderFactory {
  public:
-  MOCK_METHOD0(GetSupportedDecoders, std::vector<AudioCodecSpec>());
-  MOCK_METHOD1(IsSupportedDecoder, bool(const SdpAudioFormat&));
+  MOCK_METHOD(std::vector<AudioCodecSpec>,
+              GetSupportedDecoders,
+              (),
+              (override));
+  MOCK_METHOD(bool, IsSupportedDecoder, (const SdpAudioFormat&), (override));
   std::unique_ptr<AudioDecoder> MakeAudioDecoder(
       const SdpAudioFormat& format,
-      absl::optional<AudioCodecPairId> codec_pair_id) {
+      absl::optional<AudioCodecPairId> codec_pair_id) override {
     std::unique_ptr<AudioDecoder> return_value;
     MakeAudioDecoderMock(format, codec_pair_id, &return_value);
     return return_value;
   }
-  MOCK_METHOD3(MakeAudioDecoderMock,
-               void(const SdpAudioFormat& format,
-                    absl::optional<AudioCodecPairId> codec_pair_id,
-                    std::unique_ptr<AudioDecoder>* return_value));
+  MOCK_METHOD(void,
+              MakeAudioDecoderMock,
+              (const SdpAudioFormat& format,
+               absl::optional<AudioCodecPairId> codec_pair_id,
+               std::unique_ptr<AudioDecoder>*));
 
   // Creates a MockAudioDecoderFactory with no formats and that may not be
   // invoked to create a codec - useful for initializing a voice engine, for
diff --git a/test/mock_audio_encoder.h b/test/mock_audio_encoder.h
index 2dfd15ca98..9d9db0d66c 100644
--- a/test/mock_audio_encoder.h
+++ b/test/mock_audio_encoder.h
@@ -27,37 +27,44 @@ class MockAudioEncoder : public AudioEncoder {
   // http://crbug.com/428099.
   MockAudioEncoder();
   ~MockAudioEncoder();
-  MOCK_METHOD1(Mark, void(std::string desc));
-  MOCK_CONST_METHOD0(SampleRateHz, int());
-  MOCK_CONST_METHOD0(NumChannels, size_t());
-  MOCK_CONST_METHOD0(RtpTimestampRateHz, int());
-  MOCK_CONST_METHOD0(Num10MsFramesInNextPacket, size_t());
-  MOCK_CONST_METHOD0(Max10MsFramesInAPacket, size_t());
-  MOCK_CONST_METHOD0(GetTargetBitrate, int());
-  MOCK_CONST_METHOD0(GetFrameLengthRange,
-                     absl::optional<std::pair<TimeDelta, TimeDelta>>());
+  MOCK_METHOD(int, SampleRateHz, (), (const, override));
+  MOCK_METHOD(size_t, NumChannels, (), (const, override));
+  MOCK_METHOD(int, RtpTimestampRateHz, (), (const, override));
+  MOCK_METHOD(size_t, Num10MsFramesInNextPacket, (), (const, override));
+  MOCK_METHOD(size_t, Max10MsFramesInAPacket, (), (const, override));
+  MOCK_METHOD(int, GetTargetBitrate, (), (const, override));
+  MOCK_METHOD((absl::optional<std::pair<TimeDelta, TimeDelta>>),
+              GetFrameLengthRange,
+              (),
+              (const, override));
 
-  MOCK_METHOD0(Reset, void());
-  MOCK_METHOD1(SetFec, bool(bool enable));
-  MOCK_METHOD1(SetDtx, bool(bool enable));
-  MOCK_METHOD1(SetApplication, bool(Application application));
-  MOCK_METHOD1(SetMaxPlaybackRate, void(int frequency_hz));
-  MOCK_METHOD1(SetMaxBitrate, void(int max_bps));
-  MOCK_METHOD1(SetMaxPayloadSize, void(int max_payload_size_bytes));
-  MOCK_METHOD2(OnReceivedUplinkBandwidth,
-               void(int target_audio_bitrate_bps,
-                    absl::optional<int64_t> probing_interval_ms));
-  MOCK_METHOD1(OnReceivedUplinkPacketLossFraction,
-               void(float uplink_packet_loss_fraction));
+  MOCK_METHOD(void, Reset, (), (override));
+  MOCK_METHOD(bool, SetFec, (bool enable), (override));
+  MOCK_METHOD(bool, SetDtx, (bool enable), (override));
+  MOCK_METHOD(bool, SetApplication, (Application application), (override));
+  MOCK_METHOD(void, SetMaxPlaybackRate, (int frequency_hz), (override));
+  MOCK_METHOD(void,
+              OnReceivedUplinkBandwidth,
+              (int target_audio_bitrate_bps,
+               absl::optional<int64_t> probing_interval_ms),
+              (override));
+  MOCK_METHOD(void,
+              OnReceivedUplinkPacketLossFraction,
+              (float uplink_packet_loss_fraction),
+              (override));
 
-  MOCK_METHOD2(EnableAudioNetworkAdaptor,
-               bool(const std::string& config_string, RtcEventLog* event_log));
+  MOCK_METHOD(bool,
+              EnableAudioNetworkAdaptor,
+              (const std::string& config_string, RtcEventLog*),
+              (override));
 
   // Note, we explicitly chose not to create a mock for the Encode method.
-  MOCK_METHOD3(EncodeImpl,
-               EncodedInfo(uint32_t timestamp,
-                           rtc::ArrayView<const int16_t> audio,
-                           rtc::Buffer* encoded));
+  MOCK_METHOD(EncodedInfo,
+              EncodeImpl,
+              (uint32_t timestamp,
+               rtc::ArrayView<const int16_t> audio,
+               rtc::Buffer*),
+              (override));
 
   class FakeEncoding {
    public:
diff --git a/test/mock_audio_encoder_factory.h b/test/mock_audio_encoder_factory.h
index 3e774a39e9..392a4c11e2 100644
--- a/test/mock_audio_encoder_factory.h
+++ b/test/mock_audio_encoder_factory.h
@@ -24,23 +24,29 @@ namespace webrtc {
 class MockAudioEncoderFactory
     : public ::testing::NiceMock<AudioEncoderFactory> {
  public:
-  MOCK_METHOD0(GetSupportedEncoders, std::vector<AudioCodecSpec>());
-  MOCK_METHOD1(QueryAudioEncoder,
-               absl::optional<AudioCodecInfo>(const SdpAudioFormat& format));
+  MOCK_METHOD(std::vector<AudioCodecSpec>,
+              GetSupportedEncoders,
+              (),
+              (override));
+  MOCK_METHOD(absl::optional<AudioCodecInfo>,
+              QueryAudioEncoder,
+              (const SdpAudioFormat& format),
+              (override));
 
   std::unique_ptr<AudioEncoder> MakeAudioEncoder(
       int payload_type,
       const SdpAudioFormat& format,
-      absl::optional<AudioCodecPairId> codec_pair_id) {
+      absl::optional<AudioCodecPairId> codec_pair_id) override {
     std::unique_ptr<AudioEncoder> return_value;
     MakeAudioEncoderMock(payload_type, format, codec_pair_id, &return_value);
     return return_value;
   }
-  MOCK_METHOD4(MakeAudioEncoderMock,
-               void(int payload_type,
-                    const SdpAudioFormat& format,
-                    absl::optional<AudioCodecPairId> codec_pair_id,
-                    std::unique_ptr<AudioEncoder>* return_value));
+  MOCK_METHOD(void,
+              MakeAudioEncoderMock,
+              (int payload_type,
+               const SdpAudioFormat& format,
+               absl::optional<AudioCodecPairId> codec_pair_id,
+               std::unique_ptr<AudioEncoder>*));
 
   // Creates a MockAudioEncoderFactory with no formats and that may not be
   // invoked to create a codec - useful for initializing a voice engine, for
diff --git a/test/mock_transport.h b/test/mock_transport.h
index 5ffc10425b..9c4dc4bf8d 100644
--- a/test/mock_transport.h
+++ b/test/mock_transport.h
@@ -25,7 +25,7 @@ class MockTransport : public Transport {
               SendRtp,
               (const uint8_t*, size_t, const PacketOptions&),
               (override));
-  MOCK_METHOD(bool, SendRtcp, (const uint8_t* data, size_t len), (override));
+  MOCK_METHOD(bool, SendRtcp, (const uint8_t*, size_t len), (override));
 };
 
 }  // namespace webrtc
diff --git a/test/network/network_emulation_unittest.cc b/test/network/network_emulation_unittest.cc
index 58346abb93..9e630de9cb 100644
--- a/test/network/network_emulation_unittest.cc
+++ b/test/network/network_emulation_unittest.cc
@@ -70,7 +70,7 @@ class SocketReader : public sigslot::has_slots<> {
 
 class MockReceiver : public EmulatedNetworkReceiverInterface {
  public:
-  MOCK_METHOD1(OnPacketReceived, void(EmulatedIpPacket packet));
+  MOCK_METHOD(void, OnPacketReceived, (EmulatedIpPacket packet), (override));
 };
 
 class NetworkEmulationManagerThreeNodesRoutingTest : public ::testing::Test {
diff --git a/test/testsupport/mock/mock_frame_reader.h b/test/testsupport/mock/mock_frame_reader.h
index 8da3695d23..bda6b1ad2d 100644
--- a/test/testsupport/mock/mock_frame_reader.h
+++ b/test/testsupport/mock/mock_frame_reader.h
@@ -19,11 +19,11 @@ namespace test {
 
 class MockFrameReader : public FrameReader {
  public:
-  MOCK_METHOD0(Init, bool());
-  MOCK_METHOD0(ReadFrame, rtc::scoped_refptr<I420Buffer>());
-  MOCK_METHOD0(Close, void());
-  MOCK_METHOD0(FrameLength, size_t());
-  MOCK_METHOD0(NumberOfFrames, int());
+  MOCK_METHOD(bool, Init, (), (override));
+  MOCK_METHOD(rtc::scoped_refptr<I420Buffer>, ReadFrame, (), (override));
+  MOCK_METHOD(void, Close, (), (override));
+  MOCK_METHOD(size_t, FrameLength, (), (override));
+  MOCK_METHOD(int, NumberOfFrames, (), (override));
 };
 
 }  // namespace test