ceph/src/test/fs/mds_types.cc

   1 // -*- mode:C; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2014 Red Hat
   7  *
   8  * Author: Greg Farnum <greg@inktank.com>
   9  *
  10  * This is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public
  12  * License version 2, as published by the Free Software
  13  * Foundation.  See file COPYING.
  14  *
  15  */
  16
  17 #include "gtest/gtest.h"
  18 #include "mds/mdstypes.h"
  19 #include "mds/inode_backtrace.h"
  20
  21 TEST(inode_t, compare_equal)
  22 {
  23   inode_t foo;
  24   inode_t bar;
  25   int compare_r;
  26   bool divergent;
  27   compare_r = foo.compare(bar, &divergent);
  28   EXPECT_EQ(0, compare_r);
  29   EXPECT_FALSE(divergent);
  30   compare_r = bar.compare(foo, &divergent);
  31   EXPECT_EQ(0, compare_r);
  32   EXPECT_FALSE(divergent);
  33
  34
  35   foo.ino = 1234;
  36   foo.ctime.set_from_double(10.0);
  37   foo.mode = 0777;
  38   foo.uid = 42;
  39   foo.gid = 43;
  40   foo.nlink = 3;
  41   foo.version = 3;
  42
  43   bar = foo;
  44   compare_r = foo.compare(bar, &divergent);
  45   EXPECT_EQ(0, compare_r);
  46   EXPECT_FALSE(divergent);
  47   compare_r = bar.compare(foo, &divergent);
  48   EXPECT_EQ(0, compare_r);
  49   EXPECT_FALSE(divergent);
  50 }
  51
  52 TEST(inode_t, compare_aged)
  53 {
  54   inode_t foo;
  55   inode_t bar;
  56
  57   foo.ino = 1234;
  58   foo.ctime.set_from_double(10.0);
  59   foo.mode = 0777;
  60   foo.uid = 42;
  61   foo.gid = 43;
  62   foo.nlink = 3;
  63   foo.version = 3;
  64   foo.rstat.version = 1;
  65
  66   bar = foo;
  67   bar.version = 2;
  68
  69   int compare_r;
  70   bool divergent;
  71   compare_r = foo.compare(bar, &divergent);
  72   EXPECT_EQ(1, compare_r);
  73   EXPECT_FALSE(divergent);
  74   compare_r = bar.compare(foo, &divergent);
  75   EXPECT_EQ(-1, compare_r);
  76   EXPECT_FALSE(divergent);
  77 }
  78
  79 TEST(inode_t, compare_divergent)
  80 {
  81   inode_t foo;
  82   inode_t bar;
  83
  84   foo.ino = 1234;
  85   foo.ctime.set_from_double(10.0);
  86   foo.mode = 0777;
  87   foo.uid = 42;
  88   foo.gid = 43;
  89   foo.nlink = 3;
  90   foo.version = 3;
  91   foo.rstat.version = 1;
  92
  93   bar = foo;
  94   bar.version = 2;
  95   bar.rstat.version = 2;
  96
  97   int compare_r;
  98   bool divergent;
  99   compare_r = foo.compare(bar, &divergent);
 100   EXPECT_EQ(1, compare_r);
 101   EXPECT_TRUE(divergent);
 102   compare_r = bar.compare(foo, &divergent);
 103   EXPECT_EQ(-1, compare_r);
 104   EXPECT_TRUE(divergent);
 105 }
 106
 107 TEST(inode_backtrace_t, compare_equal)
 108 {
 109   inode_backtrace_t foo;
 110   inode_backtrace_t bar;
 111
 112   foo.ino = 1234;
 113   foo.pool = 12;
 114   foo.old_pools.insert(10);
 115   foo.old_pools.insert(5);
 116
 117   inode_backpointer_t foop;
 118   foop.dirino = 3;
 119   foop.dname = "l3";
 120   foop.version = 15;
 121   foo.ancestors.push_back(foop);
 122   foop.dirino = 2;
 123   foop.dname = "l2";
 124   foop.version = 10;
 125   foo.ancestors.push_back(foop);
 126   foop.dirino = 1;
 127   foop.dname = "l1";
 128   foop.version = 25;
 129   foo.ancestors.push_back(foop);
 130
 131   bar = foo;
 132
 133   int compare_r;
 134   bool equivalent;
 135   bool divergent;
 136
 137   compare_r = foo.compare(bar, &equivalent, &divergent);
 138   EXPECT_EQ(0, compare_r);
 139   EXPECT_TRUE(equivalent);
 140   EXPECT_FALSE(divergent);
 141 }
 142
 143 TEST(inode_backtrace_t, compare_newer)
 144 {
 145   inode_backtrace_t foo;
 146   inode_backtrace_t bar;
 147
 148   foo.ino = 1234;
 149   foo.pool = 12;
 150   foo.old_pools.insert(10);
 151   foo.old_pools.insert(5);
 152
 153   bar.ino = 1234;
 154   bar.pool = 12;
 155   bar.old_pools.insert(10);
 156
 157   inode_backpointer_t foop;
 158   foop.dirino = 3;
 159   foop.dname = "l3";
 160   foop.version = 15;
 161   foo.ancestors.push_back(foop);
 162   foop.version = 14;
 163   bar.ancestors.push_back(foop);
 164
 165   foop.dirino = 2;
 166   foop.dname = "l2";
 167   foop.version = 10;
 168   foo.ancestors.push_back(foop);
 169   foop.version = 9;
 170   bar.ancestors.push_back(foop);
 171
 172   foop.dirino = 1;
 173   foop.dname = "l1";
 174   foop.version = 25;
 175   foo.ancestors.push_back(foop);
 176   bar.ancestors.push_back(foop);
 177
 178   int compare_r;
 179   bool equivalent;
 180   bool divergent;
 181
 182   compare_r = foo.compare(bar, &equivalent, &divergent);
 183   EXPECT_EQ(1, compare_r);
 184   EXPECT_TRUE(equivalent);
 185   EXPECT_FALSE(divergent);
 186
 187   compare_r = bar.compare(foo, &equivalent, &divergent);
 188   EXPECT_EQ(-1, compare_r);
 189   EXPECT_TRUE(equivalent);
 190   EXPECT_FALSE(divergent);
 191
 192   bar.ancestors.back().dirino = 75;
 193   bar.ancestors.back().dname = "l1-old";
 194   bar.ancestors.back().version = 70;
 195
 196   compare_r = foo.compare(bar, &equivalent, &divergent);
 197   EXPECT_EQ(1, compare_r);
 198   EXPECT_FALSE(equivalent);
 199   EXPECT_FALSE(divergent);
 200
 201   compare_r = bar.compare(foo, &equivalent, &divergent);
 202   EXPECT_EQ(-1, compare_r);
 203   EXPECT_FALSE(equivalent);
 204   EXPECT_FALSE(divergent);
 205 }
 206
 207 TEST(inode_backtrace_t, compare_divergent)
 208 {
 209   inode_backtrace_t foo;
 210   inode_backtrace_t bar;
 211
 212   foo.ino = 1234;
 213   foo.pool = 12;
 214   foo.old_pools.insert(10);
 215   foo.old_pools.insert(5);
 216
 217   bar.ino = 1234;
 218   bar.pool = 12;
 219   bar.old_pools.insert(10);
 220
 221   inode_backpointer_t foop;
 222   foop.dirino = 3;
 223   foop.dname = "l3";
 224   foop.version = 15;
 225   foo.ancestors.push_back(foop);
 226   foop.version = 17;
 227   bar.ancestors.push_back(foop);
 228
 229   foop.dirino = 2;
 230   foop.dname = "l2";
 231   foop.version = 10;
 232   foo.ancestors.push_back(foop);
 233   foop.version = 9;
 234   bar.ancestors.push_back(foop);
 235
 236   foop.dirino = 1;
 237   foop.dname = "l1";
 238   foop.version = 25;
 239   foo.ancestors.push_back(foop);
 240   bar.ancestors.push_back(foop);
 241
 242   int compare_r;
 243   bool equivalent;
 244   bool divergent;
 245
 246   compare_r = foo.compare(bar, &equivalent, &divergent);
 247   EXPECT_EQ(1, compare_r);
 248   EXPECT_TRUE(divergent);
 249   compare_r = bar.compare(foo, &equivalent, &divergent);
 250   EXPECT_EQ(-1, compare_r);
 251   EXPECT_TRUE(divergent);
 252 }