WindowTest.cpp File Reference

#include <folly/portability/GTest.h>
#include <proxygen/lib/http/Window.h>

Go to the source code of this file.

Functions
	TEST (WindowTest, Basic)
	TEST (WindowTest, ChangeCapacity)
	TEST (WindowTest, ExceedWindow)
	TEST (WindowTest, Overflow)
	TEST (WindowTest, Underflow)
	TEST (WindowTest, HugeReserve)
	TEST (WindowTest, HugeFree)
	TEST (WindowTest, HugeFree2)
	TEST (WindowTest, BytesOutstanding)
	TEST (WindowTest, BytesOutstandingAfterFail)
	TEST (WindowTest, NonStrict)
	TEST (WindowTest, NewCapacityOverflow)

Function Documentation

TEST	(	WindowTest	,
		Basic
	)

Definition at line 15 of file WindowTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, proxygen::Window::free(), proxygen::Window::getCapacity(), proxygen::Window::getSize(), and proxygen::Window::reserve().

                        {
  Window w(100);
  ASSERT_TRUE(w.free(10));
  ASSERT_EQ(w.getSize(), 110);
  ASSERT_EQ(w.getCapacity(), 100);
  ASSERT_TRUE(w.reserve(20));
  ASSERT_EQ(w.getSize(), 90);
  ASSERT_TRUE(w.reserve(90));
  ASSERT_EQ(w.getSize(), 0);
  ASSERT_TRUE(w.free(5));
  ASSERT_EQ(w.getSize(), 5);
  ASSERT_TRUE(w.free(0));
  ASSERT_EQ(w.getSize(), 5);
}

TEST	(	WindowTest	,
		ChangeCapacity
	)

Definition at line 30 of file WindowTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, proxygen::Window::free(), proxygen::Window::getCapacity(), proxygen::Window::getOutstanding(), proxygen::Window::getSize(), proxygen::Window::reserve(), and proxygen::Window::setCapacity().

                                 {
  Window w(100);
  ASSERT_TRUE(w.setCapacity(10));
  ASSERT_EQ(w.getSize(), 10);
  ASSERT_EQ(w.getCapacity(), 10);
  ASSERT_TRUE(w.reserve(7));
  ASSERT_TRUE(w.setCapacity(5));
  ASSERT_EQ(w.getCapacity(), 5);
  ASSERT_EQ(w.getSize(), -2);
  ASSERT_TRUE(w.free(1));
  ASSERT_EQ(w.getSize(), -1);
  ASSERT_TRUE(w.setCapacity(6));
  ASSERT_EQ(w.getSize(), 0);
  ASSERT_EQ(w.getCapacity(), 6);
  ASSERT_TRUE(w.setCapacity(7));
  ASSERT_EQ(w.getSize(), 1);
  ASSERT_EQ(w.getCapacity(), 7);
  ASSERT_EQ(w.getOutstanding(), 6);
}

TEST	(	WindowTest	,
		ExceedWindow
	)

Definition at line 50 of file WindowTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, ASSERT_TRUE, proxygen::Window::getSize(), and proxygen::Window::reserve().

                               {
  Window w(100);
  ASSERT_TRUE(w.reserve(50));
  ASSERT_TRUE(w.reserve(40));
  ASSERT_EQ(w.getSize(), 10);
  ASSERT_FALSE(w.reserve(20));
}

TEST	(	WindowTest	,
		Overflow
	)

Definition at line 58 of file WindowTest.cpp.

References ASSERT_FALSE, max, and proxygen::Window::reserve().

                           {
  Window w(0);
  ASSERT_FALSE(w.reserve(std::numeric_limits<int32_t>::max()));
}

TEST	(	WindowTest	,
		Underflow
	)

Definition at line 63 of file WindowTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, ASSERT_TRUE, proxygen::Window::free(), proxygen::Window::getSize(), and max.

                            {
  Window w(100);
  ASSERT_TRUE(w.free(100)); // You can manually bump up the window
  ASSERT_TRUE(w.free(100)); // You can manually bump up the window
  ASSERT_EQ(w.getSize(), 300);
  ASSERT_FALSE(w.free(std::numeric_limits<int32_t>::max())); // to a point
}

TEST	(	WindowTest	,
		HugeReserve
	)

Definition at line 71 of file WindowTest.cpp.

References ASSERT_FALSE, max, and proxygen::Window::reserve().

                              {
  Window w(100);
  ASSERT_FALSE(w.reserve(std::numeric_limits<uint32_t>::max()));
}

TEST	(	WindowTest	,
		HugeFree
	)

Definition at line 76 of file WindowTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, proxygen::Window::free(), and max.

                           {
  Window w1(0);
  ASSERT_TRUE(w1.free(std::numeric_limits<int32_t>::max()));
  Window w2(1);
  ASSERT_FALSE(w2.free(std::numeric_limits<int32_t>::max()));
}

TEST	(	WindowTest	,
		HugeFree2
	)

Definition at line 83 of file WindowTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, proxygen::Window::free(), i, and max.

                            {
  for (unsigned i = 0; i < 10; ++i) {
    Window w(i);
    ASSERT_TRUE(w.free(std::numeric_limits<int32_t>::max() - i));
    ASSERT_FALSE(w.free(1));
  }
}

TEST	(	WindowTest	,
		BytesOutstanding
	)

Definition at line 91 of file WindowTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, proxygen::Window::free(), proxygen::Window::getOutstanding(), and proxygen::Window::reserve().

                                   {
  Window w(100);
  ASSERT_EQ(w.getOutstanding(), 0);
  ASSERT_TRUE(w.reserve(20));
  ASSERT_EQ(w.getOutstanding(), 20);
  ASSERT_TRUE(w.free(30));
  // outstanding bytes is -10, but the API clamps this to 0
  ASSERT_EQ(w.getOutstanding(), 0);
}

TEST	(	WindowTest	,
		BytesOutstandingAfterFail
	)

Definition at line 101 of file WindowTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, proxygen::Window::getOutstanding(), and proxygen::Window::reserve().

                                            {
  Window w(100);
  ASSERT_EQ(w.getOutstanding(), 0);
  ASSERT_FALSE(w.reserve(110));
  ASSERT_EQ(w.getOutstanding(), 0);
}

TEST	(	WindowTest	,
		NonStrict
	)

Definition at line 108 of file WindowTest.cpp.

References ASSERT_EQ, ASSERT_TRUE, proxygen::Window::getOutstanding(), proxygen::Window::getSize(), and proxygen::Window::reserve().

                            {
  Window w(100);
  ASSERT_TRUE(w.reserve(110, false));
  ASSERT_EQ(w.getOutstanding(), 110);
  ASSERT_EQ(w.getSize(), -10);
}

TEST	(	WindowTest	,
		NewCapacityOverflow
	)

Definition at line 115 of file WindowTest.cpp.

References ASSERT_EQ, ASSERT_FALSE, ASSERT_TRUE, proxygen::Window::free(), proxygen::Window::getOutstanding(), proxygen::Window::getSize(), max, and proxygen::Window::setCapacity().

                                      {
  Window w(0);
  ASSERT_TRUE(w.free(10));
  ASSERT_EQ(w.getOutstanding(), 0);
  ASSERT_EQ(w.getSize(), 10);
  ASSERT_TRUE(w.setCapacity(std::numeric_limits<int32_t>::max() - 10));
  ASSERT_EQ(w.getSize(), std::numeric_limits<int32_t>::max());
  ASSERT_FALSE(w.setCapacity(std::numeric_limits<int32_t>::max() - 9));
}