import QuantityPredicate, DirectionalTestPredicate, LogicPredicate, Predicate
import unittest
from zerolife.enum import Direction

class TruePredicate(Predicate.Predicate):
    def holds(self, dummy1, dummy2):
        return True
        
class FalsePredicate(Predicate.Predicate):
    def holds(self, dummy1, dummy2):
        return False
        
class d(object):
    def __init__(self, val):
        self.state = val

 
class andunittest(unittest.TestCase):        
    def testAND(self):
         d = [None, None] #d holds none for the dummy parameter
         t = TruePredicate()
         f = FalsePredicate()
         
         self.assertTrue(LogicPredicate.AndPredicate(t, t, t).holds(*d)) #true
         self.assertFalse(LogicPredicate.AndPredicate(f, f, f).holds(*d)) #false
         self.assertFalse(LogicPredicate.AndPredicate(f, t, f).holds(*d))  #false
         self.assertFalse(LogicPredicate.AndPredicate(t, t, t, t, t, f).holds(*d)) #false
         self.assertTrue(LogicPredicate.AndPredicate().holds(*d)) # true
            
class orunittest(unittest.TestCase):        
    def testOR(self):
        t = TruePredicate()
        f = FalsePredicate()
        d = [None, None] #another dummy list of None
        self.assertTrue( LogicPredicate.OrPredicate(t, t, t).holds(*d)) #true
        self.assertFalse(LogicPredicate.OrPredicate(f, f, f).holds(*d)) #false
        self.assertTrue(LogicPredicate.OrPredicate(f, t, f).holds(*d)) #true
        self.assertTrue(LogicPredicate.OrPredicate(t, t, t, t, t, f).holds(*d)) #true
        self.assertFalse(LogicPredicate.OrPredicate().holds(*d)) #false
         
class notunittest(unittest.TestCase):
    def testNOT(self):
        t = TruePredicate()
        f = FalsePredicate()
        d = [None, None] #another dummy list of None
        self.assertTrue(LogicPredicate.NotPredicate(f).holds(*d))
        self.assertFalse(LogicPredicate.NotPredicate(t).holds(*d))
        self.assertRaises(Exception, \
            LogicPredicate.NotPredicate(None).holds,*d)
        
class otherPredicateTest(unittest.TestCase):
    def setUp(self):
        d1 = d(1)
        d2 = d(2)
        d3 = d(3)
   
        self.board1 = [[d1, d2, d3], [d1, d2, d3], [d1, d2, d3]]
        self.board2 = [[d3, None, None], [None, d3, d2], [d2, None, d2]]
        self.ds1 = {1:3, 2:2, 3:3}
        self.ds2 = {1:0, 2:3, 3:1}
        self.dsa = {Direction.NW:1, Direction.N:1, Direction.NE:1, \
                    Direction.E:2, Direction.SE:3, Direction.S:3, \
                    Direction.SW:3, Direction.W:2 \
                   }
        self.dsb = {Direction.NW:3, Direction.N:None, Direction.NE:None, \
                    Direction.E:2, Direction.SE:2, Direction.S:None, \
                    Direction.SW:None, Direction.W:3 \
                   }        
        self.coords = (1, 1)
class quantitypredicatetest(otherPredicateTest):
    def testboards(self):
        p = QuantityPredicate.QuantityPredicate(self.ds1)
        q = QuantityPredicate.QuantityPredicate(self.ds2)
        self.assertTrue(p.holds(self.board1, self.coords))
        self.assertFalse(p.holds(self.board2, self.coords))
        self.assertTrue(q.holds(self.board2, self.coords))
        self.assertFalse(q.holds(self.board1, self.coords))
        
class directionalpredicatetest(otherPredicateTest):
    def setUp(self):
        super(directionalpredicatetest,self).setUp()
        self.p = DirectionalTestPredicate.DirectionalTestPredicate(self.dsa)
        self.q = DirectionalTestPredicate.DirectionalTestPredicate(self.dsb)
    
    def testboards(self):       
        self.assertTrue(self.p.holds(self.board1, self.coords))
        self.assertFalse(self.p.holds(self.board2, self.coords))
        self.assertTrue(self.q.holds(self.board2, self.coords))
        self.assertFalse(self.q.holds(self.board1, self.coords)) 
    
        

        
        


if __name__=="__main__":
    unittest.main()