TokenBucketTest.cpp File Reference

#include <folly/test/TokenBucketTest.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
	TEST (TokenBucket, ReverseTime)
	TEST_P (TokenBucketTest, sanity)
	INSTANTIATE_TEST_CASE_P (TokenBucket, TokenBucketTest,::testing::ValuesIn(rateToConsumeSize))
void	doTokenBucketTest (double maxQps, double consumeSize)
	TEST (TokenBucket, sanity)
	TEST (TokenBucket, ReverseTime2)
	TEST (TokenBucket, drainOnFail)

Variables
static std::vector< std::pair< double, double > >	rateToConsumeSize

Function Documentation

void doTokenBucketTest	(	double	maxQps,
		double	consumeSize
	)

Definition at line 77 of file TokenBucketTest.cpp.

References folly::BasicTokenBucket< Clock >::consume(), EXPECT_FALSE, EXPECT_GE, EXPECT_LE, and max.

Referenced by TEST().

                                                          {
  const double tenMillisecondBurst = maxQps * 0.010;
  // Select a burst size of 10 milliseconds at the max rate or the consume size
  // if 10 ms at maxQps is too small.
  const double burstSize = std::max(consumeSize, tenMillisecondBurst);
  TokenBucket tokenBucket(maxQps, burstSize, 0);
  double tokenCounter = 0;
  double currentTime = 0;
  // Simulate time advancing 10 seconds
  for (; currentTime <= 10.0; currentTime += 0.001) {
    EXPECT_FALSE(tokenBucket.consume(burstSize + 1, currentTime));
    while (tokenBucket.consume(consumeSize, currentTime)) {
      tokenCounter += consumeSize;
    }
    // Tokens consumed should exceed some lower bound based on maxQps.
    // Note: The token bucket implementation is not precise, so the lower bound
    // is somewhat fudged. The upper bound is accurate however.
    EXPECT_LE(maxQps * currentTime * 0.9 - 1, tokenCounter);
    // Tokens consumed should not exceed some upper bound based on maxQps.
    EXPECT_GE(maxQps * currentTime + 1e-6, tokenCounter);
  }
}

INSTANTIATE_TEST_CASE_P	(	TokenBucket	,
		TokenBucketTest	,
		::testing::ValuesIn(rateToConsumeSize)
	)

TEST	(	TokenBucket	,
		ReverseTime
	)

Definition at line 23 of file TokenBucketTest.cpp.

References folly::BasicTokenBucket< Clock >::available(), folly::BasicTokenBucket< Clock >::consume(), count, EXPECT_EQ, and EXPECT_FALSE.

                               {
  const double rate = 1000;
  TokenBucket tokenBucket(rate, rate * 0.01 + 1e-6, 0);
  size_t count = 0;
  while (tokenBucket.consume(1, 0.1)) {
    count += 1;
  }
  EXPECT_EQ(10, count);
  // Going backwards in time has no affect on the toke count (this protects
  // against different threads providing out of order timestamps).
  double tokensBefore = tokenBucket.available();
  EXPECT_FALSE(tokenBucket.consume(1, 0.09999999));
  EXPECT_EQ(tokensBefore, tokenBucket.available());
}

TEST	(	TokenBucket	,
		sanity
	)

Definition at line 100 of file TokenBucketTest.cpp.

References doTokenBucketTest().

                          {
  doTokenBucketTest(100, 1);
  doTokenBucketTest(1000, 1);
  doTokenBucketTest(10000, 1);
  // Consume more than one at a time.
  doTokenBucketTest(10000, 5);
}

TEST	(	TokenBucket	,
		ReverseTime2
	)

Definition at line 108 of file TokenBucketTest.cpp.

References folly::BasicTokenBucket< Clock >::available(), folly::BasicTokenBucket< Clock >::consume(), count, EXPECT_EQ, and EXPECT_FALSE.

                                {
  const double rate = 1000;
  TokenBucket tokenBucket(rate, rate * 0.01 + 1e-6);
  size_t count = 0;
  while (tokenBucket.consume(1, 0.1)) {
    count += 1;
  }
  EXPECT_EQ(10, count);
  // Going backwards in time has no affect on the toke count (this protects
  // against different threads providing out of order timestamps).
  double tokensBefore = tokenBucket.available();
  EXPECT_FALSE(tokenBucket.consume(1, 0.09999999));
  EXPECT_EQ(tokensBefore, tokenBucket.available());
}

TEST	(	TokenBucket	,
		drainOnFail
	)

Definition at line 123 of file TokenBucketTest.cpp.

References folly::BasicDynamicTokenBucket< Clock >::available(), folly::BasicDynamicTokenBucket< Clock >::consume(), folly::BasicDynamicTokenBucket< Clock >::consumeOrDrain(), EXPECT_DOUBLE_EQ, EXPECT_FALSE, and EXPECT_TRUE.

                               {
  DynamicTokenBucket tokenBucket;

  // Almost empty the bucket
  EXPECT_TRUE(tokenBucket.consume(9, 10, 10, 1));

  // Request more tokens than available
  EXPECT_FALSE(tokenBucket.consume(5, 10, 10, 1));
  EXPECT_DOUBLE_EQ(1.0, tokenBucket.available(10, 10, 1));

  // Again request more tokens than available, but ask to drain
  EXPECT_DOUBLE_EQ(1.0, tokenBucket.consumeOrDrain(5, 10, 10, 1));
  EXPECT_DOUBLE_EQ(0.0, tokenBucket.consumeOrDrain(1, 10, 10, 1));
}

TEST_P	(	TokenBucketTest	,
		sanity
	)

Definition at line 38 of file TokenBucketTest.cpp.

References folly::BasicTokenBucket< Clock >::consume(), EXPECT_FALSE, EXPECT_GE, EXPECT_LE, max, and params.

                                {
  std::pair<double, double> params = GetParam();
  double rate = params.first;
  double consumeSize = params.second;

  const double tenMillisecondBurst = rate * 0.010;
  // Select a burst size of 10 milliseconds at the max rate or the consume size
  // if 10 ms at rate is too small.
  const double burstSize = std::max(consumeSize, tenMillisecondBurst);
  TokenBucket tokenBucket(rate, burstSize, 0);
  double tokenCounter = 0;
  double currentTime = 0;
  // Simulate time advancing 10 seconds
  for (; currentTime <= 10.0; currentTime += 0.001) {
    EXPECT_FALSE(tokenBucket.consume(burstSize + 1, currentTime));
    while (tokenBucket.consume(consumeSize, currentTime)) {
      tokenCounter += consumeSize;
    }
    // Tokens consumed should exceed some lower bound based on rate.
    // Note: The token bucket implementation is not precise, so the lower bound
    // is somewhat fudged. The upper bound is accurate however.
    EXPECT_LE(rate * currentTime * 0.9 - 1, tokenCounter);
    // Tokens consumed should not exceed some upper bound based on rate.
    EXPECT_GE(rate * currentTime + 1e-6, tokenCounter);
  }
}

Variable Documentation

std::vector<std::pair<double, double> > rateToConsumeSize

static

Initial value:

= {
    {100, 1},
    {1000, 1},
    {10000, 1},
    {10000, 5},
}

Definition at line 65 of file TokenBucketTest.cpp.