// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
usingSystem;
usingSystem.Runtime.CompilerServices;
usingXunit;
namespaceRoslyn.Test.Utilities
{
publicstaticclassObjectReference
{
// We want to ensure this isn't inlined, because we need to ensure that any temporaries
// on the stack in this method or targetFactory get cleaned up. Otherwise, they might still
// be alive when we want to make later assertions.
/// Asserts that the underlying object has been released.
/// </summary>
[MethodImpl(MethodImplOptions.NoInlining)]
publicvoidAssertReleased()
{
ReleaseAndGarbageCollect();
Assert.False(_weakReference.IsAlive,"Reference should have been released but was not.");
}
/// <summary>
/// Asserts that the underlying object is still being held.
/// </summary>
[MethodImpl(MethodImplOptions.NoInlining)]
publicvoidAssertHeld()
{
ReleaseAndGarbageCollect();
// Since we are asserting it's still held, if it is held we can just recover our strong reference again
_strongReference=(T)_weakReference.Target;
Assert.True(_strongReference!=null,"Reference should still be held.");
}
// Ensure the mention of the field doesn't result in any local temporaries being created in the parent
[MethodImpl(MethodImplOptions.NoInlining)]
privatevoidReleaseAndGarbageCollect()
{
if(_strongReferenceRetrievedOutsideScopedCall)
{
thrownewInvalidOperationException($"The strong reference being held by the {nameof(ObjectReference<T>)} was retrieved via a call to {nameof(GetReference)}. Since the CLR might have cached a temporary somewhere in your stack, assertions can no longer be made about the correctness of lifetime.");
}
_strongReference=null;
// We'll loop 1000 times, or until the weak reference disappears. When we're trying to assert that the
// object is released, once the weak reference goes away, we know we're good. But if we're trying to assert
// that the object is held, our only real option is to know to do it "enough" times; but if it goes away then
// we are definitely done.
for(vari=0;i<1000&&_weakReference.IsAlive;i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
}
/// <summary>
/// Provides the underlying strong refernce to the given action. This method is marked not be inlined, to ensure that no temporaries are left
/// on the stack that might still root the strong reference. The caller must not "leak" the object out of the given action for any lifetime
/// assertions to be safe.
/// </summary>
[MethodImpl(MethodImplOptions.NoInlining)]
publicvoidUseReference(Action<T>action)
{
action(GetReferenceWithChecks());
}
/// <summary>
/// Provides the underlying strong refernce to the given function. This method is marked not be inlined, to ensure that no temporaries are left
/// on the stack that might still root the strong reference. The caller must not "leak" the object out of the given action for any lifetime
/// assertions to be safe.
/// </summary>
[MethodImpl(MethodImplOptions.NoInlining)]
publicUUseReference<U>(Func<T,U>function)
{
returnfunction(GetReferenceWithChecks());
}
/// <summary>
/// Fetches the object strongly being held from this. Because the value returned might be cached in a local temporary from
/// the caller of this function, no further calls to <see cref="AssertHeld"/> or <see cref="AssertReleased"/> may be called
/// on this object as the test is not valid either way. If you need to operate with the object without invalidating
/// the ability to reference the object, see <see cref="UseReference"/>.
/// </summary>
publicTGetReference()
{
_strongReferenceRetrievedOutsideScopedCall=true;
returnGetReferenceWithChecks();
}
privateTGetReferenceWithChecks()
{
if(_strongReference==null)
{
thrownewInvalidOperationException($"The type has already been released due to a call to {nameof(AssertReleased)}.");
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
// Copyright (c) Microsoft. All Rights Reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
