RabbitMqMessageQueue GetQueue(string queueName, bool removeExiting = false, bool oneExchangePerType = false, string inputExchange = null) { if (removeExiting) { DeleteQueue(queueName); } if (removeExiting && inputExchange != null) { DeleteExchange(inputExchange); } queuesToDelete.Add(queueName); var queue = new RabbitMqMessageQueue(ConnectionString, queueName); if (oneExchangePerType) { queue.UseExchange(null); } if (inputExchange != null) { queue.UseExchangeAsInputAddress(inputExchange); } DisposableTracker.TrackDisposable(queue); return(queue.PurgeInputQueue()); }
public void UnregisterTrackedTypeStopsTracking() { DisposableTracker.RegisterTrackedType(typeof(TestDisposable)); DisposableTracker.RegisterTrackedType(typeof(ReferenceCounted)); using (var t = new TestDisposable()) using (var t2 = new ReferenceCounted()) { //Confirm both items tracked int trackedItems = 0; DisposableTracker.EnumerateTrackedInstances((td) => trackedItems++); Assert.AreEqual(2, trackedItems); trackedItems = 0; //Remove one type, and check only one instance being tracked DisposableTracker.UnregisterTrackedType(typeof(TestDisposable)); DisposableTracker.EnumerateTrackedInstances((td) => trackedItems++); Assert.AreEqual(1, trackedItems); trackedItems = 0; //Create another instance of the type NOT being tracked //and ensure still only one tracked instance. using (var t3 = new TestDisposable()) { DisposableTracker.EnumerateTrackedInstances((td) => trackedItems++); Assert.AreEqual(1, trackedItems); } } }
private GridDefinition GetGridModel() { return(new GridDefinition { InitialPageSize = 20, ModuleGuid = Module.ModuleGuid, SettingsModuleGuid = Module.PermanentGuid, RecordType = typeof(BrowseItem), AjaxUrl = GetActionUrl(nameof(DisposableTrackerBrowse_GridData)), SortFilterStaticData = (List <object> data, int skip, int take, List <DataProviderSortInfo> sorts, List <DataProviderFilterInfo> filters) => { DataProviderGetRecords <BrowseItem> recs = DataProviderImpl <BrowseItem> .GetRecords(data, skip, take, sorts, filters); foreach (BrowseItem r in recs.Data) { r.Module = Module; } return new DataSourceResult { Data = recs.Data.ToList <object>(), Total = recs.Total, }; }, DirectDataAsync = (int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) => { List <BrowseItem> items = (from k in DisposableTracker.GetDisposableObjects() select new BrowseItem(Module, k)).ToList(); DataProviderGetRecords <BrowseItem> recs = DataProviderImpl <BrowseItem> .GetRecords(items, skip, take, sort, filters); DataSourceResult data = new DataSourceResult { Data = recs.Data.ToList <object>(), Total = recs.Total }; return Task.FromResult(data); }, }); }
/// <summary> /// Constructor. /// </summary> /// <param name="configString">The Redis configuration string used to connect to the Redis server.</param> /// <param name="keyPrefix">The string used to prefix all keys used.</param> public LockRedisProvider(string configString, string keyPrefix) { Redis = ConnectionMultiplexer.Connect(configString); KeyPrefix = keyPrefix; Id = Guid.NewGuid(); DisposableTracker.AddObject(this); }
protected virtual void Dispose(bool disposing) { if (disposing) { DisposableTracker.RemoveObject(this); } }
RabbitMqMessageQueue GetQueue(string queueName) { queuesToDelete.Add(queueName); var queue = new RabbitMqMessageQueue(ConnectionString, queueName); DisposableTracker.TrackDisposable(queue); return(queue.PurgeInputQueue()); }
public NativeGatewayServer(IAgentLibrary agentLibrary, Guid sessionUid, GatewaySettings gatewaySettings) { _disposableTracker = new DisposableTracker(this); _agentLibrary = agentLibrary; _gatewaySettings = gatewaySettings; _token = agentLibrary.GatewayServerCreate(sessionUid); _handlers = new Dictionary <byte, INativeDataHandler>(); }
public ManagedGatewayServer(IStreamFactory streamFactory, GatewaySettings gatewaySettings) { _disposableTracker = new DisposableTracker(this); _gatewaySettings = gatewaySettings; _streamFactory = streamFactory; _handlers = new IManagedDataHandler[DataHandlersMaxCount]; _streams = new List <GatewayStream>(); }
public FileStream(string filePath, FileMode mode, FileAccess Access = FileAccess.ReadWrite) { FilePath = filePath; Closed = false; Mode = mode; Stream = new System.IO.FileStream(filePath, Mode, Access); DisposableTracker.AddObject(this); }
private static async Task <DebugSession> CreateDebugSession(DisposableTracker tracker) { var taskTarget = tracker.Track(new HeapAnalysisTargetProcess()); var process = taskTarget.Start(); await taskTarget.WaitForTask(); return(tracker.Track(DebugSession.Create(ProcessInfo.FromProcess(process), DebugMode.Snapshot))); }
protected void Close() { if (!Closed) { Stream.Close(); DisposableTracker.RemoveObject(this); Closed = true; } }
public void AddReturnsSameInstance() { var tracker = new DisposableTracker(); var disposable = new Disposable(); Assert.AreSame( disposable, tracker.Track(disposable), "the value returned by Add should be the same as the passed object"); }
public static async Task WriteMemoryDump(string filePath) { using (var tracker = new DisposableTracker()) { var session = await CreateDebugSession(tracker); DumpMemoryJob.DumpSession(session, filePath); } }
protected ProxyBaseObject(T remoteObject, bool resolveRealRemoteObject) { _disposableTracker = new DisposableTracker(this); if (resolveRealRemoteObject) { remoteObject = ProxyBaseObjectHelper.ResolveRealRemoteObject(remoteObject); } _sponsorshipCookie = InitializeSponsorship(remoteObject); RemoteObject = remoteObject; }
protected virtual void Dispose(bool disposing) { if (disposing) { DisposableTracker.RemoveObject(this); YetaWFManager.Syncify(async() => // Only used if caller forgets to Unlock await UnlockAsync() ); } }
public void SutIsNode() { // Arrange var dummyBuilder = new DelegatingSpecimenBuilder(); // Act var sut = new DisposableTracker(dummyBuilder); // Assert Assert.IsAssignableFrom <ISpecimenBuilderNode>(sut); }
public Task CloseAsync() { if (!Closed) { Stream.Close(); DisposableTracker.RemoveObject(this); Closed = true; } return(Task.CompletedTask); }
public static HeapAnalysisScope LoadMemoryDump(string filePath) { using (var tracker = new DisposableTracker()) { var session = tracker.Track(DebugSession.Load(filePath)); var subject = GetSubjectFromSession(session); return(tracker.TransferOwnershipTo(t => new HeapAnalysisScope(t, subject))); } }
public void SutIsNode() { // Fixture setup var dummyBuilder = new DelegatingSpecimenBuilder(); // Exercise system var sut = new DisposableTracker(dummyBuilder); // Verify outcome Assert.IsAssignableFrom <ISpecimenBuilderNode>(sut); // Teardown }
public void SutYieldsInjectedBuilder() { // Arrange var expected = new DelegatingSpecimenBuilder(); var sut = new DisposableTracker(expected); // Act // Assert Assert.Equal(expected, sut.Single()); Assert.Equal(expected, ((System.Collections.IEnumerable)sut).Cast <object>().Single()); }
public void BuilderIsCorrect() { // Arrange var expectedBuilder = new DelegatingSpecimenBuilder(); var sut = new DisposableTracker(expectedBuilder); // Act ISpecimenBuilder result = sut.Builder; // Assert Assert.Equal(expectedBuilder, result); }
public void DisposablesIsInstance() { // Arrange var dummyBuilder = new DelegatingSpecimenBuilder(); var sut = new DisposableTracker(dummyBuilder); // Act IEnumerable <IDisposable> result = sut.Disposables; // Assert Assert.NotNull(result); }
public static async Task <HeapAnalysisScope> Create() { using (var tracker = new DisposableTracker()) { var session = await CreateDebugSession(tracker); var subject = GetSubjectFromSession(session); return(tracker.TransferOwnershipTo(t => new HeapAnalysisScope(t, subject))); } }
public void AddAfterTrackerDisposedDisposesObjectImmediately() { var tracker = new DisposableTracker(); var disposable = new Disposable(); tracker.Dispose(); tracker.Track(disposable); Assert.IsTrue( disposable.IsDisposed, "the disposable should be disposed immediately when added to a disposed tracker"); }
public void AddBeforeTrackerDisposedDoesNotDisposeItem() { var tracker = new DisposableTracker(); var disposable = new Disposable(); tracker.Track(disposable); Assert.IsFalse( disposable.IsDisposed, "the disposable should not be disposed until the tracker is"); }
public void DisposablesIsInstance() { // Fixture setup var dummyBuilder = new DelegatingSpecimenBuilder(); var sut = new DisposableTracker(dummyBuilder); // Exercise system IEnumerable <IDisposable> result = sut.Disposables; // Verify outcome Assert.NotNull(result); // Teardown }
public void BuilderIsCorrect() { // Fixture setup var expectedBuilder = new DelegatingSpecimenBuilder(); var sut = new DisposableTracker(expectedBuilder); // Exercise system ISpecimenBuilder result = sut.Builder; // Verify outcome Assert.Equal(expectedBuilder, result); // Teardown }
public void TracksOnlyRegisteredTypes() { DisposableTracker.RegisterTrackedType(typeof(TestDisposable)); using (var t = new TestDisposable()) using (var t2 = new ReferenceCounted()) { int trackedItems = 0; DisposableTracker.EnumerateTrackedInstances((td) => trackedItems++); Assert.AreEqual(1, trackedItems); } }
public void SutYieldsInjectedBuilder() { // Fixture setup var expected = new DelegatingSpecimenBuilder(); var sut = new DisposableTracker(expected); // Exercise system // Verify outcome Assert.Equal(expected, sut.Single()); Assert.Equal(expected, ((System.Collections.IEnumerable)sut).Cast <object>().Single()); // Teardown }
public void OutputsStackTraceWhenCaptured() { DisposableTracker.Enabled = false; DisposableTracker.Enabled = true; DisposableTracker.CaptureStackTraceAtCreation = true; var disposable = new TestDisposable(); var sb = new StringBuilder(); DisposableTracker.EnumerateTrackedInstances((td) => sb.Append(td.CreationStackTrace)); Assert.IsTrue(sb.Length > 0); System.Diagnostics.Trace.WriteLine(sb.ToString()); }
public FixtureBase() { Disposables = new DisposableTracker(); }