mabain/src/unittest/rollable_file_test.cpp

   1 /**
   2  * Copyright (C) 2018 Cisco Inc.
   3  *
   4  * This program is free software: you can redistribute it and/or  modify
   5  * it under the terms of the GNU General Public License, version 2,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 // @author Changxue Deng <chadeng@cisco.com>
  18
  19 #include <string>
  20
  21 #include <gtest/gtest.h>
  22
  23 #include "../rollable_file.h"
  24 #include "../mabain_consts.h"
  25 #include "../error.h"
  26 #include "../resource_pool.h"
  27
  28 using namespace mabain;
  29
  30 namespace {
  31
  32 #define ROLLABLE_FILE_TEST_DIR "/var/tmp/mabain_test"
  33 #define FAKE_DATA "dsklckk sldk&&sdijds8990s9090230290399&&^^%%sdhsjdhsjdhsjxnmzn  lkvlsdlq;';'a;b; ;;slv; ;;;sdfl; lls;lf;sld;sld;sld;sll;skl;klk;gk;akl;s"
  34 #define ONE_MEGA 1024*1024ul
  35
  36 class RollableFileTest : public ::testing::Test
  37 {
  38 public:
  39     RollableFileTest() {
  40         rfile = NULL;
  41     }
  42     virtual ~RollableFileTest() {
  43         if(rfile != NULL)
  44             delete rfile;
  45     }
  46
  47     virtual void SetUp() {
  48         std::string cmd = std::string("mkdir -p ") + ROLLABLE_FILE_TEST_DIR;
  49         if(system(cmd.c_str()) != 0) {
  50         }
  51     }
  52     virtual void TearDown() {
  53         ResourcePool::getInstance().RemoveAll();
  54         std::string cmd = std::string("rm -rf ") + ROLLABLE_FILE_TEST_DIR + "/_*";
  55         if(system(cmd.c_str()) != 0) {
  56         }
  57     }
  58
  59     void Init() {
  60     }
  61
  62 protected:
  63     RollableFile *rfile;
  64 };
  65
  66 TEST_F(RollableFileTest, constructor_test)
  67 {
  68     rfile = new RollableFile(std::string(ROLLABLE_FILE_TEST_DIR) + "/_mabain_d",
  69                 4*ONE_MEGA, 4*ONE_MEGA, CONSTS::ACCESS_MODE_WRITER, 0);
  70     EXPECT_EQ(rfile != NULL, true);
  71     delete rfile;
  72     ResourcePool::getInstance().RemoveAll();
  73
  74     rfile = new RollableFile(std::string(ROLLABLE_FILE_TEST_DIR) + "/_mabain_d",
  75                 4*ONE_MEGA, 4*ONE_MEGA, CONSTS::ACCESS_MODE_READER, 2);
  76     EXPECT_EQ(rfile != NULL, true);
  77 }
  78
  79 TEST_F(RollableFileTest, RandomWrite_test)
  80 {
  81     rfile = new RollableFile(std::string(ROLLABLE_FILE_TEST_DIR) + "/_mabain_d",
  82                 4*ONE_MEGA, 4*ONE_MEGA, CONSTS::ACCESS_MODE_WRITER, 0);
  83
  84     EXPECT_EQ(rfile != NULL, true);
  85
  86     size_t nbytes;
  87     size_t offset;
  88     uint8_t *ptr;
  89
  90     nbytes = 5;
  91     offset = 0;
  92     rfile->Reserve(offset, nbytes, ptr);
  93     nbytes = rfile->RandomWrite((const void *)FAKE_DATA, nbytes, offset);
  94     EXPECT_EQ(nbytes, 5u);
  95
  96     uint8_t buff[256];
  97     rfile->RandomRead(buff, nbytes, offset);
  98     EXPECT_EQ(memcmp(buff, FAKE_DATA, nbytes)==0, true);
  99
 100     nbytes = 78;
 101     offset = ONE_MEGA + 28372;
 102     rfile->Reserve(offset, nbytes, ptr);
 103     nbytes = rfile->RandomWrite((const void *)FAKE_DATA, nbytes, offset);
 104     EXPECT_EQ(nbytes, 78u);
 105     rfile->RandomRead(buff, nbytes, offset);
 106     EXPECT_EQ(memcmp(buff, FAKE_DATA, nbytes)==0, true);
 107 }
 108
 109 TEST_F(RollableFileTest, RandomRead_test)
 110 {
 111     rfile = new RollableFile(std::string(ROLLABLE_FILE_TEST_DIR) + "/_mabain_i",
 112                 4*ONE_MEGA, 4*ONE_MEGA,
 113                 CONSTS::ACCESS_MODE_WRITER | CONSTS::USE_SLIDING_WINDOW, 0);
 114
 115     EXPECT_EQ(rfile != NULL, true);
 116     std::atomic<size_t> sliding_addr;
 117     rfile->InitShmSlidingAddr(&sliding_addr);
 118
 119     size_t nbytes;
 120     size_t offset;
 121     uint8_t *ptr;
 122
 123     nbytes = 15;
 124     offset = 20;
 125     rfile->Reserve(offset, nbytes, ptr);
 126     nbytes = rfile->RandomWrite((const void *)FAKE_DATA, nbytes, offset);
 127     EXPECT_EQ(nbytes, 15u);
 128
 129     uint8_t buff[256];
 130     rfile->RandomRead(buff, nbytes, offset);
 131     EXPECT_EQ(memcmp(buff, FAKE_DATA, nbytes)==0, true);
 132
 133     nbytes = 35;
 134     offset = 8*ONE_MEGA + 28372;
 135     rfile->Reserve(offset, nbytes, ptr);
 136     nbytes = rfile->RandomWrite((const void *)FAKE_DATA, nbytes, offset);
 137     EXPECT_EQ(nbytes, 35u);
 138     rfile->RandomRead(buff, nbytes, offset);
 139     EXPECT_EQ(memcmp(buff, FAKE_DATA, nbytes)==0, true);
 140 }
 141
 142 TEST_F(RollableFileTest, Reserve_test)
 143 {
 144     rfile = new RollableFile(std::string(ROLLABLE_FILE_TEST_DIR) + "/_mabain_i",
 145                 4*ONE_MEGA, 4*ONE_MEGA,
 146                 CONSTS::ACCESS_MODE_WRITER | CONSTS::USE_SLIDING_WINDOW, 0);
 147     EXPECT_EQ(rfile != NULL, true);
 148
 149     size_t offset;
 150     int size;
 151     uint8_t *ptr = NULL;
 152     int rval;
 153
 154     offset = 0;
 155     size = 34;
 156     rval = rfile->Reserve(offset, size, ptr, true);
 157     EXPECT_EQ(rval, MBError::SUCCESS);
 158     EXPECT_EQ(offset, 0u);
 159     EXPECT_EQ(ptr != NULL, true);
 160
 161     offset = 12123;
 162     size = 19;
 163     rval = rfile->Reserve(offset, size, ptr, true);
 164     EXPECT_EQ(rval, MBError::SUCCESS);
 165     EXPECT_EQ(offset, 12123u);
 166     EXPECT_EQ(ptr != NULL, true);
 167 }
 168
 169 TEST_F(RollableFileTest, GetShmPtr_test)
 170 {
 171     rfile = new RollableFile(std::string(ROLLABLE_FILE_TEST_DIR) + "/_mabain_i",
 172                 4*ONE_MEGA, 4*ONE_MEGA,
 173                 CONSTS::ACCESS_MODE_WRITER | CONSTS::USE_SLIDING_WINDOW, 0);
 174     EXPECT_EQ(rfile != NULL, true);
 175
 176     size_t offset;
 177     int size;
 178     uint8_t *ptr = NULL;
 179     int rval;
 180
 181     offset = 42321;
 182     size = 49;
 183     rval = rfile->Reserve(offset, size, ptr, true);
 184     EXPECT_EQ(rval, MBError::SUCCESS);
 185     EXPECT_EQ(offset, 42321u);
 186     EXPECT_EQ(ptr != NULL, true);
 187     EXPECT_EQ(ptr == rfile->GetShmPtr(offset, size), true);
 188 }
 189
 190 TEST_F(RollableFileTest, CheckAlignment_test)
 191 {
 192     rfile = new RollableFile(std::string(ROLLABLE_FILE_TEST_DIR) + "/_mabain_i",
 193                 4*ONE_MEGA, 4*ONE_MEGA, CONSTS::ACCESS_MODE_WRITER, 0);
 194     EXPECT_EQ(rfile != NULL, true);
 195
 196     size_t offset;
 197     int size;
 198
 199     offset = 1001;
 200     size = 23;
 201     offset = rfile->CheckAlignment(offset, size);
 202     EXPECT_EQ(offset, 1001u);
 203
 204     offset = 4*ONE_MEGA-12;
 205     size = 55;
 206     offset = rfile->CheckAlignment(offset, size);
 207     EXPECT_EQ(offset, 4*ONE_MEGA);
 208 }
 209
 210 TEST_F(RollableFileTest, Flush_test)
 211 {
 212     rfile = new RollableFile(std::string(ROLLABLE_FILE_TEST_DIR) + "/_mabain_i",
 213                 4*ONE_MEGA, 4*ONE_MEGA,
 214                 CONSTS::ACCESS_MODE_WRITER | CONSTS::USE_SLIDING_WINDOW, 0);
 215     EXPECT_EQ(rfile != NULL, true);
 216     std::atomic<size_t> sliding_addr;
 217     rfile->InitShmSlidingAddr(&sliding_addr);
 218
 219     int nbytes = 78;
 220     size_t offset = ONE_MEGA + 28372;
 221     uint8_t *ptr;
 222     rfile->Reserve(offset, nbytes, ptr);
 223     nbytes = rfile->RandomWrite((const void *)FAKE_DATA, nbytes, offset);
 224     EXPECT_EQ(nbytes, 78);
 225     offset = 4*ONE_MEGA + 233232;
 226     nbytes = 101;
 227     rfile->Reserve(offset, nbytes, ptr);
 228     nbytes = rfile->RandomWrite((const void *)FAKE_DATA, nbytes, offset);
 229     EXPECT_EQ(nbytes, 101);
 230     rfile->Flush();
 231 }
 232
 233 }