WIP-pyshapelib-bramz/test/test_derivedshapestore.py

# Copyright (C) 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Tests for DerivedShapeStore"""

__version__ = "$Revision$"
# $Source$
# $Id$

import os

import unittest

import support
support.initthuban()

from Thuban.Model.data import DerivedShapeStore, ShapefileStore, SHAPETYPE_ARC
from Thuban.Model.session import Session
from Thuban.Model.table import MemoryTable, \
     FIELDTYPE_DOUBLE, FIELDTYPE_INT, FIELDTYPE_STRING


class TestDerivedShapeStore(unittest.TestCase, support.FloatComparisonMixin):

    def setUp(self):
        """Initialize self.session"""
        self.session = Session("Test Session")
        self.filename = os.path.join("..", "Data", "iceland",
                                "roads-line.shp")
        self.store = ShapefileStore(self.session, self.filename)

        self.table = MemoryTable([("type", FIELDTYPE_STRING),
                                  ("value", FIELDTYPE_DOUBLE),
                                  ("code", FIELDTYPE_INT)],
                                 [("UNKNOWN", 0.0, 0)] * 839)
        self.derived = DerivedShapeStore(self.store, self.table)

    def tearDown(self):
        """Call self.session.Destroy() and reset self.session to None"""
        self.session.Destroy()
        self.session = None

    def assertFloatTuplesEqual(self, test, value):
        """Assert equality of two lists of tuples of float"""
        for i in range(len(test)):
            self.assertFloatSeqEqual(test[i], value[i])

    def test_dependencies(self):
        """Test DerivedShapeStore dependencies"""
        # The shapestore itself depends on nothing else
        self.assertEquals(self.derived.Dependencies(),
                          (self.store, self.table))

    def test_orig_shapestore(self):
        """Test DerivedShapeStore.OrigShapeStore()"""
        self.assertEquals(self.derived.OrigShapeStore(), self.store)

    def test_shape_type(self):
        """Test DerivedShapeStore.ShapeType() with arc shapes"""
        self.assertEquals(self.derived.ShapeType(), SHAPETYPE_ARC)

    def test_boundingbox(self):
        """Test DerivedShapeStore.BoundingBox() with arc shapes"""
        self.assertFloatSeqEqual(self.derived.BoundingBox(),
                                 [-24.450359344482422, 63.426830291748047,
                                  -13.55668830871582, 66.520111083984375])

    def test_num_shapes(self):
        """Test DerivedShapeStore.NumShapes() with arc shapes"""
        self.assertEquals(self.derived.NumShapes(), 839)

    def test_shapes_in_region(self):
        """Test DerivedShapeStore.ShapesInRegion() with arc shapes"""
        self.assertEquals(self.derived.ShapesInRegion((-24.0, 64.0,
                                                     -23.75, 64.25)),
                          [613, 726, 838])

    def test_shape(self):
        """Test DerivedShapeStore.Shape() with arc shapes"""
        self.assertFloatTuplesEqual(self.derived.Shape(32).Points(),
                                    [(-15.082174301147461, 66.27738189697265),
                                     (-15.026350021362305, 66.27339172363281)])


class TestDerivedShapeStoreExceptions(unittest.TestCase):

    """Test DerivedShapeStore exceptions"""

    def test_table_with_wrong_size(self):
        """Test DerivedShapeStore() with a table with the wrong number of lines
        """
        filename = os.path.join("..", "Data", "iceland", "roads-line.shp")
        session = Session("TestDerivedShapeStore Session")
        store =  session.OpenShapefile(filename)

        table = MemoryTable([("type", FIELDTYPE_STRING),
                             ("value", FIELDTYPE_DOUBLE),
                             ("code", FIELDTYPE_INT)],
                            [("UNKNOWN", 0.0, 0),
                             ("Foo", 0.5, -1),
                             ("Foo", 0.25, 100),
                             ("bar", 1e10, 17)])

        # Trying to create a DerivedShapeStore where the number of lines
        # in the table is not the same as the number of shapes in the
        # shapefile raises a ValueError
        self.assertRaises(ValueError, DerivedShapeStore, store, table)
1	bh	1536	# Copyright (C) 2003 by Intevation GmbH
2			# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with the software for details.
7
8			"""Tests for DerivedShapeStore"""
9
10			__version__ = "$Revision$"
11			# $Source$
12			# $Id$
13
14			import os
15
16			import unittest
17
18			import support
19			support.initthuban()
20
21			from Thuban.Model.data import DerivedShapeStore, ShapefileStore, SHAPETYPE_ARC
22			from Thuban.Model.session import Session
23			from Thuban.Model.table import MemoryTable, \
24			FIELDTYPE_DOUBLE, FIELDTYPE_INT, FIELDTYPE_STRING
25
26
27			class TestDerivedShapeStore(unittest.TestCase, support.FloatComparisonMixin):
28
29			def setUp(self):
30			"""Initialize self.session"""
31			self.session = Session("Test Session")
32			self.filename = os.path.join("..", "Data", "iceland",
33			"roads-line.shp")
34			self.store = ShapefileStore(self.session, self.filename)
35
36			self.table = MemoryTable([("type", FIELDTYPE_STRING),
37			("value", FIELDTYPE_DOUBLE),
38			("code", FIELDTYPE_INT)],
39			[("UNKNOWN", 0.0, 0)] * 839)
40			self.derived = DerivedShapeStore(self.store, self.table)
41
42			def tearDown(self):
43			"""Call self.session.Destroy() and reset self.session to None"""
44			self.session.Destroy()
45			self.session = None
46
47			def assertFloatTuplesEqual(self, test, value):
48			"""Assert equality of two lists of tuples of float"""
49			for i in range(len(test)):
50			self.assertFloatSeqEqual(test[i], value[i])
51
52			def test_dependencies(self):
53			"""Test DerivedShapeStore dependencies"""
54			# The shapestore itself depends on nothing else
55			self.assertEquals(self.derived.Dependencies(),
56			(self.store, self.table))
57
58			def test_orig_shapestore(self):
59			"""Test DerivedShapeStore.OrigShapeStore()"""
60			self.assertEquals(self.derived.OrigShapeStore(), self.store)
61
62			def test_shape_type(self):
63			"""Test DerivedShapeStore.ShapeType() with arc shapes"""
64			self.assertEquals(self.derived.ShapeType(), SHAPETYPE_ARC)
65
66			def test_boundingbox(self):
67			"""Test DerivedShapeStore.BoundingBox() with arc shapes"""
68			self.assertFloatSeqEqual(self.derived.BoundingBox(),
69			[-24.450359344482422, 63.426830291748047,
70			-13.55668830871582, 66.520111083984375])
71
72			def test_num_shapes(self):
73			"""Test DerivedShapeStore.NumShapes() with arc shapes"""
74			self.assertEquals(self.derived.NumShapes(), 839)
75
76			def test_shapes_in_region(self):
77			"""Test DerivedShapeStore.ShapesInRegion() with arc shapes"""
78			self.assertEquals(self.derived.ShapesInRegion((-24.0, 64.0,
79			-23.75, 64.25)),
80			[613, 726, 838])
81
82			def test_shape(self):
83			"""Test DerivedShapeStore.Shape() with arc shapes"""
84			self.assertFloatTuplesEqual(self.derived.Shape(32).Points(),
85			[(-15.082174301147461, 66.27738189697265),
86			(-15.026350021362305, 66.27339172363281)])
87
88
89
90			class TestDerivedShapeStoreExceptions(unittest.TestCase):
91
92			"""Test DerivedShapeStore exceptions"""
93
94			def test_table_with_wrong_size(self):
95			"""Test DerivedShapeStore() with a table with the wrong number of lines
96			"""
97			filename = os.path.join("..", "Data", "iceland", "roads-line.shp")
98			session = Session("TestDerivedShapeStore Session")
99			store = session.OpenShapefile(filename)
100
101			table = MemoryTable([("type", FIELDTYPE_STRING),
102			("value", FIELDTYPE_DOUBLE),
103			("code", FIELDTYPE_INT)],
104			[("UNKNOWN", 0.0, 0),
105			("Foo", 0.5, -1),
106			("Foo", 0.25, 100),
107			("bar", 1e10, 17)])
108
109			# Trying to create a DerivedShapeStore where the number of lines
110			# in the table is not the same as the number of shapes in the
111			# shapefile raises a ValueError
112			self.assertRaises(ValueError, DerivedShapeStore, store, table)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision