]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 | { | |
11fdf7f2 TL |
23 | inode_t foo{}; |
24 | inode_t bar{}; | |
7c673cae FG |
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 | { | |
11fdf7f2 TL |
54 | inode_t foo{}; |
55 | inode_t bar{}; | |
7c673cae FG |
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 | { | |
11fdf7f2 TL |
81 | inode_t foo{}; |
82 | inode_t bar{}; | |
7c673cae FG |
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; | |
f67539c2 TL |
114 | foo.old_pools.push_back(10); |
115 | foo.old_pools.push_back(5); | |
7c673cae FG |
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; | |
f67539c2 TL |
150 | foo.old_pools.push_back(10); |
151 | foo.old_pools.push_back(5); | |
7c673cae FG |
152 | |
153 | bar.ino = 1234; | |
154 | bar.pool = 12; | |
f67539c2 | 155 | bar.old_pools.push_back(10); |
7c673cae FG |
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; | |
f67539c2 TL |
214 | foo.old_pools.push_back(10); |
215 | foo.old_pools.push_back(5); | |
7c673cae FG |
216 | |
217 | bar.ino = 1234; | |
218 | bar.pool = 12; | |
f67539c2 | 219 | bar.old_pools.push_back(10); |
7c673cae FG |
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 | } |