def test_duration():
"""Test duration
Three tests:
Does active go False when duration expires
Does active return to True when render after active went to False
Does active remain True when duration not specified
"""
w = text(value="'abc'", duration=3)
for i in range(3):
w.render()
assert (
not w.active
), "With three renders and a duration of three, widget should have not been active"
w.render()
assert (
w.active
), "After going inactive, the next render should have made it active again"
w = text(value="'abc'")
active = True
for i in range(100):
w.render()
active = w.active
if not active:
break
assert active, "Widget should not have gone inactive"
def test_minDuration():
"""Test Min Duration
Tests:
Widget is active for minDuration even when activeWhen evaluates False
Widget remains active when activeWhen goes false if minDuration not expired
Widget restores minDuration when activeWhen returns to True value
"""
ds = {"db": {"f": True}}
w = text(
value="'abc'",
duration=5,
minDuration=2,
activeWhen='db["f"]',
dataset=ds,
)
w._dataset.update("db", {"f": False})
w.render()
assert w.active, "Widget should still be active"
ds = {"db": {"f": True}}
w = text(
value="'abc'",
duration=5,
minDuration=2,
activeWhen='db["f"]',
dataset=ds,
)
w.render()
w._dataset.update("db", {"f": False})
assert (
w.active
), "Even when activeWhen goes False, widget should be active if minDuration has not expired"
w = text(value="'abc'", minDuration=3, activeWhen='db["f"]', dataset=ds)
for _ in range(5):
w.render()
assert w.active, "activeWhen is still True so should still be active"
w._dataset.update("db", {"f": False})
w.render()
assert (
not w.active
), "with minDuration expired and activeWhen false, should be inactive"
w._dataset.update("db", {"f": True})
w.render()
w._dataset.update("db", {"f": False})
w.render()
assert (
w.active
), f"minDuration should have been reset so widget should still be active. Current minDuration is {w._currentMinDuration}"
def makeSetup():
db = {"artist": "Sting", "title": "Desert Rose"}
system = {"state": "play", "temp": 40}
ds = dataset({"db": db, "sys": system})
artist = text(value="f\"Artist {db['artist']}\"", dataset=ds)
title = text(value="f\"Title {db['title']}\"", dataset=ds)
alert = text(value="'ALERT -- HOT'")
time = text("'12:32p'")
cArt = canvas(
size=(80, 16),
duration=2,
activeWhen="sys['state'] == 'play'",
dataset=ds,
name="Artist",
)
cArt.append(artist)
cTitle = canvas(
size=(80, 16),
duration=2,
activeWhen="sys['state'] == 'play'",
dataset=ds,
name="Title",
)
cTitle.append(title)
cAlert = canvas(
size=(80, 16),
duration=5,
minDuration=2,
activeWhen="sys['temp'] >= 100",
dataset=ds,
name="Alert",
)
cAlert.append(alert)
cTime = canvas(
size=(80, 16),
duration=10,
activeWhen="sys['state'] == 'stop'",
dataset=ds,
name="Time",
)
cTime.append(time, placement="mm")
seq = sequence(dataset=ds)
seq.append(cArt)
seq.append(cTitle)
seq.append(cAlert)
seq.append(cTime)
return (ds, seq)
def test_coolingPeriod():
"""Test that widget does not become active during coolingPeriod
Test:
Widget does not enter coolingPeriod prematurely
Widget with coolingPeriod does not become active until it expires
"""
ds = {"db": {"f": False}}
w = text(
value="abc",
duration=5,
coolingPeriod=10,
activeWhen='db["f"]',
dataset=ds,
)
assert (
not w.active), "Widget should be inactive because activeWhen is False"
w._dataset.update("db", {"f": True}) # Trigger widget
for _ in range(5):
w.render()
assert not w.active, "Widget should stop being active after 5 renders"
w.render()
assert not w.active, "In cooling period. Widget should not be active"
for _ in range(8):
w.render()
assert (
not w.active), "Still in cooling period. Widget should not be active"
w.render()
assert (
w.active
), "Widget should be back in active state having exited cooling Period"
def test_canvas_widget(size, offset, anchor):
"""
Place widgets and verify position
"""
w = text("X", mode="1")
ri = w.render()[0]
img = Image.new("1", size, 0)
drw = ImageDraw.Draw(img)
fnt = w.font
placement = ((offset[0], offset[1], anchor) if offset and anchor else
(offset[0],
offset[1]) if offset else anchor if anchor else None)
c = canvas(size=size, mode="1")
c.append(w, placement)
pos = compute_placement(size, fnt.getsize("X"), offset, anchor)
drw.text(pos, "X", font=fnt, fill="white")
assert (
c.render()[0] == img
), f"Placing 'X' on {size} canvas at {offset} anchored {anchor} failed\n{str(c)}"
img = Image.new("1", size, 0)
drw = ImageDraw.Draw(img)
c = canvas(size=size, mode="1")
c.append(w, placement)
drw.text(pos, "X", font=fnt, fill="white")
assert (
c.render()[0] == img
), f"Placing 'X' by append on {size} canvas at {offset} anchored {anchor} failed\n{str(c)} instead of {image2Text(img)}"
def test_text_widget():
"""Test text widget render including render after variable change."""
path = (Path(__file__).parent /
"reference/images/text_artist_sting_60x8.png")
img = Image.open(path).convert("1")
db = {"artist": "Sting"}
ds = dataset({"db": db})
w = text(dvalue="f\"Artist {db['artist']}\"",
dataset=ds,
size=(60, 8),
mode="1")
renderImage = w.render()[0]
bbox = ImageChops.difference(img, renderImage).getbbox()
assert not bbox, "Sting image did not match"
path = (Path(__file__).parent /
"reference/images/text_artist_new_republic_60x8.png")
img = Image.open(path).convert("1")
db["artist"] = "New Republic"
ds.update("db", db)
renderImage = w.render()[0]
bbox = ImageChops.difference(img, renderImage).getbbox()
assert not bbox, "New Republic image did not match"
def test_z_order():
w1 = text("ABC", size=(20, 8), background="black")
w2 = text("123", size=(20, 8), background="black")
# Place second append at a higher z
c1 = canvas(size=(20, 8))
c1.append(w1)
c1.append(w2, z=canvas.ZHIGH)
assert (w2.render()[0] == c1.render()[0]
), f"123 should have been on top but got {c1}"
# Place both appends at the same z level. Should make first append higher than the second
c2 = canvas(size=(20, 8))
c2.append(w1)
c2.append(w2)
assert (w1.render()[0] == c2.render()[0]
), f"ABC should have been on top but got {c1}"
def test_wait(makeScroll):
"""Test that pause action is working correctly."""
pause = 5
w1 = text("Five!")
swL = scroll(
size=(19, 8),
widget=w1,
actions=[("pause", pause), ("rtl")],
wait="atStart",
)
w2 = text("Four")
swS = scroll(
size=(19, 8),
widget=w2,
actions=[("pause", pause), ("rtl")],
wait="atStart",
)
c = canvas(size=(19, 16))
c.append(swL)
c.append(swS, (0, 8))
imgOrig, update = c.render(force=True)
for _ in range(pause - 1):
img, update = c.render()
assert (
imgOrig == img
), f"This image should have matched the first one as we are still in the pause period \n{image2Text(imgOrig)}\nand\n{str(img)}"
for _ in range(w2.size[0]):
img, update = c.render()
imgCrop = img.crop((0, 8, 19, 16))
w2Crop = w2.image.crop((0, 0, 19, 8))
assert (
w2Crop == imgCrop
), f"The cropped area should have matched the original 'Four' text widget\n{image2Text(w2Crop)}\nand\n{image2Text(imgCrop)}"
for _ in range(w1.size[0] - w2.size[0]):
img, update = c.render()
assert (
imgOrig == img
), f"Images should have matched again as they should have become aligned due to the wait condition \n{image2Text(imgOrig)}\nand\n{image2Text(img)}"
def test_string_eval():
s = "abc"
w = text(value=f"{s}")
drw = ImageDraw.Draw(Image.new("1", (0, 0), 0))
img = Image.new(w.image.mode, drw.textsize(s, font=w.font), w._background)
drw = ImageDraw.Draw(img)
drw.text((0, 0), s, font=w.font, fill=w._foreground)
assert ci(w.image, img), f"Images do not match for value {w.current}"
def _make_scroll(val, size, distance=1, speed=1):
w = text(value=val)
sw = scroll(
size=size,
widget=w,
actions=[("rtl")],
distance=distance,
speed=speed,
)
return sw
def test_request_size():
s = "abc"
w = text(f"{s}", size=(10, 8))
img = Image.new(w.image.mode, (10, 8), w._background)
drw = ImageDraw.Draw(img)
drw.text((0, 0), s, font=w.font, fill=w._foreground)
assert ci(w.image, img), f"Image should only contain 'ab'"
db = {"value": s}
ds = dataset()
ds.add("db", db)
w = text(dvalue="db['value']", dataset=ds, size=(10, 8))
db["value"] = s[0]
ds.update("db", db)
w.render()
img = Image.new(w.image.mode, (10, 8), w._background)
drw = ImageDraw.Draw(img)
drw.text((0, 0), s[0], font=w.font, fill=w._foreground)
assert ci(w.image, img), f"Image should only contain 'a'"
def test_should_slide_move(value, size, moved):
"""Test that default shouldIMove function is working correctly."""
msg = (
"slide moved when it shouldn't have"
if not moved
else "slide didn't move when it should have"
)
w = text(value=value)
sw = slide(size=size, widget=w, actions=[("ltr")])
startImg = sw.render()[0]
img = sw.render()[0]
bbox = ImageChops.difference(img, startImg).getbbox()
assert moved != (img == startImg), msg
def test_scroll_gap(gap):
"""Test that gaps are being computed correctly."""
w = text("'Hello'")
sw = scroll(widget=w, size=(20, 8), gap=gap)
img = sw.render()[0]
img2 = Image.new("RGBA", (0, 0), "black")
while not sw.atStart:
img2 = sw.render()[0]
bbox = ImageChops.difference(img, img2).getbbox()
assert (
not bbox
), f"scroll didn't return to start\n{image2Text(img)}\nand\n{image2Text(img2)}"
def test_canvas_widget_change():
db = {"artist": "Sting"}
w = text(dvalue="f\"Artist {db['artist']}\"",
dataset={"db": db},
size=(60, 8))
c = canvas(size=(80, 16))
c.append(w)
img, m1 = c.render()
db["artist"] = "Moby"
w._dataset.update("db", db)
img, m2 = c.render()
assert not m1 and m2, "When artist changes, canvas should have changed"
def test_text_image_print():
w = text(name="STATIC12345", value="12345")
v = "---------------------------\n"
v += "| |\n"
v += "| * *** ***** * *****|\n"
v += "| ** * * * ** * |\n"
v += "| * * * * * **** |\n"
v += "| * * * * * *|\n"
v += "| * * ****** *|\n"
v += "| * * * * * * *|\n"
v += "| *** ***** *** * *** |\n"
v += "---------------------------"
assert (str(w)[0:len(v)] == v
), f"Unexpected image produced:\n{w}\n\nShould have been\n{v}"
def test_image_placement():
# Make H
hImg = Image.new("1", (5, 8))
d = ImageDraw.Draw(hImg)
d.line([(0, 1), (0, 7)], fill="white")
d.line([(4, 1), (4, 7)], fill="white")
d.line([(0, 4), (4, 4)], fill="white")
w = text(value="H", size=(100, 16), just="rt", mode="1")
renderImage = w.render()[0]
for size in [(100, 16), (99, 15), (20, 8), (19, 8)]:
for j in ["lt", "lm", "lb", "mt", "mm", "mb", "rt", "rm", "rb"]:
offsetH = {"r": size[0] - 5, "l": 0, "m": round((size[0] - 5) / 2)}
offsetV = {"b": size[1] - 8, "t": 0, "m": round((size[1] - 8) / 2)}
w = text(value="H", size=size, just=j, mode="1")
renderImage = w.render()[0]
img = Image.new("1", size)
img.paste(hImg, (offsetH[j[0]], offsetV[j[1]]))
bbox = ImageChops.difference(img, renderImage).getbbox()
assert not bbox, f"Place {j[0]}{j[1]} failed at size {size}"
def test_popup():
"""Test animation of a window popUp widget."""
w = text(value="1\n2")
pu = popUp(size=(5, 8), widget=w, delay=(6, 6))
top = w.image.crop((0, 0, 5, 8))
btm = w.image.crop((0, 8, 5, 16))
# Start at top
assert pu.render()[0] == top
# Move to bottom
while not pu.atPauseEnd:
pu.render()
while not pu.atPause:
pu.render()
assert pu.render()[0] == btm
# Move back to top
while not pu.atPauseEnd:
pu.render()
while not pu.atPause:
pu.render()
assert pu.render()[0] == top
def test_slide1():
"""Test sliding from left to right to left and test if back to starting position."""
w = text(value="'This is a test!'")
sw = slide(
size=(100, 16),
widget=w,
actions=[("pause", 60), ("ltr"), ("pause", 2), ("rtl")],
speed=1,
background="black",
)
startImg = sw.render()[0]
# Move past initial pause
while not sw.atPauseEnd:
img, res = sw.render()
bbox = ImageChops.difference(sw.render()[0], startImg).getbbox()
assert not bbox, "slide should have moved but didn't"
while not sw.atStart:
img, res = sw.render()
bbox = ImageChops.difference(img, startImg).getbbox()
assert not bbox, "slide didn't return to start"
def makeSetup():
db = {
"artist": "Sting",
"title": "Desert Rose",
"album": "Ten Summoner's Tales",
}
system = {"state": "play", "temp": 40}
ds = dataset({"db": db, "sys": system})
# Widgets
artist = text(dvalue="f\"Artist {db['artist']}\"", dataset=ds)
title = text(dvalue="f\"Title {db['title']}\"", dataset=ds)
album = text(dvalue="f\"Album {db['album']}\"", dataset=ds)
alert = text(dvalue="'ALERT -- HOT'")
rectAlert = rectangle(
(0, 0, alert.size[0] + 3, alert.size[1] + 3),
outline="white",
fill="black",
)
time = text("12:32p")
# Canvases
cAT = canvas(size=(80, 16), duration=2)
cAT.append(artist)
cAT.append(title, placement=(0, 8))
cAA = canvas(
size=(80, 16),
duration=2,
activeWhen="len(db['album']) > 0",
dataset=ds,
)
cAA.append(artist)
cAA.append(album, placement=(0, 8))
seqPlay = sequence(size=(80, 16),
activeWhen="sys['state'] == 'play'",
dataset=ds)
seqPlay.append(cAT)
seqPlay.append(cAA)
cStop = canvas(size=(80, 16),
activeWhen="sys['state'] == 'stop'",
dataset=ds)
cStop.append(time, placement="mm")
cAlert = canvas(
size=(64, 12),
duration=5,
minDuration=2,
coolingPeriod=10,
activeWhen="sys['temp'] >= 100",
dataset=ds,
)
cAlert.append(alert, placement="mm")
cAlert.append(rectAlert, placement="mm")
wins = canvas(size=(80, 16), dataset=ds)
wins.append(seqPlay)
wins.append(cStop)
wins.append(cAlert, placement="mm", z=canvas.ZVHIGH)
return (ds, wins, seqPlay, cStop, cAlert, cAT, cAA)
def test_repr():
w = text(name="STATIC12345", value="12345")
v = "<STATIC12345.text value('12345') size(25, 8)"
assert repr(w)[0:len(v)] == v, f"Unexpected repr value given: {w}"
def _slide(actions):
w = text(value="This is a test!")
sw = slide(
size=(100, 16), widget=w, just="mm", actions=actions, speed=1
)
return sw