1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
2 // vim: ts=8 sw=2 smarttab
4 * Ceph - scalable distributed file system
6 * Copyright (C) 2011 New Dream Network
7 * Copyright (C) 2013 Cloudwatt <libre.licensing@cloudwatt.com>
9 * Author: Loic Dachary <loic@dachary.org>
11 * This is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public
13 * License version 2, as published by the Free Software
14 * Foundation. See file COPYING.
18 #include "include/types.h"
19 #include "osd/osd_types.h"
20 #include "osd/OSDMap.h"
21 #include "gtest/gtest.h"
22 #include "include/coredumpctl.h"
23 #include "common/Thread.h"
24 #include "include/stringify.h"
25 #include "osd/ReplicatedBackend.h"
30 TEST(hobject
, prefixes0
)
32 uint32_t mask
= 0xE947FA20;
36 set
<string
> prefixes_correct
;
37 prefixes_correct
.insert(string("0000000000000000.02A"));
39 set
<string
> prefixes_out(hobject_t::get_prefixes(bits
, mask
, pool
));
40 ASSERT_EQ(prefixes_out
, prefixes_correct
);
43 TEST(hobject
, prefixes1
)
45 uint32_t mask
= 0x0000000F;
49 set
<string
> prefixes_correct
;
50 prefixes_correct
.insert(string("0000000000000014.F0"));
51 prefixes_correct
.insert(string("0000000000000014.F4"));
52 prefixes_correct
.insert(string("0000000000000014.F8"));
53 prefixes_correct
.insert(string("0000000000000014.FC"));
55 set
<string
> prefixes_out(hobject_t::get_prefixes(bits
, mask
, pool
));
56 ASSERT_EQ(prefixes_out
, prefixes_correct
);
59 TEST(hobject
, prefixes2
)
61 uint32_t mask
= 0xDEADBEAF;
65 set
<string
> prefixes_correct
;
66 prefixes_correct
.insert(string("0000000000000000.FAEBDA0"));
67 prefixes_correct
.insert(string("0000000000000000.FAEBDA2"));
68 prefixes_correct
.insert(string("0000000000000000.FAEBDA4"));
69 prefixes_correct
.insert(string("0000000000000000.FAEBDA6"));
70 prefixes_correct
.insert(string("0000000000000000.FAEBDA8"));
71 prefixes_correct
.insert(string("0000000000000000.FAEBDAA"));
72 prefixes_correct
.insert(string("0000000000000000.FAEBDAC"));
73 prefixes_correct
.insert(string("0000000000000000.FAEBDAE"));
75 set
<string
> prefixes_out(hobject_t::get_prefixes(bits
, mask
, pool
));
76 ASSERT_EQ(prefixes_out
, prefixes_correct
);
79 TEST(hobject
, prefixes3
)
81 uint32_t mask
= 0xE947FA20;
85 set
<string
> prefixes_correct
;
86 prefixes_correct
.insert(string("0000000000000023.02AF749E"));
88 set
<string
> prefixes_out(hobject_t::get_prefixes(bits
, mask
, pool
));
89 ASSERT_EQ(prefixes_out
, prefixes_correct
);
92 TEST(hobject
, prefixes4
)
94 uint32_t mask
= 0xE947FA20;
98 set
<string
> prefixes_correct
;
99 prefixes_correct
.insert(string("0000000000000023."));
101 set
<string
> prefixes_out(hobject_t::get_prefixes(bits
, mask
, pool
));
102 ASSERT_EQ(prefixes_out
, prefixes_correct
);
105 TEST(hobject
, prefixes5
)
107 uint32_t mask
= 0xDEADBEAF;
109 int64_t pool
= 0x34AC5D00;
111 set
<string
> prefixes_correct
;
112 prefixes_correct
.insert(string("0000000034AC5D00.1"));
113 prefixes_correct
.insert(string("0000000034AC5D00.3"));
114 prefixes_correct
.insert(string("0000000034AC5D00.5"));
115 prefixes_correct
.insert(string("0000000034AC5D00.7"));
116 prefixes_correct
.insert(string("0000000034AC5D00.9"));
117 prefixes_correct
.insert(string("0000000034AC5D00.B"));
118 prefixes_correct
.insert(string("0000000034AC5D00.D"));
119 prefixes_correct
.insert(string("0000000034AC5D00.F"));
121 set
<string
> prefixes_out(hobject_t::get_prefixes(bits
, mask
, pool
));
122 ASSERT_EQ(prefixes_out
, prefixes_correct
);
125 TEST(pg_interval_t
, check_new_interval
)
127 // iterate through all 4 combinations
128 for (unsigned i
= 0; i
< 4; ++i
) {
130 // Create a situation where osdmaps are the same so that
131 // each test case can diverge from it using minimal code.
135 std::shared_ptr
<OSDMap
> osdmap(new OSDMap());
136 osdmap
->set_max_osd(10);
137 osdmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
138 osdmap
->set_epoch(epoch
);
139 std::shared_ptr
<OSDMap
> lastmap(new OSDMap());
140 lastmap
->set_max_osd(10);
141 lastmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
142 lastmap
->set_epoch(epoch
);
143 epoch_t same_interval_since
= epoch
;
144 epoch_t last_epoch_clean
= same_interval_since
;
145 int64_t pool_id
= 200;
148 boost::scoped_ptr
<IsPGRecoverablePredicate
> recoverable(new ReplicatedBackend::RPCRecPred());
150 OSDMap::Incremental
inc(epoch
+ 1);
151 inc
.new_pools
[pool_id
].min_size
= min_size
;
152 inc
.new_pools
[pool_id
].set_pg_num(pg_num
);
153 inc
.new_pools
[pool_id
].set_pg_num_pending(pg_num
);
154 inc
.new_up_thru
[osd_id
] = epoch
+ 1;
155 osdmap
->apply_incremental(inc
);
156 lastmap
->apply_incremental(inc
);
158 vector
<int> new_acting
;
159 new_acting
.push_back(osd_id
);
160 new_acting
.push_back(osd_id
+ 1);
161 vector
<int> old_acting
= new_acting
;
162 int old_primary
= osd_id
;
163 int new_primary
= osd_id
;
165 new_up
.push_back(osd_id
);
166 int old_up_primary
= osd_id
;
167 int new_up_primary
= osd_id
;
168 vector
<int> old_up
= new_up
;
170 pgid
.set_pool(pool_id
);
173 // Do nothing if there are no modifications in
174 // acting, up or pool size and that the pool is not
178 PastIntervals past_intervals
;
180 ASSERT_TRUE(past_intervals
.empty());
181 ASSERT_FALSE(PastIntervals::check_new_interval(old_primary
,
196 ASSERT_TRUE(past_intervals
.empty());
200 // The acting set has changed
203 vector
<int> new_acting
;
204 int _new_primary
= osd_id
+ 1;
205 new_acting
.push_back(_new_primary
);
207 PastIntervals past_intervals
;
209 ASSERT_TRUE(past_intervals
.empty());
210 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
225 old_primary
= new_primary
;
229 // The up set has changed
233 int _new_primary
= osd_id
+ 1;
234 new_up
.push_back(_new_primary
);
236 PastIntervals past_intervals
;
238 ASSERT_TRUE(past_intervals
.empty());
239 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
257 // The up primary has changed
261 int _new_up_primary
= osd_id
+ 1;
263 PastIntervals past_intervals
;
265 ASSERT_TRUE(past_intervals
.empty());
266 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
287 std::shared_ptr
<OSDMap
> osdmap(new OSDMap());
288 osdmap
->set_max_osd(10);
289 osdmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
290 osdmap
->set_epoch(epoch
);
291 int new_pg_num
= pg_num
^ 2;
292 OSDMap::Incremental
inc(epoch
+ 1);
293 inc
.new_pools
[pool_id
].min_size
= min_size
;
294 inc
.new_pools
[pool_id
].set_pg_num(new_pg_num
);
295 osdmap
->apply_incremental(inc
);
297 PastIntervals past_intervals
;
299 ASSERT_TRUE(past_intervals
.empty());
300 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
318 // PG is pre-merge source
321 std::shared_ptr
<OSDMap
> osdmap(new OSDMap());
322 osdmap
->set_max_osd(10);
323 osdmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
324 osdmap
->set_epoch(epoch
);
325 OSDMap::Incremental
inc(epoch
+ 1);
326 inc
.new_pools
[pool_id
].min_size
= min_size
;
327 inc
.new_pools
[pool_id
].set_pg_num(pg_num
);
328 inc
.new_pools
[pool_id
].set_pg_num_pending(pg_num
- 1);
329 osdmap
->apply_incremental(inc
);
330 cout
<< "pg_num " << pg_num
<< std::endl
;
331 PastIntervals past_intervals
;
333 ASSERT_TRUE(past_intervals
.empty());
334 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
346 pg_t(pg_num
- 1, pool_id
),
352 // PG was pre-merge source
355 std::shared_ptr
<OSDMap
> osdmap(new OSDMap());
356 osdmap
->set_max_osd(10);
357 osdmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
358 osdmap
->set_epoch(epoch
);
359 OSDMap::Incremental
inc(epoch
+ 1);
360 inc
.new_pools
[pool_id
].min_size
= min_size
;
361 inc
.new_pools
[pool_id
].set_pg_num(pg_num
);
362 inc
.new_pools
[pool_id
].set_pg_num_pending(pg_num
- 1);
363 osdmap
->apply_incremental(inc
);
365 cout
<< "pg_num " << pg_num
<< std::endl
;
366 PastIntervals past_intervals
;
368 ASSERT_TRUE(past_intervals
.empty());
369 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
379 lastmap
, // reverse order!
381 pg_t(pg_num
- 1, pool_id
),
387 // PG is merge source
390 std::shared_ptr
<OSDMap
> osdmap(new OSDMap());
391 osdmap
->set_max_osd(10);
392 osdmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
393 osdmap
->set_epoch(epoch
);
394 OSDMap::Incremental
inc(epoch
+ 1);
395 inc
.new_pools
[pool_id
].min_size
= min_size
;
396 inc
.new_pools
[pool_id
].set_pg_num(pg_num
- 1);
397 osdmap
->apply_incremental(inc
);
399 PastIntervals past_intervals
;
401 ASSERT_TRUE(past_intervals
.empty());
402 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
414 pg_t(pg_num
- 1, pool_id
),
420 // PG is pre-merge target
423 std::shared_ptr
<OSDMap
> osdmap(new OSDMap());
424 osdmap
->set_max_osd(10);
425 osdmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
426 osdmap
->set_epoch(epoch
);
427 OSDMap::Incremental
inc(epoch
+ 1);
428 inc
.new_pools
[pool_id
].min_size
= min_size
;
429 inc
.new_pools
[pool_id
].set_pg_num_pending(pg_num
- 1);
430 osdmap
->apply_incremental(inc
);
432 PastIntervals past_intervals
;
434 ASSERT_TRUE(past_intervals
.empty());
435 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
447 pg_t(pg_num
/ 2 - 1, pool_id
),
453 // PG was pre-merge target
456 std::shared_ptr
<OSDMap
> osdmap(new OSDMap());
457 osdmap
->set_max_osd(10);
458 osdmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
459 osdmap
->set_epoch(epoch
);
460 OSDMap::Incremental
inc(epoch
+ 1);
461 inc
.new_pools
[pool_id
].min_size
= min_size
;
462 inc
.new_pools
[pool_id
].set_pg_num_pending(pg_num
- 1);
463 osdmap
->apply_incremental(inc
);
465 PastIntervals past_intervals
;
467 ASSERT_TRUE(past_intervals
.empty());
468 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
478 lastmap
, // reverse order!
480 pg_t(pg_num
/ 2 - 1, pool_id
),
486 // PG is merge target
489 std::shared_ptr
<OSDMap
> osdmap(new OSDMap());
490 osdmap
->set_max_osd(10);
491 osdmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
492 osdmap
->set_epoch(epoch
);
493 OSDMap::Incremental
inc(epoch
+ 1);
494 inc
.new_pools
[pool_id
].min_size
= min_size
;
495 inc
.new_pools
[pool_id
].set_pg_num(pg_num
- 1);
496 osdmap
->apply_incremental(inc
);
498 PastIntervals past_intervals
;
500 ASSERT_TRUE(past_intervals
.empty());
501 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
513 pg_t(pg_num
/ 2 - 1, pool_id
),
519 // PG size has changed
522 std::shared_ptr
<OSDMap
> osdmap(new OSDMap());
523 osdmap
->set_max_osd(10);
524 osdmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
525 osdmap
->set_epoch(epoch
);
526 OSDMap::Incremental
inc(epoch
+ 1);
527 __u8 new_min_size
= min_size
+ 1;
528 inc
.new_pools
[pool_id
].min_size
= new_min_size
;
529 inc
.new_pools
[pool_id
].set_pg_num(pg_num
);
530 osdmap
->apply_incremental(inc
);
532 PastIntervals past_intervals
;
534 ASSERT_TRUE(past_intervals
.empty());
535 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
553 // The old acting set was empty : the previous interval could not
557 vector
<int> old_acting
;
559 PastIntervals past_intervals
;
563 ASSERT_TRUE(past_intervals
.empty());
564 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
580 ASSERT_NE(string::npos
, out
.str().find("acting set is too small"));
584 // The old acting set did not have enough osd : it could
588 vector
<int> old_acting
;
589 old_acting
.push_back(osd_id
);
592 // see http://tracker.ceph.com/issues/5780
593 // the size of the old acting set should be compared
594 // with the min_size of the old osdmap
596 // The new osdmap is created so that it triggers the
599 std::shared_ptr
<OSDMap
> osdmap(new OSDMap());
600 osdmap
->set_max_osd(10);
601 osdmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
602 osdmap
->set_epoch(epoch
);
603 OSDMap::Incremental
inc(epoch
+ 1);
604 __u8 new_min_size
= old_acting
.size();
605 inc
.new_pools
[pool_id
].min_size
= new_min_size
;
606 inc
.new_pools
[pool_id
].set_pg_num(pg_num
);
607 osdmap
->apply_incremental(inc
);
611 PastIntervals past_intervals
;
613 ASSERT_TRUE(past_intervals
.empty());
614 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
630 ASSERT_NE(string::npos
, out
.str().find("acting set is too small"));
634 // The acting set changes. The old acting set primary was up during the
635 // previous interval and may have been rw.
638 vector
<int> new_acting
;
639 new_acting
.push_back(osd_id
+ 4);
640 new_acting
.push_back(osd_id
+ 5);
644 PastIntervals past_intervals
;
646 ASSERT_TRUE(past_intervals
.empty());
647 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
663 ASSERT_NE(string::npos
, out
.str().find("includes interval"));
666 // The acting set changes. The old acting set primary was not up
667 // during the old interval but last_epoch_clean is in the
668 // old interval and it may have been rw.
671 vector
<int> new_acting
;
672 new_acting
.push_back(osd_id
+ 4);
673 new_acting
.push_back(osd_id
+ 5);
675 std::shared_ptr
<OSDMap
> lastmap(new OSDMap());
676 lastmap
->set_max_osd(10);
677 lastmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
678 lastmap
->set_epoch(epoch
);
679 OSDMap::Incremental
inc(epoch
+ 1);
680 inc
.new_pools
[pool_id
].min_size
= min_size
;
681 inc
.new_pools
[pool_id
].set_pg_num(pg_num
);
682 inc
.new_up_thru
[osd_id
] = epoch
- 10;
683 lastmap
->apply_incremental(inc
);
687 PastIntervals past_intervals
;
689 ASSERT_TRUE(past_intervals
.empty());
690 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
706 ASSERT_NE(string::npos
, out
.str().find("presumed to have been rw"));
710 // The acting set changes. The old acting set primary was not up
711 // during the old interval and last_epoch_clean is before the
712 // old interval : the previous interval could not possibly have
716 vector
<int> new_acting
;
717 new_acting
.push_back(osd_id
+ 4);
718 new_acting
.push_back(osd_id
+ 5);
720 epoch_t last_epoch_clean
= epoch
- 10;
722 std::shared_ptr
<OSDMap
> lastmap(new OSDMap());
723 lastmap
->set_max_osd(10);
724 lastmap
->set_state(osd_id
, CEPH_OSD_EXISTS
);
725 lastmap
->set_epoch(epoch
);
726 OSDMap::Incremental
inc(epoch
+ 1);
727 inc
.new_pools
[pool_id
].min_size
= min_size
;
728 inc
.new_pools
[pool_id
].set_pg_num(pg_num
);
729 inc
.new_up_thru
[osd_id
] = last_epoch_clean
;
730 lastmap
->apply_incremental(inc
);
734 PastIntervals past_intervals
;
736 ASSERT_TRUE(past_intervals
.empty());
737 ASSERT_TRUE(PastIntervals::check_new_interval(old_primary
,
753 ASSERT_NE(string::npos
, out
.str().find("does not include interval"));
755 } // end for, didn't want to reindent
758 TEST(pg_t
, get_ancestor
)
760 ASSERT_EQ(pg_t(0, 0), pg_t(16, 0).get_ancestor(16));
761 ASSERT_EQ(pg_t(1, 0), pg_t(17, 0).get_ancestor(16));
762 ASSERT_EQ(pg_t(0, 0), pg_t(16, 0).get_ancestor(8));
763 ASSERT_EQ(pg_t(16, 0), pg_t(16, 0).get_ancestor(80));
764 ASSERT_EQ(pg_t(16, 0), pg_t(16, 0).get_ancestor(83));
765 ASSERT_EQ(pg_t(1, 0), pg_t(1321, 0).get_ancestor(123).get_ancestor(8));
766 ASSERT_EQ(pg_t(3, 0), pg_t(1323, 0).get_ancestor(123).get_ancestor(8));
767 ASSERT_EQ(pg_t(3, 0), pg_t(1323, 0).get_ancestor(8));
777 b
= pgid
.is_split(1, 1, &s
);
781 b
= pgid
.is_split(2, 4, NULL
);
783 b
= pgid
.is_split(2, 4, &s
);
785 ASSERT_EQ(1u, s
.size());
786 ASSERT_TRUE(s
.count(pg_t(2, 0)));
789 b
= pgid
.is_split(2, 8, &s
);
791 ASSERT_EQ(3u, s
.size());
792 ASSERT_TRUE(s
.count(pg_t(2, 0)));
793 ASSERT_TRUE(s
.count(pg_t(4, 0)));
794 ASSERT_TRUE(s
.count(pg_t(6, 0)));
797 b
= pgid
.is_split(3, 8, &s
);
799 ASSERT_EQ(1u, s
.size());
800 ASSERT_TRUE(s
.count(pg_t(4, 0)));
803 b
= pgid
.is_split(6, 8, NULL
);
805 b
= pgid
.is_split(6, 8, &s
);
807 ASSERT_EQ(0u, s
.size());
812 b
= pgid
.is_split(2, 4, &s
);
814 ASSERT_EQ(1u, s
.size());
815 ASSERT_TRUE(s
.count(pg_t(3, 0)));
818 b
= pgid
.is_split(2, 6, &s
);
820 ASSERT_EQ(2u, s
.size());
821 ASSERT_TRUE(s
.count(pg_t(3, 0)));
822 ASSERT_TRUE(s
.count(pg_t(5, 0)));
825 b
= pgid
.is_split(2, 8, &s
);
827 ASSERT_EQ(3u, s
.size());
828 ASSERT_TRUE(s
.count(pg_t(3, 0)));
829 ASSERT_TRUE(s
.count(pg_t(5, 0)));
830 ASSERT_TRUE(s
.count(pg_t(7, 0)));
833 b
= pgid
.is_split(4, 8, &s
);
835 ASSERT_EQ(1u, s
.size());
836 ASSERT_TRUE(s
.count(pg_t(5, 0)));
839 b
= pgid
.is_split(3, 8, &s
);
841 ASSERT_EQ(3u, s
.size());
842 ASSERT_TRUE(s
.count(pg_t(3, 0)));
843 ASSERT_TRUE(s
.count(pg_t(5, 0)));
844 ASSERT_TRUE(s
.count(pg_t(7, 0)));
847 b
= pgid
.is_split(6, 8, &s
);
849 ASSERT_EQ(0u, s
.size());
854 b
= pgid
.is_split(7, 8, &s
);
856 ASSERT_EQ(1u, s
.size());
857 ASSERT_TRUE(s
.count(pg_t(7, 0)));
860 b
= pgid
.is_split(7, 12, &s
);
862 ASSERT_EQ(2u, s
.size());
863 ASSERT_TRUE(s
.count(pg_t(7, 0)));
864 ASSERT_TRUE(s
.count(pg_t(11, 0)));
867 b
= pgid
.is_split(7, 11, &s
);
869 ASSERT_EQ(1u, s
.size());
870 ASSERT_TRUE(s
.count(pg_t(7, 0)));
880 b
= pgid
.is_merge_source(8, 7, &parent
);
882 ASSERT_EQ(parent
, pg_t(3, 0));
883 ASSERT_TRUE(parent
.is_merge_target(8, 7));
885 b
= pgid
.is_merge_source(8, 5, &parent
);
887 ASSERT_EQ(parent
, pg_t(3, 0));
888 ASSERT_TRUE(parent
.is_merge_target(8, 5));
890 b
= pgid
.is_merge_source(8, 4, &parent
);
892 ASSERT_EQ(parent
, pg_t(3, 0));
893 ASSERT_TRUE(parent
.is_merge_target(8, 4));
895 b
= pgid
.is_merge_source(8, 3, &parent
);
897 ASSERT_EQ(parent
, pg_t(1, 0));
898 ASSERT_TRUE(parent
.is_merge_target(8, 4));
900 b
= pgid
.is_merge_source(9, 8, &parent
);
902 ASSERT_FALSE(parent
.is_merge_target(9, 8));
905 TEST(ObjectCleanRegions
, mark_data_region_dirty
)
907 ObjectCleanRegions clean_regions
;
908 uint64_t offset_1
, len_1
, offset_2
, len_2
;
914 interval_set
<uint64_t> expect_dirty_region
;
915 EXPECT_EQ(expect_dirty_region
, clean_regions
.get_dirty_regions());
916 expect_dirty_region
.insert(offset_1
, len_1
);
917 expect_dirty_region
.insert(offset_2
, len_2
);
919 clean_regions
.mark_data_region_dirty(offset_1
, len_1
);
920 clean_regions
.mark_data_region_dirty(offset_2
, len_2
);
921 EXPECT_EQ(expect_dirty_region
, clean_regions
.get_dirty_regions());
924 TEST(ObjectCleanRegions
, mark_omap_dirty
)
926 ObjectCleanRegions clean_regions
;
928 EXPECT_FALSE(clean_regions
.omap_is_dirty());
929 clean_regions
.mark_omap_dirty();
930 EXPECT_TRUE(clean_regions
.omap_is_dirty());
933 TEST(ObjectCleanRegions
, merge
)
935 ObjectCleanRegions cr1
, cr2
;
936 interval_set
<uint64_t> cr1_expect
;
937 interval_set
<uint64_t> cr2_expect
;
938 ASSERT_EQ(cr1_expect
, cr1
.get_dirty_regions());
939 ASSERT_EQ(cr2_expect
, cr2
.get_dirty_regions());
941 cr1
.mark_data_region_dirty(4096, 4096);
942 cr1_expect
.insert(4096, 4096);
943 ASSERT_EQ(cr1_expect
, cr1
.get_dirty_regions());
944 cr1
.mark_data_region_dirty(12288, 8192);
945 cr1_expect
.insert(12288, 8192);
946 ASSERT_TRUE(cr1_expect
.subset_of(cr1
.get_dirty_regions()));
947 cr1
.mark_data_region_dirty(32768, 10240);
948 cr1_expect
.insert(32768, 10240);
949 cr1_expect
.erase(4096, 4096);
950 ASSERT_TRUE(cr1_expect
.subset_of(cr1
.get_dirty_regions()));
952 cr2
.mark_data_region_dirty(20480, 12288);
953 cr2_expect
.insert(20480, 12288);
954 ASSERT_EQ(cr2_expect
, cr2
.get_dirty_regions());
955 cr2
.mark_data_region_dirty(102400, 4096);
956 cr2_expect
.insert(102400, 4096);
957 cr2
.mark_data_region_dirty(204800, 8192);
958 cr2_expect
.insert(204800, 8192);
959 cr2
.mark_data_region_dirty(409600, 4096);
960 cr2_expect
.insert(409600, 4096);
961 ASSERT_TRUE(cr2_expect
.subset_of(cr2
.get_dirty_regions()));
963 ASSERT_FALSE(cr2
.omap_is_dirty());
964 cr2
.mark_omap_dirty();
965 ASSERT_FALSE(cr1
.omap_is_dirty());
966 ASSERT_TRUE(cr2
.omap_is_dirty());
969 cr1_expect
.insert(204800, 8192);
970 ASSERT_TRUE(cr1_expect
.subset_of(cr1
.get_dirty_regions()));
971 ASSERT_TRUE(cr1
.omap_is_dirty());
974 TEST(pg_missing_t
, constructor
)
976 pg_missing_t missing
;
977 EXPECT_EQ((unsigned int)0, missing
.num_missing());
978 EXPECT_FALSE(missing
.have_missing());
981 TEST(pg_missing_t
, have_missing
)
983 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
984 pg_missing_t missing
;
985 EXPECT_FALSE(missing
.have_missing());
986 missing
.add(oid
, eversion_t(), eversion_t(), false);
987 EXPECT_TRUE(missing
.have_missing());
990 TEST(pg_missing_t
, claim
)
992 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
993 pg_missing_t missing
;
994 EXPECT_FALSE(missing
.have_missing());
995 missing
.add(oid
, eversion_t(), eversion_t(), false);
996 EXPECT_TRUE(missing
.have_missing());
999 EXPECT_FALSE(other
.have_missing());
1001 other
.claim(std::move(missing
));
1002 EXPECT_TRUE(other
.have_missing());
1005 TEST(pg_missing_t
, is_missing
)
1007 // pg_missing_t::is_missing(const hobject_t& oid) const
1009 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
1010 pg_missing_t missing
;
1011 EXPECT_FALSE(missing
.is_missing(oid
));
1012 missing
.add(oid
, eversion_t(), eversion_t(), false);
1013 EXPECT_TRUE(missing
.is_missing(oid
));
1016 // bool pg_missing_t::is_missing(const hobject_t& oid, eversion_t v) const
1018 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
1019 pg_missing_t missing
;
1020 eversion_t
need(10,5);
1021 EXPECT_FALSE(missing
.is_missing(oid
, eversion_t()));
1022 missing
.add(oid
, need
, eversion_t(), false);
1023 EXPECT_TRUE(missing
.is_missing(oid
));
1024 EXPECT_FALSE(missing
.is_missing(oid
, eversion_t()));
1025 EXPECT_TRUE(missing
.is_missing(oid
, need
));
1029 TEST(pg_missing_t
, add_next_event
)
1031 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
1032 hobject_t
oid_other(object_t("other"), "key", 9123, 9456, 0, "");
1033 eversion_t
version(10,5);
1034 eversion_t
prior_version(3,4);
1035 pg_log_entry_t
sample_e(pg_log_entry_t::DELETE
, oid
, version
, prior_version
,
1036 0, osd_reqid_t(entity_name_t::CLIENT(777), 8, 999),
1039 // new object (MODIFY)
1041 pg_missing_t missing
;
1042 pg_log_entry_t e
= sample_e
;
1044 e
.op
= pg_log_entry_t::MODIFY
;
1045 e
.prior_version
= eversion_t();
1046 EXPECT_TRUE(e
.is_update());
1047 EXPECT_TRUE(e
.object_is_indexed());
1048 EXPECT_TRUE(e
.reqid_is_indexed());
1049 EXPECT_FALSE(missing
.is_missing(oid
));
1050 missing
.add_next_event(e
);
1051 EXPECT_TRUE(missing
.is_missing(oid
));
1052 EXPECT_EQ(eversion_t(), missing
.get_items().at(oid
).have
);
1053 EXPECT_EQ(oid
, missing
.get_rmissing().at(e
.version
.version
));
1054 EXPECT_EQ(1U, missing
.num_missing());
1055 EXPECT_EQ(1U, missing
.get_rmissing().size());
1057 // adding the same object replaces the previous one
1058 missing
.add_next_event(e
);
1059 EXPECT_TRUE(missing
.is_missing(oid
));
1060 EXPECT_EQ(1U, missing
.num_missing());
1061 EXPECT_EQ(1U, missing
.get_rmissing().size());
1064 // new object (CLONE)
1066 pg_missing_t missing
;
1067 pg_log_entry_t e
= sample_e
;
1069 e
.op
= pg_log_entry_t::CLONE
;
1070 e
.prior_version
= eversion_t();
1071 EXPECT_TRUE(e
.is_clone());
1072 EXPECT_TRUE(e
.object_is_indexed());
1073 EXPECT_FALSE(e
.reqid_is_indexed());
1074 EXPECT_FALSE(missing
.is_missing(oid
));
1075 missing
.add_next_event(e
);
1076 EXPECT_TRUE(missing
.is_missing(oid
));
1077 EXPECT_EQ(eversion_t(), missing
.get_items().at(oid
).have
);
1078 EXPECT_EQ(oid
, missing
.get_rmissing().at(e
.version
.version
));
1079 EXPECT_EQ(1U, missing
.num_missing());
1080 EXPECT_EQ(1U, missing
.get_rmissing().size());
1082 // adding the same object replaces the previous one
1083 missing
.add_next_event(e
);
1084 EXPECT_TRUE(missing
.is_missing(oid
));
1085 EXPECT_EQ(1U, missing
.num_missing());
1086 EXPECT_EQ(1U, missing
.get_rmissing().size());
1089 // existing object (MODIFY)
1091 pg_missing_t missing
;
1092 pg_log_entry_t e
= sample_e
;
1094 e
.op
= pg_log_entry_t::MODIFY
;
1095 e
.prior_version
= eversion_t();
1096 EXPECT_TRUE(e
.is_update());
1097 EXPECT_TRUE(e
.object_is_indexed());
1098 EXPECT_TRUE(e
.reqid_is_indexed());
1099 EXPECT_FALSE(missing
.is_missing(oid
));
1100 missing
.add_next_event(e
);
1101 EXPECT_TRUE(missing
.is_missing(oid
));
1102 EXPECT_EQ(eversion_t(), missing
.get_items().at(oid
).have
);
1103 EXPECT_EQ(oid
, missing
.get_rmissing().at(e
.version
.version
));
1104 EXPECT_EQ(1U, missing
.num_missing());
1105 EXPECT_EQ(1U, missing
.get_rmissing().size());
1107 // adding the same object with a different version
1108 e
.prior_version
= prior_version
;
1109 missing
.add_next_event(e
);
1110 EXPECT_EQ(eversion_t(), missing
.get_items().at(oid
).have
);
1111 EXPECT_TRUE(missing
.is_missing(oid
));
1112 EXPECT_EQ(1U, missing
.num_missing());
1113 EXPECT_EQ(1U, missing
.get_rmissing().size());
1116 // object with prior version (MODIFY)
1118 pg_missing_t missing
;
1119 pg_log_entry_t e
= sample_e
;
1121 e
.op
= pg_log_entry_t::MODIFY
;
1122 EXPECT_TRUE(e
.is_update());
1123 EXPECT_TRUE(e
.object_is_indexed());
1124 EXPECT_TRUE(e
.reqid_is_indexed());
1125 EXPECT_FALSE(missing
.is_missing(oid
));
1126 missing
.add_next_event(e
);
1127 EXPECT_TRUE(missing
.is_missing(oid
));
1128 EXPECT_EQ(prior_version
, missing
.get_items().at(oid
).have
);
1129 EXPECT_EQ(version
, missing
.get_items().at(oid
).need
);
1130 EXPECT_EQ(oid
, missing
.get_rmissing().at(e
.version
.version
));
1131 EXPECT_EQ(1U, missing
.num_missing());
1132 EXPECT_EQ(1U, missing
.get_rmissing().size());
1135 // adding a DELETE matching an existing event
1137 pg_missing_t missing
;
1138 pg_log_entry_t e
= sample_e
;
1140 e
.op
= pg_log_entry_t::MODIFY
;
1141 EXPECT_TRUE(e
.is_update());
1142 EXPECT_TRUE(e
.object_is_indexed());
1143 EXPECT_TRUE(e
.reqid_is_indexed());
1144 EXPECT_FALSE(missing
.is_missing(oid
));
1145 missing
.add_next_event(e
);
1146 EXPECT_TRUE(missing
.is_missing(oid
));
1148 e
.op
= pg_log_entry_t::DELETE
;
1149 EXPECT_TRUE(e
.is_delete());
1150 missing
.add_next_event(e
);
1151 EXPECT_TRUE(missing
.is_missing(oid
));
1152 EXPECT_TRUE(missing
.get_items().at(oid
).is_delete());
1153 EXPECT_EQ(prior_version
, missing
.get_items().at(oid
).have
);
1154 EXPECT_EQ(version
, missing
.get_items().at(oid
).need
);
1155 EXPECT_EQ(oid
, missing
.get_rmissing().at(e
.version
.version
));
1156 EXPECT_EQ(1U, missing
.num_missing());
1157 EXPECT_EQ(1U, missing
.get_rmissing().size());
1160 // adding a LOST_DELETE after an existing event
1162 pg_missing_t missing
;
1163 pg_log_entry_t e
= sample_e
;
1165 e
.op
= pg_log_entry_t::MODIFY
;
1166 EXPECT_TRUE(e
.is_update());
1167 EXPECT_TRUE(e
.object_is_indexed());
1168 EXPECT_TRUE(e
.reqid_is_indexed());
1169 EXPECT_FALSE(missing
.is_missing(oid
));
1170 missing
.add_next_event(e
);
1171 EXPECT_TRUE(missing
.is_missing(oid
));
1172 EXPECT_FALSE(missing
.get_items().at(oid
).is_delete());
1174 e
.op
= pg_log_entry_t::LOST_DELETE
;
1175 e
.version
.version
++;
1176 EXPECT_TRUE(e
.is_delete());
1177 missing
.add_next_event(e
);
1178 EXPECT_TRUE(missing
.is_missing(oid
));
1179 EXPECT_TRUE(missing
.get_items().at(oid
).is_delete());
1180 EXPECT_EQ(prior_version
, missing
.get_items().at(oid
).have
);
1181 EXPECT_EQ(e
.version
, missing
.get_items().at(oid
).need
);
1182 EXPECT_EQ(oid
, missing
.get_rmissing().at(e
.version
.version
));
1183 EXPECT_EQ(1U, missing
.num_missing());
1184 EXPECT_EQ(1U, missing
.get_rmissing().size());
1188 TEST(pg_missing_t
, revise_need
)
1190 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
1191 pg_missing_t missing
;
1192 // create a new entry
1193 EXPECT_FALSE(missing
.is_missing(oid
));
1194 eversion_t
need(10,10);
1195 missing
.revise_need(oid
, need
, false);
1196 EXPECT_TRUE(missing
.is_missing(oid
));
1197 EXPECT_EQ(eversion_t(), missing
.get_items().at(oid
).have
);
1198 EXPECT_EQ(need
, missing
.get_items().at(oid
).need
);
1199 // update an existing entry and preserve have
1200 eversion_t
have(1,1);
1201 missing
.revise_have(oid
, have
);
1202 eversion_t
new_need(10,12);
1203 EXPECT_EQ(have
, missing
.get_items().at(oid
).have
);
1204 missing
.revise_need(oid
, new_need
, false);
1205 EXPECT_EQ(have
, missing
.get_items().at(oid
).have
);
1206 EXPECT_EQ(new_need
, missing
.get_items().at(oid
).need
);
1209 TEST(pg_missing_t
, revise_have
)
1211 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
1212 pg_missing_t missing
;
1213 // a non existing entry means noop
1214 EXPECT_FALSE(missing
.is_missing(oid
));
1215 eversion_t
have(1,1);
1216 missing
.revise_have(oid
, have
);
1217 EXPECT_FALSE(missing
.is_missing(oid
));
1218 // update an existing entry
1219 eversion_t
need(10,12);
1220 missing
.add(oid
, need
, have
, false);
1221 EXPECT_TRUE(missing
.is_missing(oid
));
1222 eversion_t
new_have(2,2);
1223 EXPECT_EQ(have
, missing
.get_items().at(oid
).have
);
1224 missing
.revise_have(oid
, new_have
);
1225 EXPECT_EQ(new_have
, missing
.get_items().at(oid
).have
);
1226 EXPECT_EQ(need
, missing
.get_items().at(oid
).need
);
1229 TEST(pg_missing_t
, add
)
1231 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
1232 pg_missing_t missing
;
1233 EXPECT_FALSE(missing
.is_missing(oid
));
1234 eversion_t
have(1,1);
1235 eversion_t
need(10,10);
1236 missing
.add(oid
, need
, have
, false);
1237 EXPECT_TRUE(missing
.is_missing(oid
));
1238 EXPECT_EQ(have
, missing
.get_items().at(oid
).have
);
1239 EXPECT_EQ(need
, missing
.get_items().at(oid
).need
);
1242 TEST(pg_missing_t
, rm
)
1244 // void pg_missing_t::rm(const hobject_t& oid, eversion_t v)
1246 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
1247 pg_missing_t missing
;
1248 EXPECT_FALSE(missing
.is_missing(oid
));
1250 eversion_t
need(epoch
,10);
1251 missing
.add(oid
, need
, eversion_t(), false);
1252 EXPECT_TRUE(missing
.is_missing(oid
));
1253 // rm of an older version is a noop
1254 missing
.rm(oid
, eversion_t(epoch
/ 2,20));
1255 EXPECT_TRUE(missing
.is_missing(oid
));
1256 // rm of a later version removes the object
1257 missing
.rm(oid
, eversion_t(epoch
* 2,20));
1258 EXPECT_FALSE(missing
.is_missing(oid
));
1260 // void pg_missing_t::rm(const std::map<hobject_t, pg_missing_item>::iterator &m)
1262 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
1263 pg_missing_t missing
;
1264 EXPECT_FALSE(missing
.is_missing(oid
));
1265 missing
.add(oid
, eversion_t(), eversion_t(), false);
1266 EXPECT_TRUE(missing
.is_missing(oid
));
1267 auto m
= missing
.get_items().find(oid
);
1269 EXPECT_FALSE(missing
.is_missing(oid
));
1273 TEST(pg_missing_t
, got
)
1275 // void pg_missing_t::got(const hobject_t& oid, eversion_t v)
1277 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
1278 pg_missing_t missing
;
1279 // assert if the oid does not exist
1281 PrCtl unset_dumpable
;
1282 EXPECT_DEATH(missing
.got(oid
, eversion_t()), "");
1284 EXPECT_FALSE(missing
.is_missing(oid
));
1286 eversion_t
need(epoch
,10);
1287 missing
.add(oid
, need
, eversion_t(), false);
1288 EXPECT_TRUE(missing
.is_missing(oid
));
1289 // assert if that the version to be removed is lower than the version of the object
1291 PrCtl unset_dumpable
;
1292 EXPECT_DEATH(missing
.got(oid
, eversion_t(epoch
/ 2,20)), "");
1294 // remove of a later version removes the object
1295 missing
.got(oid
, eversion_t(epoch
* 2,20));
1296 EXPECT_FALSE(missing
.is_missing(oid
));
1298 // void pg_missing_t::got(const std::map<hobject_t, pg_missing_item>::iterator &m)
1300 hobject_t
oid(object_t("objname"), "key", 123, 456, 0, "");
1301 pg_missing_t missing
;
1302 EXPECT_FALSE(missing
.is_missing(oid
));
1303 missing
.add(oid
, eversion_t(), eversion_t(), false);
1304 EXPECT_TRUE(missing
.is_missing(oid
));
1305 auto m
= missing
.get_items().find(oid
);
1307 EXPECT_FALSE(missing
.is_missing(oid
));
1311 TEST(pg_missing_t
, split_into
)
1314 hobject_t
oid1(object_t("objname"), "key1", 123, hash1
, 0, "");
1316 hobject_t
oid2(object_t("objname"), "key2", 123, hash2
, 0, "");
1317 pg_missing_t missing
;
1318 missing
.add(oid1
, eversion_t(), eversion_t(), false);
1319 missing
.add(oid2
, eversion_t(), eversion_t(), false);
1321 child_pgid
.m_seed
= 1;
1323 unsigned split_bits
= 1;
1324 missing
.split_into(child_pgid
, split_bits
, &child
);
1325 EXPECT_TRUE(child
.is_missing(oid1
));
1326 EXPECT_FALSE(child
.is_missing(oid2
));
1327 EXPECT_FALSE(missing
.is_missing(oid1
));
1328 EXPECT_TRUE(missing
.is_missing(oid2
));
1331 TEST(pg_pool_t_test
, get_pg_num_divisor
) {
1336 for (int i
= 0; i
< 16; ++i
)
1337 ASSERT_EQ(16u, p
.get_pg_num_divisor(pg_t(i
, 1)));
1342 ASSERT_EQ(16u, p
.get_pg_num_divisor(pg_t(0, 1)));
1343 ASSERT_EQ(16u, p
.get_pg_num_divisor(pg_t(1, 1)));
1344 ASSERT_EQ(16u, p
.get_pg_num_divisor(pg_t(2, 1)));
1345 ASSERT_EQ(16u, p
.get_pg_num_divisor(pg_t(3, 1)));
1346 ASSERT_EQ(8u, p
.get_pg_num_divisor(pg_t(4, 1)));
1347 ASSERT_EQ(8u, p
.get_pg_num_divisor(pg_t(5, 1)));
1348 ASSERT_EQ(8u, p
.get_pg_num_divisor(pg_t(6, 1)));
1349 ASSERT_EQ(8u, p
.get_pg_num_divisor(pg_t(7, 1)));
1350 ASSERT_EQ(16u, p
.get_pg_num_divisor(pg_t(8, 1)));
1351 ASSERT_EQ(16u, p
.get_pg_num_divisor(pg_t(9, 1)));
1352 ASSERT_EQ(16u, p
.get_pg_num_divisor(pg_t(10, 1)));
1353 ASSERT_EQ(16u, p
.get_pg_num_divisor(pg_t(11, 1)));
1356 TEST(pg_pool_t_test
, get_random_pg_position
) {
1358 for (int i
= 0; i
< 100; ++i
) {
1360 p
.set_pg_num(1 + (rand() % 1000));
1361 p
.set_pgp_num(p
.get_pg_num());
1362 pg_t
pgid(rand() % p
.get_pg_num(), 1);
1363 uint32_t h
= p
.get_random_pg_position(pgid
, rand());
1364 uint32_t ps
= p
.raw_hash_to_pg(h
);
1365 cout
<< p
.get_pg_num() << " " << pgid
<< ": "
1366 << h
<< " -> " << pg_t(ps
, 1) << std::endl
;
1367 ASSERT_EQ(pgid
.ps(), ps
);
1371 TEST(shard_id_t
, iostream
) {
1372 set
<shard_id_t
> shards
;
1373 shards
.insert(shard_id_t(0));
1374 shards
.insert(shard_id_t(1));
1375 shards
.insert(shard_id_t(2));
1378 ASSERT_EQ(out
.str(), "0,1,2");
1380 shard_id_t noshard
= shard_id_t::NO_SHARD
;
1382 ASSERT_GT(zero
, noshard
);
1385 TEST(spg_t
, parse
) {
1386 spg_t
a(pg_t(1,2), shard_id_t::NO_SHARD
);
1388 spg_t
b(pg_t(3,2), shard_id_t(2));
1389 std::string s
= stringify(a
);
1390 ASSERT_TRUE(aa
.parse(s
.c_str()));
1394 ASSERT_TRUE(bb
.parse(s
.c_str()));
1398 TEST(coll_t
, parse
) {
1399 const char *ok
[] = {
1408 const char *bad
[] = {
1412 //" 1.2_head", // hrm, this parses, which is not ideal.. pg_t's fault?
1421 for (int i
= 0; ok
[i
]; ++i
) {
1422 cout
<< "check ok " << ok
[i
] << std::endl
;
1423 ASSERT_TRUE(a
.parse(ok
[i
]));
1424 ASSERT_EQ(string(ok
[i
]), a
.to_str());
1426 for (int i
= 0; bad
[i
]; ++i
) {
1427 cout
<< "check bad " << bad
[i
] << std::endl
;
1428 ASSERT_FALSE(a
.parse(bad
[i
]));
1432 TEST(coll_t
, temp
) {
1435 ASSERT_EQ(foo
.to_str(), string("0.0_head"));
1437 coll_t temp
= foo
.get_temp();
1438 ASSERT_EQ(temp
.to_str(), string("0.0_TEMP"));
1441 ASSERT_TRUE(temp
.is_temp());
1442 ASSERT_TRUE(temp
.is_temp(&pgid2
));
1443 ASSERT_EQ(pgid
, pgid2
);
1446 TEST(coll_t
, assigment
) {
1449 ASSERT_EQ(right
.to_str(), string("0.0_head"));
1451 coll_t left
, middle
;
1453 ASSERT_EQ(left
.to_str(), string("meta"));
1454 ASSERT_EQ(middle
.to_str(), string("meta"));
1456 left
= middle
= right
;
1458 ASSERT_EQ(left
.to_str(), string("0.0_head"));
1459 ASSERT_EQ(middle
.to_str(), string("0.0_head"));
1461 ASSERT_NE(middle
.c_str(), right
.c_str());
1462 ASSERT_NE(left
.c_str(), middle
.c_str());
1465 TEST(hobject_t
, parse
) {
1469 "-1:60c2fa6d:::inc_osdmap.1:0",
1470 "-1:60c2fa6d:::inc_osdmap.1:333",
1471 "0:00000000::::head",
1472 "1:00000000:nspace:key:obj:head",
1473 "-40:00000000:nspace::obj:head",
1474 "20:00000000::key:obj:head",
1475 "20:00000000:::o%fdj:head",
1476 "20:00000000:::o%02fdj:head",
1477 "20:00000000:::_zero_%00_:head",
1481 for (unsigned i
=0; v
[i
]; ++i
) {
1483 bool b
= o
.parse(v
[i
]);
1485 cout
<< "failed to parse " << v
[i
] << std::endl
;
1488 string s
= stringify(o
);
1490 cout
<< v
[i
] << " -> " << o
<< " -> " << s
<< std::endl
;
1491 ASSERT_EQ(s
, string(v
[i
]));
1496 TEST(ghobject_t
, cmp
) {
1499 sep
.set_shard(shard_id_t(1));
1501 cout
<< min
<< " < " << sep
<< std::endl
;
1502 ASSERT_TRUE(min
< sep
);
1504 sep
.set_shard(shard_id_t::NO_SHARD
);
1505 cout
<< "sep shard " << sep
.shard_id
<< std::endl
;
1506 ghobject_t
o(hobject_t(object_t(), string(), CEPH_NOSNAP
, 0x42,
1508 cout
<< "o " << o
<< std::endl
;
1509 ASSERT_TRUE(o
> sep
);
1512 TEST(ghobject_t
, parse
) {
1516 "13#0:00000000::::head#",
1517 "13#0:00000000::::head#deadbeef",
1518 "#-1:60c2fa6d:::inc_osdmap.1:333#deadbeef",
1519 "#-1:60c2fa6d:::inc%02osdmap.1:333#deadbeef",
1520 "#-1:60c2fa6d:::inc_osdmap.1:333#",
1524 "#-40:00000000:nspace::obj:head#",
1528 for (unsigned i
=0; v
[i
]; ++i
) {
1530 bool b
= o
.parse(v
[i
]);
1532 cout
<< "failed to parse " << v
[i
] << std::endl
;
1535 string s
= stringify(o
);
1537 cout
<< v
[i
] << " -> " << o
<< " -> " << s
<< std::endl
;
1538 ASSERT_EQ(s
, string(v
[i
]));
1543 TEST(pool_opts_t
, invalid_opt
) {
1544 EXPECT_FALSE(pool_opts_t::is_opt_name("INVALID_OPT"));
1545 PrCtl unset_dumpable
;
1546 EXPECT_DEATH(pool_opts_t::get_opt_desc("INVALID_OPT"), "");
1549 TEST(pool_opts_t
, scrub_min_interval
) {
1550 EXPECT_TRUE(pool_opts_t::is_opt_name("scrub_min_interval"));
1551 EXPECT_EQ(pool_opts_t::get_opt_desc("scrub_min_interval"),
1552 pool_opts_t::opt_desc_t(pool_opts_t::SCRUB_MIN_INTERVAL
,
1553 pool_opts_t::DOUBLE
));
1556 EXPECT_FALSE(opts
.is_set(pool_opts_t::SCRUB_MIN_INTERVAL
));
1558 PrCtl unset_dumpable
;
1559 EXPECT_DEATH(opts
.get(pool_opts_t::SCRUB_MIN_INTERVAL
), "");
1562 EXPECT_FALSE(opts
.get(pool_opts_t::SCRUB_MIN_INTERVAL
, &val
));
1563 opts
.set(pool_opts_t::SCRUB_MIN_INTERVAL
, static_cast<double>(2015));
1564 EXPECT_TRUE(opts
.get(pool_opts_t::SCRUB_MIN_INTERVAL
, &val
));
1565 EXPECT_EQ(val
, 2015);
1566 opts
.unset(pool_opts_t::SCRUB_MIN_INTERVAL
);
1567 EXPECT_FALSE(opts
.is_set(pool_opts_t::SCRUB_MIN_INTERVAL
));
1570 TEST(pool_opts_t
, scrub_max_interval
) {
1571 EXPECT_TRUE(pool_opts_t::is_opt_name("scrub_max_interval"));
1572 EXPECT_EQ(pool_opts_t::get_opt_desc("scrub_max_interval"),
1573 pool_opts_t::opt_desc_t(pool_opts_t::SCRUB_MAX_INTERVAL
,
1574 pool_opts_t::DOUBLE
));
1577 EXPECT_FALSE(opts
.is_set(pool_opts_t::SCRUB_MAX_INTERVAL
));
1579 PrCtl unset_dumpable
;
1580 EXPECT_DEATH(opts
.get(pool_opts_t::SCRUB_MAX_INTERVAL
), "");
1583 EXPECT_FALSE(opts
.get(pool_opts_t::SCRUB_MAX_INTERVAL
, &val
));
1584 opts
.set(pool_opts_t::SCRUB_MAX_INTERVAL
, static_cast<double>(2015));
1585 EXPECT_TRUE(opts
.get(pool_opts_t::SCRUB_MAX_INTERVAL
, &val
));
1586 EXPECT_EQ(val
, 2015);
1587 opts
.unset(pool_opts_t::SCRUB_MAX_INTERVAL
);
1588 EXPECT_FALSE(opts
.is_set(pool_opts_t::SCRUB_MAX_INTERVAL
));
1591 TEST(pool_opts_t
, deep_scrub_interval
) {
1592 EXPECT_TRUE(pool_opts_t::is_opt_name("deep_scrub_interval"));
1593 EXPECT_EQ(pool_opts_t::get_opt_desc("deep_scrub_interval"),
1594 pool_opts_t::opt_desc_t(pool_opts_t::DEEP_SCRUB_INTERVAL
,
1595 pool_opts_t::DOUBLE
));
1598 EXPECT_FALSE(opts
.is_set(pool_opts_t::DEEP_SCRUB_INTERVAL
));
1600 PrCtl unset_dumpable
;
1601 EXPECT_DEATH(opts
.get(pool_opts_t::DEEP_SCRUB_INTERVAL
), "");
1604 EXPECT_FALSE(opts
.get(pool_opts_t::DEEP_SCRUB_INTERVAL
, &val
));
1605 opts
.set(pool_opts_t::DEEP_SCRUB_INTERVAL
, static_cast<double>(2015));
1606 EXPECT_TRUE(opts
.get(pool_opts_t::DEEP_SCRUB_INTERVAL
, &val
));
1607 EXPECT_EQ(val
, 2015);
1608 opts
.unset(pool_opts_t::DEEP_SCRUB_INTERVAL
);
1609 EXPECT_FALSE(opts
.is_set(pool_opts_t::DEEP_SCRUB_INTERVAL
));
1612 struct RequiredPredicate
: IsPGRecoverablePredicate
{
1613 unsigned required_size
;
1614 explicit RequiredPredicate(unsigned required_size
) : required_size(required_size
) {}
1615 bool operator()(const set
<pg_shard_t
> &have
) const override
{
1616 return have
.size() >= required_size
;
1620 using namespace std
;
1621 struct MapPredicate
{
1622 map
<int, pair
<PastIntervals::osd_state_t
, epoch_t
>> states
;
1623 explicit MapPredicate(
1624 const vector
<pair
<int, pair
<PastIntervals::osd_state_t
, epoch_t
>>> &_states
)
1625 : states(_states
.begin(), _states
.end()) {}
1626 PastIntervals::osd_state_t
operator()(epoch_t start
, int osd
, epoch_t
*lost_at
) {
1627 auto val
= states
.at(osd
);
1629 *lost_at
= val
.second
;
1634 using sit
= shard_id_t
;
1635 using PI
= PastIntervals
;
1636 using pst
= pg_shard_t
;
1637 using ival
= PastIntervals::pg_interval_t
;
1638 using ivallst
= std::list
<ival
>;
1639 const int N
= 0x7fffffff /* CRUSH_ITEM_NONE, can't import crush.h here */;
1641 struct PITest
: ::testing::Test
{
1646 epoch_t last_epoch_started
,
1647 unsigned min_to_peer
,
1648 vector
<pair
<int, pair
<PastIntervals::osd_state_t
, epoch_t
>>> osd_states
,
1651 set
<pg_shard_t
> probe
,
1653 map
<int, epoch_t
> blocked_by
,
1655 RequiredPredicate
rec_pred(min_to_peer
);
1656 MapPredicate
map_pred(osd_states
);
1658 PI::PriorSet
correct(
1664 new RequiredPredicate(rec_pred
));
1666 PastIntervals compact
;
1667 for (auto &&i
: intervals
) {
1668 compact
.add_interval(ec_pool
, i
);
1670 PI::PriorSet compact_ps
= compact
.get_prior_set(
1673 new RequiredPredicate(rec_pred
),
1678 ASSERT_EQ(correct
, compact_ps
);
1682 TEST_F(PITest
, past_intervals_rep
) {
1684 /* ec_pool */ false,
1686 { ival
{{0, 1, 2}, {0, 1, 2}, 10, 20, true, 0, 0}
1687 , ival
{{ 1, 2}, { 1, 2}, 21, 30, true, 1, 1}
1688 , ival
{{ 2}, { 2}, 31, 35, false, 2, 2}
1689 , ival
{{0, 2}, {0, 2}, 36, 50, true, 0, 0}
1693 /* osd states at end */
1694 { make_pair(0, make_pair(PI::UP
, 0))
1695 , make_pair(1, make_pair(PI::UP
, 0))
1696 , make_pair(2, make_pair(PI::DOWN
, 0))
1698 /* acting */ {0, 1 },
1700 /* probe */ {pst(0), pst(1)},
1702 /* blocked_by */ {},
1703 /* pg_down */ false);
1706 TEST_F(PITest
, past_intervals_ec
) {
1710 { ival
{{0, 1, 2}, {0, 1, 2}, 10, 20, true, 0, 0}
1711 , ival
{{N
, 1, 2}, {N
, 1, 2}, 21, 30, true, 1, 1}
1715 /* osd states at end */
1716 { make_pair(0, make_pair(PI::DOWN
, 0))
1717 , make_pair(1, make_pair(PI::UP
, 0))
1718 , make_pair(2, make_pair(PI::UP
, 0))
1720 /* acting */ {N
, 1, 2},
1722 /* probe */ {pst(1, sit(1)), pst(2, sit(2))},
1724 /* blocked_by */ {},
1725 /* pg_down */ false);
1728 TEST_F(PITest
, past_intervals_rep_down
) {
1730 /* ec_pool */ false,
1732 { ival
{{0, 1, 2}, {0, 1, 2}, 10, 20, true, 0, 0}
1733 , ival
{{ 1, 2}, { 1, 2}, 21, 30, true, 1, 1}
1734 , ival
{{ 2}, { 2}, 31, 35, true, 2, 2}
1735 , ival
{{0, 2}, {0, 2}, 36, 50, true, 0, 0}
1739 /* osd states at end */
1740 { make_pair(0, make_pair(PI::UP
, 0))
1741 , make_pair(1, make_pair(PI::UP
, 0))
1742 , make_pair(2, make_pair(PI::DOWN
, 0))
1744 /* acting */ {0, 1 },
1746 /* probe */ {pst(0), pst(1)},
1748 /* blocked_by */ {{2, 0}},
1749 /* pg_down */ true);
1752 TEST_F(PITest
, past_intervals_ec_down
) {
1756 { ival
{{0, 1, 2}, {0, 1, 2}, 10, 20, true, 0, 0}
1757 , ival
{{N
, 1, 2}, {N
, 1, 2}, 21, 30, true, 1, 1}
1758 , ival
{{N
, N
, 2}, {N
, N
, 2}, 31, 35, false, 2, 2}
1762 /* osd states at end */
1763 { make_pair(0, make_pair(PI::UP
, 0))
1764 , make_pair(1, make_pair(PI::DOWN
, 0))
1765 , make_pair(2, make_pair(PI::UP
, 0))
1767 /* acting */ {0, N
, 2},
1769 /* probe */ {pst(0, sit(0)), pst(2, sit(2))},
1771 /* blocked_by */ {{1, 0}},
1772 /* pg_down */ true);
1775 TEST_F(PITest
, past_intervals_rep_no_subsets
) {
1777 /* ec_pool */ false,
1779 { ival
{{0, 2}, {0, 2}, 10, 20, true, 0, 0}
1780 , ival
{{ 1, 2}, { 1, 2}, 21, 30, true, 1, 1}
1781 , ival
{{0, 1 }, {0, 1 }, 31, 35, true, 0, 0}
1785 /* osd states at end */
1786 { make_pair(0, make_pair(PI::UP
, 0))
1787 , make_pair(1, make_pair(PI::UP
, 0))
1788 , make_pair(2, make_pair(PI::DOWN
, 0))
1790 /* acting */ {0, 1 },
1792 /* probe */ {pst(0), pst(1)},
1794 /* blocked_by */ {},
1795 /* pg_down */ false);
1798 TEST_F(PITest
, past_intervals_ec_no_subsets
) {
1802 { ival
{{0, N
, 2}, {0, N
, 2}, 10, 20, true, 0, 0}
1803 , ival
{{N
, 1, 2}, {N
, 1, 2}, 21, 30, true, 1, 1}
1804 , ival
{{0, 1, N
}, {0, 1, N
}, 31, 35, true, 0, 0}
1808 /* osd states at end */
1809 { make_pair(0, make_pair(PI::UP
, 0))
1810 , make_pair(1, make_pair(PI::DOWN
, 0))
1811 , make_pair(2, make_pair(PI::UP
, 0))
1813 /* acting */ {0, N
, 2},
1815 /* probe */ {pst(0, sit(0)), pst(2, sit(2))},
1817 /* blocked_by */ {{1, 0}},
1818 /* pg_down */ true);
1821 TEST_F(PITest
, past_intervals_ec_no_subsets2
) {
1825 { ival
{{N
, 1, 2}, {N
, 1, 2}, 10, 20, true, 0, 0}
1826 , ival
{{0, N
, 2}, {0, N
, 2}, 21, 30, true, 1, 1}
1827 , ival
{{0, 3, N
}, {0, 3, N
}, 31, 35, true, 0, 0}
1831 /* osd states at end */
1832 { make_pair(0, make_pair(PI::UP
, 0))
1833 , make_pair(1, make_pair(PI::DOWN
, 0))
1834 , make_pair(2, make_pair(PI::UP
, 0))
1835 , make_pair(3, make_pair(PI::UP
, 0))
1837 /* acting */ {0, N
, 2},
1839 /* probe */ {pst(0, sit(0)), pst(2, sit(2)), pst(3, sit(1))},
1841 /* blocked_by */ {},
1842 /* pg_down */ false);
1845 TEST_F(PITest
, past_intervals_rep_lost
) {
1847 /* ec_pool */ false,
1849 { ival
{{0, 1, 2}, {0, 1, 2}, 10, 20, true, 0, 0}
1850 , ival
{{ 1, 2}, { 1, 2}, 21, 30, true, 1, 1}
1851 , ival
{{ 2}, { 2}, 31, 35, true, 2, 2}
1852 , ival
{{0, 2}, {0, 2}, 36, 50, true, 0, 0}
1856 /* osd states at end */
1857 { make_pair(0, make_pair(PI::UP
, 0))
1858 , make_pair(1, make_pair(PI::UP
, 0))
1859 , make_pair(2, make_pair(PI::LOST
, 55))
1861 /* acting */ {0, 1 },
1863 /* probe */ {pst(0), pst(1)},
1865 /* blocked_by */ {},
1866 /* pg_down */ false);
1869 TEST_F(PITest
, past_intervals_ec_lost
) {
1873 { ival
{{0, N
, 2}, {0, N
, 2}, 10, 20, true, 0, 0}
1874 , ival
{{N
, 1, 2}, {N
, 1, 2}, 21, 30, true, 1, 1}
1875 , ival
{{0, 1, N
}, {0, 1, N
}, 31, 35, true, 0, 0}
1879 /* osd states at end */
1880 { make_pair(0, make_pair(PI::UP
, 0))
1881 , make_pair(1, make_pair(PI::LOST
, 36))
1882 , make_pair(2, make_pair(PI::UP
, 0))
1884 /* acting */ {0, N
, 2},
1886 /* probe */ {pst(0, sit(0)), pst(2, sit(2))},
1888 /* blocked_by */ {},
1889 /* pg_down */ false);
1893 object_manifest_t l
,
1894 object_manifest_t to_remove
,
1895 object_manifest_t g
,
1896 object_ref_delta_t expected_delta
)
1899 object_ref_delta_t delta
;
1900 to_remove
.calc_refs_to_drop_on_removal(
1909 // calc_refs_to_drop specifically handles nullptr identically to empty
1911 if (l
.chunk_map
.empty() || g
.chunk_map
.empty()) {
1912 object_ref_delta_t delta
;
1913 to_remove
.calc_refs_to_drop_on_removal(
1914 l
.chunk_map
.empty() ? nullptr : &l
,
1915 g
.chunk_map
.empty() ? nullptr : &g
,
1923 void ci_ref_test_on_modify(
1924 object_manifest_t l
,
1925 object_manifest_t to_remove
,
1926 ObjectCleanRegions clean_regions
,
1927 object_ref_delta_t expected_delta
)
1930 object_ref_delta_t delta
;
1931 to_remove
.calc_refs_to_drop_on_modify(
1941 void ci_ref_test_inc_on_set(
1942 object_manifest_t l
,
1943 object_manifest_t added_set
,
1944 object_manifest_t g
,
1945 object_ref_delta_t expected_delta
)
1948 object_ref_delta_t delta
;
1949 added_set
.calc_refs_to_inc_on_set(
1959 hobject_t
mk_hobject(string name
)
1970 object_manifest_t
mk_manifest(
1971 std::map
<uint64_t, std::tuple
<uint64_t, uint64_t, string
>> m
)
1973 object_manifest_t ret
;
1974 ret
.type
= object_manifest_t::TYPE_CHUNKED
;
1975 for (auto &[offset
, tgt
] : m
) {
1976 auto &[tgt_off
, length
, name
] = tgt
;
1977 auto &ci
= ret
.chunk_map
[offset
];
1978 ci
.offset
= tgt_off
;
1980 ci
.oid
= mk_hobject(name
);
1985 object_ref_delta_t
mk_delta(std::map
<string
, int> _m
) {
1986 std::map
<hobject_t
, int> m
;
1987 for (auto &[name
, delta
] : _m
) {
1993 return object_ref_delta_t(std::move(m
));
1996 TEST(chunk_info_test
, calc_refs_to_drop
) {
1999 mk_manifest({{0, {0, 1024, "foo"}}}),
2001 mk_delta({{"foo", -1}}));
2006 TEST(chunk_info_test
, calc_refs_to_drop_match
) {
2008 mk_manifest({{0, {0, 1024, "foo"}}}),
2009 mk_manifest({{0, {0, 1024, "foo"}}}),
2010 mk_manifest({{0, {0, 1024, "foo"}}}),
2015 TEST(chunk_info_test
, calc_refs_to_drop_head_match
) {
2018 mk_manifest({{0, {0, 1024, "foo"}}}),
2019 mk_manifest({{0, {0, 1024, "foo"}}}),
2024 TEST(chunk_info_test
, calc_refs_to_drop_tail_match
) {
2026 mk_manifest({{0, {0, 1024, "foo"}}}),
2027 mk_manifest({{0, {0, 1024, "foo"}}}),
2033 TEST(chunk_info_test
, calc_refs_to_drop_second_reference
) {
2035 mk_manifest({{0, {0, 1024, "foo"}}}),
2036 mk_manifest({{0, {0, 1024, "foo"}}, {4<<10, {0, 1<<10, "foo"}}}),
2038 mk_delta({{"foo", -1}}));
2042 TEST(chunk_info_test
, calc_refs_offsets_dont_match
) {
2044 mk_manifest({{0, {0, 1024, "foo"}}}),
2045 mk_manifest({{512, {0, 1024, "foo"}}, {(4<<10) + 512, {0, 1<<10, "foo"}}}),
2047 mk_delta({{"foo", -2}}));
2051 TEST(chunk_info_test
, calc_refs_g_l_match
) {
2053 mk_manifest({{4096, {0, 1024, "foo"}}}),
2054 mk_manifest({{0, {0, 1024, "foo"}}, {4096, {0, 1024, "bar"}}}),
2055 mk_manifest({{4096, {0, 1024, "foo"}}}),
2056 mk_delta({{"foo", -2}, {"bar", -1}}));
2060 TEST(chunk_info_test
, calc_refs_g_l_match_no_this
) {
2062 mk_manifest({{4096, {0, 1024, "foo"}}}),
2063 mk_manifest({{0, {0, 1024, "bar"}}}),
2064 mk_manifest({{4096, {0, 1024, "foo"}}}),
2065 mk_delta({{"foo", -1}, {"bar", -1}}));
2069 TEST(chunk_info_test
, calc_refs_modify_mismatch
) {
2070 ObjectCleanRegions
clean_regions(0, 8192, false);
2071 clean_regions
.mark_data_region_dirty(0, 1024);
2072 clean_regions
.mark_data_region_dirty(512, 1024);
2073 ci_ref_test_on_modify(
2074 mk_manifest({{512, {2048, 1024, "foo"}}, {4096, {0, 1024, "foo"}}}),
2075 mk_manifest({{0, {0, 1024, "bar"}}, {512, {2048, 1024, "ttt"}}}),
2077 mk_delta({{"bar", -1}, {"ttt", -1}}));
2080 TEST(chunk_info_test
, calc_refs_modify_match
) {
2081 ObjectCleanRegions
clean_regions(0, 8192, false);
2082 clean_regions
.mark_data_region_dirty(0, 1024);
2083 clean_regions
.mark_data_region_dirty(512, 1024);
2084 clean_regions
.mark_data_region_dirty(4096, 1024);
2085 ci_ref_test_on_modify(
2086 mk_manifest({{512, {2048, 1024, "foo"}}, {4096, {0, 1024, "ttt"}}}),
2087 mk_manifest({{0, {0, 1024, "bar"}}, {512, {2048, 1024, "foo"}}, {4096, {0, 1024, "ttt"}}}),
2089 mk_delta({{"bar", -1}}));
2092 TEST(chunk_info_test
, calc_refs_modify_match_dirty_overlap
) {
2093 ObjectCleanRegions
clean_regions(0, 8192, false);
2094 clean_regions
.mark_data_region_dirty(0, 256);
2095 clean_regions
.mark_data_region_dirty(256, 4096);
2096 ci_ref_test_on_modify(
2098 mk_manifest({{0, {0, 256, "bar"}}, {512, {2048, 1024, "foo"}}, {4096, {0, 1024, "ttt"}}}),
2100 mk_delta({{"bar", -1}, {"foo", -1}, {"ttt", -1}}));
2103 TEST(chunk_info_test
, calc_refs_modify_match_dirty_overlap2
) {
2104 ObjectCleanRegions
clean_regions(0, 8192, false);
2105 clean_regions
.mark_data_region_dirty(0, 256);
2106 clean_regions
.mark_data_region_dirty(256, 1024);
2107 clean_regions
.mark_data_region_dirty(3584, 1024);
2108 ci_ref_test_on_modify(
2109 mk_manifest({{512, {2048, 1024, "foo"}}, {4096, {0, 1024, "ttt"}}}),
2110 mk_manifest({{0, {0, 256, "bar"}}, {512, {2048, 1024, "foo"}}, {4096, {0, 1024, "ttt"}}}),
2112 mk_delta({{"bar", -1}}));
2115 TEST(chunk_info_test
, calc_refs_modify_match_dirty_overlap3
) {
2116 ObjectCleanRegions
clean_regions(0, 8192, false);
2117 clean_regions
.mark_data_region_dirty(0, 256);
2118 clean_regions
.mark_data_region_dirty(256, 4096);
2119 ci_ref_test_on_modify(
2120 mk_manifest({{512, {2048, 1024, "foo"}}, {4096, {0, 1024, "ttt"}}}),
2121 mk_manifest({{0, {0, 256, "bar"}}, {512, {2048, 1024, "foo"}}, {4096, {0, 1024, "ttt"}}}),
2123 mk_delta({{"bar", -1}}));
2126 TEST(chunk_info_test
, calc_refs_modify_match_clone_overlap
) {
2127 ObjectCleanRegions
clean_regions(0, 8192, false);
2128 clean_regions
.mark_data_region_dirty(0, 256);
2129 clean_regions
.mark_data_region_dirty(256, 1024);
2130 clean_regions
.mark_data_region_dirty(3584, 1024);
2131 ci_ref_test_on_modify(
2132 mk_manifest({{512, {2048, 1024, "foo"}}, {4096, {0, 1024, "ttt"}}}),
2133 mk_manifest({{0, {0, 256, "bar"}}, {256, {2048, 1024, "foo"}}, {3584, {0, 1024, "ttt"}}}),
2135 mk_delta({{"bar", -1}, {"foo", -1}, {"ttt", -1}}));
2138 TEST(chunk_info_test
, calc_refs_modify_no_snap
) {
2139 ObjectCleanRegions
clean_regions(0, 8192, false);
2140 clean_regions
.mark_data_region_dirty(0, 1024);
2141 clean_regions
.mark_data_region_dirty(512, 1024);
2142 ci_ref_test_on_modify(
2144 mk_manifest({{0, {0, 1024, "bar"}}, {512, {2048, 1024, "ttt"}}}),
2146 mk_delta({{"bar", -1}, {"ttt", -1}}));
2149 TEST(chunk_info_test
, calc_refs_inc
) {
2150 ci_ref_test_inc_on_set(
2151 mk_manifest({{256, {0, 256, "aaa"}}, {4096, {0, 1024, "foo"}}}),
2152 mk_manifest({{1024, {0, 1024, "bar"}}}),
2153 mk_manifest({{4096, {0, 1024, "foo"}}}),
2154 mk_delta({{"bar", 1}}));
2157 TEST(chunk_info_test
, calc_refs_inc2
) {
2158 ci_ref_test_inc_on_set(
2159 mk_manifest({{512, {0, 1024, "aaa"}}, {4096, {0, 1024, "foo"}}}),
2160 mk_manifest({{1024, {0, 1024, "bar"}}, {4096, {0, 1024, "bbb"}}}),
2161 mk_manifest({{512, {0, 1024, "foo"}}}),
2162 mk_delta({{"bar", 1}, {"bbb", 1}}));
2165 TEST(chunk_info_test
, calc_refs_inc_no_l
) {
2166 ci_ref_test_inc_on_set(
2168 mk_manifest({{1024, {0, 1024, "bar"}}, {4096, {0, 1024, "bbb"}}}),
2169 mk_manifest({{512, {0, 1024, "foo"}}}),
2170 mk_delta({{"bar", 1}, {"bbb", 1}}));
2173 TEST(chunk_info_test
, calc_refs_inc_no_g
) {
2174 ci_ref_test_inc_on_set(
2175 mk_manifest({{512, {0, 1024, "aaa"}}, {4096, {0, 1024, "foo"}}}),
2176 mk_manifest({{1024, {0, 1024, "bar"}}, {4096, {0, 1024, "foo"}}}),
2178 mk_delta({{"bar", 1}}));
2181 TEST(chunk_info_test
, calc_refs_inc_match_g_l
) {
2182 ci_ref_test_inc_on_set(
2183 mk_manifest({{256, {0, 256, "aaa"}}, {4096, {0, 1024, "foo"}}}),
2184 mk_manifest({{256, {0, 256, "aaa"}}, {4096, {0, 1024, "foo"}}}),
2185 mk_manifest({{256, {0, 256, "aaa"}}, {4096, {0, 1024, "foo"}}}),
2186 mk_delta({{"aaa", -1}, {"foo", -1}}));
2189 TEST(chunk_info_test
, calc_refs_inc_match
) {
2190 ci_ref_test_inc_on_set(
2191 mk_manifest({{256, {0, 256, "bbb"}}, {4096, {0, 1024, "foo"}}}),
2192 mk_manifest({{256, {0, 256, "aaa"}}, {4096, {0, 1024, "foo"}}}),
2193 mk_manifest({{256, {0, 256, "aaa"}}, {4096, {0, 1024, "ccc"}}}),
2199 * compile-command: "cd ../.. ;
2200 * make unittest_osd_types ;
2201 * ./unittest_osd_types # --gtest_filter=pg_missing_t.constructor