public void SameHandleReturnsSameReferenceAndReleasesObject()
{
VerifyImmediateFinalizers();
var handle = (IntPtr)234;
TestConstruction(handle);
CollectGarbage();
Assert.False(SKObject.GetInstance <LifecycleObject>(handle, out var inst));
Assert.Null(inst);
void TestConstruction(IntPtr h)
{
LifecycleObject i = null;
Assert.False(SKObject.GetInstance(h, out i));
Assert.Null(i);
var first = SKObject.GetObject <LifecycleObject>(h);
Assert.True(SKObject.GetInstance(h, out i));
Assert.NotNull(i);
Assert.Same(first, i);
var second = SKObject.GetObject <LifecycleObject>(h);
Assert.Same(first, second);
}
}
public void StreamIsNotCollectedPrematurely()
{
DoWork(out var handle);
CollectGarbage();
Assert.False(SKObject.GetInstance <SKDynamicMemoryWStream>(handle, out _));
public void DuplicateStreamIsCollected()
{
VerifySupportsExceptionsInDelegates();
var handle = DoWork();
CollectGarbage();
Assert.False(SKObject.GetInstance <SKManagedStream>(handle, out _));
IntPtr DoWork()
{
var dotnet = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });
var stream = new SKManagedStream(dotnet, true);
Assert.Equal(1, stream.ReadByte());
Assert.Equal(2, stream.ReadByte());
var dupe1 = stream.Duplicate();
Assert.Equal(1, dupe1.ReadByte());
Assert.Equal(2, dupe1.ReadByte());
Assert.Throws <InvalidOperationException>(() => stream.Duplicate());
stream.Dispose();
var dupe2 = dupe1.Duplicate();
Assert.Equal(1, dupe2.ReadByte());
Assert.Equal(2, dupe2.ReadByte());
return(dupe2.Handle);
}
}
public void ObjectsWithTheSameHandleButDoNotOwnTheirHandlesAreCreatedAndDisposedCorrectly()
{
var handle = (IntPtr)567;
var inst = Construct();
CollectGarbage();
Assert.True(SKObject.GetInstance <LifecycleObject>(handle, out var obj));
Assert.Equal(2, obj.Value);
Assert.Same(inst, obj);
LifecycleObject Construct()
{
var inst1 = new LifecycleObject(handle, false)
{
Value = 1
};
var inst2 = new LifecycleObject(handle, false)
{
Value = 2
};
Assert.NotSame(inst1, inst2);
return(inst2);
}
}
public unsafe void StreamLosesOwnershipAndCanBeDisposedButIsNotActually()
{
var path = Path.Combine(PathToImages, "color-wheel.png");
var stream = new SKMemoryStream(File.ReadAllBytes(path));
var handle = stream.Handle;
Assert.True(stream.OwnsHandle);
Assert.False(stream.IgnorePublicDispose);
Assert.True(SKObject.GetInstance <SKMemoryStream>(handle, out _));
var codec = SKCodec.Create(stream);
Assert.False(stream.OwnsHandle);
Assert.True(stream.IgnorePublicDispose);
stream.Dispose();
Assert.True(SKObject.GetInstance <SKMemoryStream>(handle, out var inst));
Assert.Same(stream, inst);
Assert.Equal(SKCodecResult.Success, codec.GetPixels(out var pixels));
Assert.NotEmpty(pixels);
codec.Dispose();
Assert.False(SKObject.GetInstance <SKMemoryStream>(handle, out _));
}
public void StreamIsAccessableFromNativeType()
{
VerifyImmediateFinalizers();
var paint = CreatePaint(out var typefaceHandle);
CollectGarbage();
Assert.False(SKObject.GetInstance <SKTypeface>(typefaceHandle, out _));
var tf = paint.Typeface;
Assert.Equal("Roboto2", tf.FamilyName);
Assert.True(tf.TryGetTableTags(out var tags));
Assert.NotEmpty(tags);
SKPaint CreatePaint(out IntPtr handle)
{
var bytes = File.ReadAllBytes(Path.Combine(PathToFonts, "Roboto2-Regular_NoEmbed.ttf"));
var dotnet = new MemoryStream(bytes);
var stream = new SKManagedStream(dotnet, true);
var typeface = SKTypeface.FromStream(stream);
handle = typeface.Handle;
return(new SKPaint
{
Typeface = typeface
});
}
}
public void ConstructorsAreCached()
{
var handle = (IntPtr)123;
SKObject.GetObject <LifecycleObject>(handle);
Assert.True(SKObject.constructors.ContainsKey(typeof(LifecycleObject)));
}
public void CanInstantiateAbstractClassesWithImplementation()
{
var handle = GetNextPtr();
var obj = SKObject.GetOrAddObject <AbstractObject>(handle, (h, o) => new ConcreteObject(h, o));
Assert.NotNull(obj);
Assert.IsType <ConcreteObject>(obj);
}
public void EmptyDataIsNotDisposed()
{
var empty = SKData.Empty;
Assert.True(SKObject.GetInstance <SKData>(empty.Handle, out _));
empty.Dispose();
Assert.True(SKObject.GetInstance <SKData>(empty.Handle, out _));
}
public void StreamIsCollectedEvenWhenNotProperlyDisposed()
{
VerifyImmediateFinalizers();
var handle = DoWork();
CollectGarbage();
var exists = SKObject.GetInstance <SKManagedWStream>(handle, out _);
Assert.False(exists);
public unsafe void StreamIsNotDisposedWhenReferencedIsDisposed()
{
var stream = new SKManagedWStream(new MemoryStream(), true);
var handle = stream.Handle;
var document = SKDocument.CreatePdf(stream);
document.Dispose();
Assert.True(SKObject.GetInstance <SKManagedWStream>(handle, out _));
}
public void CanInstantiateAbstractClassesWithImplementation()
{
var handle = (IntPtr)444;
Assert.Throws <MemberAccessException>(() => SKObject.GetObject <AbstractObject>(handle));
var obj = SKObject.GetObject <AbstractObject, ConcreteObject>(handle);
Assert.NotNull(obj);
Assert.IsType <ConcreteObject>(obj);
}
public unsafe void GCStillCollectsTypeface()
{
if (!IsWindows)
{
throw new SkipException("Test designed for Windows.");
}
var handle = DoWork();
CollectGarbage();
Assert.False(SKObject.GetInstance <SKTypeface>(handle, out _));
public void DisposeDoesNotInvalidateObjectIfItIsNotOwned()
{
var handle = (IntPtr)345;
var obj = SKObject.GetObject <LifecycleObject>(handle, false);
Assert.False(obj.DestroyedNative);
obj.Dispose();
Assert.False(obj.DestroyedNative);
}
public void SameHandleReturnsSameReferenceAndReleasesObject()
{
VerifyImmediateFinalizers();
var handle = GetNextPtr();
TestConstruction(handle);
CollectGarbage();
// there should be nothing if the GC ran
Assert.False(SKObject.GetInstance <LifecycleObject>(handle, out var inst));
Assert.Null(inst);
public void DisposeInvalidatesObject()
{
var handle = (IntPtr)345;
var obj = SKObject.GetObject <LifecycleObject>(handle);
Assert.Equal(handle, obj.Handle);
Assert.False(obj.DestroyedNative);
obj.Dispose();
Assert.Equal(IntPtr.Zero, obj.Handle);
Assert.True(obj.DestroyedNative);
}
public unsafe void ManagedStreamIsCollectedWhenTypefaceIsDisposed()
{
var bytes = File.ReadAllBytes(Path.Combine(PathToFonts, "Distortable.ttf"));
var dotnet = new MemoryStream(bytes);
var stream = new SKManagedStream(dotnet, true);
var handle = stream.Handle;
var typeface = SKTypeface.FromStream(stream);
typeface.Dispose();
Assert.False(SKObject.GetInstance <SKManagedStream>(handle, out _));
Assert.Throws <ObjectDisposedException>(() => dotnet.Position);
}
public void StaticSrgbIsReturnedAsTheStaticInstance()
{
var handle = SkiaApi.sk_colorspace_new_srgb();
try
{
var cs = SKObject.GetObject <SKColorSpace>(handle, unrefExisting: false);
Assert.Equal("SKColorSpaceStatic", cs.GetType().Name);
}
finally
{
SkiaApi.sk_refcnt_safe_unref(handle);
}
}
public unsafe void InvalidStreamIsDisposedImmediately()
{
var stream = CreateTestSKStream();
var handle = stream.Handle;
Assert.True(stream.OwnsHandle);
Assert.False(stream.IgnorePublicDispose);
Assert.True(SKObject.GetInstance <SKStream>(handle, out _));
Assert.Null(SKTypeface.FromStream(stream));
Assert.False(stream.OwnsHandle);
Assert.True(stream.IgnorePublicDispose);
Assert.False(SKObject.GetInstance <SKStream>(handle, out _));
}
public void ManagedStreamIsNotCollectedPrematurely()
{
using (var document = CreateDocument(out var handle))
{
var paintList = new List <SKPaint>();
for (var index = 0; index < 10; index++)
{
var fontStream = File.OpenRead(Path.Combine(PathToFonts, "Roboto2-Regular_NoEmbed.ttf"));
var typeface = SKTypeface.FromStream(fontStream);
var paint = new SKPaint
{
Typeface = typeface
};
paintList.Add(paint);
}
using (var pageCanvas = document.BeginPage(792, 842))
{
foreach (var paint in paintList)
{
for (var i = 0; i < 100; i++)
{
pageCanvas.DrawText("Text", 0, 5 * i, paint);
}
}
document.EndPage();
}
CollectGarbage();
Assert.True(SKObject.GetInstance <SKDynamicMemoryWStream>(handle, out _));
document.Close();
}
SKDocument CreateDocument(out IntPtr streamHandle)
{
var stream = new SKDynamicMemoryWStream();
streamHandle = stream.Handle;
return(SKDocument.CreatePdf(stream, new SKDocumentPdfMetadata()));
}
}
public unsafe void StreamThatHasLostOwnershipIsDisposed()
{
var bytes = File.ReadAllBytes(Path.Combine(PathToImages, "color-wheel.png"));
var dotnet = new MemoryStream(bytes);
var stream = new SKManagedStream(dotnet, true);
var handle = stream.Handle;
Assert.True(stream.OwnsHandle);
Assert.True(SKObject.GetInstance <SKManagedStream>(handle, out _));
var codec = SKCodec.Create(stream);
Assert.False(stream.OwnsHandle);
codec.Dispose();
Assert.False(SKObject.GetInstance <SKManagedStream>(handle, out _));
}
static void DoWork(out IntPtr streamHandle)
{
using (var document = CreateDocument(out streamHandle))
{
using (var pageCanvas = document.BeginPage(792, 842))
{
document.EndPage();
}
CollectGarbage();
Assert.True(SKObject.GetInstance <SKDynamicMemoryWStream>(streamHandle, out _));
document.Close();
}
Assert.True(SKObject.GetInstance <SKDynamicMemoryWStream>(streamHandle, out _));
}
public unsafe void StreamLosesOwnershipToCodecButIsNotForgotten()
{
var bytes = File.ReadAllBytes(Path.Combine(PathToImages, "color-wheel.png"));
var stream = new SKMemoryStream(bytes);
var handle = stream.Handle;
Assert.True(stream.OwnsHandle);
Assert.True(SKObject.GetInstance <SKMemoryStream>(handle, out _));
var codec = SKCodec.Create(stream);
Assert.False(stream.OwnsHandle);
stream.Dispose();
Assert.True(SKObject.GetInstance <SKMemoryStream>(handle, out _));
Assert.Equal(SKCodecResult.Success, codec.GetPixels(out var pixels));
Assert.NotEmpty(pixels);
}
public unsafe void StreamLosesOwnershipAndCanBeGarbageCollected()
{
VerifyImmediateFinalizers();
var bytes = File.ReadAllBytes(Path.Combine(PathToImages, "color-wheel.png"));
DoWork(out var codecH, out var streamH);
CollectGarbage();
Assert.False(SKObject.GetInstance <SKMemoryStream>(streamH, out _));
Assert.False(SKObject.GetInstance <SKCodec>(codecH, out _));
void DoWork(out IntPtr codecHandle, out IntPtr streamHandle)
{
var codec = CreateCodec(out streamHandle);
codecHandle = codec.Handle;
CollectGarbage();
Assert.Equal(SKCodecResult.Success, codec.GetPixels(out var pixels));
Assert.NotEmpty(pixels);
Assert.True(SKObject.GetInstance <SKMemoryStream>(streamHandle, out var stream));
Assert.False(stream.OwnsHandle);
Assert.True(stream.IgnorePublicDispose);
}
SKCodec CreateCodec(out IntPtr streamHandle)
{
var stream = new SKMemoryStream(bytes);
streamHandle = stream.Handle;
Assert.True(stream.OwnsHandle);
Assert.False(stream.IgnorePublicDispose);
Assert.True(SKObject.GetInstance <SKMemoryStream>(streamHandle, out _));
return(SKCodec.Create(stream));
}
}
public void EnsureConcurrencyResultsInCorrectDeregistration()
{
var handle = (IntPtr)446;
var obj = new ImmediateRecreationObject(handle, true);
Assert.Null(obj.NewInstance);
Assert.Equal(obj, SKObject.instances[handle]?.Target);
obj.Dispose();
Assert.True(SKObject.GetInstance <ImmediateRecreationObject>(handle, out _));
var newObj = obj.NewInstance;
Assert.NotEqual(obj, SKObject.instances[handle]?.Target);
Assert.Equal(newObj, SKObject.instances[handle]?.Target);
newObj.Dispose();
Assert.False(SKObject.GetInstance <ImmediateRecreationObject>(handle, out _));
}
public void ObjectsWithTheSameHandleButDoNotOwnTheirHandlesAreCreatedAndCollectedCorrectly()
{
VerifyImmediateFinalizers();
var handle = (IntPtr)566;
Construct();
CollectGarbage();
Assert.False(SKObject.GetInstance <LifecycleObject>(handle, out _));
void Construct()
{
var inst1 = new LifecycleObject(handle, false);
var inst2 = new LifecycleObject(handle, false);
Assert.NotSame(inst1, inst2);
}
}
public void StreamIsCollectedEvenWhenNotProperlyDisposed()
{
VerifyImmediateFinalizers();
var handle = DoWork();
CollectGarbage();
var exists = SKObject.GetInstance <SKManagedStream>(handle, out _);
Assert.False(exists);
IntPtr DoWork()
{
var dotnet = CreateTestStream();
var stream = new SKManagedStream(dotnet, true);
return(stream.Handle);
}
}
public unsafe void StreamLosesOwnershipAndCanBeGarbageCollected()
{
VerifyImmediateFinalizers();
var bytes = File.ReadAllBytes(Path.Combine(PathToFonts, "Distortable.ttf"));
DoWork(out var typefaceH, out var streamH);
CollectGarbage();
Assert.False(SKObject.GetInstance <SKMemoryStream>(streamH, out _));
Assert.False(SKObject.GetInstance <SKTypeface>(typefaceH, out _));
void DoWork(out IntPtr typefaceHandle, out IntPtr streamHandle)
{
var typeface = CreateTypeface(out streamHandle);
typefaceHandle = typeface.Handle;
CollectGarbage();
Assert.NotEmpty(typeface.GetTableTags());
Assert.True(SKObject.GetInstance <SKMemoryStream>(streamHandle, out var stream));
Assert.False(stream.OwnsHandle);
Assert.True(stream.IgnorePublicDispose);
}
SKTypeface CreateTypeface(out IntPtr streamHandle)
{
var stream = new SKMemoryStream(bytes);
streamHandle = stream.Handle;
Assert.True(stream.OwnsHandle);
Assert.False(stream.IgnorePublicDispose);
Assert.True(SKObject.GetInstance <SKMemoryStream>(streamHandle, out _));
return(SKTypeface.FromStream(stream));
}
}
public void DataCreatedByImageExpiresAfterFinalizers()
{
var bitmap = CreateTestBitmap();
var image = SKImage.FromBitmap(bitmap);
var handle = DoEncode();
CollectGarbage();
Assert.False(SKObject.GetInstance <SKData>(handle, out _));
IntPtr DoEncode()
{
var result = image.Encode();
Assert.NotNull(result);
Assert.Equal(1, result.GetReferenceCount());
return(result.Handle);
}
}
static void TestConstruction(IntPtr h)
{
// make sure there is nothing
Assert.False(SKObject.GetInstance(h, out LifecycleObject i));
Assert.Null(i);
// get/create the object
var first = LifecycleObject.GetObject(h);
// get the same one
Assert.True(SKObject.GetInstance(h, out i));
Assert.NotNull(i);
// compare
Assert.Same(first, i);
// get/create the object
var second = LifecycleObject.GetObject(h);
// compare
Assert.Same(first, second);
}
