public void when_disposed_then_disposes_all_items()
{
// ACT
_disposableCollection.Dispose();
// ASSERT
Assert.True(_disposable1.HasBeenDisposed);
Assert.True(_disposable2.HasBeenDisposed);
}
public void Dispose_Count_IsEmpty()
{
var collection = new DisposableCollection();
collection.Dispose();
var count = collection.Count;
Assert.AreEqual(0, count);
}
static void Main(string[] args)
{
using (var token = event1.Register(Event1))
{
event1.Invoke(); // Outputs "Received event1!"
}
event1.Invoke(); // Outputs nothing
var token1 = event2.Register(x => Console.WriteLine("Got: " + x));
var token2 = event2.Register(x => Console.WriteLine("Really got: " + x));
var token3 = event2.Register(x => Console.WriteLine("Yes! I've got: " + x));
event2.Invoke("Ham"); // Outputs "Got: Ham", "Really got: Ham", "Yes! I've got: Ham"
token2.Dispose();
event2.Invoke("Ham"); // Outputs "Got: Ham", "Yes! I've got: Ham"
var tokens = new DisposableCollection();
tokens.Add(token1);
tokens.Add(token3);
tokens.Dispose();
event2.Invoke("Milk?"); // Outputs nothing
}
public void TestDisposing()
{
var disposable = new Disposable();
var disposables = new DisposableCollection(disposable);
disposables.Dispose();
Assert.True(disposable.IsDisposed);
}
public void Add_Dispose()
{
var collection = new DisposableCollection();
var disposable = new Mock<IDisposable>(MockBehavior.Strict);
disposable.Setup(_ => _.Dispose());
collection.Add(disposable.Object);
collection.Dispose();
disposable.Verify(_ => _.Dispose(), Times.Once);
Assert.AreEqual(0, collection.Count);
}
public void TestObjectDisposedException()
{
var c = new DisposableCollection();
c.Dispose();
c.Dispose(); // second call should have no effect
Assert.ThrowsException <ObjectDisposedException>(() =>
c.Add(new MockDisposable()));
Assert.ThrowsException <ObjectDisposedException>(() =>
c.Clear());
Assert.ThrowsException <ObjectDisposedException>(() =>
c.Contains(new MockDisposable()));
Assert.ThrowsException <ObjectDisposedException>(() =>
c.GetEnumerator());
Assert.ThrowsException <ObjectDisposedException>(() =>
c.Remove(new MockDisposable()));
}
public void Throws_ObjectDisposedException()
{
var d1 = new Component();
var collection = new DisposableCollection {d1};
collection.Dispose();
Assert.Throws<ObjectDisposedException>(() => collection.Add(d1));
Assert.Throws<ObjectDisposedException>(() => collection.Insert(0, d1));
// Cannot test object disposed exception for removal, as the collection
// is empty after it has been disposed.
Assert.AreEqual(0, collection.Count);
}
protected override void Dispose(bool disposing)
{
if (_isDisposed)
{
return;
}
if (disposing && _disposeTexturesWhenClose)
{
_textures.Dispose();
}
_isDisposed = true;
}
public void EndGame(Side winner)
{
Debug.LogFormat("End multiplayer game, winner: {0}", winner);
if (winner == Side.Bottom)
{
Model.CheckBestScore();
}
OnGameOver.Dispatch(winner);
if (Model.IsHost)
{
_netService.SendGameOver(winner);
}
_disposableCollection.Dispose();
}
public void Dispose_DoubleDisposeWorks()
{
var expected = new TestDisposableObject();
//Act
using (var target = new DisposableCollection())
{
target.Add(expected);
target.Dispose();
};
//Assert
expected.IsDisposed.Should().BeTrue();
}
public void DisposableCollection_Dispose()
{
_count = 0;
DisposableCollection <Dummy> collection
= new DisposableCollection <Dummy>
{
new Dummy(),
new Dummy(),
new Dummy()
};
collection.Dispose();
Assert.AreEqual(3, _count);
}
public void TestBasicDisposal()
{
var d1 = new MockDisposable();
var d2 = new MockDisposable();
Assert.IsFalse(d1.Disposed);
Assert.IsFalse(d2.Disposed);
var coll = new DisposableCollection {
d1, d2
};
coll.Dispose();
Assert.IsTrue(d1.Disposed);
Assert.IsTrue(d2.Disposed);
}
public void Add_and_dispose()
{
var collection = new DisposableCollection();
var d1 = new Component();
var d2 = new DodgyDisposable();
var d3 = new Component();
collection.Add(d1);
collection.Add(d2);
collection.Add(d3);
var d1Disposed = false;
d1.Disposed += (sender, args) => d1Disposed = true;
var d3Disposed = false;
d3.Disposed += (sender, args) => d3Disposed = true;
Assert.IsFalse(collection.IsDisposed);
collection.Dispose();
Assert.IsTrue(collection.IsDisposed);
Assert.IsTrue(d1Disposed);
Assert.IsTrue(d3Disposed);
Assert.AreEqual(1, d2.DisposeCount);
}
public void TearDown()
{
_disposables.Dispose();
}
public void Dispose_Add_Fail()
{
var collection = new DisposableCollection();
collection.Dispose();
collection.Add(Disposable.Empty);
}
public void Dispose()
{
_bindings.Dispose();
_appliedBindings.Dispose();
}
public void Dispose_Remove_Fail()
{
var collection = new DisposableCollection();
collection.Dispose();
collection.Remove(Disposable.Empty);
}
public void Dispose_Reverse()
{
var order = String.Empty;
var collection = new DisposableCollection();
const int count = 6;
for (var i = 1; i <= count; ++i)
{
var local = i;
var disposable = new Mock<IDisposable>(MockBehavior.Strict);
disposable.Setup(_ => _.Dispose()).Callback(() => order += local);
collection.Add(disposable.Object);
}
Assert.AreEqual(count, collection.Count);
collection.Dispose();
Assert.AreEqual(0, collection.Count);
Assert.AreEqual("654321", order);
}
public void Dispose_Clear_Fail()
{
var collection = new DisposableCollection();
collection.Dispose();
collection.Clear();
}
private IDisposable SetupOpenCL(out Context context, out Device device, out CommandQueue commandQueue, out Kernel kernel, out Kernel kernel4, bool runOnGPU, bool useRelaxedMath, bool enableProfiling)
{
var disposables = new DisposableCollection <IDisposable>(true);
try
{
string buildOptions = "-cl-fast-relaxed-math";
if (runOnGPU)
{
Console.WriteLine("Trying to run on a processor graphics");
}
else
{
Console.WriteLine("Trying to run on a CPU");
}
Platform platform = GetIntelOpenCLPlatform();
Assert.IsNotNull(platform, "Failed to find Intel OpenCL platform.");
// create the OpenCL context
if (runOnGPU)
{
Device[] devices = platform.GetDevices(DeviceType.Gpu);
device = devices[0];
context = Context.Create(device);
disposables.Add(context);
}
else
{
Device[] devices = platform.GetDevices(DeviceType.Cpu);
device = devices[0];
context = Context.Create(device);
}
commandQueue = context.CreateCommandQueue(device, enableProfiling ? CommandQueueProperties.ProfilingEnable : 0);
disposables.Add(commandQueue);
string source = @"
__kernel void
SimpleKernel( const __global float *input, __global float *output)
{
size_t index = get_global_id(0);
output[index] = rsqrt(fabs(input[index]));
}
__kernel /*__attribute__((vec_type_hint(float4))) */ void
SimpleKernel4( const __global float4 *input, __global float4 *output)
{
size_t index = get_global_id(0);
output[index] = rsqrt(fabs(input[index]));
}
";
Program program = context.CreateProgramWithSource(source);
disposables.Add(program);
program.Build(useRelaxedMath ? buildOptions : null);
kernel = program.CreateKernel("SimpleKernel");
disposables.Add(kernel);
kernel4 = program.CreateKernel("SimpleKernel4");
disposables.Add(kernel4);
Console.WriteLine("Using device {0}...", device.Name);
Console.WriteLine("Using {0} compute units...", device.MaxComputeUnits);
Console.WriteLine("Buffer alignment required for zero-copying is {0} bytes", device.MemoryBaseAddressAlignment);
}
catch
{
disposables.Dispose();
throw;
}
return(disposables);
}
public void Add_Remove_Dispose()
{
var collection = new DisposableCollection();
var disposable = new Mock<IDisposable>(MockBehavior.Strict);
disposable.Setup(_ => _.Dispose());
collection.Add(disposable.Object);
var contains = collection.Remove(disposable.Object);
Assert.IsTrue(contains);
collection.Dispose();
disposable.Verify(_ => _.Dispose(), Times.Never);
Assert.AreEqual(0, collection.Count);
}
public void Dispose()
{
_disposableCollection.Dispose();
}
private IDisposable SetupOpenCL(out Context context, out Device device, out CommandQueue commandQueue, out Kernel kernel, out Kernel kernel4, bool runOnGPU, bool useRelaxedMath, bool enableProfiling)
{
DisposableCollection<IDisposable> disposables = new DisposableCollection<IDisposable>(true);
try
{
string buildOptions = "-cl-fast-relaxed-math";
if (runOnGPU)
Console.WriteLine("Trying to run on a processor graphics");
else
Console.WriteLine("Trying to run on a CPU");
Platform platform = GetIntelOpenCLPlatform();
Assert.IsNotNull(platform, "Failed to find Intel OpenCL platform.");
// create the OpenCL context
if (runOnGPU)
{
Device[] devices = platform.GetDevices(DeviceType.Gpu);
device = devices[0];
context = Context.Create(device);
disposables.Add(context);
}
else
{
Device[] devices = platform.GetDevices(DeviceType.Cpu);
device = devices[0];
context = Context.Create(device);
}
commandQueue = context.CreateCommandQueue(device, enableProfiling ? CommandQueueProperties.ProfilingEnable : 0);
disposables.Add(commandQueue);
string source = @"
__kernel void
SimpleKernel( const __global float *input, __global float *output)
{
size_t index = get_global_id(0);
output[index] = rsqrt(fabs(input[index]));
}
__kernel /*__attribute__((vec_type_hint(float4))) */ void
SimpleKernel4( const __global float4 *input, __global float4 *output)
{
size_t index = get_global_id(0);
output[index] = rsqrt(fabs(input[index]));
}
";
Program program = context.CreateProgramWithSource(source);
disposables.Add(program);
program.Build(useRelaxedMath ? buildOptions : null);
kernel = program.CreateKernel("SimpleKernel");
disposables.Add(kernel);
kernel4 = program.CreateKernel("SimpleKernel4");
disposables.Add(kernel4);
Console.WriteLine("Using device {0}...", device.Name);
Console.WriteLine("Using {0} compute units...", device.MaxComputeUnits);
Console.WriteLine("Buffer alignment required for zero-copying is {0} bytes", device.MemoryBaseAddressAlignment);
}
catch
{
disposables.Dispose();
throw;
}
return disposables;
}
public void TearDown()
{
_disposableCollection.Dispose();
}
public void Dispose()
{
_tokens?.Dispose();
}