// BackupMetadataFile WriteAysnc function with cancellation token canceled test // 1. Set up the expected values. // 2. WriteAsync call with cancellation token got canceled // 3. Verify it throws and the exception is as expected Awaitable<void> BackupMetadataFileTests::Test_BackupMetadataFile_WriteAsync_WithCanceledToken_Throws( __in KString const & fileName) { NTSTATUS status = STATUS_UNSUCCESSFUL; KAllocator & allocator = underlyingSystem_->PagedAllocator(); KWString filePath(allocator, fileName); BackupMetadataFile::SPtr backupMetadataFileSPtr = nullptr; status = BackupMetadataFile::Create( *prId_, filePath, allocator, backupMetadataFileSPtr); VERIFY_IS_TRUE(NT_SUCCESS(status)); // Expected const FABRIC_BACKUP_OPTION expectedBackupOption = FABRIC_BACKUP_OPTION_FULL; KGuid expectedParentBackupId; expectedParentBackupId.CreateNew(); KGuid expectedBackupId; expectedBackupId.CreateNew(); KGuid expectedPartitionId; expectedPartitionId.CreateNew(); const FABRIC_REPLICA_ID expectedReplicaId = 16; const LONG64 expectedDataLossNumber = 32; const LONG64 expectedConfigurationNumber = 64; TxnReplicator::Epoch expectedStartingEpoch = TxnReplicator::Epoch(expectedDataLossNumber, expectedConfigurationNumber); FABRIC_SEQUENCE_NUMBER expectedStartingLSN = 8; TxnReplicator::Epoch expectedBackupEpoch = TxnReplicator::Epoch(expectedDataLossNumber, expectedConfigurationNumber); FABRIC_SEQUENCE_NUMBER expectedBackupLSN = 128; CancellationTokenSource::SPtr cts; status = CancellationTokenSource::Create(allocator, BACKUPMETADATAFILETEST_TAG, cts); VERIFY_IS_TRUE(NT_SUCCESS(status)); cts->Cancel(); status = co_await backupMetadataFileSPtr->WriteAsync( expectedBackupOption, expectedParentBackupId, expectedBackupId, expectedPartitionId, expectedReplicaId, expectedStartingEpoch, expectedStartingLSN, expectedBackupEpoch, expectedBackupLSN, cts->Token); VERIFY_ARE_EQUAL(STATUS_CANCELLED, status); Common::File::Delete(static_cast<LPCWSTR>(fileName), true); }
void ReplicaManagerWrapper::UpdateConfiguration( wstring const & previousReplicasDescription, ULONG previousQuorum, wstring const & currentReplicasDescription, ULONG currentQuorum) { ReplicaInformationVector previousActiveReplicas; size_t previousReplicaCount; GenerateActiveReplicas(previousReplicasDescription, previousReplicaCount, previousActiveReplicas); ReplicaInformationVector currentActiveReplicas; size_t currentReplicaCount; GenerateActiveReplicas(currentReplicasDescription, currentReplicaCount, currentActiveReplicas); Trace.WriteInfo(TestReplicaManagerSource, "*********** UpdateConfiguration with current replicas: {0}, quorum {1}, previous: {2}, quorum {3}", currentReplicasDescription, currentQuorum, previousReplicasDescription, previousQuorum); auto error = replicaManagerSPtr_->UpdateConfiguration( previousActiveReplicas, previousQuorum, currentActiveReplicas, currentQuorum, true, true); VERIFY_IS_TRUE(error.IsSuccess(), L"UpdateConfiguration (catchup replicas set) should succeed"); }
TEST_FIXTURE(e2e_raw_client, update_entity_with_patch) { auto model = client.get_model().get(); //check the old value auto query_result = client.get_data_from_server(U("Accounts(101)")).get(); auto old_entity = std::dynamic_pointer_cast<odata_entity_value>(query_result[0]); std::shared_ptr<odata_value> old_value; old_entity->get_property_value(U("Country"), old_value); auto old_country = std::dynamic_pointer_cast<odata_primitive_value>(old_value); VERIFY_ARE_EQUAL(U("US"), old_country->as<::utility::string_t>()); //update the entity with patch old_entity->set_value(U("Country"), U("GB")); auto response_code = client.patch_entity(U("Accounts"), old_entity).get(); VERIFY_ARE_EQUAL(204, response_code); //query the updated entity auto check_query = client.get_data_from_server(U("Accounts(101)")).get(); auto new_entity = std::dynamic_pointer_cast<odata_entity_value>(check_query[0]); std::shared_ptr<odata_value> property_value; VERIFY_IS_TRUE(new_entity->get_property_value(U("Country"), property_value)); auto primitive_value = std::dynamic_pointer_cast<odata_primitive_value>(property_value); ::utility::string_t new_country = primitive_value->as<::utility::string_t>(); VERIFY_ARE_EQUAL(U("GB"), new_country); }
TEST_FIXTURE(e2e_raw_client, create_entity) { auto model = client.get_model().get(); ::utility::string_t entity_set_name = U("Accounts"); std::shared_ptr<odata_entity_value> entity = std::make_shared<odata_entity_value>(model->find_entity_set_type(entity_set_name)); entity->set_value(U("AccountID"), 130); entity->set_value(U("Country"), U("CN")); auto accountinfo_type = model->find_complex_type(U("AccountInfo")); auto account_info = std::make_shared<odata_complex_value>(accountinfo_type); ::utility::string_t account_firstname = U("cpp"); ::utility::string_t account_lastname = U("client"); account_info->set_value(U("FirstName"), account_firstname); account_info->set_value(U("LastName"), account_lastname); entity->set_value(U("AccountInfo"), account_info); auto response_code = client.create_entity(entity_set_name, entity).get(); VERIFY_ARE_EQUAL(201, response_code); //query the newly created entity auto query_result = client.get_data_from_server(U("Accounts(130)")).get(); VERIFY_ARE_EQUAL(query_result.size(), 1); auto new_entity = std::dynamic_pointer_cast<odata_entity_value>(query_result[0]); std::shared_ptr<odata_value> property_value; VERIFY_IS_TRUE(entity->get_property_value(U("AccountID"), property_value)); auto primitive_value = std::dynamic_pointer_cast<odata_primitive_value>(property_value); int32_t new_id = primitive_value->as<int32_t>(); VERIFY_ARE_EQUAL(130, new_id); }
template <bool ManualReset> void AsyncWaitHandleDestructRaceCallback() { auto wh = make_shared<AsyncWaitHandle<ManualReset>>(); AutoResetEvent callbackCanStart(false); AutoResetEvent resultEvent(false); wh->BeginWaitOne( TimeSpan::MaxValue, [&resultEvent, &callbackCanStart] (AsyncOperationSPtr const & op) mutable { Trace.WriteInfo(TraceType, "callback waiting for action"); callbackCanStart.WaitOne(); Trace.WriteInfo(TraceType, "callback starting action"); ErrorCode result = op->End(op); VERIFY_IS_TRUE(result.IsSuccess()); resultEvent.Set(); Trace.WriteInfo(TraceType, "leaving callback"); }, AsyncOperationSPtr()); //make wh destruction and callback race wh->Set(); wh.reset(); callbackCanStart.Set(); BOOST_REQUIRE(resultEvent.WaitOne(TimeSpan::FromSeconds(60))); }
void FontTests::TestSetFontAdjustsWindow() { if (!OneCoreDelay::IsIsWindowPresent()) { Log::Comment(L"Adjusting window size by changing font scenario can't be checked on platform without classic window operations."); Log::Result(WEX::Logging::TestResults::Skipped); return; } const HANDLE hConsoleOutput = GetStdOutputHandle(); const HWND hwnd = GetConsoleWindow(); VERIFY_IS_TRUE(!!IsWindow(hwnd)); RECT rc = { 0 }; CONSOLE_FONT_INFOEX cfiex = { 0 }; cfiex.cbSize = sizeof(cfiex); Log::Comment(L"First set the console window to Consolas 16."); wcscpy_s(cfiex.FaceName, L"Consolas"); cfiex.dwFontSize.Y = 16; VERIFY_WIN32_BOOL_SUCCEEDED(OneCoreDelay::SetCurrentConsoleFontEx(hConsoleOutput, FALSE, &cfiex)); Sleep(250); VERIFY_WIN32_BOOL_SUCCEEDED(GetClientRect(hwnd, &rc), L"Retrieve client rectangle size for Consolas 16."); SIZE szConsolas; szConsolas.cx = rc.right - rc.left; szConsolas.cy = rc.bottom - rc.top; Log::Comment(NoThrowString().Format(L"Client rect size is (X: %d, Y: %d)", szConsolas.cx, szConsolas.cy)); Log::Comment(L"Adjust console window to Lucida Console 12."); wcscpy_s(cfiex.FaceName, L"Lucida Console"); cfiex.dwFontSize.Y = 12; VERIFY_WIN32_BOOL_SUCCEEDED(OneCoreDelay::SetCurrentConsoleFontEx(hConsoleOutput, FALSE, &cfiex)); Sleep(250); VERIFY_WIN32_BOOL_SUCCEEDED(GetClientRect(hwnd, &rc), L"Retrieve client rectangle size for Lucida Console 12."); SIZE szLucida; szLucida.cx = rc.right - rc.left; szLucida.cy = rc.bottom - rc.top; Log::Comment(NoThrowString().Format(L"Client rect size is (X: %d, Y: %d)", szLucida.cx, szLucida.cy)); Log::Comment(L"Window should shrink in size when going to Lucida 12 from Consolas 16."); VERIFY_IS_LESS_THAN(szLucida.cx, szConsolas.cx); VERIFY_IS_LESS_THAN(szLucida.cy, szConsolas.cy); Log::Comment(L"Adjust console window back to Consolas 16."); wcscpy_s(cfiex.FaceName, L"Consolas"); cfiex.dwFontSize.Y = 16; VERIFY_WIN32_BOOL_SUCCEEDED(OneCoreDelay::SetCurrentConsoleFontEx(hConsoleOutput, FALSE, &cfiex)); Sleep(250); VERIFY_WIN32_BOOL_SUCCEEDED(GetClientRect(hwnd, &rc), L"Retrieve client rectangle size for Consolas 16."); szConsolas.cx = rc.right - rc.left; szConsolas.cy = rc.bottom - rc.top; Log::Comment(NoThrowString().Format(L"Client rect size is (X: %d, Y: %d)", szConsolas.cx, szConsolas.cy)); Log::Comment(L"Window should grow in size when going from Lucida 12 to Consolas 16."); VERIFY_IS_LESS_THAN(szLucida.cx, szConsolas.cx); VERIFY_IS_LESS_THAN(szLucida.cy, szConsolas.cy); }
void NodeIdRangeTests::TestSubtractRanges(NodeIdRange const & range, vector<NodeIdRange> const & excludes) { vector<NodeIdRange> result; range.Subtract(excludes, result); Trace.WriteInfo(TraceRangeTest, "Range {0} exclude {1} returned {2}", range, excludes, result); LargeInteger overlapSize = LargeInteger::Zero; for (size_t i = 0; i < result.size(); i++) { VERIFY_IS_TRUE(!result[i].IsEmpty); VERIFY_IS_TRUE(range.Contains(result[i])); for (size_t j = 0; j < excludes.size(); j++) { VERIFY_IS_TRUE(result[i].Disjoint(excludes[j])); } overlapSize = overlapSize + GetOverlapSize(range, result[i]); } for (size_t i = 0; i + 1 < result.size(); i++) { for (size_t j = i + 1; j < result.size(); j++) { VERIFY_IS_TRUE(result[i].Disjoint(result[j])); } } for (size_t i = 0; i < excludes.size(); i++) { overlapSize = overlapSize + GetOverlapSize(range, excludes[i]); } VERIFY_IS_TRUE(GetRangeSize(range) == overlapSize); }
void ReplicaManagerWrapper::UpdateConfiguration( ReplicaInformationVector const & previousActiveReplicas, ULONG previousQuorum, ReplicaInformationVector const & currentActiveReplicas, ULONG currentQuorum) { auto error = replicaManagerSPtr_->UpdateConfiguration( previousActiveReplicas, previousQuorum, currentActiveReplicas, currentQuorum, true, true); VERIFY_IS_TRUE(error.IsSuccess(), L"UpdateConfiguration (catchup replicas set) should succeed"); }
void NodeIdRangeTests::TestSubtract(NodeIdRange const & range, NodeIdRange const & exclude) { NodeIdRange range1, range2; range.Subtract(exclude, range1, range2); Trace.WriteInfo(TraceRangeTest, "Range {0} exclude {1} returned {2} and {3}", range, exclude, range1, range2); if (!range1.IsEmpty) { VERIFY_IS_TRUE(range.Contains(range1) && exclude.Disjoint(range1)); if (!range2.IsEmpty) { VERIFY_IS_TRUE(range1.Disjoint(range2) && !range1.IsSuccAdjacent(range2) && !range1.IsPredAdjacent(range2)); } } if (!range2.IsEmpty) { VERIFY_IS_TRUE((range2.IsEmpty || range.Contains(range2)) && exclude.Disjoint(range2)); } VERIFY_IS_TRUE(GetRangeSize(range) == GetOverlapSize(range, exclude) + GetRangeSize(range1) + GetRangeSize(range2)); }
template <bool ManualReset> void AsyncWaitHandleSetBeforeWait() { AsyncWaitHandle<ManualReset> asyncWaitHandle(true); AutoResetEvent resultEvent(false); asyncWaitHandle.BeginWaitOne( TimeSpan::MaxValue, [&asyncWaitHandle, &resultEvent] (AsyncOperationSPtr const & op) { ErrorCode result = asyncWaitHandle.EndWaitOne(op); VERIFY_IS_TRUE(result.IsSuccess()); resultEvent.Set(); }, AsyncOperationSPtr()); BOOST_REQUIRE(resultEvent.WaitOne(TimeSpan::FromSeconds(60))); }
TEST_FIXTURE(e2e_raw_client, query_basic_properties_in_entity) { auto query_result = client.get_data_from_server(U("People(4)")).get(); VERIFY_ARE_EQUAL(query_result.size(), 1); VERIFY_ARE_EQUAL(edm_type_kind_t::Entity, query_result[0]->get_value_type()->get_type_kind()); std::shared_ptr<odata_entity_value> entity = std::dynamic_pointer_cast<odata_entity_value>(query_result[0]); //collection property std::shared_ptr<odata_value> collection_property; VERIFY_IS_TRUE(entity->get_property_value(U("Numbers"), collection_property)); VERIFY_ARE_EQUAL(edm_type_kind_t::Collection, collection_property->get_value_type()->get_type_kind()); auto collection_value = std::dynamic_pointer_cast<odata_collection_value>(collection_property); auto collection_vector = collection_value->get_collection_values(); VERIFY_ARE_EQUAL(3, collection_vector.size()); auto collectin_member = std::dynamic_pointer_cast<odata_primitive_value>(collection_vector[1]); VERIFY_ARE_EQUAL(U("555-555-5555"), collectin_member->as<::utility::string_t>()); //TODO-tiano: check the other property types }
void CreateAndOpenReplicaManager() { perfCounters_ = REPerformanceCounters::CreateInstance(PartitionId,1); IReplicatorHealthClientSPtr temp; ApiMonitoringWrapperSPtr temp2; config_ = REInternalSettings::Create(nullptr,oldConfig_), replicaManagerSPtr_ = std::shared_ptr<ReplicaManager>(new ReplicaManager( config_, false, perfCounters_, 1, /* ReplicaId*/ false, /* requireserviceACK */ endpointUniqueId_, transport_, 0, /* initialProgress */ ReplicaManagerEpoch, stateProvider_, partition_, temp, temp2, PartitionId)); VERIFY_IS_TRUE(replicaManagerSPtr_->Open().IsSuccess(), L"Replica manager opened"); }
Awaitable<void> ReplicatorPerfTest::Run( __in wstring const & testFolder, __in int concurrentTransactions, __in int totalTransactions, __in Data::Log::LogManager & logManager) { #ifndef PERF_TEST UNREFERENCED_PARAMETER(testFolder); UNREFERENCED_PARAMETER(concurrentTransactions); UNREFERENCED_PARAMETER(totalTransactions); UNREFERENCED_PARAMETER(logManager); #else Replica::SPtr replica = Replica::Create( pId_, rId_, testFolder, logManager, underlyingSystem_->PagedAllocator()); co_await replica->OpenAsync(); FABRIC_EPOCH epoch1; epoch1.DataLossNumber = 1; epoch1.ConfigurationNumber = 1; epoch1.Reserved = nullptr; co_await replica->ChangeRoleAsync(epoch1, FABRIC_REPLICA_ROLE_PRIMARY); replica->SetReadStatus(FABRIC_SERVICE_PARTITION_ACCESS_STATUS_GRANTED); replica->SetWriteStatus(FABRIC_SERVICE_PARTITION_ACCESS_STATUS_GRANTED); KUri::CSPtr stateProviderName = GetStateProviderName(0); { Transaction::SPtr txn; replica->TxnReplicator->CreateTransaction(txn); KFinally([&] {txn->Dispose(); }); NTSTATUS status = co_await replica->TxnReplicator->AddAsync(*txn, *stateProviderName, L"ReplicatorPerfTest"); VERIFY_IS_TRUE(NT_SUCCESS(status)); co_await txn->CommitAsync(); } { IStateProvider2::SPtr stateProvider2; NTSTATUS status = replica->TxnReplicator->Get(*stateProviderName, stateProvider2); VERIFY_IS_TRUE(NT_SUCCESS(status)); VERIFY_IS_NOT_NULL(stateProvider2); VERIFY_ARE_EQUAL(*stateProviderName, stateProvider2->GetName()); IStore<int, int>::SPtr store = dynamic_cast<IStore<int, int>*>(stateProvider2.RawPtr()); Stopwatch s; s.Start(); KArray<Awaitable<void>> tasks(underlyingSystem_->PagedAllocator(), concurrentTransactions, 0); for (int i = 0; i < concurrentTransactions; i++) { status = tasks.Append(DoWorkOnKey(store, replica, totalTransactions / concurrentTransactions, i)); KInvariant(NT_SUCCESS(status)); } co_await TaskUtilities<Awaitable<void>>::WhenAll(tasks); s.Stop(); int64 txPerSec = ((totalTransactions * 1000) / s.ElapsedMilliseconds); Trace.WriteInfo( TraceComponent, "{0}: Tx/Sec is {1}", prId_->TraceId, txPerSec); } replica->SetReadStatus(FABRIC_SERVICE_PARTITION_ACCESS_STATUS_NOT_PRIMARY); replica->SetWriteStatus(FABRIC_SERVICE_PARTITION_ACCESS_STATUS_NOT_PRIMARY); co_await replica->CloseAsync(); #endif co_return; }
VOID FailCoalesceFlushTest( KGuid diskId, KtlLogManager::SPtr logManager ) { NTSTATUS status; KGuid logContainerGuid; KtlLogContainerId logContainerId; StreamCloseSynchronizer closeStreamSync; ContainerCloseSynchronizer closeContainerSync; logContainerGuid.CreateNew(); logContainerId = static_cast<KtlLogContainerId>(logContainerGuid); // // Create container and a stream within it // { KtlLogManager::AsyncCreateLogContainer::SPtr createContainerAsync; LONGLONG logSize = DefaultTestLogFileSize; KtlLogContainer::SPtr logContainer; KSynchronizer sync; KGuid logStreamGuid; KtlLogStreamId logStreamId; logStreamGuid.CreateNew(); logStreamId = static_cast<KtlLogStreamId>(logStreamGuid); status = logManager->CreateAsyncCreateLogContainerContext(createContainerAsync); VERIFY_IS_TRUE(NT_SUCCESS(status)); createContainerAsync->StartCreateLogContainer(diskId, logContainerId, logSize, 0, // Max Number Streams 0, // Max Record Size logContainer, NULL, // ParentAsync sync); status = sync.WaitForCompletion(); VERIFY_IS_TRUE(NT_SUCCESS(status)); { KtlLogContainer::AsyncCreateLogStreamContext::SPtr createStreamAsync; KtlLogStream::SPtr logStream; ULONG metadataLength = 0x10000; status = logContainer->CreateAsyncCreateLogStreamContext(createStreamAsync); VERIFY_IS_TRUE(NT_SUCCESS(status)); KBuffer::SPtr securityDescriptor = nullptr; KtlLogStreamType logStreamType = KLogicalLogInformation::GetLogicalLogStreamType(); createStreamAsync->StartCreateLogStream(logStreamId, logStreamType, nullptr, // Alias nullptr, securityDescriptor, metadataLength, DEFAULT_STREAM_SIZE, DEFAULT_MAX_RECORD_SIZE, logStream, NULL, // ParentAsync sync); status = sync.WaitForCompletion(); VERIFY_IS_TRUE(NT_SUCCESS(status)); // // Verify that log stream id is set correctly // KtlLogStreamId queriedLogStreamId; logStream->QueryLogStreamId(queriedLogStreamId); VERIFY_IS_TRUE(queriedLogStreamId.Get() == logStreamId.Get() ? true : false); logStream->StartClose(NULL, closeStreamSync.CloseCompletionCallback()); status = closeStreamSync.WaitForCompletion(); VERIFY_IS_TRUE(NT_SUCCESS(status)); logStream = nullptr; } // // Open the stream // { KtlLogContainer::AsyncOpenLogStreamContext::SPtr openStreamAsync; KtlLogStream::SPtr logStream; ULONG metadataLength; status = logContainer->CreateAsyncOpenLogStreamContext(openStreamAsync); VERIFY_IS_TRUE(NT_SUCCESS(status)); openStreamAsync->StartOpenLogStream(logStreamId, &metadataLength, logStream, NULL, // ParentAsync sync); status = sync.WaitForCompletion(); VERIFY_IS_TRUE(NT_SUCCESS(status)); // // Create an interceptor for the closing flush for the // coalesce records and then apply it. Once applied close // the stream and verify it doesn't stop responding. // status = CompleteOnStartInterceptor<OverlayStream::CoalesceRecords::AsyncAppendOrFlushContext>::Create(KTL_TAG_TEST, *g_Allocator, STATUS_INSUFFICIENT_RESOURCES, FailCoalesceFlushInterceptor); VERIFY_IS_TRUE(NT_SUCCESS(status)); KtlLogStreamUser* logStreamUser = static_cast<KtlLogStreamUser*>(logStream.RawPtr()); KtlLogStreamKernel* logStreamKernel = static_cast<KtlLogStreamKernel*>(logStreamUser->GetKernelPointer()); OverlayStream* overlayStream = logStreamKernel->GetOverlayStream(); OverlayStream::CoalesceRecords* coalesceRecords = (overlayStream->GetCoalesceRecords()).RawPtr(); OverlayStream::CoalesceRecords::AsyncAppendOrFlushContext* closeFlushContext = coalesceRecords->GetCloseFlushContext(); FailCoalesceFlushInterceptor->EnableIntercept(*closeFlushContext); logStream->StartClose(NULL, closeStreamSync.CloseCompletionCallback()); // Allow time for the stream to close and the coalesce // flush async to finish up. KNt::Sleep(1000); FailCoalesceFlushInterceptor->DisableIntercept(); FailCoalesceFlushInterceptor = nullptr; status = closeStreamSync.WaitForCompletion(60 * 1000); VERIFY_IS_TRUE(NT_SUCCESS(status)); logStream = nullptr; } // // Delete the stream // { KtlLogContainer::AsyncDeleteLogStreamContext::SPtr deleteStreamAsync; status = logContainer->CreateAsyncDeleteLogStreamContext(deleteStreamAsync); VERIFY_IS_TRUE(NT_SUCCESS(status)); deleteStreamAsync->StartDeleteLogStream(logStreamId, NULL, // ParentAsync sync); status = sync.WaitForCompletion(); VERIFY_IS_TRUE(NT_SUCCESS(status)); } logContainer->StartClose(NULL, closeContainerSync.CloseCompletionCallback()); status = closeContainerSync.WaitForCompletion(); VERIFY_IS_TRUE(NT_SUCCESS(status)); KtlLogManager::AsyncDeleteLogContainer::SPtr deleteContainerAsync; status = logManager->CreateAsyncDeleteLogContainerContext(deleteContainerAsync); VERIFY_IS_TRUE(NT_SUCCESS(status)); deleteContainerAsync->StartDeleteLogContainer(diskId, logContainerId, NULL, // ParentAsync sync); status = sync.WaitForCompletion(); VERIFY_IS_TRUE(NT_SUCCESS(status)); } }
void CloseReplicaManager() { VERIFY_IS_TRUE(replicaManagerSPtr_->Close(false).IsSuccess(), L"Replica manager closed"); }
void LruCacheTest::PerfTestHelper( int operationCount, size_t capacity, bool enableTrim) { //SetVerifyOutput localVerifySettings(VerifyOutputSettings::LogOnlyFailures); size_t bucketCount = 10240; LruCache<wstring, TestCacheEntry> cache(enableTrim ? capacity : 0, bucketCount); Random rand(static_cast<int>(DateTime::Now().Ticks)); vector<TestCacheEntrySPtr> entries; for (auto ix=0; ix<operationCount; ++ix) { entries.push_back(make_shared<TestCacheEntry>(GetRandomKey(rand))); } Stopwatch stopwatch; // Write stopwatch.Restart(); for (auto it=entries.begin(); it!=entries.end(); ++it) { auto entry = *it; bool success = cache.TryPutOrGet(entry); VERIFY_IS_TRUE(success); } stopwatch.Stop(); Trace.WriteInfo( TraceComponent, "LruCache-put: operations={0} elapsed={1} throughput={2} ops/s", cache.Size, stopwatch.Elapsed, (double)cache.Size / stopwatch.ElapsedMilliseconds * 1000); // Read stopwatch.Restart(); for (auto it=entries.begin(); it!=entries.end(); ++it) { shared_ptr<TestCacheEntry> result; bool success = cache.TryGet((*it)->GetKey(), result); VERIFY_IS_TRUE(success); } stopwatch.Stop(); Trace.WriteInfo( TraceComponent, "LruCache-get: operations={0} elapsed={1} throughput={2} ops/s", cache.Size, stopwatch.Elapsed, (double)cache.Size / stopwatch.ElapsedMilliseconds * 1000); Trace.WriteInfo( TraceComponent, "CacheSize: {0}", cache.Size); }
// BackupMetadataFile Equal function test // 1. Set up the expected values. // 2. Equal call on same BackupMetadataFile should return true. // 3. Equal call on different BackupMetadataFile should return false. Awaitable<void> BackupMetadataFileTests::Test_BackupMetadataFile_Equal( __in KString const & fileName) { NTSTATUS status = STATUS_UNSUCCESSFUL; KAllocator & allocator = underlyingSystem_->PagedAllocator(); KWString filePath(allocator, fileName); BackupMetadataFile::SPtr backupMetadataFileSPtr = nullptr; status = BackupMetadataFile::Create( *prId_, filePath, allocator, backupMetadataFileSPtr); VERIFY_IS_TRUE(NT_SUCCESS(status)); // Expected const FABRIC_BACKUP_OPTION expectedBackupOption = FABRIC_BACKUP_OPTION_FULL; KGuid expectedParentBackupId; expectedParentBackupId.CreateNew(); KGuid expectedBackupId; expectedBackupId.CreateNew(); KGuid expectedPartitionId; expectedPartitionId.CreateNew(); const FABRIC_REPLICA_ID expectedReplicaId = 16; const LONG64 expectedDataLossNumber = 32; const LONG64 expectedConfigurationNumber = 64; TxnReplicator::Epoch expectedStartingEpoch = TxnReplicator::Epoch(expectedDataLossNumber, expectedConfigurationNumber); FABRIC_SEQUENCE_NUMBER expectedStartingLSN = 8; TxnReplicator::Epoch expectedBackupEpoch = TxnReplicator::Epoch(expectedDataLossNumber, expectedConfigurationNumber); FABRIC_SEQUENCE_NUMBER expectedBackupLSN = 128; status = co_await backupMetadataFileSPtr->WriteAsync( expectedBackupOption, expectedParentBackupId, expectedBackupId, expectedPartitionId, expectedReplicaId, expectedStartingEpoch, expectedStartingLSN, expectedBackupEpoch, expectedBackupLSN, CancellationToken::None); VERIFY_IS_TRUE(NT_SUCCESS(status)); KGuid readId; readId.CreateNew(); status = co_await backupMetadataFileSPtr->ReadAsync(readId, CancellationToken::None); VERIFY_IS_TRUE(NT_SUCCESS(status)); // Same BackupMetadataFile should equal CODING_ERROR_ASSERT(backupMetadataFileSPtr->Equals(*backupMetadataFileSPtr)); BackupMetadataFile::SPtr newBackupMetadataFileSPtr = nullptr; status = BackupMetadataFile::Create( *prId_, filePath, allocator, newBackupMetadataFileSPtr); VERIFY_IS_TRUE(NT_SUCCESS(status)); // The new BackupMetadataFile backup option set to incremental. status = co_await newBackupMetadataFileSPtr->WriteAsync( FABRIC_BACKUP_OPTION_INCREMENTAL, expectedParentBackupId, expectedBackupId, expectedPartitionId, expectedReplicaId, expectedStartingEpoch, expectedStartingLSN, expectedBackupEpoch, expectedBackupLSN, CancellationToken::None); VERIFY_IS_TRUE(NT_SUCCESS(status)); status = co_await newBackupMetadataFileSPtr->ReadAsync(readId, CancellationToken::None); VERIFY_IS_TRUE(NT_SUCCESS(status)); // Different BackupMetadataFiles should return false CODING_ERROR_ASSERT(backupMetadataFileSPtr->Equals(*newBackupMetadataFileSPtr) == false); Common::File::Delete(static_cast<LPCWSTR>(fileName), true); }