folly/test/MallctlHelperTest.cpp

   1 /*
   2  * Copyright 2016 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <folly/MallctlHelper.h>
  18 #include <folly/Malloc.h>
  19 #include <folly/init/Init.h>
  20 #include <gtest/gtest.h>
  21
  22 using namespace folly;
  23
  24 const char* malloc_conf = "purge:decay,decay_time:10";
  25
  26 class MallctlHelperTest : public ::testing::Test {
  27  protected:
  28   void TearDown() override {
  29     // Reset decay_time of arena 0 to 10 seconds.
  30     ssize_t decayTime = 10;
  31     EXPECT_NO_THROW(mallctlWrite("arena.0.decay_time", decayTime));
  32   }
  33
  34   static ssize_t readArena0DecayTime() {
  35     ssize_t decayTime = 0;
  36     EXPECT_NO_THROW(mallctlRead("arena.0.decay_time", &decayTime));
  37     return decayTime;
  38   }
  39 };
  40
  41 TEST_F(MallctlHelperTest, valid_read) {
  42   ssize_t decayTime = 0;
  43   EXPECT_NO_THROW(mallctlRead("opt.decay_time", &decayTime));
  44   EXPECT_EQ(10, decayTime);
  45 }
  46
  47 TEST_F(MallctlHelperTest, invalid_read) {
  48   ssize_t decayTime = 0;
  49   EXPECT_THROW(mallctlRead("invalid", &decayTime), std::runtime_error);
  50   EXPECT_EQ(0, decayTime);
  51 }
  52
  53 TEST_F(MallctlHelperTest, valid_write) {
  54   ssize_t decayTime = 20;
  55   EXPECT_NO_THROW(mallctlWrite("arena.0.decay_time", decayTime));
  56   EXPECT_EQ(20, readArena0DecayTime());
  57 }
  58
  59 TEST_F(MallctlHelperTest, invalid_write) {
  60   ssize_t decayTime = 20;
  61   EXPECT_THROW(mallctlWrite("invalid", decayTime), std::runtime_error);
  62   EXPECT_EQ(10, readArena0DecayTime());
  63 }
  64
  65 TEST_F(MallctlHelperTest, valid_read_write) {
  66   ssize_t oldDecayTime = 0;
  67   ssize_t newDecayTime = 20;
  68   EXPECT_NO_THROW(
  69       mallctlReadWrite("arena.0.decay_time", &oldDecayTime, newDecayTime));
  70   EXPECT_EQ(10, oldDecayTime);
  71   EXPECT_EQ(20, readArena0DecayTime());
  72 }
  73
  74 TEST_F(MallctlHelperTest, invalid_read_write) {
  75   ssize_t oldDecayTime = 0;
  76   ssize_t newDecayTime = 20;
  77   EXPECT_THROW(
  78       mallctlReadWrite("invalid", &oldDecayTime, newDecayTime),
  79       std::runtime_error);
  80   EXPECT_EQ(0, oldDecayTime);
  81   EXPECT_EQ(10, readArena0DecayTime());
  82 }
  83
  84 TEST_F(MallctlHelperTest, valid_call) {
  85   EXPECT_NO_THROW(mallctlCall("arena.0.decay"));
  86 }
  87
  88 TEST_F(MallctlHelperTest, invalid_call) {
  89   EXPECT_THROW(mallctlCall("invalid"), std::runtime_error);
  90 }
  91
  92 int main(int argc, char** argv) {
  93   ::testing::InitGoogleTest(&argc, argv);
  94   init(&argc, &argv);
  95   return usingJEMalloc() ? RUN_ALL_TESTS() : 0;
  96 }