This is an automated email from the ASF dual-hosted git repository. granthenke pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/kudu.git
commit 344f635b7bd47d609502ed64a1aec74e72c88619 Author: honeyhexin <[email protected]> AuthorDate: Tue Aug 6 13:29:43 2019 +0800 [code style] Keep same code style in test files Change all ASSERT_NO_FATAL_FAILURE to NO_FATALS to keep the same code style in test files. In addition, delete out-of-date logic in client-test. Change-Id: I67689fe8113d88f60ac33fa38504813128209da3 Reviewed-on: http://gerrit.cloudera.org:8080/14016 Reviewed-by: Adar Dembo <[email protected]> Tested-by: Kudu Jenkins --- src/kudu/cfile/bloomfile-test.cc | 6 +- src/kudu/cfile/mt-bloomfile-test.cc | 2 +- src/kudu/client/client-test.cc | 167 +++++++++------------ src/kudu/common/wire_protocol-test.cc | 2 +- src/kudu/consensus/consensus_queue-test.cc | 10 +- src/kudu/consensus/leader_election-test.cc | 52 +++---- src/kudu/consensus/mt-log-test.cc | 6 +- src/kudu/consensus/raft_consensus_quorum-test.cc | 22 +-- src/kudu/fs/block_manager-test.cc | 20 +-- src/kudu/integration-tests/alter_table-test.cc | 4 +- .../integration-tests/create-table-stress-test.cc | 6 +- src/kudu/integration-tests/linked_list-test.cc | 8 +- .../integration-tests/master_failover-itest.cc | 2 +- src/kudu/integration-tests/registration-test.cc | 2 +- .../update_scan_delta_compact-test.cc | 8 +- src/kudu/master/master-test.cc | 8 +- src/kudu/rpc/rpc-test.cc | 10 +- src/kudu/tablet/compaction-test.cc | 28 ++-- src/kudu/tablet/composite-pushdown-test.cc | 30 ++-- src/kudu/tablet/major_delta_compaction-test.cc | 64 ++++---- src/kudu/tablet/mt-rowset_delta_compaction-test.cc | 4 +- src/kudu/tablet/tablet_random_access-test.cc | 3 +- src/kudu/tserver/tablet_server-test.cc | 58 +++---- src/kudu/tserver/ts_tablet_manager-test.cc | 4 +- src/kudu/util/env-test.cc | 20 +-- src/kudu/util/trace-test.cc | 2 +- 26 files changed, 261 insertions(+), 287 deletions(-) diff --git a/src/kudu/cfile/bloomfile-test.cc b/src/kudu/cfile/bloomfile-test.cc index 56bb694..10a6e4c 100644 --- a/src/kudu/cfile/bloomfile-test.cc +++ b/src/kudu/cfile/bloomfile-test.cc @@ -81,14 +81,14 @@ class BloomFileTest : public BloomFileTestBase { TEST_F(BloomFileTest, TestWriteAndRead) { - ASSERT_NO_FATAL_FAILURE(WriteTestBloomFile()); + NO_FATALS(WriteTestBloomFile()); ASSERT_OK(OpenBloomFile()); VerifyBloomFile(); } #ifdef NDEBUG TEST_F(BloomFileTest, Benchmark) { - ASSERT_NO_FATAL_FAILURE(WriteTestBloomFile()); + NO_FATALS(WriteTestBloomFile()); ASSERT_OK(OpenBloomFile()); uint64_t count_present = ReadBenchmark(); @@ -108,7 +108,7 @@ TEST_F(BloomFileTest, Benchmark) { #endif TEST_F(BloomFileTest, TestLazyInit) { - ASSERT_NO_FATAL_FAILURE(WriteTestBloomFile()); + NO_FATALS(WriteTestBloomFile()); shared_ptr<MemTracker> tracker = MemTracker::CreateTracker(-1, "test"); int64_t initial_mem_usage = tracker->consumption(); diff --git a/src/kudu/cfile/mt-bloomfile-test.cc b/src/kudu/cfile/mt-bloomfile-test.cc index 76aada1..940be0f 100644 --- a/src/kudu/cfile/mt-bloomfile-test.cc +++ b/src/kudu/cfile/mt-bloomfile-test.cc @@ -40,7 +40,7 @@ class MTBloomFileTest : public BloomFileTestBase { }; TEST_F(MTBloomFileTest, Benchmark) { - ASSERT_NO_FATAL_FAILURE(WriteTestBloomFile()); + NO_FATALS(WriteTestBloomFile()); ASSERT_OK(OpenBloomFile()); std::vector<scoped_refptr<kudu::Thread> > threads; diff --git a/src/kudu/client/client-test.cc b/src/kudu/client/client-test.cc index 290380e..ac7b6c1 100644 --- a/src/kudu/client/client-test.cc +++ b/src/kudu/client/client-test.cc @@ -210,7 +210,7 @@ class ClientTest : public KuduTest { .add_master_server_addr(cluster_->mini_master()->bound_rpc_addr().ToString()) .Build(&client_)); - ASSERT_NO_FATAL_FAILURE(CreateTable(kTableName, 1, GenerateSplitRows(), {}, &client_table_)); + NO_FATALS(CreateTable(kTableName, 1, GenerateSplitRows(), {}, &client_table_)); } void TearDown() override { @@ -356,10 +356,9 @@ class ClientTest : public KuduTest { shared_ptr<KuduSession> session = client->NewSession(); ASSERT_OK(session->SetFlushMode(KuduSession::AUTO_FLUSH_BACKGROUND)); session->SetTimeoutMillis(60000); - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table, session.get(), - num_rows, first_row)); + NO_FATALS(InsertTestRows(table, session.get(), num_rows, first_row)); FlushSessionOrDie(session); - ASSERT_NO_FATAL_FAILURE(CheckNoRpcOverflow()); + NO_FATALS(CheckNoRpcOverflow()); } // Inserts 'num_rows' using the default client. @@ -376,7 +375,7 @@ class ClientTest : public KuduTest { ASSERT_OK(session->Apply(update.release())); } FlushSessionOrDie(session); - ASSERT_NO_FATAL_FAILURE(CheckNoRpcOverflow()); + NO_FATALS(CheckNoRpcOverflow()); } void DeleteTestRows(KuduTable* table, int lo, int hi) { @@ -388,7 +387,7 @@ class ClientTest : public KuduTest { ASSERT_OK(session->Apply(del.release())) } FlushSessionOrDie(session); - ASSERT_NO_FATAL_FAILURE(CheckNoRpcOverflow()); + NO_FATALS(CheckNoRpcOverflow()); } unique_ptr<KuduInsert> BuildTestRow(KuduTable* table, int index) { @@ -853,8 +852,7 @@ TEST_F(ClientTest, TestRandomizedLimitScans) { FLAGS_flush_threshold_secs = 1; FLAGS_scanner_batch_size_rows = batch_size; - ASSERT_NO_FATAL_FAILURE(InsertTestRows( - client_table_.get(), num_rows)); + NO_FATALS(InsertTestRows(client_table_.get(), num_rows)); SleepFor(MonoDelta::FromSeconds(1)); LOG(INFO) << Substitute("Total number of rows: $0, batch size: $1", num_rows, batch_size); @@ -892,8 +890,7 @@ TEST_F(ClientTest, TestRandomizedLimitScans) { } TEST_F(ClientTest, TestScan) { - ASSERT_NO_FATAL_FAILURE(InsertTestRows( - client_table_.get(), FLAGS_test_scan_num_rows)); + NO_FATALS(InsertTestRows(client_table_.get(), FLAGS_test_scan_num_rows)); ASSERT_EQ(FLAGS_test_scan_num_rows, CountRowsFromClient(client_table_.get())); @@ -925,8 +922,7 @@ TEST_F(ClientTest, TestScanAtSnapshot) { int half_the_rows = FLAGS_test_scan_num_rows / 2; // Insert half the rows - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), - half_the_rows)); + NO_FATALS(InsertTestRows(client_table_.get(), half_the_rows)); // Get the time from the server and transform to micros, disregarding any // logical values (we shouldn't have any with a single server anyway). @@ -934,8 +930,7 @@ TEST_F(ClientTest, TestScanAtSnapshot) { cluster_->mini_tablet_server(0)->server()->clock()->Now()); // Insert the second half of the rows - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), - half_the_rows, half_the_rows)); + NO_FATALS(InsertTestRows(client_table_.get(), half_the_rows, half_the_rows)); KuduScanner scanner(client_table_.get()); ASSERT_OK(scanner.Open()); @@ -1014,8 +1009,8 @@ TEST_P(ScanMultiTabletParamTest, Test) { ASSERT_OK(row->SetInt32(0, i * kRowsPerTablet)); rows.emplace_back(std::move(row)); } - ASSERT_NO_FATAL_FAILURE(CreateTable("TestScanMultiTablet", 1, - std::move(rows), {}, &table)); + NO_FATALS(CreateTable("TestScanMultiTablet", 1, + std::move(rows), {}, &table)); } // Insert rows with keys 12, 13, 15, 17, 22, 23, 25, 27...47 into each @@ -1142,8 +1137,7 @@ TEST_F(ClientTest, TestScanEmptyTable) { // row block with the proper number of rows filled in. Impala issues // scans like this in order to implement COUNT(*). TEST_F(ClientTest, TestScanEmptyProjection) { - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), - FLAGS_test_scan_num_rows)); + NO_FATALS(InsertTestRows(client_table_.get(), FLAGS_test_scan_num_rows)); KuduScanner scanner(client_table_.get()); ASSERT_OK(scanner.SetProjectedColumnNames({})); ASSERT_EQ(scanner.GetProjectionSchema().num_columns(), 0); @@ -1177,8 +1171,7 @@ TEST_F(ClientTest, TestProjectInvalidColumn) { // Test a scan where we have a predicate on a key column that is not // in the projection. TEST_F(ClientTest, TestScanPredicateKeyColNotProjected) { - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), - FLAGS_test_scan_num_rows)); + NO_FATALS(InsertTestRows(client_table_.get(), FLAGS_test_scan_num_rows)); KuduScanner scanner(client_table_.get()); ASSERT_OK(scanner.SetProjectedColumnNames({ "int_val" })); ASSERT_EQ(scanner.GetProjectionSchema().num_columns(), 1); @@ -1214,8 +1207,7 @@ TEST_F(ClientTest, TestScanPredicateKeyColNotProjected) { // Test a scan where we have a predicate on a non-key column that is // not in the projection. TEST_F(ClientTest, TestScanPredicateNonKeyColNotProjected) { - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), - FLAGS_test_scan_num_rows)); + NO_FATALS(InsertTestRows(client_table_.get(), FLAGS_test_scan_num_rows)); KuduScanner scanner(client_table_.get()); ASSERT_OK(scanner.AddConjunctPredicate( client_table_->NewComparisonPredicate("int_val", KuduPredicate::GREATER_EQUAL, @@ -1286,7 +1278,7 @@ TEST_F(ClientTest, TestInvalidPredicates) { TEST_F(ClientTest, TestScanCloseProxy) { const string kEmptyTable = "TestScanCloseProxy"; shared_ptr<KuduTable> table; - ASSERT_NO_FATAL_FAILURE(CreateTable(kEmptyTable, 3, GenerateSplitRows(), {}, &table)); + NO_FATALS(CreateTable(kEmptyTable, 3, GenerateSplitRows(), {}, &table)); { // Open and close an empty scanner. @@ -1297,8 +1289,7 @@ TEST_F(ClientTest, TestScanCloseProxy) { } // Insert some test rows. - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), - FLAGS_test_scan_num_rows)); + NO_FATALS(InsertTestRows(table.get(), FLAGS_test_scan_num_rows)); { // Open and close a scanner with rows. KuduScanner scanner(table.get()); @@ -1329,8 +1320,7 @@ TEST_F(ClientTest, TestRowPtrNoRedaction) { TEST_F(ClientTest, TestScanYourWrites) { // Insert the rows - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), - FLAGS_test_scan_num_rows)); + NO_FATALS(InsertTestRows(client_table_.get(), FLAGS_test_scan_num_rows)); // Verify that no matter which replica is selected, client could // achieve read-your-writes/read-your-reads. @@ -1428,8 +1418,8 @@ TEST_F(ClientTest, TestScanFaultTolerance) { FLAGS_leader_failure_exp_backoff_max_delta_ms = 1000; const int kNumReplicas = 3; - ASSERT_NO_FATAL_FAILURE(CreateTable(kScanTable, kNumReplicas, {}, {}, &table)); - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), FLAGS_test_scan_num_rows)); + NO_FATALS(CreateTable(kScanTable, kNumReplicas, {}, {}, &table)); + NO_FATALS(InsertTestRows(table.get(), FLAGS_test_scan_num_rows)); // Do an initial scan to determine the expected rows for later verification. vector<string> expected_rows; @@ -1455,14 +1445,14 @@ TEST_F(ClientTest, TestScanFaultTolerance) { // Restarting and waiting should result in a SCANNER_EXPIRED error. LOG(INFO) << "Doing a scan while restarting a tserver and waiting for it to come up..."; - ASSERT_NO_FATAL_FAILURE(internal::DoScanWithCallback(table.get(), expected_rows, limit, + NO_FATALS(internal::DoScanWithCallback(table.get(), expected_rows, limit, boost::bind(&ClientTest_TestScanFaultTolerance_Test::RestartTServerAndWait, this, _1))); // Restarting and not waiting means the tserver is hopefully bootstrapping, leading to // a TABLET_NOT_RUNNING error. LOG(INFO) << "Doing a scan while restarting a tserver..."; - ASSERT_NO_FATAL_FAILURE(internal::DoScanWithCallback(table.get(), expected_rows, limit, + NO_FATALS(internal::DoScanWithCallback(table.get(), expected_rows, limit, boost::bind(&ClientTest_TestScanFaultTolerance_Test::RestartTServerAsync, this, _1))); for (int i = 0; i < cluster_->num_tablet_servers(); i++) { @@ -1472,7 +1462,7 @@ TEST_F(ClientTest, TestScanFaultTolerance) { // Killing the tserver should lead to an RPC timeout. LOG(INFO) << "Doing a scan while killing a tserver..."; - ASSERT_NO_FATAL_FAILURE(internal::DoScanWithCallback(table.get(), expected_rows, limit, + NO_FATALS(internal::DoScanWithCallback(table.get(), expected_rows, limit, boost::bind(&ClientTest_TestScanFaultTolerance_Test::KillTServer, this, _1))); @@ -1497,8 +1487,8 @@ TEST_F(ClientTest, TestNonFaultTolerantScannerExpired) { shared_ptr<KuduTable> table; const int kNumReplicas = 1; - ASSERT_NO_FATAL_FAILURE(CreateTable(kScanTable, kNumReplicas, {}, {}, &table)); - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), FLAGS_test_scan_num_rows)); + NO_FATALS(CreateTable(kScanTable, kNumReplicas, {}, {}, &table)); + NO_FATALS(InsertTestRows(table.get(), FLAGS_test_scan_num_rows)); KuduScanner scanner(table.get()); ASSERT_OK(scanner.SetTimeoutMillis(30 * 1000)); @@ -1560,11 +1550,11 @@ TEST_F(ClientTest, TestNonCoveringRangePartitions) { // Aggresively clear the meta cache between insert batches so that the meta // cache will execute GetTableLocation RPCs at different partition keys. - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), 50, 0)); + NO_FATALS(InsertTestRows(table.get(), 50, 0)); client_->data_->meta_cache_->ClearCache(); - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), 50, 50)); + NO_FATALS(InsertTestRows(table.get(), 50, 50)); client_->data_->meta_cache_->ClearCache(); - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), 100, 200)); + NO_FATALS(InsertTestRows(table.get(), 100, 200)); client_->data_->meta_cache_->ClearCache(); // Insert out-of-range rows. @@ -1770,8 +1760,8 @@ TEST_F(ClientTest, TestExclusiveInclusiveRangeBounds) { ASSERT_OK(alterer->Alter()); ASSERT_OK(client_->OpenTable(table_name, &table)); - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), 100, 0)); - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), 100, 200)); + NO_FATALS(InsertTestRows(table.get(), 100, 0)); + NO_FATALS(InsertTestRows(table.get(), 100, 200)); // Insert out-of-range rows. shared_ptr<KuduSession> session = client_->NewSession(); @@ -1981,11 +1971,11 @@ TEST_F(ClientTest, TestMetaCacheExpiry) { TEST_F(ClientTest, TestGetTabletServerBlacklist) { shared_ptr<KuduTable> table; - ASSERT_NO_FATAL_FAILURE(CreateTable("blacklist", - 3, - GenerateSplitRows(), - {}, - &table)); + NO_FATALS(CreateTable("blacklist", + 3, + GenerateSplitRows(), + {}, + &table)); InsertTestRows(table.get(), 1, 0); // Look up the tablet and its replicas into the metadata cache. @@ -2058,16 +2048,16 @@ TEST_F(ClientTest, TestGetTabletServerBlacklist) { TEST_F(ClientTest, TestScanWithEncodedRangePredicate) { shared_ptr<KuduTable> table; - ASSERT_NO_FATAL_FAILURE(CreateTable("split-table", - 1, /* replicas */ - GenerateSplitRows(), - {}, - &table)); + NO_FATALS(CreateTable("split-table", + 1, /* replicas */ + GenerateSplitRows(), + {}, + &table)); - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), 100)); + NO_FATALS(InsertTestRows(table.get(), 100)); vector<string> all_rows; - ASSERT_NO_FATAL_FAILURE(ScanTableToStrings(table.get(), &all_rows)); + NO_FATALS(ScanTableToStrings(table.get(), &all_rows)); ASSERT_EQ(100, all_rows.size()); unique_ptr<KuduPartialRow> row(table->schema().NewRow()); @@ -2182,7 +2172,7 @@ int64_t SumResults(const KuduScanBatch& batch) { } // anonymous namespace TEST_F(ClientTest, TestScannerKeepAlive) { - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), 1000)); + NO_FATALS(InsertTestRows(client_table_.get(), 1000)); // Set the scanner ttl really low FLAGS_scanner_ttl_ms = 100; // 100 milliseconds // Start a scan but don't get the whole data back @@ -2249,7 +2239,7 @@ TEST_F(ClientTest, TestScannerKeepAlive) { // Test cleanup of scanners on the server side when closed. TEST_F(ClientTest, TestCloseScanner) { - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), 10)); + NO_FATALS(InsertTestRows(client_table_.get(), 10)); const tserver::ScannerManager* manager = cluster_->mini_tablet_server(0)->server()->scanner_manager(); @@ -2301,7 +2291,7 @@ TEST_F(ClientTest, TestScanTimeout) { // Warm the cache so that the subsequent timeout occurs within the scan, // not the lookup. - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), 1)); + NO_FATALS(InsertTestRows(client_table_.get(), 1)); // The "overall operation" timed out; no replicas failed. { @@ -2314,7 +2304,7 @@ TEST_F(ClientTest, TestScanTimeout) { // Insert some more rows so that the scan takes multiple batches, instead of // fetching all the data on the 'Open()' call. - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), 1000, 1)); + NO_FATALS(InsertTestRows(client_table_.get(), 1000, 1)); { google::FlagSaver saver; FLAGS_scanner_max_batch_size_bytes = 100; @@ -4194,17 +4184,17 @@ TEST_F(ClientTest, TestReplicatedMultiTabletTable) { const int kNumReplicas = 3; shared_ptr<KuduTable> table; - ASSERT_NO_FATAL_FAILURE(CreateTable(kReplicatedTable, - kNumReplicas, - GenerateSplitRows(), - {}, - &table)); + NO_FATALS(CreateTable(kReplicatedTable, + kNumReplicas, + GenerateSplitRows(), + {}, + &table)); // Should have no rows to begin with. ASSERT_EQ(0, CountRowsFromClient(table.get())); // Insert some data. - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), kNumRowsToWrite)); + NO_FATALS(InsertTestRows(table.get(), kNumRowsToWrite)); // Should now see the data. ASSERT_EQ(kNumRowsToWrite, CountRowsFromClient(table.get())); @@ -4220,14 +4210,14 @@ TEST_F(ClientTest, TestReplicatedMultiTabletTableFailover) { const int kNumTries = 100; shared_ptr<KuduTable> table; - ASSERT_NO_FATAL_FAILURE(CreateTable(kReplicatedTable, - kNumReplicas, - GenerateSplitRows(), - {}, - &table)); + NO_FATALS(CreateTable(kReplicatedTable, + kNumReplicas, + GenerateSplitRows(), + {}, + &table)); // Insert some data. - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), kNumRowsToWrite)); + NO_FATALS(InsertTestRows(table.get(), kNumRowsToWrite)); // Find the leader of the first tablet. scoped_refptr<internal::RemoteTablet> rt = MetaCacheLookup(table.get(), ""); @@ -4269,24 +4259,16 @@ TEST_F(ClientTest, TestReplicatedMultiTabletTableFailover) { // This test that we can keep writing to a tablet when the leader // tablet dies. -// This currently forces leader promotion through RPC and creates -// a new client afterwards. TEST_F(ClientTest, TestReplicatedTabletWritesWithLeaderElection) { const string kReplicatedTable = "replicated_failover_on_writes"; const int kNumRowsToWrite = 100; const int kNumReplicas = 3; shared_ptr<KuduTable> table; - ASSERT_NO_FATAL_FAILURE(CreateTable(kReplicatedTable, kNumReplicas, {}, {}, &table)); + NO_FATALS(CreateTable(kReplicatedTable, kNumReplicas, {}, {}, &table)); // Insert some data. - ASSERT_NO_FATAL_FAILURE(InsertTestRows(table.get(), kNumRowsToWrite)); - - // TODO: we have to sleep here to make sure that the leader has time to - // propagate the writes to the followers. We can remove this once the - // followers run a leader election on their own and handle advancing - // the commit index. - SleepFor(MonoDelta::FromMilliseconds(1500)); + NO_FATALS(InsertTestRows(table.get(), kNumRowsToWrite)); // Find the leader replica scoped_refptr<internal::RemoteTablet> rt = MetaCacheLookup(table.get(), ""); @@ -4305,16 +4287,10 @@ TEST_F(ClientTest, TestReplicatedTabletWritesWithLeaderElection) { ASSERT_OK(KillTServer(killed_uuid)); LOG(INFO) << "Inserting additional rows..."; - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_.get(), - table.get(), - kNumRowsToWrite, - kNumRowsToWrite)); - - // TODO: we have to sleep here to make sure that the leader has time to - // propagate the writes to the followers. We can remove this once the - // followers run a leader election on their own and handle advancing - // the commit index. - SleepFor(MonoDelta::FromMilliseconds(1500)); + NO_FATALS(InsertTestRows(client_.get(), + table.get(), + kNumRowsToWrite, + kNumRowsToWrite)); LOG(INFO) << "Counting rows..."; ASSERT_EQ(2 * kNumRowsToWrite, CountRowsFromClient(table.get(), @@ -4383,7 +4359,7 @@ TEST_F(ClientTest, TestRandomWriteOperation) { if (i % 50 == 0) { LOG(INFO) << "Correctness test " << i; FlushSessionOrDie(session); - ASSERT_NO_FATAL_FAILURE(CheckCorrectness(&scanner, row, nrows)); + NO_FATALS(CheckCorrectness(&scanner, row, nrows)); LOG(INFO) << "...complete"; } @@ -4420,7 +4396,7 @@ TEST_F(ClientTest, TestRandomWriteOperation) { // And one more time for the last batch. FlushSessionOrDie(session); - ASSERT_NO_FATAL_FAILURE(CheckCorrectness(&scanner, row, nrows)); + NO_FATALS(CheckCorrectness(&scanner, row, nrows)); } // Test whether a batch can handle several mutations in a batch @@ -4485,8 +4461,7 @@ TEST_F(ClientTest, TestSeveralRowMutatesPerBatch) { // rows are inserted. TEST_F(ClientTest, TestMasterLookupPermits) { int initial_value = client_->data_->meta_cache_->master_lookup_sem_.GetValue(); - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), - FLAGS_test_scan_num_rows)); + NO_FATALS(InsertTestRows(client_table_.get(), FLAGS_test_scan_num_rows)); ASSERT_EQ(initial_value, client_->data_->meta_cache_->master_lookup_sem_.GetValue()); } @@ -4950,7 +4925,7 @@ TEST_P(LatestObservedTimestampParamTest, Test) { // Check that a write updates the latest observed timestamp. const uint64_t ts0 = client_->GetLatestObservedTimestamp(); ASSERT_EQ(KuduClient::kNoTimestamp, ts0); - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), 1, 0)); + NO_FATALS(InsertTestRows(client_table_.get(), 1, 0)); const uint64_t ts1 = client_->GetLatestObservedTimestamp(); ASSERT_NE(ts0, ts1); @@ -5067,8 +5042,7 @@ TEST_F(ClientTest, TestReadAtSnapshotNoTimestampSet) { CHECK_OK(row->SetInt32(0, i * kRowsPerTablet)); rows.push_back(std::move(row)); } - ASSERT_NO_FATAL_FAILURE(CreateTable("test_table", 1, - std::move(rows), {}, &table)); + NO_FATALS(CreateTable("test_table", 1, std::move(rows), {}, &table)); // Insert some data into the table, so each tablet would get populated. shared_ptr<KuduSession> session(client_->NewSession()); ASSERT_OK(session->SetFlushMode(KuduSession::MANUAL_FLUSH)); @@ -5435,8 +5409,7 @@ INSTANTIATE_TEST_CASE_P(BinaryColEncodings, ::testing::Values(kPlainBin, kPrefix, kDictionary)); TEST_F(ClientTest, TestClonePredicates) { - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), - 2, 0)); + NO_FATALS(InsertTestRows(client_table_.get(), 2, 0)); unique_ptr<KuduPredicate> predicate(client_table_->NewComparisonPredicate( "key", KuduPredicate::EQUAL, @@ -5593,7 +5566,7 @@ TEST_F(ClientTest, TestBatchScanConstIterator) { { // Insert a few rows const int kRowNum = 2; - ASSERT_NO_FATAL_FAILURE(InsertTestRows(client_table_.get(), kRowNum)); + NO_FATALS(InsertTestRows(client_table_.get(), kRowNum)); KuduScanner scanner(client_table_.get()); ASSERT_OK(scanner.Open()); diff --git a/src/kudu/common/wire_protocol-test.cc b/src/kudu/common/wire_protocol-test.cc index 0317cab..49dc500 100644 --- a/src/kudu/common/wire_protocol-test.cc +++ b/src/kudu/common/wire_protocol-test.cc @@ -579,7 +579,7 @@ TEST_F(WireProtocolTest, TestColumnPredicateInList) { kudu::ColumnPredicate cp = kudu::ColumnPredicate::InList(col1, &values); ColumnPredicatePB pb; - ASSERT_NO_FATAL_FAILURE(ColumnPredicateToPB(cp, &pb)); + NO_FATALS(ColumnPredicateToPB(cp, &pb)); ASSERT_OK(ColumnPredicateFromPB(schema, &arena, pb, &predicate)); ASSERT_EQ(predicate->predicate_type(), PredicateType::InList); diff --git a/src/kudu/consensus/consensus_queue-test.cc b/src/kudu/consensus/consensus_queue-test.cc index 840816c..807681b 100644 --- a/src/kudu/consensus/consensus_queue-test.cc +++ b/src/kudu/consensus/consensus_queue-test.cc @@ -590,11 +590,11 @@ TEST_F(ConsensusQueueTest, TestQueueLoadsOperationsForPeer) { // Now we start tracking the peer, this negotiation round should let // the queue know how far along the peer is. - ASSERT_NO_FATAL_FAILURE(UpdatePeerWatermarkToOp(&request, - &response, - peers_last_op, - MinimumOpId(), - &send_more_immediately)); + NO_FATALS(UpdatePeerWatermarkToOp(&request, + &response, + peers_last_op, + MinimumOpId(), + &send_more_immediately)); // The queue should reply that there are more messages for the peer. ASSERT_TRUE(send_more_immediately); diff --git a/src/kudu/consensus/leader_election-test.cc b/src/kudu/consensus/leader_election-test.cc index f0f7b47..245fb47 100644 --- a/src/kudu/consensus/leader_election-test.cc +++ b/src/kudu/consensus/leader_election-test.cc @@ -495,16 +495,16 @@ TEST_F(VoteCounterTest, TestVoteCounter_EarlyDecision) { { // Start off undecided. VoteCounter counter(kNumVoters, kMajoritySize); - ASSERT_NO_FATAL_FAILURE(AssertUndecided(counter)); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 0, 0)); + NO_FATALS(AssertUndecided(counter)); + NO_FATALS(AssertVoteCount(counter, 0, 0)); ASSERT_FALSE(counter.AreAllVotesIn()); // First yes vote. bool duplicate; ASSERT_OK(counter.RegisterVote(voter_uuids[0], VOTE_GRANTED, &duplicate)); ASSERT_FALSE(duplicate); - ASSERT_NO_FATAL_FAILURE(AssertUndecided(counter)); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 1, 0)); + NO_FATALS(AssertUndecided(counter)); + NO_FATALS(AssertVoteCount(counter, 1, 0)); ASSERT_FALSE(counter.AreAllVotesIn()); // Second yes vote wins it in a configuration of 3. @@ -514,7 +514,7 @@ TEST_F(VoteCounterTest, TestVoteCounter_EarlyDecision) { ElectionVote decision; ASSERT_OK(counter.GetDecision(&decision)); ASSERT_TRUE(decision == VOTE_GRANTED); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 2, 0)); + NO_FATALS(AssertVoteCount(counter, 2, 0)); ASSERT_FALSE(counter.AreAllVotesIn()); } @@ -522,16 +522,16 @@ TEST_F(VoteCounterTest, TestVoteCounter_EarlyDecision) { { // Start off undecided. VoteCounter counter(kNumVoters, kMajoritySize); - ASSERT_NO_FATAL_FAILURE(AssertUndecided(counter)); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 0, 0)); + NO_FATALS(AssertUndecided(counter)); + NO_FATALS(AssertVoteCount(counter, 0, 0)); ASSERT_FALSE(counter.AreAllVotesIn()); // First no vote. bool duplicate; ASSERT_OK(counter.RegisterVote(voter_uuids[0], VOTE_DENIED, &duplicate)); ASSERT_FALSE(duplicate); - ASSERT_NO_FATAL_FAILURE(AssertUndecided(counter)); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 0, 1)); + NO_FATALS(AssertUndecided(counter)); + NO_FATALS(AssertVoteCount(counter, 0, 1)); ASSERT_FALSE(counter.AreAllVotesIn()); // Second no vote loses it in a configuration of 3. @@ -541,7 +541,7 @@ TEST_F(VoteCounterTest, TestVoteCounter_EarlyDecision) { ElectionVote decision; ASSERT_OK(counter.GetDecision(&decision)); ASSERT_TRUE(decision == VOTE_DENIED); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 0, 2)); + NO_FATALS(AssertVoteCount(counter, 0, 2)); ASSERT_FALSE(counter.AreAllVotesIn()); } } @@ -554,23 +554,23 @@ TEST_F(VoteCounterTest, TestVoteCounter_LateDecision) { // Start off undecided. VoteCounter counter(kNumVoters, kMajoritySize); - ASSERT_NO_FATAL_FAILURE(AssertUndecided(counter)); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 0, 0)); + NO_FATALS(AssertUndecided(counter)); + NO_FATALS(AssertVoteCount(counter, 0, 0)); ASSERT_FALSE(counter.AreAllVotesIn()); // Add single yes vote, still undecided. bool duplicate; ASSERT_OK(counter.RegisterVote(voter_uuids[0], VOTE_GRANTED, &duplicate)); ASSERT_FALSE(duplicate); - ASSERT_NO_FATAL_FAILURE(AssertUndecided(counter)); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 1, 0)); + NO_FATALS(AssertUndecided(counter)); + NO_FATALS(AssertVoteCount(counter, 1, 0)); ASSERT_FALSE(counter.AreAllVotesIn()); // Attempt duplicate vote. ASSERT_OK(counter.RegisterVote(voter_uuids[0], VOTE_GRANTED, &duplicate)); ASSERT_TRUE(duplicate); - ASSERT_NO_FATAL_FAILURE(AssertUndecided(counter)); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 1, 0)); + NO_FATALS(AssertUndecided(counter)); + NO_FATALS(AssertVoteCount(counter, 1, 0)); ASSERT_FALSE(counter.AreAllVotesIn()); // Attempt to change vote. @@ -578,27 +578,27 @@ TEST_F(VoteCounterTest, TestVoteCounter_LateDecision) { ASSERT_TRUE(s.IsInvalidArgument()); ASSERT_STR_CONTAINS(s.ToString(), "voted a different way twice"); LOG(INFO) << "Expected vote-changed error: " << s.ToString(); - ASSERT_NO_FATAL_FAILURE(AssertUndecided(counter)); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 1, 0)); + NO_FATALS(AssertUndecided(counter)); + NO_FATALS(AssertVoteCount(counter, 1, 0)); ASSERT_FALSE(counter.AreAllVotesIn()); // Add more votes... ASSERT_OK(counter.RegisterVote(voter_uuids[1], VOTE_DENIED, &duplicate)); ASSERT_FALSE(duplicate); - ASSERT_NO_FATAL_FAILURE(AssertUndecided(counter)); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 1, 1)); + NO_FATALS(AssertUndecided(counter)); + NO_FATALS(AssertVoteCount(counter, 1, 1)); ASSERT_FALSE(counter.AreAllVotesIn()); ASSERT_OK(counter.RegisterVote(voter_uuids[2], VOTE_GRANTED, &duplicate)); ASSERT_FALSE(duplicate); - ASSERT_NO_FATAL_FAILURE(AssertUndecided(counter)); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 2, 1)); + NO_FATALS(AssertUndecided(counter)); + NO_FATALS(AssertVoteCount(counter, 2, 1)); ASSERT_FALSE(counter.AreAllVotesIn()); ASSERT_OK(counter.RegisterVote(voter_uuids[3], VOTE_DENIED, &duplicate)); ASSERT_FALSE(duplicate); - ASSERT_NO_FATAL_FAILURE(AssertUndecided(counter)); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 2, 2)); + NO_FATALS(AssertUndecided(counter)); + NO_FATALS(AssertVoteCount(counter, 2, 2)); ASSERT_FALSE(counter.AreAllVotesIn()); // Win the election. @@ -608,7 +608,7 @@ TEST_F(VoteCounterTest, TestVoteCounter_LateDecision) { ElectionVote decision; ASSERT_OK(counter.GetDecision(&decision)); ASSERT_TRUE(decision == VOTE_GRANTED); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 3, 2)); + NO_FATALS(AssertVoteCount(counter, 3, 2)); ASSERT_TRUE(counter.AreAllVotesIn()); // Attempt to vote with > the whole configuration. @@ -617,7 +617,7 @@ TEST_F(VoteCounterTest, TestVoteCounter_LateDecision) { ASSERT_STR_CONTAINS(s.ToString(), "cause the number of votes to exceed the expected number"); LOG(INFO) << "Expected voters-exceeded error: " << s.ToString(); ASSERT_TRUE(counter.IsDecided()); - ASSERT_NO_FATAL_FAILURE(AssertVoteCount(counter, 3, 2)); + NO_FATALS(AssertVoteCount(counter, 3, 2)); ASSERT_TRUE(counter.AreAllVotesIn()); } diff --git a/src/kudu/consensus/mt-log-test.cc b/src/kudu/consensus/mt-log-test.cc index fb142cd..d4ced17 100644 --- a/src/kudu/consensus/mt-log-test.cc +++ b/src/kudu/consensus/mt-log-test.cc @@ -236,11 +236,11 @@ TEST_F(MultiThreadedLogTest, TestAppends) { FLAGS_num_writer_threads * FLAGS_num_batches_per_thread, FLAGS_num_writer_threads, FLAGS_num_batches_per_thread)) { - ASSERT_NO_FATAL_FAILURE(Run()); + NO_FATALS(Run()); } ASSERT_OK(log_->Close()); if (FLAGS_verify_log) { - ASSERT_NO_FATAL_FAILURE(VerifyLog()); + NO_FATALS(VerifyLog()); } } @@ -255,7 +255,7 @@ TEST_F(MultiThreadedLogTest, TestAppendThreadStartStopRaces) { ASSERT_OK(BuildLog()); LogWriterThread(1); ASSERT_OK(log_->Close()); - ASSERT_NO_FATAL_FAILURE(VerifyLog()); + NO_FATALS(VerifyLog()); } } // namespace log diff --git a/src/kudu/consensus/raft_consensus_quorum-test.cc b/src/kudu/consensus/raft_consensus_quorum-test.cc index a6dbab0..75edcab 100644 --- a/src/kudu/consensus/raft_consensus_quorum-test.cc +++ b/src/kudu/consensus/raft_consensus_quorum-test.cc @@ -1045,8 +1045,8 @@ TEST_F(RaftConsensusQuorumTest, TestRequestVote) { &response)); ASSERT_TRUE(response.vote_granted()); ASSERT_EQ(last_op_id.term() + 1, response.responder_term()); - ASSERT_NO_FATAL_FAILURE(AssertDurableTermAndVote(kPeerIndex, last_op_id.term() + 1, - fs_managers_[0]->uuid())); + NO_FATALS(AssertDurableTermAndVote(kPeerIndex, last_op_id.term() + 1, + fs_managers_[0]->uuid())); ASSERT_EQ(1, flush_count() - flush_count_before) << "A granted vote should flush only once"; @@ -1071,8 +1071,8 @@ TEST_F(RaftConsensusQuorumTest, TestRequestVote) { ASSERT_TRUE(response.has_consensus_error()); ASSERT_EQ(ConsensusErrorPB::ALREADY_VOTED, response.consensus_error().code()); ASSERT_EQ(last_op_id.term() + 1, response.responder_term()); - ASSERT_NO_FATAL_FAILURE(AssertDurableTermAndVote(kPeerIndex, last_op_id.term() + 1, - fs_managers_[0]->uuid())); + NO_FATALS(AssertDurableTermAndVote(kPeerIndex, last_op_id.term() + 1, + fs_managers_[0]->uuid())); ASSERT_EQ(0, flush_count() - flush_count_before) << "Rejected votes for same term should not flush"; @@ -1091,8 +1091,8 @@ TEST_F(RaftConsensusQuorumTest, TestRequestVote) { &response)); ASSERT_TRUE(response.vote_granted()); ASSERT_EQ(last_op_id.term() + 2, response.responder_term()); - ASSERT_NO_FATAL_FAILURE(AssertDurableTermAndVote(kPeerIndex, last_op_id.term() + 2, - fs_managers_[0]->uuid())); + NO_FATALS(AssertDurableTermAndVote(kPeerIndex, last_op_id.term() + 2, + fs_managers_[0]->uuid())); ASSERT_EQ(1, flush_count() - flush_count_before) << "Accepted votes with increased term should flush once"; @@ -1109,8 +1109,8 @@ TEST_F(RaftConsensusQuorumTest, TestRequestVote) { ASSERT_TRUE(response.has_consensus_error()); ASSERT_EQ(ConsensusErrorPB::INVALID_TERM, response.consensus_error().code()); ASSERT_EQ(last_op_id.term() + 2, response.responder_term()); - ASSERT_NO_FATAL_FAILURE(AssertDurableTermAndVote(kPeerIndex, last_op_id.term() + 2, - fs_managers_[0]->uuid())); + NO_FATALS(AssertDurableTermAndVote(kPeerIndex, last_op_id.term() + 2, + fs_managers_[0]->uuid())); ASSERT_EQ(0, flush_count() - flush_count_before) << "Rejected votes for old terms should not flush"; @@ -1126,8 +1126,8 @@ TEST_F(RaftConsensusQuorumTest, TestRequestVote) { ASSERT_TRUE(response.vote_granted()); ASSERT_FALSE(response.has_consensus_error()); ASSERT_EQ(last_op_id.term() + 2, response.responder_term()); - ASSERT_NO_FATAL_FAILURE(AssertDurableTermAndVote(kPeerIndex, last_op_id.term() + 2, - fs_managers_[0]->uuid())); + NO_FATALS(AssertDurableTermAndVote(kPeerIndex, last_op_id.term() + 2, + fs_managers_[0]->uuid())); ASSERT_EQ(0, flush_count() - flush_count_before) << "Pre-elections should not flush"; request.set_is_pre_election(false); @@ -1148,7 +1148,7 @@ TEST_F(RaftConsensusQuorumTest, TestRequestVote) { ASSERT_TRUE(response.has_consensus_error()); ASSERT_EQ(ConsensusErrorPB::LAST_OPID_TOO_OLD, response.consensus_error().code()); ASSERT_EQ(last_op_id.term() + 3, response.responder_term()); - ASSERT_NO_FATAL_FAILURE(AssertDurableTermWithoutVote(kPeerIndex, last_op_id.term() + 3)); + NO_FATALS(AssertDurableTermWithoutVote(kPeerIndex, last_op_id.term() + 3)); ASSERT_EQ(1, flush_count() - flush_count_before) << "Rejected votes for old op index but new term should flush once."; diff --git a/src/kudu/fs/block_manager-test.cc b/src/kudu/fs/block_manager-test.cc index d83344b..c3135f3 100644 --- a/src/kudu/fs/block_manager-test.cc +++ b/src/kudu/fs/block_manager-test.cc @@ -649,7 +649,7 @@ TYPED_TEST(BlockManagerTest, AbortTest) { ASSERT_TRUE(this->bm_->OpenBlock(written_block->id(), nullptr) .IsNotFound()); - ASSERT_NO_FATAL_FAILURE(CheckMetrics(entity, 0, 0, 0, 2, 0, test_data.size() * 2)); + NO_FATALS(CheckMetrics(entity, 0, 0, 0, 2, 0, test_data.size() * 2)); } TYPED_TEST(BlockManagerTest, PersistenceTest) { @@ -718,7 +718,7 @@ TYPED_TEST(BlockManagerTest, BlockDistributionTest) { paths, true /* create */, false /* load_test_group */)); - ASSERT_NO_FATAL_FAILURE(this->RunBlockDistributionTest(paths)); + NO_FATALS(this->RunBlockDistributionTest(paths)); } TYPED_TEST(BlockManagerTest, MultiPathTest) { @@ -734,7 +734,7 @@ TYPED_TEST(BlockManagerTest, MultiPathTest) { true /* create */, false /* load_test_group */)); - ASSERT_NO_FATAL_FAILURE(this->RunMultipathTest(paths)); + NO_FATALS(this->RunMultipathTest(paths)); } static void CloseHelper(ReadableBlock* block) { @@ -770,7 +770,7 @@ TYPED_TEST(BlockManagerTest, MetricsTest) { shared_ptr<MemTracker>(), { this->test_dir_ }, false)); - ASSERT_NO_FATAL_FAILURE(CheckMetrics(entity, 0, 0, 0, 0, 0, 0)); + NO_FATALS(CheckMetrics(entity, 0, 0, 0, 0, 0, 0)); for (int i = 0; i < 3; i++) { unique_ptr<WritableBlock> writer; @@ -778,7 +778,7 @@ TYPED_TEST(BlockManagerTest, MetricsTest) { // An open writer. Also reflected in total_writable_blocks. ASSERT_OK(this->bm_->CreateBlock(this->test_block_opts_, &writer)); - ASSERT_NO_FATAL_FAILURE(CheckMetrics( + NO_FATALS(CheckMetrics( entity, 0, 1, i, i + 1, i * kTestData.length(), i * kTestData.length())); @@ -786,13 +786,13 @@ TYPED_TEST(BlockManagerTest, MetricsTest) { // is now reflected in total_bytes_written. ASSERT_OK(writer->Append(kTestData)); ASSERT_OK(writer->Close()); - ASSERT_NO_FATAL_FAILURE(CheckMetrics( + NO_FATALS(CheckMetrics( entity, 0, 0, i, i + 1, i * kTestData.length(), (i + 1) * kTestData.length())); // An open reader. ASSERT_OK(this->bm_->OpenBlock(writer->id(), &reader)); - ASSERT_NO_FATAL_FAILURE(CheckMetrics( + NO_FATALS(CheckMetrics( entity, 1, 0, i + 1, i + 1, i * kTestData.length(), (i + 1) * kTestData.length())); @@ -800,20 +800,20 @@ TYPED_TEST(BlockManagerTest, MetricsTest) { gscoped_ptr<uint8_t[]> scratch(new uint8_t[kTestData.length()]); Slice data(scratch.get(), kTestData.length()); ASSERT_OK(reader->Read(0, data)); - ASSERT_NO_FATAL_FAILURE(CheckMetrics( + NO_FATALS(CheckMetrics( entity, 1, 0, i + 1, i + 1, (i + 1) * kTestData.length(), (i + 1) * kTestData.length())); // The reader is now gone. ASSERT_OK(reader->Close()); - ASSERT_NO_FATAL_FAILURE(CheckMetrics( + NO_FATALS(CheckMetrics( entity, 0, 0, i + 1, i + 1, (i + 1) * kTestData.length(), (i + 1) * kTestData.length())); } } TYPED_TEST(BlockManagerTest, MemTrackerTest) { - ASSERT_NO_FATAL_FAILURE(this->RunMemTrackerTest()); + NO_FATALS(this->RunMemTrackerTest()); } TYPED_TEST(BlockManagerTest, TestDiskSpaceCheck) { diff --git a/src/kudu/integration-tests/alter_table-test.cc b/src/kudu/integration-tests/alter_table-test.cc index 5ce0e12..6333dfe 100644 --- a/src/kudu/integration-tests/alter_table-test.cc +++ b/src/kudu/integration-tests/alter_table-test.cc @@ -856,7 +856,7 @@ TEST_F(AlterTableTest, TestBootstrapAfterAlters) { // Test that restart doesn't fail when trying to replay updates or inserts // with the dropped column. - ASSERT_NO_FATAL_FAILURE(RestartTabletServer()); + NO_FATALS(RestartTabletServer()); NO_FATALS(ScanToStrings(&rows)); ASSERT_EQ(2, rows.size()); @@ -870,7 +870,7 @@ TEST_F(AlterTableTest, TestBootstrapAfterAlters) { ASSERT_EQ("(int32 c0=0, int32 c2=12345, int32 c1=20000)", rows[0]); ASSERT_EQ("(int32 c0=16777216, int32 c2=12345, int32 c1=20000)", rows[1]); - ASSERT_NO_FATAL_FAILURE(RestartTabletServer()); + NO_FATALS(RestartTabletServer()); NO_FATALS(ScanToStrings(&rows)); ASSERT_EQ(2, rows.size()); ASSERT_EQ("(int32 c0=0, int32 c2=12345, int32 c1=20000)", rows[0]); diff --git a/src/kudu/integration-tests/create-table-stress-test.cc b/src/kudu/integration-tests/create-table-stress-test.cc index f0b71ee..7a147b1 100644 --- a/src/kudu/integration-tests/create-table-stress-test.cc +++ b/src/kudu/integration-tests/create-table-stress-test.cc @@ -176,7 +176,7 @@ TEST_F(CreateTableStressTest, CreateAndDeleteBigTable) { return; } string table_name = "test_table"; - ASSERT_NO_FATAL_FAILURE(CreateBigTable(table_name, FLAGS_num_test_tablets)); + NO_FATALS(CreateBigTable(table_name, FLAGS_num_test_tablets)); master::GetTableLocationsResponsePB resp; ASSERT_OK(WaitForRunningTabletCount(cluster_->mini_master(), table_name, FLAGS_num_test_tablets, &resp)); @@ -211,7 +211,7 @@ TEST_F(CreateTableStressTest, RestartMasterDuringCreation) { } string table_name = "test_table"; - ASSERT_NO_FATAL_FAILURE(CreateBigTable(table_name, FLAGS_num_test_tablets)); + NO_FATALS(CreateBigTable(table_name, FLAGS_num_test_tablets)); for (int i = 0; i < 3; i++) { SleepFor(MonoDelta::FromMicroseconds(500)); @@ -241,7 +241,7 @@ TEST_F(CreateTableStressTest, TestGetTableLocationsOptions) { string table_name = "test_table"; LOG(INFO) << CURRENT_TEST_NAME() << ": Step 1. Creating big table " << table_name << " ..."; LOG_TIMING(INFO, "creating big table") { - ASSERT_NO_FATAL_FAILURE(CreateBigTable(table_name, FLAGS_num_test_tablets)); + NO_FATALS(CreateBigTable(table_name, FLAGS_num_test_tablets)); } master::GetTableLocationsRequestPB req; diff --git a/src/kudu/integration-tests/linked_list-test.cc b/src/kudu/integration-tests/linked_list-test.cc index 52cfc5b..eddc34c 100644 --- a/src/kudu/integration-tests/linked_list-test.cc +++ b/src/kudu/integration-tests/linked_list-test.cc @@ -214,7 +214,7 @@ TEST_F(LinkedListTest, TestLoadAndVerify) { this, _1))); LOG(INFO) << "Done with tserver kill test."; ASSERT_OK(CheckTabletServersAreAlive(tablet_servers_.size()-1)); - ASSERT_NO_FATAL_FAILURE(RestartCluster()); + NO_FATALS(RestartCluster()); // Again wait for cluster to finish bootstrapping. WaitForTSAndReplicas(); @@ -230,7 +230,7 @@ TEST_F(LinkedListTest, TestLoadAndVerify) { } // Kill and restart the cluster, verify data remains. - ASSERT_NO_FATAL_FAILURE(RestartCluster()); + NO_FATALS(RestartCluster()); LOG(INFO) << "Verifying rows after restarting entire cluster."; @@ -260,13 +260,13 @@ TEST_F(LinkedListTest, TestLoadAndVerify) { ASSERT_OK(CheckTabletServersAreAlive(tablet_servers_.size() - 1)); } - ASSERT_NO_FATAL_FAILURE(RestartCluster()); + NO_FATALS(RestartCluster()); // Sleep a little bit, so that the tablet is probably in bootstrapping state. SleepFor(MonoDelta::FromMilliseconds(100)); // Restart while bootstrapping - ASSERT_NO_FATAL_FAILURE(RestartCluster()); + NO_FATALS(RestartCluster()); ASSERT_OK(tester_->WaitAndVerify(FLAGS_seconds_to_run, written)); ASSERT_OK(CheckTabletServersAreAlive(tablet_servers_.size())); diff --git a/src/kudu/integration-tests/master_failover-itest.cc b/src/kudu/integration-tests/master_failover-itest.cc index 9dcaa97..5bc3465 100644 --- a/src/kudu/integration-tests/master_failover-itest.cc +++ b/src/kudu/integration-tests/master_failover-itest.cc @@ -109,7 +109,7 @@ class MasterFailoverTest : public KuduTest, virtual void SetUp() OVERRIDE { KuduTest::SetUp(); - ASSERT_NO_FATAL_FAILURE(RestartCluster()); + NO_FATALS(RestartCluster()); } virtual void TearDown() OVERRIDE { diff --git a/src/kudu/integration-tests/registration-test.cc b/src/kudu/integration-tests/registration-test.cc index 4bb712d..0f6d93c 100644 --- a/src/kudu/integration-tests/registration-test.cc +++ b/src/kudu/integration-tests/registration-test.cc @@ -239,7 +239,7 @@ TEST_F(RegistrationTest, TestTSRegisters) { << "Should not include wildcards in registration"; } - ASSERT_NO_FATAL_FAILURE(CheckTabletServersPage()); + NO_FATALS(CheckTabletServersPage()); // Restart the master, so it loses the descriptor, and ensure that the // heartbeater thread handles re-registering. diff --git a/src/kudu/integration-tests/update_scan_delta_compact-test.cc b/src/kudu/integration-tests/update_scan_delta_compact-test.cc index f3b30ae..13d4970 100644 --- a/src/kudu/integration-tests/update_scan_delta_compact-test.cc +++ b/src/kudu/integration-tests/update_scan_delta_compact-test.cc @@ -106,7 +106,7 @@ class UpdateScanDeltaCompactionTest : public KuduTest { } void CreateTable() { - ASSERT_NO_FATAL_FAILURE(InitCluster()); + NO_FATALS(InitCluster()); gscoped_ptr<KuduTableCreator> table_creator(client_->NewTableCreator()); ASSERT_OK(table_creator->table_name(kTableName) .schema(&schema_) @@ -196,9 +196,9 @@ TEST_F(UpdateScanDeltaCompactionTest, TestAll) { FLAGS_maintenance_manager_polling_interval_ms = 50; } - ASSERT_NO_FATAL_FAILURE(CreateTable()); - ASSERT_NO_FATAL_FAILURE(InsertBaseData()); - ASSERT_NO_FATAL_FAILURE(RunThreads()); + NO_FATALS(CreateTable()); + NO_FATALS(InsertBaseData()); + NO_FATALS(RunThreads()); } void UpdateScanDeltaCompactionTest::InsertBaseData() { diff --git a/src/kudu/master/master-test.cc b/src/kudu/master/master-test.cc index 045f144..25190cd 100644 --- a/src/kudu/master/master-test.cc +++ b/src/kudu/master/master-test.cc @@ -570,7 +570,7 @@ TEST_F(MasterTest, TestCatalog) { ASSERT_OK(CreateTable(kTableName, kTableSchema)); ListTablesResponsePB tables; - ASSERT_NO_FATAL_FAILURE(DoListAllTables(&tables)); + NO_FATALS(DoListAllTables(&tables)); ASSERT_EQ(1, tables.tables_size()); ASSERT_EQ(kTableName, tables.tables(0).name()); @@ -586,7 +586,7 @@ TEST_F(MasterTest, TestCatalog) { } // List tables, should show no table - ASSERT_NO_FATAL_FAILURE(DoListAllTables(&tables)); + NO_FATALS(DoListAllTables(&tables)); ASSERT_EQ(0, tables.tables_size()); // Re-create the table @@ -598,7 +598,7 @@ TEST_F(MasterTest, TestCatalog) { ASSERT_OK(mini_master_->master()-> WaitUntilCatalogManagerIsLeaderAndReadyForTests(MonoDelta::FromSeconds(5))); - ASSERT_NO_FATAL_FAILURE(DoListAllTables(&tables)); + NO_FATALS(DoListAllTables(&tables)); ASSERT_EQ(1, tables.tables_size()); ASSERT_EQ(kTableName, tables.tables(0).name()); @@ -1719,7 +1719,7 @@ TEST_F(MasterTest, TestTableIdentifierWithIdAndName) { ASSERT_OK(CreateTable(kTableName, kTableSchema)); ListTablesResponsePB tables; - ASSERT_NO_FATAL_FAILURE(DoListAllTables(&tables)); + NO_FATALS(DoListAllTables(&tables)); ASSERT_EQ(1, tables.tables_size()); ASSERT_EQ(kTableName, tables.tables(0).name()); string table_id = tables.tables(0).id(); diff --git a/src/kudu/rpc/rpc-test.cc b/src/kudu/rpc/rpc-test.cc index 88fe7fa..839198c 100644 --- a/src/kudu/rpc/rpc-test.cc +++ b/src/kudu/rpc/rpc-test.cc @@ -942,15 +942,15 @@ TEST_P(TestRpc, TestCallTimeout) { // Test a very short timeout - we expect this will time out while the // call is still trying to connect, or in the send queue. This was triggering ASAN failures // before. - ASSERT_NO_FATAL_FAILURE(DoTestExpectTimeout(p, MonoDelta::FromNanoseconds(1))); + NO_FATALS(DoTestExpectTimeout(p, MonoDelta::FromNanoseconds(1))); // Test a longer timeout - expect this will time out after we send the request, // but shorter than our threshold for two-stage timeout handling. - ASSERT_NO_FATAL_FAILURE(DoTestExpectTimeout(p, MonoDelta::FromMilliseconds(200))); + NO_FATALS(DoTestExpectTimeout(p, MonoDelta::FromMilliseconds(200))); // Test a longer timeout - expect this will trigger the "two-stage timeout" // code path. - ASSERT_NO_FATAL_FAILURE(DoTestExpectTimeout(p, MonoDelta::FromMilliseconds(1500))); + NO_FATALS(DoTestExpectTimeout(p, MonoDelta::FromMilliseconds(1500))); } // Inject 500ms delay in negotiation, and send a call with a short timeout, followed by @@ -970,7 +970,7 @@ TEST_P(TestRpc, TestCallTimeoutDoesntAffectNegotiation) { GenericCalculatorService::static_service_name()); FLAGS_rpc_negotiation_inject_delay_ms = 500; - ASSERT_NO_FATAL_FAILURE(DoTestExpectTimeout(p, MonoDelta::FromMilliseconds(50))); + NO_FATALS(DoTestExpectTimeout(p, MonoDelta::FromMilliseconds(50))); ASSERT_OK(DoTestSyncCall(p, GenericCalculatorService::kAddMethodName)); // Only the second call should have been received by the server, because we @@ -1015,7 +1015,7 @@ TEST_F(TestRpc, TestNegotiationTimeout) { GenericCalculatorService::static_service_name()); bool is_negotiation_error = false; - ASSERT_NO_FATAL_FAILURE(DoTestExpectTimeout( + NO_FATALS(DoTestExpectTimeout( p, MonoDelta::FromMilliseconds(100), &is_negotiation_error)); EXPECT_TRUE(is_negotiation_error); diff --git a/src/kudu/tablet/compaction-test.cc b/src/kudu/tablet/compaction-test.cc index fd0006d..c45a61f 100644 --- a/src/kudu/tablet/compaction-test.cc +++ b/src/kudu/tablet/compaction-test.cc @@ -389,7 +389,7 @@ class TestCompaction : public KuduRowSetTest { // Flush it to disk and re-open it. shared_ptr<DiskRowSet> rs; FlushMRSAndReopenNoRoll(*mrs, schema, &rs); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); rowsets.push_back(rs); // Perform some updates into DMS @@ -399,7 +399,7 @@ class TestCompaction : public KuduRowSetTest { // Merge them. shared_ptr<DiskRowSet> result_rs; - ASSERT_NO_FATAL_FAILURE(CompactAndReopenNoRoll(rowsets, projection, &result_rs)); + NO_FATALS(CompactAndReopenNoRoll(rowsets, projection, &result_rs)); // Verify the resulting compaction output has the right number // of rows. @@ -438,7 +438,7 @@ class TestCompaction : public KuduRowSetTest { } shared_ptr<DiskRowSet> rs; FlushMRSAndReopenNoRoll(*mrs, schema_, &rs); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); rowsets.push_back(rs); } } else { @@ -557,7 +557,7 @@ TEST_F(TestCompaction, TestRowSetInput) { mem_trackers_.tablet_tracker, &mrs)); InsertRows(mrs.get(), 10, 0); FlushMRSAndReopenNoRoll(*mrs, schema_, &rs); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); } // Update the rows in the rowset. @@ -597,7 +597,7 @@ TEST_F(TestCompaction, TestDuplicatedGhostRowsMerging) { mem_trackers_.tablet_tracker, &mrs)); InsertRows(mrs.get(), 10, 0); FlushMRSAndReopenNoRoll(*mrs, schema_, &rs1); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); } // Now delete the rows, this will make the rs report them as deleted and // so we would reinsert them into the MRS. @@ -611,7 +611,7 @@ TEST_F(TestCompaction, TestDuplicatedGhostRowsMerging) { InsertRows(mrs.get(), 10, 0); UpdateRows(mrs.get(), 10, 0, 1); FlushMRSAndReopenNoRoll(*mrs, schema_, &rs2); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); } DeleteRows(rs2.get(), 10); @@ -623,7 +623,7 @@ TEST_F(TestCompaction, TestDuplicatedGhostRowsMerging) { InsertRows(mrs.get(), 10, 0); UpdateRows(mrs.get(), 10, 0, 2); FlushMRSAndReopenNoRoll(*mrs, schema_, &rs3); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); } shared_ptr<DiskRowSet> result; @@ -847,7 +847,7 @@ TEST_F(TestCompaction, TestMRSCompactionDoesntOutputUnobservableRows) { mem_trackers_.tablet_tracker, &mrs)); InsertRow(mrs.get(), 1, 1); FlushMRSAndReopenNoRoll(*mrs, schema_, &rs1); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); } // Now make the row a ghost in rs1 in the same transaction as we reinsert it in the mrs then @@ -868,7 +868,7 @@ TEST_F(TestCompaction, TestMRSCompactionDoesntOutputUnobservableRows) { InsertRowInTransaction(mrs.get(), tx, 2, 0); tx.Commit(); FlushMRSAndReopenNoRoll(*mrs, schema_, &rs2); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); } MvccSnapshot all_snap = MvccSnapshot::CreateSnapshotIncludingAllTransactions(); @@ -912,7 +912,7 @@ TEST_F(TestCompaction, TestOneToOne) { // Flush it to disk and re-open. shared_ptr<DiskRowSet> rs; FlushMRSAndReopenNoRoll(*mrs, schema_, &rs); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); // Update the rows with some updates that weren't in the snapshot. UpdateRows(mrs.get(), 1000, 0, 2); @@ -957,7 +957,7 @@ TEST_F(TestCompaction, TestKUDU102) { InsertRows(mrs.get(), 10, 0); shared_ptr<DiskRowSet> rs; FlushMRSAndReopenNoRoll(*mrs, schema_, &rs); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); shared_ptr<MemRowSet> mrs_b; ASSERT_OK(MemRowSet::Create(1, schema_, log_anchor_registry_.get(), @@ -966,7 +966,7 @@ TEST_F(TestCompaction, TestKUDU102) { MvccSnapshot snap(mvcc_); shared_ptr<DiskRowSet> rs_b; FlushMRSAndReopenNoRoll(*mrs_b, schema_, &rs_b); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); // Update all the rows in the second row set UpdateRows(mrs_b.get(), 10, 100, 2); @@ -1058,7 +1058,7 @@ TEST_F(TestCompaction, BenchmarkMergeWithoutOverlap) { LOG(INFO) << "Skipped: must enable slow tests."; return; } - ASSERT_NO_FATAL_FAILURE(DoBenchmark<false>()); + NO_FATALS(DoBenchmark<false>()); } // Benchmark for the compaction merge input when the inputs are entirely @@ -1068,7 +1068,7 @@ TEST_F(TestCompaction, BenchmarkMergeWithOverlap) { LOG(INFO) << "Skipped: must enable slow tests."; return; } - ASSERT_NO_FATAL_FAILURE(DoBenchmark<true>()); + NO_FATALS(DoBenchmark<true>()); } #endif diff --git a/src/kudu/tablet/composite-pushdown-test.cc b/src/kudu/tablet/composite-pushdown-test.cc index 4698d8a..7a7c32f 100644 --- a/src/kudu/tablet/composite-pushdown-test.cc +++ b/src/kudu/tablet/composite-pushdown-test.cc @@ -145,7 +145,7 @@ TEST_F(CompositePushdownTest, TestPushDownExactEquality) { spec.AddPredicate(pred_host); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, "Exact match using compound key")); + NO_FATALS(ScanTablet(&spec, &results, "Exact match using compound key")); ASSERT_EQ(1, results.size()); EXPECT_EQ("(int16 year=2001, int8 month=9, int8 day=7, " R"(string hostname="foo", string data="2001/09/07-foo"))", @@ -172,7 +172,7 @@ TEST_F(CompositePushdownTest, TestPushDownStringInequality) { spec.AddPredicate(*pred_host); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, "Exact match using compound key")); + NO_FATALS(ScanTablet(&spec, &results, "Exact match using compound key")); ASSERT_EQ(2, results.size()); EXPECT_EQ("(int16 year=2001, int8 month=9, int8 day=7, " R"(string hostname="baz", string data="2001/09/07-baz"))", @@ -196,7 +196,7 @@ TEST_F(CompositePushdownTest, TestPushDownDateEquality) { spec.AddPredicate(pred_day); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, "Exact match using compound key")); + NO_FATALS(ScanTablet(&spec, &results, "Exact match using compound key")); ASSERT_EQ(3, results.size()); EXPECT_EQ("(int16 year=2001, int8 month=9, int8 day=7, " R"(string hostname="baz", string data="2001/09/07-baz"))", @@ -220,8 +220,8 @@ TEST_F(CompositePushdownTest, TestPushDownPrefixEquality) { spec.AddPredicate(pred_year); spec.AddPredicate(pred_month); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, - "Prefix match using 2/3 of a compound key")); + NO_FATALS(ScanTablet(&spec, &results, + "Prefix match using 2/3 of a compound key")); ASSERT_EQ(28 * 3, results.size()); EXPECT_EQ("(int16 year=2001, int8 month=9, int8 day=1, " R"(string hostname="baz", string data="2001/09/01-baz"))", @@ -235,8 +235,8 @@ TEST_F(CompositePushdownTest, TestPushDownPrefixEquality) { ScanSpec spec; spec.AddPredicate(pred_year); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, - "Prefix match using 1/3 of a compound key")); + NO_FATALS(ScanTablet(&spec, &results, + "Prefix match using 1/3 of a compound key")); ASSERT_EQ(28 * 12 * 3, results.size()); EXPECT_EQ("(int16 year=2001, int8 month=1, int8 day=1, " R"(string hostname="baz", string data="2001/01/01-baz"))", @@ -274,7 +274,7 @@ TEST_F(CompositePushdownTest, TestPushDownPrefixEqualitySuffixInequality) { spec.AddPredicate(pred_month_eq); spec.AddPredicate(pred_day_ge_lt); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, "Prefix equality, suffix inequality")); + NO_FATALS(ScanTablet(&spec, &results, "Prefix equality, suffix inequality")); ASSERT_EQ(15 * 3, results.size()); EXPECT_EQ("(int16 year=2001, int8 month=9, int8 day=1, " R"(string hostname="baz", string data="2001/09/01-baz"))", @@ -291,7 +291,7 @@ TEST_F(CompositePushdownTest, TestPushDownPrefixEqualitySuffixInequality) { spec.AddPredicate(pred_month_eq); spec.AddPredicate(pred_day_ge); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, "Prefix equality, suffix inequality")); + NO_FATALS(ScanTablet(&spec, &results, "Prefix equality, suffix inequality")); ASSERT_EQ(28 * 3, results.size()); EXPECT_EQ("(int16 year=2001, int8 month=9, int8 day=1, " R"(string hostname="baz", string data="2001/09/01-baz"))", @@ -308,7 +308,7 @@ TEST_F(CompositePushdownTest, TestPushDownPrefixEqualitySuffixInequality) { spec.AddPredicate(pred_month_eq); spec.AddPredicate(pred_day_lt); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, "Prefix equality, suffix inequality")); + NO_FATALS(ScanTablet(&spec, &results, "Prefix equality, suffix inequality")); ASSERT_EQ(15 * 3, results.size()); EXPECT_EQ("(int16 year=2001, int8 month=9, int8 day=1, " R"(string hostname="baz", string data="2001/09/01-baz"))", @@ -324,7 +324,7 @@ TEST_F(CompositePushdownTest, TestPushDownPrefixEqualitySuffixInequality) { spec.AddPredicate(pred_year); spec.AddPredicate(pred_month_ge_lt); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, "Prefix equality, suffix inequality")); + NO_FATALS(ScanTablet(&spec, &results, "Prefix equality, suffix inequality")); ASSERT_EQ(3 * 28 * 3, results.size()); EXPECT_EQ("(int16 year=2001, int8 month=9, int8 day=1, " R"(string hostname="baz", string data="2001/09/01-baz"))", @@ -340,7 +340,7 @@ TEST_F(CompositePushdownTest, TestPushDownPrefixEqualitySuffixInequality) { spec.AddPredicate(pred_year); spec.AddPredicate(pred_month_lt); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, "Prefix equality, suffix inequality")); + NO_FATALS(ScanTablet(&spec, &results, "Prefix equality, suffix inequality")); ASSERT_EQ(8 * 28 * 3, results.size()); EXPECT_EQ("(int16 year=2001, int8 month=1, int8 day=1, " R"(string hostname="baz", string data="2001/01/01-baz"))", @@ -361,7 +361,7 @@ TEST_F(CompositePushdownTest, TestPushdownPrefixInequality) { ScanSpec spec; spec.AddPredicate(pred_year); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, "Prefix inequality")); + NO_FATALS(ScanTablet(&spec, &results, "Prefix inequality")); ASSERT_EQ(3 * 12 * 28 * 3, results.size()); EXPECT_EQ("(int16 year=2001, int8 month=1, int8 day=1, " R"(string hostname="baz", string data="2001/01/01-baz"))", @@ -377,7 +377,7 @@ TEST_F(CompositePushdownTest, TestPushdownPrefixInequality) { ScanSpec spec; spec.AddPredicate(pred_year); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, "Prefix inequality")); + NO_FATALS(ScanTablet(&spec, &results, "Prefix inequality")); ASSERT_EQ(10 * 12 * 28 * 3, results.size()); // Needed because results from memrowset are returned first and memrowset begins // with last 10% of the keys (e.g., last few years) @@ -395,7 +395,7 @@ TEST_F(CompositePushdownTest, TestPushdownPrefixInequality) { ScanSpec spec; spec.AddPredicate(pred_year); vector<string> results; - ASSERT_NO_FATAL_FAILURE(ScanTablet(&spec, &results, "Prefix inequality")); + NO_FATALS(ScanTablet(&spec, &results, "Prefix inequality")); ASSERT_EQ(4 * 12 * 28 * 3, results.size()); EXPECT_EQ("(int16 year=2000, int8 month=1, int8 day=1, " R"(string hostname="baz", string data="2000/01/01-baz"))", diff --git a/src/kudu/tablet/major_delta_compaction-test.cc b/src/kudu/tablet/major_delta_compaction-test.cc index 24af96f..48857bf 100644 --- a/src/kudu/tablet/major_delta_compaction-test.cc +++ b/src/kudu/tablet/major_delta_compaction-test.cc @@ -209,7 +209,7 @@ TEST_F(TestMajorDeltaCompaction, TestKudu2656) { // unchanged columns intact. TEST_F(TestMajorDeltaCompaction, TestCompact) { const int kNumRows = 100; - ASSERT_NO_FATAL_FAILURE(WriteTestTablet(kNumRows)); + NO_FATALS(WriteTestTablet(kNumRows)); ASSERT_OK(tablet()->Flush()); vector<shared_ptr<RowSet> > all_rowsets; @@ -229,17 +229,17 @@ TEST_F(TestMajorDeltaCompaction, TestCompact) { for (int i = 0; i < 3; i++) { SCOPED_TRACE(Substitute("Update/compact round $0", i)); // Update the even rows and verify. - ASSERT_NO_FATAL_FAILURE(UpdateRows(kNumRows, false)); - ASSERT_NO_FATAL_FAILURE(VerifyData()); + NO_FATALS(UpdateRows(kNumRows, false)); + NO_FATALS(VerifyData()); // Flush the deltas, make sure data stays the same. ASSERT_OK(tablet()->FlushBiggestDMS()); - ASSERT_NO_FATAL_FAILURE(VerifyData()); + NO_FATALS(VerifyData()); // Update the odd rows and flush deltas - ASSERT_NO_FATAL_FAILURE(UpdateRows(kNumRows, true)); + NO_FATALS(UpdateRows(kNumRows, true)); ASSERT_OK(tablet()->FlushBiggestDMS()); - ASSERT_NO_FATAL_FAILURE(VerifyData()); + NO_FATALS(VerifyData()); // Major compact some columns. vector<ColumnId> col_ids; @@ -248,14 +248,14 @@ TEST_F(TestMajorDeltaCompaction, TestCompact) { } ASSERT_OK(tablet()->DoMajorDeltaCompaction(col_ids, rs)); - ASSERT_NO_FATAL_FAILURE(VerifyData()); + NO_FATALS(VerifyData()); } } // Verify that we do issue UNDO files and that we can read them. TEST_F(TestMajorDeltaCompaction, TestUndos) { const int kNumRows = 100; - ASSERT_NO_FATAL_FAILURE(WriteTestTablet(kNumRows)); + NO_FATALS(WriteTestTablet(kNumRows)); ASSERT_OK(tablet()->Flush()); vector<shared_ptr<RowSet> > all_rowsets; @@ -266,26 +266,26 @@ TEST_F(TestMajorDeltaCompaction, TestUndos) { MvccSnapshot snap(*tablet()->mvcc_manager()); // Verify the old data and grab a copy of the old state. - ASSERT_NO_FATAL_FAILURE(VerifyDataWithMvccAndExpectedState(snap, expected_state_)); + NO_FATALS(VerifyDataWithMvccAndExpectedState(snap, expected_state_)); vector<ExpectedRow> old_state(expected_state_.size()); std::copy(expected_state_.begin(), expected_state_.end(), old_state.begin()); // Flush the DMS, make sure we still see the old data. - ASSERT_NO_FATAL_FAILURE(UpdateRows(kNumRows, false)); + NO_FATALS(UpdateRows(kNumRows, false)); ASSERT_OK(tablet()->FlushBiggestDMS()); - ASSERT_NO_FATAL_FAILURE(VerifyDataWithMvccAndExpectedState(snap, old_state)); + NO_FATALS(VerifyDataWithMvccAndExpectedState(snap, old_state)); // Major compact, check we still have the old data. vector<ColumnId> col_ids_to_compact = { schema_.column_id(1), schema_.column_id(3), schema_.column_id(4) }; ASSERT_OK(tablet()->DoMajorDeltaCompaction(col_ids_to_compact, rs)); - ASSERT_NO_FATAL_FAILURE(VerifyDataWithMvccAndExpectedState(snap, old_state)); + NO_FATALS(VerifyDataWithMvccAndExpectedState(snap, old_state)); // Test adding three updates per row to three REDO files. for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { - ASSERT_NO_FATAL_FAILURE(UpdateRows(kNumRows, false)); + NO_FATALS(UpdateRows(kNumRows, false)); } ASSERT_OK(tablet()->FlushBiggestDMS()); } @@ -294,37 +294,37 @@ TEST_F(TestMajorDeltaCompaction, TestUndos) { // and the new data. col_ids_to_compact.pop_back(); ASSERT_OK(tablet()->DoMajorDeltaCompaction(col_ids_to_compact, rs)); - ASSERT_NO_FATAL_FAILURE(VerifyDataWithMvccAndExpectedState(snap, old_state)); - ASSERT_NO_FATAL_FAILURE(VerifyData()); + NO_FATALS(VerifyDataWithMvccAndExpectedState(snap, old_state)); + NO_FATALS(VerifyData()); } // Test that the delete REDO mutations are written back and not filtered out. TEST_F(TestMajorDeltaCompaction, TestCarryDeletesOver) { const int kNumRows = 100; - ASSERT_NO_FATAL_FAILURE(WriteTestTablet(kNumRows)); + NO_FATALS(WriteTestTablet(kNumRows)); ASSERT_OK(tablet()->Flush()); vector<shared_ptr<RowSet> > all_rowsets; tablet()->GetRowSetsForTests(&all_rowsets); shared_ptr<RowSet> rs = all_rowsets.front(); - ASSERT_NO_FATAL_FAILURE(UpdateRows(kNumRows, false)); + NO_FATALS(UpdateRows(kNumRows, false)); ASSERT_OK(tablet()->FlushBiggestDMS()); MvccSnapshot updates_snap(*tablet()->mvcc_manager()); vector<ExpectedRow> old_state(expected_state_.size()); std::copy(expected_state_.begin(), expected_state_.end(), old_state.begin()); - ASSERT_NO_FATAL_FAILURE(DeleteRows(kNumRows)); + NO_FATALS(DeleteRows(kNumRows)); ASSERT_OK(tablet()->FlushBiggestDMS()); vector<ColumnId> col_ids_to_compact = { schema_.column_id(4) }; ASSERT_OK(tablet()->DoMajorDeltaCompaction(col_ids_to_compact, rs)); - ASSERT_NO_FATAL_FAILURE(VerifyData()); + NO_FATALS(VerifyData()); - ASSERT_NO_FATAL_FAILURE(VerifyDataWithMvccAndExpectedState(updates_snap, old_state)); + NO_FATALS(VerifyDataWithMvccAndExpectedState(updates_snap, old_state)); } // Verify that reinserts only happen in the MRS and not down into the DRS. This test serves as a @@ -334,13 +334,13 @@ TEST_F(TestMajorDeltaCompaction, TestReinserts) { const int kNumRows = 100; // Reinsert all the rows directly in the MRS. - ASSERT_NO_FATAL_FAILURE(WriteTestTablet(kNumRows)); // 1st batch. - ASSERT_NO_FATAL_FAILURE(DeleteRows(kNumRows)); // Delete 1st batch. - ASSERT_NO_FATAL_FAILURE(WriteTestTablet(kNumRows)); // 2nd batch. + NO_FATALS(WriteTestTablet(kNumRows)); // 1st batch. + NO_FATALS(DeleteRows(kNumRows)); // Delete 1st batch. + NO_FATALS(WriteTestTablet(kNumRows)); // 2nd batch. ASSERT_OK(tablet()->Flush()); // Update those rows, we'll try to read them at the end. - ASSERT_NO_FATAL_FAILURE(UpdateRows(kNumRows, false)); // Update 2nd batch. + NO_FATALS(UpdateRows(kNumRows, false)); // Update 2nd batch. vector<ExpectedRow> old_state(expected_state_.size()); std::copy(expected_state_.begin(), expected_state_.end(), old_state.begin()); MvccSnapshot second_batch_inserts(*tablet()->mvcc_manager()); @@ -349,12 +349,12 @@ TEST_F(TestMajorDeltaCompaction, TestReinserts) { tablet()->GetRowSetsForTests(&all_rowsets); ASSERT_EQ(1, all_rowsets.size()); - ASSERT_NO_FATAL_FAILURE(VerifyData()); + NO_FATALS(VerifyData()); // Delete the rows (will go into the DMS) then reinsert them (will go in a new MRS), then flush // the DMS with the deletes so that we can major compact them. - ASSERT_NO_FATAL_FAILURE(DeleteRows(kNumRows)); // Delete 2nd batch. - ASSERT_NO_FATAL_FAILURE(WriteTestTablet(kNumRows)); // 3rd batch. + NO_FATALS(DeleteRows(kNumRows)); // Delete 2nd batch. + NO_FATALS(WriteTestTablet(kNumRows)); // 3rd batch. ASSERT_OK(tablet()->FlushBiggestDMS()); // At this point, here's the layout (the 1st batch was discarded during the first flush): @@ -369,7 +369,7 @@ TEST_F(TestMajorDeltaCompaction, TestReinserts) { ASSERT_OK(tablet()->DoMajorDeltaCompaction(col_ids_to_compact, rs)); // The data we'll see here is the 3rd batch of inserts, doesn't have updates. - ASSERT_NO_FATAL_FAILURE(VerifyData()); + NO_FATALS(VerifyData()); // Test that the 3rd batch of inserts goes into a new RS, even though it's the same row keys. ASSERT_OK(tablet()->Flush()); @@ -378,19 +378,19 @@ TEST_F(TestMajorDeltaCompaction, TestReinserts) { ASSERT_EQ(2, all_rowsets.size()); // Verify the 3rd batch. - ASSERT_NO_FATAL_FAILURE(VerifyData()); + NO_FATALS(VerifyData()); // Verify the updates in the second batch are still readable, from the first RS. - ASSERT_NO_FATAL_FAILURE(VerifyDataWithMvccAndExpectedState(second_batch_inserts, old_state)); + NO_FATALS(VerifyDataWithMvccAndExpectedState(second_batch_inserts, old_state)); } // Verify that we won't schedule a major compaction when files are just composed of deletes. TEST_F(TestMajorDeltaCompaction, TestJustDeletes) { const int kNumRows = 100; - ASSERT_NO_FATAL_FAILURE(WriteTestTablet(kNumRows)); + NO_FATALS(WriteTestTablet(kNumRows)); ASSERT_OK(tablet()->Flush()); - ASSERT_NO_FATAL_FAILURE(DeleteRows(kNumRows)); + NO_FATALS(DeleteRows(kNumRows)); ASSERT_OK(tablet()->FlushBiggestDMS()); shared_ptr<RowSet> rs; diff --git a/src/kudu/tablet/mt-rowset_delta_compaction-test.cc b/src/kudu/tablet/mt-rowset_delta_compaction-test.cc index 6af4d12..08a54df 100644 --- a/src/kudu/tablet/mt-rowset_delta_compaction-test.cc +++ b/src/kudu/tablet/mt-rowset_delta_compaction-test.cc @@ -179,9 +179,9 @@ class TestMultiThreadedRowSetDeltaCompaction : public TestRowSet { StartThreads(rs.get()); SleepFor(MonoDelta::FromSeconds(FLAGS_num_seconds_per_thread)); base::subtle::NoBarrier_Store(&should_run_, 0); - ASSERT_NO_FATAL_FAILURE(JoinThreads()); + NO_FATALS(JoinThreads()); - ASSERT_NO_FATAL_FAILURE(ReadVerify(rs.get())); + NO_FATALS(ReadVerify(rs.get())); } bool ShouldRun() const { diff --git a/src/kudu/tablet/tablet_random_access-test.cc b/src/kudu/tablet/tablet_random_access-test.cc index 0c87894..12455e8 100644 --- a/src/kudu/tablet/tablet_random_access-test.cc +++ b/src/kudu/tablet/tablet_random_access-test.cc @@ -51,6 +51,7 @@ #include "kudu/util/monotime.h" #include "kudu/util/status.h" #include "kudu/util/stopwatch.h" +#include "kudu/util/test_macros.h" #include "kudu/util/test_util.h" #include "kudu/util/thread.h" @@ -157,7 +158,7 @@ class TestRandomAccess : public KuduTabletTest { s.start(); while (s.elapsed().wall_seconds() < FLAGS_runtime_seconds) { for (int i = 0; i < 100; i++) { - ASSERT_NO_FATAL_FAILURE(DoRandomBatch()); + NO_FATALS(DoRandomBatch()); op_count++; } } diff --git a/src/kudu/tserver/tablet_server-test.cc b/src/kudu/tserver/tablet_server-test.cc index 9ef93ac..a7d5b4e 100644 --- a/src/kudu/tserver/tablet_server-test.cc +++ b/src/kudu/tserver/tablet_server-test.cc @@ -819,7 +819,7 @@ TEST_F(TabletServerTest, TestInsert) { Timestamp now_before = mini_server_->server()->clock()->Now(); rows_inserted = nullptr; - ASSERT_NO_FATAL_FAILURE(ShutdownAndRebuildTablet()); + NO_FATALS(ShutdownAndRebuildTablet()); VerifyRows(schema_, { KeyValue(1, 1), KeyValue(2, 1), KeyValue(1234, 5678) }); // get the clock's timestamp after replay @@ -1108,7 +1108,7 @@ TEST_F(TabletServerTest, TestInsertAndMutate) { rows_inserted = nullptr; rows_updated = nullptr; - ASSERT_NO_FATAL_FAILURE(ShutdownAndRebuildTablet()); + NO_FATALS(ShutdownAndRebuildTablet()); VerifyRows(schema_, { KeyValue(2, 3), KeyValue(3, 4), KeyValue(4, 4), KeyValue(6, 6) }); // get the clock's timestamp after replay @@ -1294,7 +1294,7 @@ TEST_F(TabletServerTest, TestRecoveryWithMutationsWhileFlushing) { // Shutdown the tserver and try and rebuild the tablet from the log // produced on recovery (recovery flushed no state, but produced a new // log). - ASSERT_NO_FATAL_FAILURE(ShutdownAndRebuildTablet()); + NO_FATALS(ShutdownAndRebuildTablet()); VerifyRows(schema_, { KeyValue(1, 10), KeyValue(2, 20), KeyValue(3, 30), @@ -1307,7 +1307,7 @@ TEST_F(TabletServerTest, TestRecoveryWithMutationsWhileFlushing) { // Shutdown and rebuild again to test that the log generated during // the previous recovery allows to perform recovery again. - ASSERT_NO_FATAL_FAILURE(ShutdownAndRebuildTablet()); + NO_FATALS(ShutdownAndRebuildTablet()); VerifyRows(schema_, { KeyValue(1, 10), KeyValue(2, 20), KeyValue(3, 30), @@ -1332,7 +1332,7 @@ TEST_F(TabletServerTest, TestRecoveryWithMutationsWhileFlushingAndCompacting) { // flush the first time ASSERT_OK(tablet_replica_->tablet()->Flush()); - ASSERT_NO_FATAL_FAILURE(ShutdownAndRebuildTablet()); + NO_FATALS(ShutdownAndRebuildTablet()); VerifyRows(schema_, { KeyValue(1, 10), KeyValue(2, 20), KeyValue(3, 30), @@ -1372,7 +1372,7 @@ TEST_F(TabletServerTest, TestRecoveryWithMutationsWhileFlushingAndCompacting) { // Shutdown the tserver and try and rebuild the tablet from the log // produced on recovery (recovery flushed no state, but produced a new // log). - ASSERT_NO_FATAL_FAILURE(ShutdownAndRebuildTablet()); + NO_FATALS(ShutdownAndRebuildTablet()); VerifyRows(schema_, { KeyValue(1, 11), KeyValue(2, 22), KeyValue(3, 32), @@ -1389,14 +1389,14 @@ TEST_F(TabletServerTest, TestRecoveryWithMutationsWhileFlushingAndCompacting) { ASSERT_GE(now_after.value(), now_before.value()); } -#define ANFF ASSERT_NO_FATAL_FAILURE +#define ANFF NO_FATALS // Regression test for KUDU-176. Ensures that after a major delta compaction, // restarting properly recovers the tablet. TEST_F(TabletServerTest, TestKUDU_176_RecoveryAfterMajorDeltaCompaction) { // Flush a DRS with 1 rows. - ASSERT_NO_FATAL_FAILURE(InsertTestRowsRemote(1, 1)); + NO_FATALS(InsertTestRowsRemote(1, 1)); ASSERT_OK(tablet_replica_->tablet()->Flush()); ANFF(VerifyRows(schema_, { KeyValue(1, 1) })); @@ -1600,7 +1600,7 @@ TEST_F(TabletServerTest, TestReadLatest) { METRIC_tablet_active_scanners.Instantiate(tablet->tablet()->GetMetricEntity(), 0); ScanResponsePB resp; - ASSERT_NO_FATAL_FAILURE(OpenScannerWithAllColumns(&resp)); + NO_FATALS(OpenScannerWithAllColumns(&resp)); // Ensure that the scanner ID came back and got inserted into the // ScannerManager map. @@ -1619,7 +1619,7 @@ TEST_F(TabletServerTest, TestReadLatest) { // Drain all the rows from the scanner. vector<string> results; - ASSERT_NO_FATAL_FAILURE(DrainScannerToStrings(resp.scanner_id(), schema_, &results)); + NO_FATALS(DrainScannerToStrings(resp.scanner_id(), schema_, &results)); ASSERT_EQ(num_rows, results.size()); KuduPartialRow row(&schema_); @@ -1673,7 +1673,7 @@ TEST_P(ExpiredScannerParamTest, Test) { // Open a scanner but don't read from it. ScanResponsePB resp; - ASSERT_NO_FATAL_FAILURE(OpenScannerWithAllColumns(&resp, mode)); + NO_FATALS(OpenScannerWithAllColumns(&resp, mode)); // The scanner should expire after a short time. ASSERT_EVENTUALLY([&]() { @@ -1790,7 +1790,7 @@ TEST_P(ScannerOpenWhenServerShutsDownParamTest, Test) { ASSERT_OK(tablet_replica_->tablet()->Flush()); ScanResponsePB resp; - ASSERT_NO_FATAL_FAILURE(OpenScannerWithAllColumns(&resp, mode)); + NO_FATALS(OpenScannerWithAllColumns(&resp, mode)); // Scanner is now open. The test will now shut down the TS with the scanner still // out there. Due to KUDU-161 this used to fail, since the scanner (and thus the MRS) @@ -1854,7 +1854,7 @@ TEST_F(TabletServerTest, TestSnapshotScan) { ASSERT_TRUE(resp.has_more_results()); // Drain all the rows from the scanner. vector<string> results; - ASSERT_NO_FATAL_FAILURE(DrainScannerToStrings(resp.scanner_id(), schema_, &results)); + NO_FATALS(DrainScannerToStrings(resp.scanner_id(), schema_, &results)); // on each scan we should get (num_rows / num_batches) * batch_idx rows back int expected_num_rows = (num_rows / num_batches) * batch_idx; ASSERT_EQ(expected_num_rows, results.size()); @@ -2089,7 +2089,7 @@ TEST_F(TabletServerTest, TestSnapshotScan_SnapshotInTheFutureWithPropagatedTimes HybridClock::GetLogicalValue(propagated_timestamp)); vector<string> results; - ASSERT_NO_FATAL_FAILURE(DrainScannerToStrings(resp.scanner_id(), schema_, &results)); + NO_FATALS(DrainScannerToStrings(resp.scanner_id(), schema_, &results)); ASSERT_EQ(1, results.size()); ASSERT_EQ(R"((int32 key=0, int32 int_val=0, string string_val="original0"))", results[0]); } @@ -2157,7 +2157,7 @@ TEST_F(TabletServerTest, TestScanYourWrites) { propagated_timestamp = resp.snap_timestamp(); // Drain all the rows from the scanner. vector<string> results; - ASSERT_NO_FATAL_FAILURE(DrainScannerToStrings(resp.scanner_id(), schema_, &results)); + NO_FATALS(DrainScannerToStrings(resp.scanner_id(), schema_, &results)); ASSERT_EQ(kNumRows, results.size()); ASSERT_EQ(R"((int32 key=0, int32 int_val=0, string string_val="original0"))", results[0]); ASSERT_EQ(R"((int32 key=99, int32 int_val=99, string string_val="original99"))", results[99]); @@ -2168,7 +2168,7 @@ TEST_F(TabletServerTest, TestScanYourWrites) { ScanYourWritesTest(propagated_timestamp, &new_resp); // Drain all the rows from the scanner. results.clear(); - ASSERT_NO_FATAL_FAILURE(DrainScannerToStrings(new_resp.scanner_id(), schema_, &results)); + NO_FATALS(DrainScannerToStrings(new_resp.scanner_id(), schema_, &results)); ASSERT_EQ(kNumRows, results.size()); ASSERT_EQ(R"((int32 key=0, int32 int_val=0, string string_val="original0"))", results[0]); ASSERT_EQ(R"((int32 key=99, int32 int_val=99, string string_val="original99"))", results[99]); @@ -2246,7 +2246,7 @@ TEST_F(TabletServerTest, TestScanWithStringPredicates) { // Drain all the rows from the scanner. vector<string> results; - ASSERT_NO_FATAL_FAILURE( + NO_FATALS( DrainScannerToStrings(resp.scanner_id(), schema_, &results)); ASSERT_EQ(10, results.size()); ASSERT_EQ(R"((int32 key=50, int32 int_val=100, string string_val="hello 50"))", results[0]); @@ -2356,7 +2356,7 @@ TEST_F(TabletServerTest, TestScanWithPredicates) { // Drain all the rows from the scanner. vector<string> results; - ASSERT_NO_FATAL_FAILURE( + NO_FATALS( DrainScannerToStrings(resp.scanner_id(), schema_, &results)); ASSERT_EQ(50, results.size()); } @@ -2402,7 +2402,7 @@ TEST_F(TabletServerTest, TestScanWithEncodedPredicates) { // Drain all the rows from the scanner. vector<string> results; - ASSERT_NO_FATAL_FAILURE( + NO_FATALS( DrainScannerToStrings(resp.scanner_id(), schema_, &results)); ASSERT_EQ(9, results.size()); EXPECT_EQ(R"((int32 key=51, int32 int_val=102, string string_val="hello 51"))", @@ -2878,7 +2878,7 @@ void TabletServerTest::DoOrderedScanTest(const Schema& projection, } vector<string> results; - ASSERT_NO_FATAL_FAILURE( + NO_FATALS( DrainScannerToStrings(resp.scanner_id(), projection, &results)); ASSERT_EQ(30, results.size()); @@ -2988,14 +2988,14 @@ TEST_F(TabletServerTest, TestAlterSchema) { const Schema projection({ ColumnSchema("key", INT32), (ColumnSchema("c2", INT32)) }, 1); // Try recovering from the original log - ASSERT_NO_FATAL_FAILURE(ShutdownAndRebuildTablet()); + NO_FATALS(ShutdownAndRebuildTablet()); VerifyRows(projection, { KeyValue(0, 7), KeyValue(1, 7), KeyValue(2, 5), KeyValue(3, 5) }); // Try recovering from the log generated on recovery - ASSERT_NO_FATAL_FAILURE(ShutdownAndRebuildTablet()); + NO_FATALS(ShutdownAndRebuildTablet()); VerifyRows(projection, { KeyValue(0, 7), KeyValue(1, 7), KeyValue(2, 5), @@ -3039,11 +3039,11 @@ TEST_F(TabletServerTest, TestAlterSchema_AddColWithoutWriteDefault) { VerifyRows(projection, { KeyValue(0, 7), KeyValue(1, 7) }); // Try recovering from the original log - ASSERT_NO_FATAL_FAILURE(ShutdownAndRebuildTablet()); + NO_FATALS(ShutdownAndRebuildTablet()); VerifyRows(projection, { KeyValue(0, 7), KeyValue(1, 7) }); // Try recovering from the log generated on recovery - ASSERT_NO_FATAL_FAILURE(ShutdownAndRebuildTablet()); + NO_FATALS(ShutdownAndRebuildTablet()); VerifyRows(projection, { KeyValue(0, 7), KeyValue(1, 7) }); } @@ -3092,9 +3092,9 @@ TEST_F(TabletServerTest, TestDeleteTablet) { // Put some data in the tablet. We flush and insert more rows to ensure that // there is data both in the MRS and on disk. - ASSERT_NO_FATAL_FAILURE(InsertTestRowsRemote(1, 1)); + NO_FATALS(InsertTestRowsRemote(1, 1)); ASSERT_OK(tablet_replica_->tablet()->Flush()); - ASSERT_NO_FATAL_FAILURE(InsertTestRowsRemote(2, 1)); + NO_FATALS(InsertTestRowsRemote(2, 1)); const int block_count_after_flush = ondisk->value(); if (FLAGS_block_manager == "log") { @@ -3450,7 +3450,7 @@ TEST_F(TabletServerTest, TestChecksumScan) { ASSERT_FALSE(resp.has_more_results()); // Finally, delete row 2, so we're back to the row 1 checksum. - ASSERT_NO_FATAL_FAILURE(DeleteTestRowsRemote(key, 1)); + NO_FATALS(DeleteTestRowsRemote(key, 1)); FLAGS_scanner_batch_size_rows = 100; req = new_req; controller.Reset(); @@ -3606,7 +3606,7 @@ TEST_F(TabletServerTest, TestNoMetricsForTombstonedTablet) { ASSERT_TRUE(mini_server_->server()->tablet_manager()->LookupTablet(kTabletId, &tablet)); // Insert one row and check the insertion is recorded in the metrics. - ASSERT_NO_FATAL_FAILURE(InsertTestRowsRemote(0, 1, 1)); + NO_FATALS(InsertTestRowsRemote(0, 1, 1)); scoped_refptr<Counter> rows_inserted = METRIC_rows_inserted.Instantiate(tablet->tablet()->GetMetricEntity()); int64_t num_rows_running = rows_inserted->value(); @@ -3658,7 +3658,7 @@ TEST_F(TabletServerTest, TestTabletNumberOfDiskRowSetsMetric) { ASSERT_EQ(0, num_diskrowsets->value()); // Insert a row and flush. There should be 1 diskrowset. - ASSERT_NO_FATAL_FAILURE(InsertTestRowsRemote(0, 1, 1)); + NO_FATALS(InsertTestRowsRemote(0, 1, 1)); ASSERT_OK(tablet->tablet()->Flush()); ASSERT_EQ(1, num_diskrowsets->value()); } diff --git a/src/kudu/tserver/ts_tablet_manager-test.cc b/src/kudu/tserver/ts_tablet_manager-test.cc index 0dd569f..6e5544d 100644 --- a/src/kudu/tserver/ts_tablet_manager-test.cc +++ b/src/kudu/tserver/ts_tablet_manager-test.cc @@ -52,10 +52,10 @@ #include "kudu/util/test_util.h" #define ASSERT_REPORT_HAS_UPDATED_TABLET(report, tablet_id) \ - ASSERT_NO_FATAL_FAILURE(AssertReportHasUpdatedTablet(report, tablet_id)) + NO_FATALS(AssertReportHasUpdatedTablet(report, tablet_id)) #define ASSERT_MONOTONIC_REPORT_SEQNO(report_seqno, tablet_report) \ - ASSERT_NO_FATAL_FAILURE(AssertMonotonicReportSeqno(report_seqno, tablet_report)) + NO_FATALS(AssertMonotonicReportSeqno(report_seqno, tablet_report)) using std::string; using std::vector; diff --git a/src/kudu/util/env-test.cc b/src/kudu/util/env-test.cc index 5bc1f0b..e668461 100644 --- a/src/kudu/util/env-test.cc +++ b/src/kudu/util/env-test.cc @@ -167,7 +167,7 @@ class TestEnv : public KuduTest { unique_ptr<uint8_t[]> scratch(new uint8_t[n]); Slice s(scratch.get(), n); ASSERT_OK(raf->Read(offset, s)); - ASSERT_NO_FATAL_FAILURE(VerifyTestData(s, offset)); + NO_FATALS(VerifyTestData(s, offset)); } void TestAppendV(size_t num_slices, size_t slice_size, size_t iterations, @@ -213,8 +213,8 @@ class TestEnv : public KuduTest { if (!fast) { // Verify as write. Note: this requires that file is pre-allocated, otherwise // the Read() fails with EINVAL. - ASSERT_NO_FATAL_FAILURE(ReadAndVerifyTestData(raf.get(), num_slices * slice_size * i, - num_slices * slice_size)); + NO_FATALS(ReadAndVerifyTestData(raf.get(), num_slices * slice_size * i, + num_slices * slice_size)); } } } @@ -226,8 +226,8 @@ class TestEnv : public KuduTest { ASSERT_OK(env_util::OpenFileForRandom(env_, kTestPath, &raf)); } for (int i = 0; i < iterations; i++) { - ASSERT_NO_FATAL_FAILURE(ReadAndVerifyTestData(raf.get(), num_slices * slice_size * i, - num_slices * slice_size)); + NO_FATALS(ReadAndVerifyTestData(raf.get(), num_slices * slice_size * i, + num_slices * slice_size)); } } @@ -474,7 +474,7 @@ TEST_F(TestEnv, TestReadFully) { Env* env = Env::Default(); WriteTestFile(env, kTestPath, kFileSize); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); // Reopen for read shared_ptr<RandomAccessFile> raf; @@ -571,15 +571,15 @@ TEST_F(TestEnv, TestIOVMax) { TEST_F(TestEnv, TestAppendV) { WritableFileOptions opts; LOG(INFO) << "Testing AppendV() only, NO pre-allocation"; - ASSERT_NO_FATAL_FAILURE(TestAppendV(2000, 1024, 5, true, false, opts)); + NO_FATALS(TestAppendV(2000, 1024, 5, true, false, opts)); if (!fallocate_supported_) { LOG(INFO) << "fallocate not supported, skipping preallocated runs"; } else { LOG(INFO) << "Testing AppendV() only, WITH pre-allocation"; - ASSERT_NO_FATAL_FAILURE(TestAppendV(2000, 1024, 5, true, true, opts)); + NO_FATALS(TestAppendV(2000, 1024, 5, true, true, opts)); LOG(INFO) << "Testing AppendV() together with Append() and Read(), WITH pre-allocation"; - ASSERT_NO_FATAL_FAILURE(TestAppendV(128, 4096, 5, false, true, opts)); + NO_FATALS(TestAppendV(128, 4096, 5, false, true, opts)); } } @@ -592,7 +592,7 @@ TEST_F(TestEnv, TestGetExecutablePath) { TEST_F(TestEnv, TestOpenEmptyRandomAccessFile) { Env* env = Env::Default(); string test_file = GetTestPath("test_file"); - ASSERT_NO_FATAL_FAILURE(WriteTestFile(env, test_file, 0)); + NO_FATALS(WriteTestFile(env, test_file, 0)); unique_ptr<RandomAccessFile> readable_file; ASSERT_OK(env->NewRandomAccessFile(test_file, &readable_file)); uint64_t size; diff --git a/src/kudu/util/trace-test.cc b/src/kudu/util/trace-test.cc index ed0b577..9473a54 100644 --- a/src/kudu/util/trace-test.cc +++ b/src/kudu/util/trace-test.cc @@ -538,7 +538,7 @@ TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording1) { TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL); DropTracedMetadataRecords(); - ASSERT_NO_FATAL_FAILURE(); + NO_FATALS(); VerifyCallbackAndRecordedEvents(2, 2); }
