调整ut

mutouyun · mutouyun · commit 94ad05ce3540 · 2021-09-18T00:11:11.000+08:00
diff --git a/test/test_ipc.cpp b/test/test_ipc.cpp
@@ -109,10 +109,10 @@ void test_sr(char const * name, int s_cnt, int r_cnt) {
     for (int k = 0; k < s_cnt; ++k) {
         ipc_ut::sender() << [name, &sw, r_cnt, k] {
             Que que { name, ipc::sender };
-            EXPECT_TRUE(que.wait_for_recv(r_cnt));
+            ASSERT_TRUE(que.wait_for_recv(r_cnt));
             sw.start();
             for (int i = 0; i < (int)data_set__.get().size(); ++i) {
-                EXPECT_TRUE(que.send(data_set__.get()[i]));
+                ASSERT_TRUE(que.send(data_set__.get()[i]));
             }
         };
     }
@@ -132,15 +132,15 @@ void test_sr(char const * name, int s_cnt, int r_cnt) {
                 if (data_set != got) {
                     printf("data_set__.get()[%d] != got, size = %zd/%zd\n", 
                             i, data_set.size(), got.size());
-                    EXPECT_TRUE(false);
+                    ASSERT_TRUE(false);
                 }
             }
         };
     }
 
     ipc_ut::sender().wait_for_done();
     Que que { name };
-    EXPECT_TRUE(que.wait_for_recv(r_cnt));
+    ASSERT_TRUE(que.wait_for_recv(r_cnt));
     for (int k = 0; k < r_cnt; ++k) {
         que.send(rand_buf{msg_head{-1}});
     }
diff --git a/test/test_queue.cpp b/test/test_queue.cpp
@@ -103,7 +103,7 @@ void test_sr(elems_t<Rp, Rc, Ts> && elems, int s_cnt, int r_cnt, char const * me
             queue_t<Rp, Rc, Ts> que { &elems };
             ASSERT_TRUE(que.connect());
             while (pop(que).pid_ >= 0) ;
-            EXPECT_TRUE(que.disconnect());
+            ASSERT_TRUE(que.disconnect());
         };
     }
 
@@ -133,34 +133,34 @@ TEST(Queue, el_connection) {
         elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;
         EXPECT_TRUE(el.connect_sender());
         for (std::size_t i = 0; i < 10000; ++i) {
-            EXPECT_FALSE(el.connect_sender());
+            ASSERT_FALSE(el.connect_sender());
         }
         el.disconnect_sender();
         EXPECT_TRUE(el.connect_sender());
     }
     {
         elems_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::unicast> el;
         for (std::size_t i = 0; i < 10000; ++i) {
-            EXPECT_TRUE(el.connect_sender());
+            ASSERT_TRUE(el.connect_sender());
         }
     }
     {
         elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;
         auto cc = el.connect_receiver();
         EXPECT_NE(cc, 0);
         for (std::size_t i = 0; i < 10000; ++i) {
-            EXPECT_EQ(el.connect_receiver(), 0);
+            ASSERT_EQ(el.connect_receiver(), 0);
         }
         EXPECT_EQ(el.disconnect_receiver(cc), 0);
         EXPECT_EQ(el.connect_receiver(), cc);
     }
     {
         elems_t<ipc::relat::single, ipc::relat::multi, ipc::trans::broadcast> el;
         for (std::size_t i = 0; i < (sizeof(ipc::circ::cc_t) * CHAR_BIT); ++i) {
-            EXPECT_NE(el.connect_receiver(), 0);
+            ASSERT_NE(el.connect_receiver(), 0);
         }
         for (std::size_t i = 0; i < 10000; ++i) {
-            EXPECT_EQ(el.connect_receiver(), 0);
+            ASSERT_EQ(el.connect_receiver(), 0);
         }
     }
 }
@@ -171,11 +171,11 @@ TEST(Queue, connection) {
         queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
         // sending
         for (std::size_t i = 0; i < 10000; ++i) {
-            EXPECT_TRUE(que.ready_sending());
+            ASSERT_TRUE(que.ready_sending());
         }
         for (std::size_t i = 0; i < 10000; ++i) {
             queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
-            EXPECT_FALSE(que.ready_sending());
+            ASSERT_FALSE(que.ready_sending());
         }
         for (std::size_t i = 0; i < 10000; ++i) {
             que.shut_sending();
@@ -186,66 +186,66 @@ TEST(Queue, connection) {
         }
         // receiving
         for (std::size_t i = 0; i < 10000; ++i) {
-            EXPECT_TRUE(que.connect());
+            ASSERT_TRUE(que.connect());
         }
         for (std::size_t i = 0; i < 10000; ++i) {
             queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
-            EXPECT_FALSE(que.connect());
+            ASSERT_FALSE(que.connect());
         }
         EXPECT_TRUE(que.disconnect());
         for (std::size_t i = 0; i < 10000; ++i) {
-            EXPECT_FALSE(que.disconnect());
+            ASSERT_FALSE(que.disconnect());
         }
         {
             queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
             EXPECT_TRUE(que.connect());
         }
         for (std::size_t i = 0; i < 10000; ++i) {
             queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};
-            EXPECT_FALSE(que.connect());
+            ASSERT_FALSE(que.connect());
         }
     }
     {
         elems_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> el;
         queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
         // sending
         for (std::size_t i = 0; i < 10000; ++i) {
-            EXPECT_TRUE(que.ready_sending());
+            ASSERT_TRUE(que.ready_sending());
         }
         for (std::size_t i = 0; i < 10000; ++i) {
             queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
-            EXPECT_TRUE(que.ready_sending());
+            ASSERT_TRUE(que.ready_sending());
         }
         for (std::size_t i = 0; i < 10000; ++i) {
             que.shut_sending();
         }
         for (std::size_t i = 0; i < 10000; ++i) {
             queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
-            EXPECT_TRUE(que.ready_sending());
+            ASSERT_TRUE(que.ready_sending());
         }
         // receiving
         for (std::size_t i = 0; i < 10000; ++i) {
-            EXPECT_TRUE(que.connect());
+            ASSERT_TRUE(que.connect());
         }
         for (std::size_t i = 1; i < (sizeof(ipc::circ::cc_t) * CHAR_BIT); ++i) {
             queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
-            EXPECT_TRUE(que.connect());
+            ASSERT_TRUE(que.connect());
         }
         for (std::size_t i = 0; i < 10000; ++i) {
             queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
-            EXPECT_FALSE(que.connect());
+            ASSERT_FALSE(que.connect());
         }
-        EXPECT_TRUE(que.disconnect());
+        ASSERT_TRUE(que.disconnect());
         for (std::size_t i = 0; i < 10000; ++i) {
-            EXPECT_FALSE(que.disconnect());
+            ASSERT_FALSE(que.disconnect());
         }
         {
             queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
-            EXPECT_TRUE(que.connect());
+            ASSERT_TRUE(que.connect());
         }
         for (std::size_t i = 0; i < 10000; ++i) {
             queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};
-            EXPECT_FALSE(que.connect());
+            ASSERT_FALSE(que.connect());
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -109,10 +109,10 @@ void test_sr(char const * name, int s_cnt, int r_cnt) {`
`109`	`109`	`for (int k = 0; k < s_cnt; ++k) {`
`110`	`110`	`ipc_ut::sender() << [name, &sw, r_cnt, k] {`
`111`	`111`	`Que que { name, ipc::sender };`
`112`		`- EXPECT_TRUE(que.wait_for_recv(r_cnt));`
	`112`	`+ ASSERT_TRUE(que.wait_for_recv(r_cnt));`
`113`	`113`	`sw.start();`
`114`	`114`	`for (int i = 0; i < (int)data_set__.get().size(); ++i) {`
`115`		`- EXPECT_TRUE(que.send(data_set__.get()[i]));`
	`115`	`+ ASSERT_TRUE(que.send(data_set__.get()[i]));`
`116`	`116`	`}`
`117`	`117`	`};`
`118`	`118`	`}`
`@@ -132,15 +132,15 @@ void test_sr(char const * name, int s_cnt, int r_cnt) {`
`132`	`132`	`if (data_set != got) {`
`133`	`133`	`printf("data_set__.get()[%d] != got, size = %zd/%zd\n",`
`134`	`134`	`i, data_set.size(), got.size());`
`135`		`- EXPECT_TRUE(false);`
	`135`	`+ ASSERT_TRUE(false);`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`	`};`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`ipc_ut::sender().wait_for_done();`
`142`	`142`	`Que que { name };`
`143`		`- EXPECT_TRUE(que.wait_for_recv(r_cnt));`
	`143`	`+ ASSERT_TRUE(que.wait_for_recv(r_cnt));`
`144`	`144`	`for (int k = 0; k < r_cnt; ++k) {`
`145`	`145`	`que.send(rand_buf{msg_head{-1}});`
`146`	`146`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ void test_sr(elems_t<Rp, Rc, Ts> && elems, int s_cnt, int r_cnt, char const * me`
`103`	`103`	`queue_t<Rp, Rc, Ts> que { &elems };`
`104`	`104`	`ASSERT_TRUE(que.connect());`
`105`	`105`	`while (pop(que).pid_ >= 0) ;`
`106`		`- EXPECT_TRUE(que.disconnect());`
	`106`	`+ ASSERT_TRUE(que.disconnect());`
`107`	`107`	`};`
`108`	`108`	`}`
`109`	`109`
`@@ -133,34 +133,34 @@ TEST(Queue, el_connection) {`
`133`	`133`	`elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;`
`134`	`134`	`EXPECT_TRUE(el.connect_sender());`
`135`	`135`	`for (std::size_t i = 0; i < 10000; ++i) {`
`136`		`- EXPECT_FALSE(el.connect_sender());`
	`136`	`+ ASSERT_FALSE(el.connect_sender());`
`137`	`137`	`}`
`138`	`138`	`el.disconnect_sender();`
`139`	`139`	`EXPECT_TRUE(el.connect_sender());`
`140`	`140`	`}`
`141`	`141`	`{`
`142`	`142`	`elems_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::unicast> el;`
`143`	`143`	`for (std::size_t i = 0; i < 10000; ++i) {`
`144`		`- EXPECT_TRUE(el.connect_sender());`
	`144`	`+ ASSERT_TRUE(el.connect_sender());`
`145`	`145`	`}`
`146`	`146`	`}`
`147`	`147`	`{`
`148`	`148`	`elems_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> el;`
`149`	`149`	`auto cc = el.connect_receiver();`
`150`	`150`	`EXPECT_NE(cc, 0);`
`151`	`151`	`for (std::size_t i = 0; i < 10000; ++i) {`
`152`		`- EXPECT_EQ(el.connect_receiver(), 0);`
	`152`	`+ ASSERT_EQ(el.connect_receiver(), 0);`
`153`	`153`	`}`
`154`	`154`	`EXPECT_EQ(el.disconnect_receiver(cc), 0);`
`155`	`155`	`EXPECT_EQ(el.connect_receiver(), cc);`
`156`	`156`	`}`
`157`	`157`	`{`
`158`	`158`	`elems_t<ipc::relat::single, ipc::relat::multi, ipc::trans::broadcast> el;`
`159`	`159`	`for (std::size_t i = 0; i < (sizeof(ipc::circ::cc_t) * CHAR_BIT); ++i) {`
`160`		`- EXPECT_NE(el.connect_receiver(), 0);`
	`160`	`+ ASSERT_NE(el.connect_receiver(), 0);`
`161`	`161`	`}`
`162`	`162`	`for (std::size_t i = 0; i < 10000; ++i) {`
`163`		`- EXPECT_EQ(el.connect_receiver(), 0);`
	`163`	`+ ASSERT_EQ(el.connect_receiver(), 0);`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`	`}`
`@@ -171,11 +171,11 @@ TEST(Queue, connection) {`
`171`	`171`	`queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};`
`172`	`172`	`// sending`
`173`	`173`	`for (std::size_t i = 0; i < 10000; ++i) {`
`174`		`- EXPECT_TRUE(que.ready_sending());`
	`174`	`+ ASSERT_TRUE(que.ready_sending());`
`175`	`175`	`}`
`176`	`176`	`for (std::size_t i = 0; i < 10000; ++i) {`
`177`	`177`	`queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};`
`178`		`- EXPECT_FALSE(que.ready_sending());`
	`178`	`+ ASSERT_FALSE(que.ready_sending());`
`179`	`179`	`}`
`180`	`180`	`for (std::size_t i = 0; i < 10000; ++i) {`
`181`	`181`	`que.shut_sending();`
`@@ -186,66 +186,66 @@ TEST(Queue, connection) {`
`186`	`186`	`}`
`187`	`187`	`// receiving`
`188`	`188`	`for (std::size_t i = 0; i < 10000; ++i) {`
`189`		`- EXPECT_TRUE(que.connect());`
	`189`	`+ ASSERT_TRUE(que.connect());`
`190`	`190`	`}`
`191`	`191`	`for (std::size_t i = 0; i < 10000; ++i) {`
`192`	`192`	`queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};`
`193`		`- EXPECT_FALSE(que.connect());`
	`193`	`+ ASSERT_FALSE(que.connect());`
`194`	`194`	`}`
`195`	`195`	`EXPECT_TRUE(que.disconnect());`
`196`	`196`	`for (std::size_t i = 0; i < 10000; ++i) {`
`197`		`- EXPECT_FALSE(que.disconnect());`
	`197`	`+ ASSERT_FALSE(que.disconnect());`
`198`	`198`	`}`
`199`	`199`	`{`
`200`	`200`	`queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};`
`201`	`201`	`EXPECT_TRUE(que.connect());`
`202`	`202`	`}`
`203`	`203`	`for (std::size_t i = 0; i < 10000; ++i) {`
`204`	`204`	`queue_t<ipc::relat::single, ipc::relat::single, ipc::trans::unicast> que{&el};`
`205`		`- EXPECT_FALSE(que.connect());`
	`205`	`+ ASSERT_FALSE(que.connect());`
`206`	`206`	`}`
`207`	`207`	`}`
`208`	`208`	`{`
`209`	`209`	`elems_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> el;`
`210`	`210`	`queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};`
`211`	`211`	`// sending`
`212`	`212`	`for (std::size_t i = 0; i < 10000; ++i) {`
`213`		`- EXPECT_TRUE(que.ready_sending());`
	`213`	`+ ASSERT_TRUE(que.ready_sending());`
`214`	`214`	`}`
`215`	`215`	`for (std::size_t i = 0; i < 10000; ++i) {`
`216`	`216`	`queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};`
`217`		`- EXPECT_TRUE(que.ready_sending());`
	`217`	`+ ASSERT_TRUE(que.ready_sending());`
`218`	`218`	`}`
`219`	`219`	`for (std::size_t i = 0; i < 10000; ++i) {`
`220`	`220`	`que.shut_sending();`
`221`	`221`	`}`
`222`	`222`	`for (std::size_t i = 0; i < 10000; ++i) {`
`223`	`223`	`queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};`
`224`		`- EXPECT_TRUE(que.ready_sending());`
	`224`	`+ ASSERT_TRUE(que.ready_sending());`
`225`	`225`	`}`
`226`	`226`	`// receiving`
`227`	`227`	`for (std::size_t i = 0; i < 10000; ++i) {`
`228`		`- EXPECT_TRUE(que.connect());`
	`228`	`+ ASSERT_TRUE(que.connect());`
`229`	`229`	`}`
`230`	`230`	`for (std::size_t i = 1; i < (sizeof(ipc::circ::cc_t) * CHAR_BIT); ++i) {`
`231`	`231`	`queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};`
`232`		`- EXPECT_TRUE(que.connect());`
	`232`	`+ ASSERT_TRUE(que.connect());`
`233`	`233`	`}`
`234`	`234`	`for (std::size_t i = 0; i < 10000; ++i) {`
`235`	`235`	`queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};`
`236`		`- EXPECT_FALSE(que.connect());`
	`236`	`+ ASSERT_FALSE(que.connect());`
`237`	`237`	`}`
`238`		`- EXPECT_TRUE(que.disconnect());`
	`238`	`+ ASSERT_TRUE(que.disconnect());`
`239`	`239`	`for (std::size_t i = 0; i < 10000; ++i) {`
`240`		`- EXPECT_FALSE(que.disconnect());`
	`240`	`+ ASSERT_FALSE(que.disconnect());`
`241`	`241`	`}`
`242`	`242`	`{`
`243`	`243`	`queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};`
`244`		`- EXPECT_TRUE(que.connect());`
	`244`	`+ ASSERT_TRUE(que.connect());`
`245`	`245`	`}`
`246`	`246`	`for (std::size_t i = 0; i < 10000; ++i) {`
`247`	`247`	`queue_t<ipc::relat::multi, ipc::relat::multi, ipc::trans::broadcast> que{&el};`
`248`		`- EXPECT_FALSE(que.connect());`
	`248`	`+ ASSERT_FALSE(que.connect());`
`249`	`249`	`}`
`250`	`250`	`}`
`251`	`251`	`}`