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();
}
