#! /usr/bin/python3
# Test program for module {shape}
# Last edited on 2021-02-08 20:34:13 by jstolfi

import trafo
import shape
import sys
from math import sqrt, sin, cos, floor, ceil, inf, nan, pi

class MyTrafo(trafo.Trafo):

  def __init__(self,name):
    self.name = name

class MyShape(shape.Shape):

  def __init__(self,name):
    self.name = name

sys.stderr.write("--- creating some {Trafo} onjects ---------------------\n")

T0 = MyTrafo("T0")
T1 = MyTrafo("T1")
T3 = MyTrafo("T3")

sys.stderr.write("--- creating some {Shape} objects ---------------------\n")
F0 = MyShape("F0")
F1 = MyShape("F1")
F2 = MyShape("F2")
F3 = MyShape("F3")
F4 = MyShape("F4")

sys.stderr.write("--- testing {vacuum,shape.is_vacuum} -------------------------\n")
Fa = shape.vacuum()
assert Fa == None
assert shape.is_vacuum(Fa)
assert shape.is_vacuum((0,None))
assert not shape.is_vacuum((1,None))
assert shape.is_vacuum((0,T0))
assert not shape.is_vacuum((1,T0))
assert not shape.is_vacuum(F0)
assert not shape.is_vacuum((0,None,F0))
assert not shape.is_vacuum((1,None,F0))

sys.stderr.write("--- testing {plenum,is_plenum} -------------------------\n")
F2 = shape.plenum()
assert F2 == (1,None)
assert shape.is_plenum(F2)
assert shape.is_plenum((1,None))
assert not shape.is_plenum((0,None))
assert shape.is_plenum((1,T0))
assert not shape.is_plenum((0,T0))
assert not shape.is_plenum(F0)
assert not shape.is_plenum((0,None,F0))
assert not shape.is_plenum((1,None,F0))

sys.stderr.write("--- testing {complement} -------------------------\n")
assert shape.is_plenum(shape.complement(shape.vacuum()))
assert shape.is_vacuum(shape.complement(shape.plenum()))
assert shape.complement(F0) == (1,None,F0)
assert shape.complement((0,T0,F0)) == (1,T0,F0)
assert shape.complement((1,T0,F0)) == (0,T0,F0)

F0C = shape.complement(F0)
F1C = shape.complement(F1)

sys.stderr.write("--- testing {union,intersection} -------------------------\n")
assert shape.is_vacuum(shape.union([]))
assert shape.is_plenum(shape.intersection([]))
assert shape.union([F0]) == F0
assert shape.intersection([F0]) == F0
assert shape.union([F0, F1]) == (0,None,F0,F1)
assert shape.intersection([F0, F1]) == (1,None,F0C,F1C)
assert shape.union([F0,shape.vacuum(),F1]) == (0,None,F0,F1)
assert shape.intersection([F0,plenum(),F1]) == (1,None,F0C,F1C)
assert shape.is_plenum(shape.union([F0,plenum(),F1]))
assert shape.is_vacuum(shape.intersection([F0,shape.vacuum(),F1]))
assert shape.union([shape.complement(F0)]) == shape.complement(F0)
assert shape.intersection([shape.complement(F0)]) == shape.complement(F0)
assert shape.union([shape.complement(F0),shape.complement(F1)]) == (0,None,F0C,F1C)

sys.stderr.write("--- testing {difference} -------------------------\n")
assert shape.is_vacuum(shape.difference(shape.vacuum(),[]))
assert shape.difference(F0,[]) == F0
assert shape.difference(F0C,[]) == F0C
assert shape.is_plenum(shape.difference(plenum(),[]))
sys.stderr.write("??? To be completed ???\n")

sys.stderr.write("--- testing {transform} -------------------------\n")
assert shape.is_vacuum(shape.transform(vacuum(),T0))
assert shape.is_plenum(shape.transform(plenum(),T0))
assert shape.transform(F0,T0) == (0,T0,F0)
assert shape.transform(F0C,T0) == (1,T0,F0)
assert shape.transform((0,T1,F0,F1),T2) == (0,(0,T1,T2),F0,F1)
assert shape.transform((1,T1,F0,F1),T2) == (1,(0,T1,T2),F0,F1)

sys.stderr.write("??? To be completed ???\n")

sys.stderr.write("--- testing {cbit} -------------------------\n")

assert shape.cbit(None) == 0
assert shape.cbit(F0) == 0
assert shape.cbit(F1C) == 1
assert shape.cbit((0,T3, F1,F2)) == 0
assert shape.cbit((1,T3, F1,F2)) == 1

sys.stderr.write("??? To be completed ???\n")

sys.stderr.write("--- testing {trafo} -------------------------\n")

assert shape.trafo(None) == None
assert shape.trafo(F0) == None
assert shape.trafo(F1C) == None
assert shape.trafo((0,T3, F1,F2)) == T3
assert shape.trafo((1,T3, F1,F2)) == T3
assert shape.trafo((1,(0,T2,T1), F1,F2)) == (0,T2,T1)

sys.stderr.write("??? To be completed ???\n")

sys.stderr.write("--- testing {nterms} -------------------------\n")

assert shape.nterms(None) == 0
assert shape.nterms(F0) == 1
assert shape.nterms(F1C) == 1
assert shape.nterms((0,T3, F1,F2)) == 2
assert shape.nterms((1,T3, F1,F2)) == 2
assert shape.nterms((1,(0,T2,T1))) == 0

sys.stderr.write("??? To be completed ???\n")

sys.stderr.write("--- testing {term} -------------------------\n")

assert shape.term(F0,0) == F0
assert shape.term(F1C,0) == F1
assert shape.term((0,T3, F1,F2),0) == F1
assert shape.term((0,T3, F1,F2),1) == F2
assert shape.term((1,T3, F1,F2),0) == F1
assert shape.term((1,T3, F1,F2),1) == F2

sys.stderr.write("??? To be completed ???\n")

sys.stderr.write("--- testing {simplify} -------------------------\n")
assert shape.simplify(None) == None
assert shape.simplify(F0) == F0
assert shape.simplify(F1C) == F1C

sys.stderr.write("??? To be completed ???\n")