def test_Image_makeWithFilter(image, context):
outSubset = skia.IRect(100, 100)
offset = skia.IPoint(0, 0)
assert isinstance(
image.makeWithFilter(context, skia.ImageFilters.Blur(1., 1.),
skia.IRect(100, 100), skia.IRect(100, 100),
outSubset, offset), skia.Image)
def test_IRect_init():
assert isinstance(skia.IRect(), skia.IRect)
assert isinstance(skia.IRect(240, 120), skia.IRect)
assert isinstance(skia.IRect(0, 0, 240, 120), skia.IRect)
assert isinstance(skia.IRect.MakeEmpty(), skia.IRect)
assert isinstance(skia.IRect.MakeWH(240, 120), skia.IRect)
assert isinstance(skia.IRect.MakeSize(skia.ISize.MakeEmpty()), skia.IRect)
assert isinstance(skia.IRect.MakeLTRB(0, 0, 240, 120), skia.IRect)
assert isinstance(skia.IRect.MakeXYWH(0, 0, 240, 120), skia.IRect)
def test_Rect_methods(rect):
assert rect.__repr__() == 'Rect(0, 0, 240, 120)'
assert not rect.isEmpty()
assert rect.isSorted()
assert rect.isFinite()
assert rect.x() == 0.
assert rect.y() == 0.
assert rect.left() == 0.
assert rect.top() == 0.
assert rect.right() == 240.
assert rect.bottom() == 120.
assert rect.width() == 240.
assert rect.height() == 120.
assert rect.centerX() == 120.
assert rect.centerY() == 60.
# rect.toQuad()
rect.setEmpty()
rect.set(skia.IRect(240, 120))
rect.setLTRB(0, 0, 240, 120)
# rect.setBounds()
# rect.setBoundsCheck()
# rect.setBoundsNoCheck()
rect.set(skia.Point.Make(0, 0), skia.Point.Make(240, 120))
rect.setXYWH(0, 0, 240, 120)
rect.setWH(240, 120)
rect.setIWH(240, 120)
assert isinstance(rect.makeOffset(10, 10), skia.Rect)
assert isinstance(rect.makeOffset(skia.Point.Make(10, 10)), skia.Rect)
assert isinstance(rect.makeInset(10, 10), skia.Rect)
assert isinstance(rect.makeOutset(10, 10), skia.Rect)
rect.offset(0, 0)
rect.offset(skia.Point.Make(0, 0))
rect.offsetTo(0, 0)
rect.inset(0, 0)
rect.outset(0, 0)
assert rect.intersect(skia.Rect.MakeLTRB(0, 0, 250, 130))
assert rect.intersect(skia.Rect.MakeLTRB(0, 0, 240, 120),
skia.Rect.MakeLTRB(0, 0, 250, 130))
rect.intersects(skia.Rect.MakeWH(20, 20))
rect.join(skia.Rect.MakeLTRB(10, 10, 20, 20))
rect.joinNonEmptyArg(skia.Rect.MakeLTRB(10, 10, 20, 20))
rect.joinPossiblyEmptyRect(skia.Rect.MakeEmpty())
assert rect.contains(20, 10)
assert rect.contains(skia.Rect.MakeLTRB(10, 10, 20, 20))
assert rect.contains(skia.IRect.MakeLTRB(10, 10, 20, 20))
irect = skia.IRect.MakeEmpty()
rect2 = skia.Rect.MakeEmpty()
rect.round(irect)
rect.roundOut(irect)
rect.roundOut(rect2)
rect.roundIn(irect)
assert isinstance(rect.round(), skia.IRect)
assert isinstance(rect.roundOut(), skia.IRect)
rect.sort()
assert isinstance(rect.makeSorted(), skia.Rect)
rect.asScalars()
rect.dump(True)
rect.dump()
rect.dumpHex()
assert skia.Rect.Intersects(rect, skia.Rect.MakeLTRB(10, 10, 20, 20))
def test_IRect_methods(irect):
assert irect.__repr__() == 'IRect(0, 0, 240, 120)'
assert irect.left() == 0
assert irect.top() == 0
assert irect.right() == 240
assert irect.bottom() == 120
assert irect.x() == 0
assert irect.y() == 0
assert irect.topLeft() == skia.IPoint.Make(0, 0)
assert irect.width() == 240
assert irect.height() == 120
assert isinstance(irect.size(), skia.ISize)
assert irect.width64() == 240
assert irect.height64() == 120
assert not irect.isEmpty64()
assert not irect.isEmpty()
irect.setEmpty()
irect.setLTRB(0, 0, 240, 120)
irect.setXYWH(0, 0, 240, 120)
irect.setWH(240, 120)
assert isinstance(irect.makeOffset(10, 10), skia.IRect)
assert isinstance(irect.makeOffset(skia.IPoint.Make(10, 10)), skia.IRect)
assert isinstance(irect.makeInset(10, 10), skia.IRect)
assert isinstance(irect.makeOutset(10, 10), skia.IRect)
irect.offset(0, 0)
irect.offset(skia.IPoint.Make(0, 0))
irect.inset(0, 0)
irect.outset(0, 0)
irect.adjust(0, 0, 0, 0)
assert irect.contains(20, 10)
assert irect.contains(skia.IRect.MakeLTRB(10, 10, 20, 20))
assert irect.contains(skia.Rect.MakeLTRB(10, 10, 20, 20))
assert irect.containsNoEmptyCheck(skia.IRect.MakeLTRB(10, 10, 20, 20))
assert irect.intersect(skia.IRect.MakeLTRB(0, 0, 250, 130))
assert irect.intersect(skia.IRect.MakeLTRB(0, 0, 240, 120),
skia.IRect.MakeLTRB(0, 0, 250, 130))
irect.join(skia.IRect.MakeLTRB(10, 10, 20, 20))
irect.sort()
assert isinstance(irect.makeSorted(), skia.IRect)
assert skia.IRect.Intersects(irect, skia.IRect(10, 10, 20, 20))
def test_ImageFilter_CropRect_applyTo(croprect):
assert isinstance(
croprect.applyTo(skia.IRect(100, 100), skia.Matrix(), False),
skia.IRect)
def test_Region_setRects(region):
assert isinstance(region.setRects([skia.IRect(10, 10)]), bool)
def other():
return skia.Region(skia.IRect(50, 50))
def region():
return skia.Region(skia.IRect(100, 100))
import skia
import pytest
@pytest.mark.parametrize('args', [
tuple(),
(skia.Region(), ),
(skia.IRect(100, 100), ),
])
def test_Region_init(args):
assert isinstance(skia.Region(*args), skia.Region)
@pytest.fixture
def region():
return skia.Region(skia.IRect(100, 100))
@pytest.fixture
def other():
return skia.Region(skia.IRect(50, 50))
def test_Region_eq(region):
assert region == region
def test_Region_ne(region, other):
assert region != other
def test_Bitmap_erase(bitmap):
bitmap.erase(0xFFFFFFFF, skia.IRect(100, 100))
def test_Canvas_drawIRect(canvas):
canvas.drawIRect(skia.IRect(10, 10), skia.Paint())
def test_IRect_containsNoEmptyCheck(irect):
assert irect.containsNoEmptyCheck(skia.IRect(10, 10, 20, 20))
def test_IRect__not_contains(irect):
assert (60, 60) in skia.IRect(50, 50, 100, 100)
assert (120, 120) not in skia.IRect(50, 50, 100, 100)
def test_IRect_inset(irect):
irect.inset(0, 0)
def test_IRect_outset(irect):
irect.outset(0, 0)
def test_IRect_adjust(irect):
irect.adjust(0, 0, 0, 0)
@pytest.mark.parametrize('args', [
(20, 10),
(skia.IRect(10, 10, 20, 20), ),
(skia.Rect(10, 10, 20, 20), ),
])
def test_IRect_contains(irect, args):
assert irect.contains(*args)
@pytest.mark.parametrize('operand', [
skia.IRect(10, 10, 20, 20),
skia.Rect(10, 10, 20, 20),
])
def test_IRect__contains(irect, operand):
assert operand in irect
def test_IRect__not_contains(irect):
])
def test_Canvas_quickReject(canvas, args):
assert isinstance(canvas.quickReject(*args), bool)
@pytest.mark.parametrize('args, kls', [
(tuple(), skia.Rect),
((skia.Rect(100, 100), ), bool),
])
def test_Canvas_getLocalClipBounds(canvas, args, kls):
assert isinstance(canvas.getLocalClipBounds(*args), kls)
@pytest.mark.parametrize('args, kls', [
(tuple(), skia.IRect),
((skia.IRect(100, 100), ), bool),
])
def test_Canvas_getDeviceClipBounds(canvas, args, kls):
assert isinstance(canvas.getDeviceClipBounds(*args), kls)
@pytest.mark.parametrize('args', [
(skia.ColorWHITE, ),
(skia.ColorWHITE, skia.BlendMode.kSrcOver),
])
def test_Canvas_drawColor(canvas, args):
canvas.drawColor(*args)
def test_Canvas_clear(canvas):
canvas.clear(skia.ColorWHITE)
def test_Canvas_androidFramework_setDeviceClipRestriction(canvas):
canvas.androidFramework_setDeviceClipRestriction(skia.IRect(320, 240))
def test_IRect_init(args):
assert isinstance(skia.IRect(*args), skia.IRect)
def test_Surface_notifyContentWillChange(surface):
surface.notifyContentWillChange(skia.Surface.kDiscard_ContentChangeMode)
@pytest.mark.parametrize('args', [
(skia.ImageInfo.MakeN32Premul(120, 120),),
(120, 120),
])
def test_Surface_makeSurface(surface, args):
check_surface(surface.makeSurface(*args))
@pytest.mark.parametrize('args', [
tuple(),
(skia.IRect(100, 100),),
])
def test_Surface_makeImageSnapshot(surface, args):
assert isinstance(surface.makeImageSnapshot(*args), skia.Image)
def test_Surface_draw(surface):
surface.draw(surface.getCanvas(), 0, 0, None)
def test_Surface_peekPixels(surface):
assert isinstance(surface.peekPixels(skia.Pixmap()), bool)
@pytest.mark.parametrize('args', [
(skia.Pixmap(), 0, 0),
def test_IRect_join(irect):
irect.join(skia.IRect(10, 10, 20, 20))
def test_Bitmap_extractSubset(bitmap):
dst = skia.Bitmap()
assert isinstance(bitmap.extractSubset(dst, skia.IRect(50, 50)), bool)
def test_IRect_Intersects(irect):
assert skia.IRect.Intersects(irect, skia.IRect(10, 10, 20, 20))
def test_Region_quickContains(region):
assert isinstance(region.quickContains(skia.IRect(5, 5)), bool)
def test_IRect_eq(irect):
assert irect == skia.IRect(0, 0, 240, 120)
def test_Region_cliperator(region):
for rect in region.cliperator(skia.IRect(100, 100)):
assert isinstance(rect, skia.IRect)
def test_IRect_ne(irect):
assert irect != skia.IRect()
def cliperator(region):
yield skia.Region.Cliperator(region, skia.IRect(100, 100))
def irect():
return skia.IRect(0, 0, 240, 120)
def test_Codec_getValidSubset(codec):
assert isinstance(codec.getValidSubset(skia.IRect(128, 128)), bool)
def test_ImageFilter_CropRect_flags(croprect):
assert isinstance(croprect.flags(), int)
def test_ImageFilter_CropRect_rect(croprect):
assert isinstance(croprect.rect(), skia.Rect)
def test_ImageFilter_CropRect_applyTo(croprect):
assert isinstance(
croprect.applyTo(skia.IRect(100, 100), skia.Matrix(), False),
skia.IRect)
@pytest.mark.parametrize('args', [
(skia.IRect(100, 100), skia.Matrix(),
skia.ImageFilter.kForward_MapDirection),
(skia.IRect(100, 100), skia.Matrix(),
skia.ImageFilter.kReverse_MapDirection, skia.IRect(100, 100))
])
def test_ImageFilter_filterBounds(imagefilter, args):
assert isinstance(imagefilter.filterBounds(*args), skia.IRect)
def test_ImageFilter_isColorFilterNode(imagefilter):
assert isinstance(
imagefilter.isColorFilterNode(), (skia.ColorFilter, type(None)))
def test_ImageFilter_countInputs(imagefilter):
assert isinstance(imagefilter.countInputs(), int)
