import unittest

from pymutable_geometries import *

from django.contrib.gis.geos.error import GEOSIndexError

class GEOSPyMutableTest(unittest.TestCase):

    '''

    Tests Pythonic Mutability of Python GEOS geometry wrappers

    get/set/delitem on a slice, normal list methods

    '''

    def test01_getitem(self):

        'Test getting a single item from a geometry'

        for g in slice_geometries():

            for i in seqrange():

                self.assertEqual(g.coords[i], getcoords(g.geom[i]))

    def test02_getslice(self):

        'Test getting a slice from a geometry'

        for f in getslice_functions():

            for g in slice_geometries():

                msg = "fcn %s, geom %s" % (f.__name__, str(g.geom_type))

                self.assertEqual(f(g.coords), getcoords(f(g.geom)), msg)

    def test03_getitem_indexException(self):

        'Test get single item with out-of-bounds index'

        for g in slice_geometries():

            for i in SEQ_OUT_OF_BOUNDS:

                self.assertRaises(GEOSIndexError, lambda: g.geom[i])

    def test04_delitem_single(self):

        'Test delete single item from a geometry'

        for i in seqrange():

            for g in slice_geometries():

                if g.geom.ring and i in SEQ_BOUNDS: continue

                del g.coords[i]

                del g.geom[i]

                self.assertEqual(g.tuple_coords, g.geom.coords)

    def test05_delitem_slice(self):

        'Test delete slice from a geometry'

        for f in delslice_functions():

            for g in slice_geometries():

                if g.geom.ring and not f.ring: continue

                f(g.coords)

                f(g.geom)

                msg = "fcn %s, geom %s" % (f.__name__, str(g.geom_type))

                self.assertEqual(g.tuple_coords, g.geom.coords, msg)

    def test06_delitem_single_indexException(self):

        'Test delete single item with out-of-bounds index'

        def func(x, i): del x[i]

        for g in slice_geometries():

            for i in SEQ_OUT_OF_BOUNDS:

                self.assertRaises(GEOSIndexError, func, g.geom, i)

    def test07_setitem_single(self):

        "Test set single item (make sure we didn't break this)"

        for i in seqrange():

            for g in slice_geometries():

                if g.geom.ring and i in SEQ_BOUNDS: continue

                ag, ac = g.newitem(rng=(400,410))

                g.coords[i] = ac

                g.geom[i] = ag

                self.assertEqual(g.tuple_coords, g.geom.coords)

    def test08_setslice_simple(self):

        'Test setting a simple slice of a geometry'

        for g in slice_geometries():

            for f in setslice_simple_functions(g):

                if g.geom.ring and not f.ring: continue

                f(g.coords)

                f(g.geom)

                msg = "fcn %s, geom %s" % (f.__name__, str(g.geom_type))

                self.assertEqual(g.tuple_coords, g.geom.coords, msg)

    def test09_setslice_extended(self):

        'Test setting an extended slice of a geometry'

        for g in slice_geometries():

            for f in setslice_extended_functions(g):

                if g.geom.ring and not f.ring: continue

                f(g.coords)

                f(g.geom)

                msg = "fcn %s, geom %s" % (f.__name__, str(g.geom_type))

                self.assertEqual(g.tuple_coords, g.geom.coords, msg)

    def test10_setslice_extended_mismatched(self):

        'Test setting extended slice with array of mismatched length'

        for g in slice_geometries():

            ag, ac = g.newitem(rng=(400,410))

            def func(): g.geom[2:8:2] = [ ag, ]

            self.assertRaises(ValueError, func)

    def test11_setitem_single_indexException(self):

        'Test set single item with out-of-bounds index'

        for g in slice_geometries():

            ag, ac = g.newitem(rng=(400,410))

            def func(i): g.geom[i] = ag

            for i in SEQ_OUT_OF_BOUNDS:

                self.assertRaises(GEOSIndexError, func, i)

    def test12_append(self):

        'Test list method append'

        for g in slice_geometries(ring=False):

            ag, ac = g.newitem(rng=(400,410))

            g.geom.append(ag)

            g.coords.append(ac)

            self.assertEqual(g.tuple_coords, g.geom.coords)

    def test13_extend(self):

        'Test list method extend'

        for g in slice_geometries():

            items = g.coords_fcn(5)

            if g.geom.ring: items[-1] = g.coords[0]

            g.geom.extend(map(g.subtype,items))

            g.coords.extend(items)

            self.assertEqual(g.tuple_coords, g.geom.coords)

    def test14_insert(self):

        'Test list method insert'

        for i in xrange(*SEQ_OUT_OF_BOUNDS):

            for g in slice_geometries():

                if g.geom.ring and i in SEQ_BOUNDS + SEQ_OUT_OF_BOUNDS:

                    continue

                ag, ac = g.newitem(rng=(200,250))

                g.geom.insert(i, ag)

                g.coords.insert(i, ac)

                self.assertEqual(g.tuple_coords, g.geom.coords)

    def test15_insert_typeError(self):

        'Test list method insert raises error on invalid index'

        for g in slice_geometries():

            ag, ac = g.newitem(rng=(200,250))

            self.assertRaises(TypeError, g.geom.insert, 'hi', ag)

    def test16_pop(self):

        'Test list method pop'

        for i in seqrange():

            for g in slice_geometries():

                if g.geom.ring and i in SEQ_BOUNDS + SEQ_OUT_OF_BOUNDS:

                    continue

                self.assertEqual(g.coords.pop(i), getcoords(g.geom.pop(i)))

    def test16_index(self):

        'Test list method index'

        for i in xrange(0, SEQ_LENGTH):

            for g in slice_geometries():

                if g.geom.ring and i in SEQ_BOUNDS: continue

                ag, ac = g.newitem(rng=(400,410))

                g.geom[i] = ag

                self.assertEqual(i, g.geom.index(ag))

    def test17_index_ValueError(self):

        'Test list method raises ValueError if value not found'

        for g in slice_geometries():

            ag, ac = g.newitem(rng=(400,410))

            self.assertRaises(ValueError, g.geom.index, ag)

    def test18_remove(self):

        'Test list method remove'

        for i in xrange(0, SEQ_LENGTH):

            for g in slice_geometries():

                if g.geom.ring and i in SEQ_BOUNDS: continue

                ag, ac = g.newitem(rng=(400,410))

                g.geom[i] = ag

                g.coords[i] = ac

                g.geom.remove(ag)

                g.coords.remove(ac)

                self.assertEqual(g.tuple_coords, g.geom.coords)

    def test19_count(self):

        'Test list method count'

        for g in slice_geometries():

            self.assertEqual(SEQ_LENGTH, g.geom.count())

    def test20_setslice_geos_fcns(self):

        'Test geos properties after setting a simple slice of a geometry'

        for g in slice_geometries(ring=False):

            for f in setslice_simple_functions(g):

                f(g.coords)

                f(g.geom)

                if not len(g.coords): continue

                for tf in test_geos_functions():

                    cg = g.make_geom()

                    self.assertEqual(tf(cg) , tf(g.geom))

    def test21_delslice_geos_fcns(self):

        'Test geos properties after deleting a slice of a geometry'

        for f in delslice_functions():

            for g in slice_geometries(ring=False):

                f(g.coords)

                f(g.geom)

                if not len(g.coords): continue

                for tf in test_geos_functions():

                    cg = g.make_geom()

                    self.assertEqual(tf(cg) , tf(g.geom))

def suite():

    s = unittest.TestSuite()

    s.addTest(unittest.makeSuite(GEOSPyMutableTest))

    return s

def run(verbosity=2):

    unittest.TextTestRunner(verbosity=verbosity).run(suite())

if __name__ == '__main__':

    run()