Only run sanity check once at the end

sipa · sipa · commit 402ad5aaca95 · 2020-04-06T14:39:42.000-07:00
diff --git a/src/test/fuzz/prevector.cpp b/src/test/fuzz/prevector.cpp
@@ -26,7 +26,8 @@ class prevector_tester {
 
     typedef typename pretype::size_type Size;
 
-    void test() {
+public:
+    void test() const {
         const pretype& const_pre_vector = pre_vector;
         assert(real_vector.size() == pre_vector.size());
         assert(real_vector.empty() == pre_vector.empty());
@@ -66,70 +67,59 @@ class prevector_tester {
         }
     }
 
-public:
     void resize(Size s) {
         real_vector.resize(s);
         assert(real_vector.size() == s);
         pre_vector.resize(s);
         assert(pre_vector.size() == s);
-        test();
     }
 
     void reserve(Size s) {
         real_vector.reserve(s);
         assert(real_vector.capacity() >= s);
         pre_vector.reserve(s);
         assert(pre_vector.capacity() >= s);
-        test();
     }
 
     void insert(Size position, const T& value) {
         real_vector.insert(real_vector.begin() + position, value);
         pre_vector.insert(pre_vector.begin() + position, value);
-        test();
     }
 
     void insert(Size position, Size count, const T& value) {
         real_vector.insert(real_vector.begin() + position, count, value);
         pre_vector.insert(pre_vector.begin() + position, count, value);
-        test();
     }
 
     template<typename I>
     void insert_range(Size position, I first, I last) {
         real_vector.insert(real_vector.begin() + position, first, last);
         pre_vector.insert(pre_vector.begin() + position, first, last);
-        test();
     }
 
     void erase(Size position) {
         real_vector.erase(real_vector.begin() + position);
         pre_vector.erase(pre_vector.begin() + position);
-        test();
     }
 
     void erase(Size first, Size last) {
         real_vector.erase(real_vector.begin() + first, real_vector.begin() + last);
         pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last);
-        test();
     }
 
     void update(Size pos, const T& value) {
         real_vector[pos] = value;
         pre_vector[pos] = value;
-        test();
     }
 
     void push_back(const T& value) {
         real_vector.push_back(value);
         pre_vector.push_back(value);
-        test();
     }
 
     void pop_back() {
         real_vector.pop_back();
         pre_vector.pop_back();
-        test();
     }
 
     void clear() {
@@ -152,13 +142,11 @@ class prevector_tester {
 
     void shrink_to_fit() {
         pre_vector.shrink_to_fit();
-        test();
     }
 
     void swap() {
         real_vector.swap(real_vector_alt);
         pre_vector.swap(pre_vector_alt);
-        test();
     }
 
     void move() {
@@ -190,7 +178,6 @@ class prevector_tester {
             pre_vector[p] = v;
             ++p;
         }
-        test();
     }
 };
 
@@ -277,4 +264,6 @@ void test_one_input(const std::vector<uint8_t>& buffer)
         }
         }
     }
+
+    test.test();
 }

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,8 @@ class prevector_tester {`
`26`	`26`
`27`	`27`	`typedef typename pretype::size_type Size;`
`28`	`28`
`29`		`- void test() {`
	`29`	`+public:`
	`30`	`+ void test() const {`
`30`	`31`	`const pretype& const_pre_vector = pre_vector;`
`31`	`32`	`assert(real_vector.size() == pre_vector.size());`
`32`	`33`	`assert(real_vector.empty() == pre_vector.empty());`
`@@ -66,70 +67,59 @@ class prevector_tester {`
`66`	`67`	`}`
`67`	`68`	`}`
`68`	`69`
`69`		`-public:`
`70`	`70`	`void resize(Size s) {`
`71`	`71`	`real_vector.resize(s);`
`72`	`72`	`assert(real_vector.size() == s);`
`73`	`73`	`pre_vector.resize(s);`
`74`	`74`	`assert(pre_vector.size() == s);`
`75`		`- test();`
`76`	`75`	`}`
`77`	`76`
`78`	`77`	`void reserve(Size s) {`
`79`	`78`	`real_vector.reserve(s);`
`80`	`79`	`assert(real_vector.capacity() >= s);`
`81`	`80`	`pre_vector.reserve(s);`
`82`	`81`	`assert(pre_vector.capacity() >= s);`
`83`		`- test();`
`84`	`82`	`}`
`85`	`83`
`86`	`84`	`void insert(Size position, const T& value) {`
`87`	`85`	`real_vector.insert(real_vector.begin() + position, value);`
`88`	`86`	`pre_vector.insert(pre_vector.begin() + position, value);`
`89`		`- test();`
`90`	`87`	`}`
`91`	`88`
`92`	`89`	`void insert(Size position, Size count, const T& value) {`
`93`	`90`	`real_vector.insert(real_vector.begin() + position, count, value);`
`94`	`91`	`pre_vector.insert(pre_vector.begin() + position, count, value);`
`95`		`- test();`
`96`	`92`	`}`
`97`	`93`
`98`	`94`	`template<typename I>`
`99`	`95`	`void insert_range(Size position, I first, I last) {`
`100`	`96`	`real_vector.insert(real_vector.begin() + position, first, last);`
`101`	`97`	`pre_vector.insert(pre_vector.begin() + position, first, last);`
`102`		`- test();`
`103`	`98`	`}`
`104`	`99`
`105`	`100`	`void erase(Size position) {`
`106`	`101`	`real_vector.erase(real_vector.begin() + position);`
`107`	`102`	`pre_vector.erase(pre_vector.begin() + position);`
`108`		`- test();`
`109`	`103`	`}`
`110`	`104`
`111`	`105`	`void erase(Size first, Size last) {`
`112`	`106`	`real_vector.erase(real_vector.begin() + first, real_vector.begin() + last);`
`113`	`107`	`pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last);`
`114`		`- test();`
`115`	`108`	`}`
`116`	`109`
`117`	`110`	`void update(Size pos, const T& value) {`
`118`	`111`	`real_vector[pos] = value;`
`119`	`112`	`pre_vector[pos] = value;`
`120`		`- test();`
`121`	`113`	`}`
`122`	`114`
`123`	`115`	`void push_back(const T& value) {`
`124`	`116`	`real_vector.push_back(value);`
`125`	`117`	`pre_vector.push_back(value);`
`126`		`- test();`
`127`	`118`	`}`
`128`	`119`
`129`	`120`	`void pop_back() {`
`130`	`121`	`real_vector.pop_back();`
`131`	`122`	`pre_vector.pop_back();`
`132`		`- test();`
`133`	`123`	`}`
`134`	`124`
`135`	`125`	`void clear() {`
`@@ -152,13 +142,11 @@ class prevector_tester {`
`152`	`142`
`153`	`143`	`void shrink_to_fit() {`
`154`	`144`	`pre_vector.shrink_to_fit();`
`155`		`- test();`
`156`	`145`	`}`
`157`	`146`
`158`	`147`	`void swap() {`
`159`	`148`	`real_vector.swap(real_vector_alt);`
`160`	`149`	`pre_vector.swap(pre_vector_alt);`
`161`		`- test();`
`162`	`150`	`}`
`163`	`151`
`164`	`152`	`void move() {`
`@@ -190,7 +178,6 @@ class prevector_tester {`
`190`	`178`	`pre_vector[p] = v;`
`191`	`179`	`++p;`
`192`	`180`	`}`
`193`		`- test();`
`194`	`181`	`}`
`195`	`182`	`};`
`196`	`183`
`@@ -277,4 +264,6 @@ void test_one_input(const std::vector<uint8_t>& buffer)`
`277`	`264`	`}`
`278`	`265`	`}`
`279`	`266`	`}`
	`267`	`+`
	`268`	`+ test.test();`
`280`	`269`	`}`