package congestion

import (
	"time"

	"github.com/lucas-clemente/quic-go/protocol"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

const initialCongestionWindowPackets protocol.PacketNumber = 10
const defaultWindowTCP = protocol.ByteCount(initialCongestionWindowPackets) * protocol.DefaultTCPMSS

type mockClock time.Time

func (c *mockClock) Now() time.Time {
	return time.Time(*c)
}

func (c *mockClock) Advance(d time.Duration) {
	*c = mockClock(time.Time(*c).Add(d))
}

const MaxCongestionWindow = protocol.PacketNumber(200)

var _ = Describe("Cubic Sender", func() {
	var (
		sender            SendAlgorithmWithDebugInfo
		clock             mockClock
		bytesInFlight     protocol.ByteCount
		packetNumber      protocol.PacketNumber
		ackedPacketNumber protocol.PacketNumber
		rttStats          *RTTStats
	)

	BeforeEach(func() {
		bytesInFlight = 0
		packetNumber = 1
		ackedPacketNumber = 0
		clock = mockClock{}
		rttStats = NewRTTStats()
		sender = NewCubicSender(&clock, rttStats, true /*reno*/, initialCongestionWindowPackets, MaxCongestionWindow)
	})

	SendAvailableSendWindowLen := func(packetLength protocol.ByteCount) int {
		// Send as long as TimeUntilSend returns Zero.
		packets_sent := 0
		can_send := sender.TimeUntilSend(clock.Now(), bytesInFlight) == 0
		for can_send {
			sender.OnPacketSent(clock.Now(), bytesInFlight, packetNumber, packetLength, true)
			packetNumber++
			packets_sent++
			bytesInFlight += packetLength
			can_send = sender.TimeUntilSend(clock.Now(), bytesInFlight) == 0
		}
		return packets_sent
	}

	// Normal is that TCP acks every other segment.
	AckNPacketsLen := func(n int, packetLength protocol.ByteCount) {
		rttStats.UpdateRTT(60*time.Millisecond, 0, clock.Now())
		sender.MaybeExitSlowStart()
		for i := 0; i < n; i++ {
			ackedPacketNumber++
			sender.OnPacketAcked(ackedPacketNumber, packetLength, bytesInFlight)
		}
		bytesInFlight -= protocol.ByteCount(n) * packetLength
		clock.Advance(time.Millisecond)
	}

	LoseNPacketsLen := func(n int, packetLength protocol.ByteCount) {
		for i := 0; i < n; i++ {
			ackedPacketNumber++
			sender.OnPacketLost(ackedPacketNumber, packetLength, bytesInFlight)
		}
		bytesInFlight -= protocol.ByteCount(n) * packetLength
	}

	// Does not increment acked_packet_number_.
	LosePacket := func(number protocol.PacketNumber) {
		sender.OnPacketLost(number, protocol.DefaultTCPMSS, bytesInFlight)
		bytesInFlight -= protocol.DefaultTCPMSS
	}

	SendAvailableSendWindow := func() int { return SendAvailableSendWindowLen(protocol.DefaultTCPMSS) }
	AckNPackets := func(n int) { AckNPacketsLen(n, protocol.DefaultTCPMSS) }
	LoseNPackets := func(n int) { LoseNPacketsLen(n, protocol.DefaultTCPMSS) }

	It("simpler sender", func() {
		// At startup make sure we are at the default.
		Expect(sender.GetCongestionWindow()).To(Equal(defaultWindowTCP))
		// At startup make sure we can send.
		Expect(sender.TimeUntilSend(clock.Now(), 0)).To(BeZero())
		// Make sure we can send.
		Expect(sender.TimeUntilSend(clock.Now(), 0)).To(BeZero())
		// And that window is un-affected.
		Expect(sender.GetCongestionWindow()).To(Equal(defaultWindowTCP))

		// Fill the send window with data, then verify that we can't send.
		SendAvailableSendWindow()
		Expect(sender.TimeUntilSend(clock.Now(), sender.GetCongestionWindow())).ToNot(BeZero())
	})

	It("application limited slow start", func() {
		// Send exactly 10 packets and ensure the CWND ends at 14 packets.
		const kNumberOfAcks = 5
		// At startup make sure we can send.
		Expect(sender.TimeUntilSend(clock.Now(), 0)).To(BeZero())
		// Make sure we can send.
		Expect(sender.TimeUntilSend(clock.Now(), 0)).To(BeZero())

		SendAvailableSendWindow()
		for i := 0; i < kNumberOfAcks; i++ {
			AckNPackets(2)
		}
		bytesToSend := sender.GetCongestionWindow()
		// It's expected 2 acks will arrive when the bytes_in_flight are greater than
		// half the CWND.
		Expect(bytesToSend).To(Equal(defaultWindowTCP + protocol.DefaultTCPMSS*2*2))
	})

	It("exponential slow start", func() {
		const kNumberOfAcks = 20
		// At startup make sure we can send.
		Expect(sender.TimeUntilSend(clock.Now(), 0)).To(BeZero())
		Expect(sender.BandwidthEstimate()).To(BeZero())
		// Make sure we can send.
		Expect(sender.TimeUntilSend(clock.Now(), 0)).To(BeZero())

		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
		}
		cwnd := sender.GetCongestionWindow()
		Expect(cwnd).To(Equal(defaultWindowTCP + protocol.DefaultTCPMSS*2*kNumberOfAcks))
		Expect(sender.BandwidthEstimate()).To(Equal(BandwidthFromDelta(cwnd, rttStats.SmoothedRTT())))
	})

	It("slow start packet loss", func() {
		sender.SetNumEmulatedConnections(1)
		const kNumberOfAcks = 10
		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
		}
		SendAvailableSendWindow()
		expected_send_window := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * kNumberOfAcks)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Lose a packet to exit slow start.
		LoseNPackets(1)
		packets_in_recovery_window := expected_send_window / protocol.DefaultTCPMSS

		// We should now have fallen out of slow start with a reduced window.
		expected_send_window = protocol.ByteCount(float32(expected_send_window) * renoBeta)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Recovery phase. We need to ack every packet in the recovery window before
		// we exit recovery.
		number_of_packets_in_window := expected_send_window / protocol.DefaultTCPMSS
		AckNPackets(int(packets_in_recovery_window))
		SendAvailableSendWindow()
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// We need to ack an entire window before we increase CWND by 1.
		AckNPackets(int(number_of_packets_in_window) - 2)
		SendAvailableSendWindow()
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Next ack should increase cwnd by 1.
		AckNPackets(1)
		expected_send_window += protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Now RTO and ensure slow start gets reset.
		Expect(sender.HybridSlowStart().Started()).To(BeTrue())
		sender.OnRetransmissionTimeout(true)
		Expect(sender.HybridSlowStart().Started()).To(BeFalse())
	})

	It("slow start packet loss with large reduction", func() {
		sender.SetSlowStartLargeReduction(true)

		sender.SetNumEmulatedConnections(1)
		const kNumberOfAcks = 10
		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
		}
		SendAvailableSendWindow()
		expected_send_window := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * kNumberOfAcks)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Lose a packet to exit slow start. We should now have fallen out of
		// slow start with a window reduced by 1.
		LoseNPackets(1)
		expected_send_window -= protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Lose 5 packets in recovery and verify that congestion window is reduced
		// further.
		LoseNPackets(5)
		expected_send_window -= 5 * protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		packets_in_recovery_window := expected_send_window / protocol.DefaultTCPMSS

		// Recovery phase. We need to ack every packet in the recovery window before
		// we exit recovery.
		number_of_packets_in_window := expected_send_window / protocol.DefaultTCPMSS
		AckNPackets(int(packets_in_recovery_window))
		SendAvailableSendWindow()
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// We need to ack the rest of the window before cwnd increases by 1.
		AckNPackets(int(number_of_packets_in_window - 1))
		SendAvailableSendWindow()
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Next ack should increase cwnd by 1.
		AckNPackets(1)
		expected_send_window += protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Now RTO and ensure slow start gets reset.
		Expect(sender.HybridSlowStart().Started()).To(BeTrue())
		sender.OnRetransmissionTimeout(true)
		Expect(sender.HybridSlowStart().Started()).To(BeFalse())
	})

	It("slow start half packet loss with large reduction", func() {
		sender.SetSlowStartLargeReduction(true)

		sender.SetNumEmulatedConnections(1)
		const kNumberOfAcks = 10
		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window in half sized packets.
			SendAvailableSendWindowLen(protocol.DefaultTCPMSS / 2)
			AckNPackets(2)
		}
		SendAvailableSendWindowLen(protocol.DefaultTCPMSS / 2)
		expected_send_window := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * kNumberOfAcks)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Lose a packet to exit slow start. We should now have fallen out of
		// slow start with a window reduced by 1.
		LoseNPackets(1)
		expected_send_window -= protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Lose 10 packets in recovery and verify that congestion window is reduced
		// by 5 packets.
		LoseNPacketsLen(10, protocol.DefaultTCPMSS/2)
		expected_send_window -= 5 * protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))
	})

	It("no PRR when less than one packet in flight", func() {
		SendAvailableSendWindow()
		LoseNPackets(int(initialCongestionWindowPackets) - 1)
		AckNPackets(1)
		// PRR will allow 2 packets for every ack during recovery.
		Expect(SendAvailableSendWindow()).To(Equal(2))
		// Simulate abandoning all packets by supplying a bytes_in_flight of 0.
		// PRR should now allow a packet to be sent, even though prr's state
		// variables believe it has sent enough packets.
		Expect(sender.TimeUntilSend(clock.Now(), 0)).To(BeZero())
	})

	It("slow start packet loss PRR", func() {
		sender.SetNumEmulatedConnections(1)
		// Test based on the first example in RFC6937.
		// Ack 10 packets in 5 acks to raise the CWND to 20, as in the example.
		const kNumberOfAcks = 5
		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
		}
		SendAvailableSendWindow()
		expected_send_window := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * kNumberOfAcks)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		LoseNPackets(1)

		// We should now have fallen out of slow start with a reduced window.
		send_window_before_loss := expected_send_window
		expected_send_window = protocol.ByteCount(float32(expected_send_window) * renoBeta)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Testing TCP proportional rate reduction.
		// We should send packets paced over the received acks for the remaining
		// outstanding packets. The number of packets before we exit recovery is the
		// original CWND minus the packet that has been lost and the one which
		// triggered the loss.
		remaining_packets_in_recovery := send_window_before_loss/protocol.DefaultTCPMSS - 2

		for i := protocol.ByteCount(0); i < remaining_packets_in_recovery; i++ {
			AckNPackets(1)
			SendAvailableSendWindow()
			Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))
		}

		// We need to ack another window before we increase CWND by 1.
		number_of_packets_in_window := expected_send_window / protocol.DefaultTCPMSS
		for i := protocol.ByteCount(0); i < number_of_packets_in_window; i++ {
			AckNPackets(1)
			Expect(SendAvailableSendWindow()).To(Equal(1))
			Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))
		}

		AckNPackets(1)
		expected_send_window += protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))
	})

	It("slow start burst packet loss PRR", func() {
		sender.SetNumEmulatedConnections(1)
		// Test based on the second example in RFC6937, though we also implement
		// forward acknowledgements, so the first two incoming acks will trigger
		// PRR immediately.
		// Ack 20 packets in 10 acks to raise the CWND to 30.
		const kNumberOfAcks = 10
		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
		}
		SendAvailableSendWindow()
		expected_send_window := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * kNumberOfAcks)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Lose one more than the congestion window reduction, so that after loss,
		// bytes_in_flight is lesser than the congestion window.
		send_window_after_loss := protocol.ByteCount(renoBeta * float32(expected_send_window))
		num_packets_to_lose := (expected_send_window-send_window_after_loss)/protocol.DefaultTCPMSS + 1
		LoseNPackets(int(num_packets_to_lose))
		// Immediately after the loss, ensure at least one packet can be sent.
		// Losses without subsequent acks can occur with timer based loss detection.
		Expect(sender.TimeUntilSend(clock.Now(), bytesInFlight)).To(BeZero())
		AckNPackets(1)

		// We should now have fallen out of slow start with a reduced window.
		expected_send_window = protocol.ByteCount(float32(expected_send_window) * renoBeta)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Only 2 packets should be allowed to be sent, per PRR-SSRB
		Expect(SendAvailableSendWindow()).To(Equal(2))

		// Ack the next packet, which triggers another loss.
		LoseNPackets(1)
		AckNPackets(1)

		// Send 2 packets to simulate PRR-SSRB.
		Expect(SendAvailableSendWindow()).To(Equal(2))

		// Ack the next packet, which triggers another loss.
		LoseNPackets(1)
		AckNPackets(1)

		// Send 2 packets to simulate PRR-SSRB.
		Expect(SendAvailableSendWindow()).To(Equal(2))

		// Exit recovery and return to sending at the new rate.
		for i := 0; i < kNumberOfAcks; i++ {
			AckNPackets(1)
			Expect(SendAvailableSendWindow()).To(Equal(1))
		}
	})

	It("RTO congestion window", func() {
		Expect(sender.GetCongestionWindow()).To(Equal(defaultWindowTCP))
		Expect(sender.SlowstartThreshold()).To(Equal(MaxCongestionWindow))

		// Expect the window to decrease to the minimum once the RTO fires
		// and slow start threshold to be set to 1/2 of the CWND.
		sender.OnRetransmissionTimeout(true)
		Expect(sender.GetCongestionWindow()).To(Equal(protocol.ByteCount(2 * protocol.DefaultTCPMSS)))
		Expect(sender.SlowstartThreshold()).To(Equal(protocol.PacketNumber(5)))
	})

	It("RTO congestion window no retransmission", func() {
		Expect(sender.GetCongestionWindow()).To(Equal(defaultWindowTCP))

		// Expect the window to remain unchanged if the RTO fires but no
		// packets are retransmitted.
		sender.OnRetransmissionTimeout(false)
		Expect(sender.GetCongestionWindow()).To(Equal(defaultWindowTCP))
	})

	It("retransmission delay", func() {
		const kRttMs = 10 * time.Millisecond
		const kDeviationMs = 3 * time.Millisecond
		Expect(sender.RetransmissionDelay()).To(BeZero())

		rttStats.UpdateRTT(kRttMs, 0, clock.Now())

		// Initial value is to set the median deviation to half of the initial
		// rtt, the median in then multiplied by a factor of 4 and finally the
		// smoothed rtt is added which is the initial rtt.
		expected_delay := kRttMs + kRttMs/2*4
		Expect(sender.RetransmissionDelay()).To(Equal(expected_delay))

		for i := 0; i < 100; i++ {
			// run to make sure that we converge.
			rttStats.UpdateRTT(kRttMs+kDeviationMs, 0, clock.Now())
			rttStats.UpdateRTT(kRttMs-kDeviationMs, 0, clock.Now())
		}
		expected_delay = kRttMs + kDeviationMs*4

		Expect(rttStats.SmoothedRTT()).To(BeNumerically("~", kRttMs, time.Millisecond))
		Expect(sender.RetransmissionDelay()).To(BeNumerically("~", expected_delay, time.Millisecond))
		Expect(sender.BandwidthEstimate() / BytesPerSecond).To(Equal(Bandwidth(
			sender.GetCongestionWindow() * protocol.ByteCount(time.Second) / protocol.ByteCount(rttStats.SmoothedRTT()),
		)))
	})

	It("slow start max send window", func() {
		const kMaxCongestionWindowTCP = 50
		const kNumberOfAcks = 100
		sender = NewCubicSender(&clock, rttStats, false, initialCongestionWindowPackets, kMaxCongestionWindowTCP)

		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
		}
		expected_send_window := kMaxCongestionWindowTCP * protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(protocol.ByteCount(expected_send_window)))
	})

	It("tcp reno max congestion window", func() {
		const kMaxCongestionWindowTCP = 50
		const kNumberOfAcks = 1000
		sender = NewCubicSender(&clock, rttStats, false, initialCongestionWindowPackets, kMaxCongestionWindowTCP)

		SendAvailableSendWindow()
		AckNPackets(2)
		// Make sure we fall out of slow start.
		LoseNPackets(1)

		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
		}

		expected_send_window := kMaxCongestionWindowTCP * protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(protocol.ByteCount(expected_send_window)))
	})

	It("tcp cubic max congestion window", func() {
		const kMaxCongestionWindowTCP = 50
		// Set to 10000 to compensate for small cubic alpha.
		const kNumberOfAcks = 10000

		sender = NewCubicSender(&clock, rttStats, false, initialCongestionWindowPackets, kMaxCongestionWindowTCP)

		SendAvailableSendWindow()
		AckNPackets(2)
		// Make sure we fall out of slow start.
		LoseNPackets(1)

		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
		}

		expected_send_window := kMaxCongestionWindowTCP * protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(protocol.ByteCount(expected_send_window)))
	})

	It("tcp cubic reset epoch on quiescence", func() {
		const kMaxCongestionWindow = 50
		const kMaxCongestionWindowBytes = kMaxCongestionWindow * protocol.DefaultTCPMSS
		sender = NewCubicSender(&clock, rttStats, false, initialCongestionWindowPackets, kMaxCongestionWindow)

		num_sent := SendAvailableSendWindow()

		// Make sure we fall out of slow start.
		saved_cwnd := sender.GetCongestionWindow()
		LoseNPackets(1)
		Expect(saved_cwnd).To(BeNumerically(">", sender.GetCongestionWindow()))

		// Ack the rest of the outstanding packets to get out of recovery.
		for i := 1; i < num_sent; i++ {
			AckNPackets(1)
		}
		Expect(bytesInFlight).To(BeZero())

		// Send a new window of data and ack all; cubic growth should occur.
		saved_cwnd = sender.GetCongestionWindow()
		num_sent = SendAvailableSendWindow()
		for i := 0; i < num_sent; i++ {
			AckNPackets(1)
		}
		Expect(saved_cwnd).To(BeNumerically("<", sender.GetCongestionWindow()))
		Expect(kMaxCongestionWindowBytes).To(BeNumerically(">", sender.GetCongestionWindow()))
		Expect(bytesInFlight).To(BeZero())

		// Quiescent time of 100 seconds
		clock.Advance(100 * time.Second)

		// Send new window of data and ack one packet. Cubic epoch should have
		// been reset; ensure cwnd increase is not dramatic.
		saved_cwnd = sender.GetCongestionWindow()
		SendAvailableSendWindow()
		AckNPackets(1)
		Expect(saved_cwnd).To(BeNumerically("~", sender.GetCongestionWindow(), protocol.DefaultTCPMSS))
		Expect(kMaxCongestionWindowBytes).To(BeNumerically(">", sender.GetCongestionWindow()))
	})

	It("tcp cubic shifted epoch on quiescence", func() {
		const kMaxCongestionWindow = 50
		const kMaxCongestionWindowBytes = kMaxCongestionWindow * protocol.DefaultTCPMSS
		sender = NewCubicSender(&clock, rttStats, false, initialCongestionWindowPackets, kMaxCongestionWindow)

		num_sent := SendAvailableSendWindow()

		// Make sure we fall out of slow start.
		saved_cwnd := sender.GetCongestionWindow()
		LoseNPackets(1)
		Expect(saved_cwnd).To(BeNumerically(">", sender.GetCongestionWindow()))

		// Ack the rest of the outstanding packets to get out of recovery.
		for i := 1; i < num_sent; i++ {
			AckNPackets(1)
		}
		Expect(bytesInFlight).To(BeZero())

		// Send a new window of data and ack all; cubic growth should occur.
		saved_cwnd = sender.GetCongestionWindow()
		num_sent = SendAvailableSendWindow()
		for i := 0; i < num_sent; i++ {
			AckNPackets(1)
		}
		Expect(saved_cwnd).To(BeNumerically("<", sender.GetCongestionWindow()))
		Expect(kMaxCongestionWindowBytes).To(BeNumerically(">", sender.GetCongestionWindow()))
		Expect(bytesInFlight).To(BeZero())

		// Quiescent time of 100 seconds
		clock.Advance(100 * time.Second)

		// Send new window of data and ack one packet. Cubic epoch should have
		// been reset; ensure cwnd increase is not dramatic.
		saved_cwnd = sender.GetCongestionWindow()
		SendAvailableSendWindow()
		AckNPackets(1)
		Expect(saved_cwnd).To(BeNumerically("~", sender.GetCongestionWindow(), protocol.DefaultTCPMSS))
		Expect(kMaxCongestionWindowBytes).To(BeNumerically(">", sender.GetCongestionWindow()))
	})

	It("multiple losses in one window", func() {
		SendAvailableSendWindow()
		initial_window := sender.GetCongestionWindow()
		LosePacket(ackedPacketNumber + 1)
		post_loss_window := sender.GetCongestionWindow()
		Expect(initial_window).To(BeNumerically(">", post_loss_window))
		LosePacket(ackedPacketNumber + 3)
		Expect(sender.GetCongestionWindow()).To(Equal(post_loss_window))
		LosePacket(packetNumber - 1)
		Expect(sender.GetCongestionWindow()).To(Equal(post_loss_window))

		// Lose a later packet and ensure the window decreases.
		LosePacket(packetNumber)
		Expect(post_loss_window).To(BeNumerically(">", sender.GetCongestionWindow()))
	})

	It("don't track ack packets", func() {
		// Send a packet with no retransmittable data, and ensure it's not tracked.
		Expect(sender.OnPacketSent(clock.Now(), bytesInFlight, packetNumber, protocol.DefaultTCPMSS, false)).To(BeFalse())
		packetNumber++

		// Send a data packet with retransmittable data, and ensure it is tracked.
		Expect(sender.OnPacketSent(clock.Now(), bytesInFlight, packetNumber, protocol.DefaultTCPMSS, true)).To(BeTrue())
	})

	// TEST_F(TcpCubicSenderPacketsTest, ConfigureInitialWindow) {
	//   QuicConfig config;
	//
	//   QuicTagVector options;
	//   options.push_back(kIW03);
	//   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
	//   sender.SetFromConfig(config, Perspective::IS_SERVER);
	//   Expect( sender.congestion_window()).To(Equal(3u))
	//
	//   options.clear();
	//   options.push_back(kIW10);
	//   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
	//   sender.SetFromConfig(config, Perspective::IS_SERVER);
	//   Expect( sender.congestion_window()).To(Equal(10u))
	//
	//   options.clear();
	//   options.push_back(kIW20);
	//   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
	//   sender.SetFromConfig(config, Perspective::IS_SERVER);
	//   Expect( sender.congestion_window()).To(Equal(20u))
	//
	//   options.clear();
	//   options.push_back(kIW50);
	//   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
	//   sender.SetFromConfig(config, Perspective::IS_SERVER);
	//   Expect( sender.congestion_window()).To(Equal(50u))
	// }
	//
	// TEST_F(TcpCubicSenderPacketsTest, ConfigureMinimumWindow) {
	//   QuicConfig config;
	//
	//   // Verify that kCOPT: kMIN1 forces the min CWND to 1 packet.
	//   QuicTagVector options;
	//   options.push_back(kMIN1);
	//   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
	//   sender.SetFromConfig(config, Perspective::IS_SERVER);
	//   sender.OnRetransmissionTimeout(true);
	//   Expect( sender.congestion_window()).To(Equal(1u))
	// }

	It("2 connection congestion avoidance at end of recovery", func() {
		sender.SetNumEmulatedConnections(2)
		// Ack 10 packets in 5 acks to raise the CWND to 20.
		const kNumberOfAcks = 5
		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
		}
		SendAvailableSendWindow()
		expected_send_window := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * kNumberOfAcks)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		LoseNPackets(1)

		// We should now have fallen out of slow start with a reduced window.
		expected_send_window = protocol.ByteCount(float32(expected_send_window) * sender.RenoBeta())
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// No congestion window growth should occur in recovery phase, i.e., until the
		// currently outstanding 20 packets are acked.
		for i := 0; i < 10; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			Expect(sender.InRecovery()).To(BeTrue())
			AckNPackets(2)
			Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))
		}
		Expect(sender.InRecovery()).To(BeFalse())

		// Out of recovery now. Congestion window should not grow for half an RTT.
		packets_in_send_window := expected_send_window / protocol.DefaultTCPMSS
		SendAvailableSendWindow()
		AckNPackets(int(packets_in_send_window/2 - 2))
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Next ack should increase congestion window by 1MSS.
		SendAvailableSendWindow()
		AckNPackets(2)
		expected_send_window += protocol.DefaultTCPMSS
		packets_in_send_window += 1
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Congestion window should remain steady again for half an RTT.
		SendAvailableSendWindow()
		AckNPackets(int(packets_in_send_window/2 - 1))
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Next ack should cause congestion window to grow by 1MSS.
		SendAvailableSendWindow()
		AckNPackets(2)
		expected_send_window += protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))
	})

	It("1 connection congestion avoidance at end of recovery", func() {
		sender.SetNumEmulatedConnections(1)
		// Ack 10 packets in 5 acks to raise the CWND to 20.
		const kNumberOfAcks = 5
		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
		}
		SendAvailableSendWindow()
		expected_send_window := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * kNumberOfAcks)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		LoseNPackets(1)

		// We should now have fallen out of slow start with a reduced window.
		expected_send_window = protocol.ByteCount(float32(expected_send_window) * renoBeta)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// No congestion window growth should occur in recovery phase, i.e., until the
		// currently outstanding 20 packets are acked.
		for i := 0; i < 10; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			Expect(sender.InRecovery()).To(BeTrue())
			AckNPackets(2)
			Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))
		}
		Expect(sender.InRecovery()).To(BeFalse())

		// Out of recovery now. Congestion window should not grow during RTT.
		for i := protocol.ByteCount(0); i < expected_send_window/protocol.DefaultTCPMSS-2; i += 2 {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
			Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))
		}

		// Next ack should cause congestion window to grow by 1MSS.
		SendAvailableSendWindow()
		AckNPackets(2)
		expected_send_window += protocol.DefaultTCPMSS
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))
	})

	// TEST_F(TcpCubicSenderPacketsTest, BandwidthResumption) {
	//   // Test that when provided with CachedNetworkParameters and opted in to the
	//   // bandwidth resumption experiment, that the TcpCubicSenderPackets sets
	//   // initial CWND appropriately.
	//
	//   // Set some common values.
	//   CachedNetworkParameters cached_network_params;
	//   const QuicPacketCount kNumberOfPackets = 123;
	//   const int kBandwidthEstimateBytesPerSecond =
	//       kNumberOfPackets * protocol.DefaultTCPMSS;
	//   cached_network_params.set_bandwidth_estimate_bytes_per_second(
	//       kBandwidthEstimateBytesPerSecond);
	//   cached_network_params.set_min_rtt_ms(1000);
	//
	//   // Make sure that a bandwidth estimate results in a changed CWND.
	//   cached_network_params.set_timestamp(clock.WallNow().ToUNIXSeconds() -
	//                                       (kNumSecondsPerHour - 1));
	//   sender.ResumeConnectionState(cached_network_params, false);
	//   Expect( sender.congestion_window()).To(Equal(kNumberOfPackets))
	//
	//   // Resumed CWND is limited to be in a sensible range.
	//   cached_network_params.set_bandwidth_estimate_bytes_per_second(
	//       (kMaxCongestionWindow + 1) * protocol.DefaultTCPMSS);
	//   sender.ResumeConnectionState(cached_network_params, false);
	//   Expect( sender.congestion_window()).To(Equal(kMaxCongestionWindow))
	//
	//   cached_network_params.set_bandwidth_estimate_bytes_per_second(
	//       (kMinCongestionWindowForBandwidthResumption - 1) * protocol.DefaultTCPMSS);
	//   sender.ResumeConnectionState(cached_network_params, false);
	//   EXPECT_EQ(kMinCongestionWindowForBandwidthResumption,
	//             sender.congestion_window());
	//
	//   // Resume to the max value.
	//   cached_network_params.set_max_bandwidth_estimate_bytes_per_second(
	//       (kMinCongestionWindowForBandwidthResumption + 10) * protocol.DefaultTCPMSS);
	//   sender.ResumeConnectionState(cached_network_params, true);
	//   EXPECT_EQ((kMinCongestionWindowForBandwidthResumption + 10) * protocol.DefaultTCPMSS,
	//             sender.GetCongestionWindow());
	// }
	//
	// TEST_F(TcpCubicSenderPacketsTest, PaceBelowCWND) {
	//   QuicConfig config;
	//
	//   // Verify that kCOPT: kMIN4 forces the min CWND to 1 packet, but allows up
	//   // to 4 to be sent.
	//   QuicTagVector options;
	//   options.push_back(kMIN4);
	//   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
	//   sender.SetFromConfig(config, Perspective::IS_SERVER);
	//   sender.OnRetransmissionTimeout(true);
	//   Expect( sender.congestion_window()).To(Equal(1u))
	//   EXPECT_TRUE(
	//       sender.TimeUntilSend(QuicTime::Zero(), protocol.DefaultTCPMSS).IsZero());
	//   EXPECT_TRUE(
	//       sender.TimeUntilSend(QuicTime::Zero(), 2 * protocol.DefaultTCPMSS).IsZero());
	//   EXPECT_TRUE(
	//       sender.TimeUntilSend(QuicTime::Zero(), 3 * protocol.DefaultTCPMSS).IsZero());
	//   EXPECT_FALSE(
	//       sender.TimeUntilSend(QuicTime::Zero(), 4 * protocol.DefaultTCPMSS).IsZero());
	// }

	It("reset after connection migration", func() {
		Expect(sender.GetCongestionWindow()).To(Equal(defaultWindowTCP))
		Expect(sender.SlowstartThreshold()).To(Equal(MaxCongestionWindow))

		// Starts with slow start.
		sender.SetNumEmulatedConnections(1)
		const kNumberOfAcks = 10
		for i := 0; i < kNumberOfAcks; i++ {
			// Send our full send window.
			SendAvailableSendWindow()
			AckNPackets(2)
		}
		SendAvailableSendWindow()
		expected_send_window := defaultWindowTCP + (protocol.DefaultTCPMSS * 2 * kNumberOfAcks)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))

		// Loses a packet to exit slow start.
		LoseNPackets(1)

		// We should now have fallen out of slow start with a reduced window. Slow
		// start threshold is also updated.
		expected_send_window = protocol.ByteCount(float32(expected_send_window) * renoBeta)
		Expect(sender.GetCongestionWindow()).To(Equal(expected_send_window))
		Expect(sender.SlowstartThreshold()).To(Equal(protocol.PacketNumber(expected_send_window / protocol.DefaultTCPMSS)))

		// Resets cwnd and slow start threshold on connection migrations.
		sender.OnConnectionMigration()
		Expect(sender.GetCongestionWindow()).To(Equal(defaultWindowTCP))
		Expect(sender.SlowstartThreshold()).To(Equal(MaxCongestionWindow))
		Expect(sender.HybridSlowStart().Started()).To(BeFalse())
	})
})