public void GoodDispose()
{
int dummyHandle = 0xDEAD;
FakeSafeHandle sf = new FakeSafeHandle();
sf.ChangeHandle(new IntPtr(dummyHandle));
Assert.AreEqual((int)sf.DangerousGetHandle(), dummyHandle, "handle");
sf.DangerousRelease();
try {
sf.Close();
Assert.Fail("#1");
} catch (ObjectDisposedException) {
}
try {
sf.Dispose();
Assert.Fail("#2");
} catch (ObjectDisposedException) {
}
//In Ms.Net SafeHandle does not change the value of the handle after being SetInvalid or Disposed.
Assert.AreEqual((int)sf.DangerousGetHandle(), dummyHandle, "handle");
//Handle was closed properly.
Assert.IsTrue(sf.released, "released");
Assert.IsTrue(sf.IsClosed, "closed");
//Handle value is not changed, so the value itself is still valid (not 0 or -1)
Assert.IsFalse(sf.IsInvalid, "invalid");
GC.SuppressFinalize(sf);
}
public void CloseWillDispose()
{
FakeSafeHandle sf = new FakeSafeHandle();
sf.Close();
Assert.IsTrue(sf.disposed, "disposed");
}
public void Dispose3()
{
FakeSafeHandle sf = new FakeSafeHandle();
sf.Close();
sf.DangerousRelease();
}
public void BadDispose2 ()
{
FakeSafeHandle sf = new FakeSafeHandle ();
sf.Close ();
sf.DangerousRelease ();
}
public void ReleaseAfterDispose1()
{
int dummyHandle = 0xDEAD;
FakeSafeHandle sf = new FakeSafeHandle(true);
sf.ChangeHandle(new IntPtr(dummyHandle));
Assert.AreEqual((int)sf.DangerousGetHandle(), dummyHandle, "handle");
bool success = false;
sf.DangerousAddRef(ref success);
Assert.IsTrue(success, "dar");
sf.Dispose();
//Still one ref left.
Assert.IsFalse(sf.released, "released");
Assert.IsFalse(sf.IsClosed, "closed");
sf.DangerousRelease();
//In Ms.Net SafeHandle does not change the value of the handle after being SetInvalid or Disposed.
Assert.AreEqual((int)sf.DangerousGetHandle(), dummyHandle, "handle");
//Handle was closed properly.
Assert.IsTrue(sf.released, "released");
Assert.IsTrue(sf.IsClosed, "closed");
//Handle value is not changed, so the value itself is still valid (not 0 or -1)
Assert.IsFalse(sf.IsInvalid, "invalid");
}
public void MultipleDisposes ()
{
FakeSafeHandle sf = new FakeSafeHandle ();
sf.Dispose ();
sf.Dispose ();
sf.Dispose ();
}
public void MultipleDisposes()
{
FakeSafeHandle sf = new FakeSafeHandle();
sf.Dispose();
sf.Dispose();
sf.Dispose();
}
public void DangerousAddRefOnNewInstance()
{
FakeSafeHandle sf = new FakeSafeHandle();
sf.ChangeHandle(IntPtr.Zero);
Assert.IsTrue(sf.IsInvalid, "invalid");
bool success = false;
sf.DangerousAddRef(ref success);
Assert.IsTrue(success, "daroni");
}
public void BadDispose1()
{
FakeSafeHandle sf = new FakeSafeHandle();
sf.DangerousRelease();
try {
sf.DangerousRelease();
Assert.Fail("#1");
} catch (ObjectDisposedException) {
}
GC.SuppressFinalize(sf);
}
public void BadDispose1 ()
{
FakeSafeHandle sf = new FakeSafeHandle ();
sf.DangerousRelease ();
try {
sf.DangerousRelease ();
Assert.Fail ("#1");
} catch (ObjectDisposedException) {
}
GC.SuppressFinalize (sf);
}
public void NoReleaseUnowned()
{
FakeSafeHandle sf = new FakeSafeHandle(false);
sf.Close();
Assert.AreEqual(sf.released, false, "r1");
sf = new FakeSafeHandle(false);
sf.DangerousRelease();
Assert.AreEqual(sf.released, false, "r2");
sf = new FakeSafeHandle(false);
((IDisposable)sf).Dispose();
Assert.AreEqual(sf.released, false, "r3");
}
public void NoReleaseUnowned ()
{
FakeSafeHandle sf = new FakeSafeHandle (false);
sf.Close ();
Assert.AreEqual (sf.released, false, "r1");
sf = new FakeSafeHandle (false);
sf.DangerousRelease ();
Assert.AreEqual (sf.released, false, "r2");
sf = new FakeSafeHandle (false);
((IDisposable) sf).Dispose ();
Assert.AreEqual (sf.released, false, "r3");
}
public void ReleaseAfterDispose2()
{
FakeSafeHandle sf = new FakeSafeHandle(true);
bool success = false;
sf.DangerousAddRef(ref success);
Assert.IsTrue(success, "dar");
sf.Dispose();
sf.DangerousRelease();
//Second release need to throw ObjectDisposedException.
//No more ref to release.
sf.DangerousRelease();
}
public void NoReleaseUnowned()
{
FakeSafeHandle sf = new FakeSafeHandle(false);
sf.Close();
Assert.IsFalse(sf.released, "r1");
Assert.IsTrue(sf.IsClosed, "c1");
sf = new FakeSafeHandle(false);
sf.DangerousRelease();
Assert.IsFalse(sf.released, "r2");
Assert.IsTrue(sf.IsClosed, "c2");
sf = new FakeSafeHandle(false);
((IDisposable)sf).Dispose();
Assert.IsFalse(sf.released, "r3");
Assert.IsTrue(sf.IsClosed, "c3");
}
public void SetHandleAsInvalid()
{
int dummyHandle = 0xDEAD;
FakeSafeHandle sf = new FakeSafeHandle();
sf.ChangeHandle(new IntPtr(dummyHandle));
Assert.AreEqual((int)sf.DangerousGetHandle(), dummyHandle, "handle");
sf.SetHandleAsInvalid();
//In Ms.Net SafeHandle does not change the value of the handle after being SetInvalid or Disposed.
Assert.AreEqual((int)sf.DangerousGetHandle(), dummyHandle, "handle");
//Released == false since handle was not released, Set Invalid was called before it could be released.
Assert.IsFalse(sf.released, "released");
//IsClosed == true since handle is pointing to a disposed or invalid object.
Assert.IsTrue(sf.IsClosed, "closed");
//Handle value is not changed, so the value itself is still valid (not 0 or -1)
Assert.IsFalse(sf.IsInvalid, "invalid");
}
public void SetInvalidRelease1()
{
FakeSafeHandle sf = new FakeSafeHandle(true);
bool success = false;
sf.DangerousAddRef(ref success);
Assert.IsTrue(success, "dar");
sf.SetHandleAsInvalid();
Assert.IsFalse(sf.released, "released");
Assert.IsTrue(sf.IsClosed, "closed");
//Allow remaining refs to be released after SetHandleAsInvalid
sf.DangerousRelease();
sf.DangerousRelease();
Assert.IsFalse(sf.released, "released");
Assert.IsTrue(sf.IsClosed, "closed");
}
public void CloseWillDispose ()
{
FakeSafeHandle sf = new FakeSafeHandle ();
sf.Close ();
Assert.IsTrue (sf.disposed, "disposed");
}
public void SimpleDispose()
{
FakeSafeHandle sf = new FakeSafeHandle();
sf.Dispose();
}
public void SimpleDispose ()
{
FakeSafeHandle sf = new FakeSafeHandle ();
sf.Dispose ();
}
public void DangerousAddRefOnNewInstance ()
{
FakeSafeHandle sf = new FakeSafeHandle ();
sf.ChangeHandle (IntPtr.Zero);
Assert.IsTrue (sf.IsInvalid, "invalid");
bool success = false;
sf.DangerousAddRef (ref success);
Assert.IsTrue (success, "daroni");
}
public void NoReleaseUnowned ()
{
FakeSafeHandle sf = new FakeSafeHandle (false);
sf.Close ();
Assert.IsFalse (sf.released, "r1");
Assert.IsTrue (sf.IsClosed, "c1");
sf = new FakeSafeHandle (false);
sf.DangerousRelease ();
Assert.IsFalse (sf.released, "r2");
Assert.IsTrue (sf.IsClosed, "c2");
sf = new FakeSafeHandle (false);
((IDisposable) sf).Dispose ();
Assert.IsFalse (sf.released, "r3");
Assert.IsTrue (sf.IsClosed, "c3");
}
public void ReleaseAfterDispose2 ()
{
FakeSafeHandle sf = new FakeSafeHandle (true);
bool success = false;
sf.DangerousAddRef(ref success);
Assert.IsTrue (success, "dar");
sf.Dispose ();
sf.DangerousRelease ();
//Second release need to throw ObjectDisposedException.
//No more ref to release.
sf.DangerousRelease ();
}
public void ReleaseAfterDispose1 ()
{
int dummyHandle = 0xDEAD;
FakeSafeHandle sf = new FakeSafeHandle (true);
sf.ChangeHandle (new IntPtr (dummyHandle));
Assert.AreEqual ((int)sf.DangerousGetHandle(), dummyHandle, "handle");
bool success = false;
sf.DangerousAddRef(ref success);
Assert.IsTrue (success, "dar");
sf.Dispose ();
//Still one ref left.
Assert.IsFalse (sf.released, "released");
Assert.IsFalse (sf.IsClosed, "closed");
sf.DangerousRelease ();
//In Ms.Net SafeHandle does not change the value of the handle after being SetInvalid or Disposed.
Assert.AreEqual ((int)sf.DangerousGetHandle(), dummyHandle, "handle");
//Handle was closed properly.
Assert.IsTrue (sf.released, "released");
Assert.IsTrue (sf.IsClosed, "closed");
//Handle value is not changed, so the value itself is still valid (not 0 or -1)
Assert.IsFalse (sf.IsInvalid, "invalid");
}
public void SetInvalidRelease1 ()
{
FakeSafeHandle sf = new FakeSafeHandle (true);
bool success = false;
sf.DangerousAddRef(ref success);
Assert.IsTrue (success, "dar");
sf.SetHandleAsInvalid();
Assert.IsFalse (sf.released, "released");
Assert.IsTrue (sf.IsClosed, "closed");
//Allow remaining refs to be released after SetHandleAsInvalid
sf.DangerousRelease ();
sf.DangerousRelease ();
Assert.IsFalse (sf.released, "released");
Assert.IsTrue (sf.IsClosed, "closed");
}
public void SetInvalidDispose ()
{
int dummyHandle = 0xDEAD;
FakeSafeHandle sf = new FakeSafeHandle (true);
sf.ChangeHandle (new IntPtr (dummyHandle));
Assert.AreEqual ((int)sf.DangerousGetHandle(), dummyHandle, "handle");
sf.SetHandleAsInvalid();
sf.Dispose ();
//In Ms.Net SafeHandle does not change the value of the handle after being SetInvalid or Disposed.
Assert.AreEqual ((int)sf.DangerousGetHandle(), dummyHandle, "handle");
//Released == false since handle was not released, Set Invalid was called before it could be released.
Assert.IsFalse (sf.released, "released");
//IsClosed == true since handle is pointing to a disposed or invalid object.
Assert.IsTrue (sf.IsClosed, "closed");
//Handle value is not changed, so the value itself is still valid (not 0 or -1)
Assert.IsFalse (sf.IsInvalid, "invalid");
}
public void GoodDispose ()
{
int dummyHandle = 0xDEAD;
FakeSafeHandle sf = new FakeSafeHandle ();
sf.ChangeHandle (new IntPtr (dummyHandle));
Assert.AreEqual ((int)sf.DangerousGetHandle(), dummyHandle, "handle");
sf.DangerousRelease ();
try {
sf.Close ();
Assert.Fail ("#1");
} catch (ObjectDisposedException) {
}
try {
sf.Dispose ();
Assert.Fail ("#2");
} catch (ObjectDisposedException) {
}
//In Ms.Net SafeHandle does not change the value of the handle after being SetInvalid or Disposed.
Assert.AreEqual ((int)sf.DangerousGetHandle(), dummyHandle, "handle");
//Handle was closed properly.
Assert.IsTrue (sf.released, "released");
Assert.IsTrue (sf.IsClosed, "closed");
//Handle value is not changed, so the value itself is still valid (not 0 or -1)
Assert.IsFalse (sf.IsInvalid, "invalid");
GC.SuppressFinalize (sf);
}
