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, RAW_SHAPEFILE
     
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 assertPointListEquals(self, test, value):
        """Assert equality of two lists of lists of tuples of float"""
        for i in range(len(test)):
            self.assertEquals(len(test[i]), len(value[i]))
            for j in range(len(test[i])):
                self.assertFloatSeqEqual(test[i][j], value[i][j])

    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_raw_format(self):
        """Test DerivedShapeStore.RawShapeFormat() with shapefiles"""
        self.assertEquals(self.derived.RawShapeFormat(), RAW_SHAPEFILE)

    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.assertPointListEquals(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	bh	1564	from Thuban.Model.data import DerivedShapeStore, ShapefileStore, \
22			SHAPETYPE_ARC, RAW_SHAPEFILE
23
24	bh	1536	from Thuban.Model.session import Session
25			from Thuban.Model.table import MemoryTable, \
26			FIELDTYPE_DOUBLE, FIELDTYPE_INT, FIELDTYPE_STRING
27
28
29			class TestDerivedShapeStore(unittest.TestCase, support.FloatComparisonMixin):
30
31			def setUp(self):
32			"""Initialize self.session"""
33			self.session = Session("Test Session")
34			self.filename = os.path.join("..", "Data", "iceland",
35			"roads-line.shp")
36			self.store = ShapefileStore(self.session, self.filename)
37
38			self.table = MemoryTable([("type", FIELDTYPE_STRING),
39			("value", FIELDTYPE_DOUBLE),
40			("code", FIELDTYPE_INT)],
41			[("UNKNOWN", 0.0, 0)] * 839)
42			self.derived = DerivedShapeStore(self.store, self.table)
43
44			def tearDown(self):
45			"""Call self.session.Destroy() and reset self.session to None"""
46			self.session.Destroy()
47			self.session = None
48
49	bh	1551	def assertPointListEquals(self, test, value):
50			"""Assert equality of two lists of lists of tuples of float"""
51	bh	1536	for i in range(len(test)):
52	bh	1551	self.assertEquals(len(test[i]), len(value[i]))
53			for j in range(len(test[i])):
54			self.assertFloatSeqEqual(test[i][j], value[i][j])
55	bh	1536
56			def test_dependencies(self):
57			"""Test DerivedShapeStore dependencies"""
58			# The shapestore itself depends on nothing else
59			self.assertEquals(self.derived.Dependencies(),
60			(self.store, self.table))
61
62			def test_orig_shapestore(self):
63			"""Test DerivedShapeStore.OrigShapeStore()"""
64			self.assertEquals(self.derived.OrigShapeStore(), self.store)
65
66			def test_shape_type(self):
67			"""Test DerivedShapeStore.ShapeType() with arc shapes"""
68			self.assertEquals(self.derived.ShapeType(), SHAPETYPE_ARC)
69
70	bh	1564	def test_raw_format(self):
71			"""Test DerivedShapeStore.RawShapeFormat() with shapefiles"""
72			self.assertEquals(self.derived.RawShapeFormat(), RAW_SHAPEFILE)
73
74	bh	1536	def test_boundingbox(self):
75			"""Test DerivedShapeStore.BoundingBox() with arc shapes"""
76			self.assertFloatSeqEqual(self.derived.BoundingBox(),
77			[-24.450359344482422, 63.426830291748047,
78			-13.55668830871582, 66.520111083984375])
79
80			def test_num_shapes(self):
81			"""Test DerivedShapeStore.NumShapes() with arc shapes"""
82			self.assertEquals(self.derived.NumShapes(), 839)
83
84			def test_shapes_in_region(self):
85			"""Test DerivedShapeStore.ShapesInRegion() with arc shapes"""
86			self.assertEquals(self.derived.ShapesInRegion((-24.0, 64.0,
87			-23.75, 64.25)),
88			[613, 726, 838])
89
90			def test_shape(self):
91			"""Test DerivedShapeStore.Shape() with arc shapes"""
92	bh	1551	self.assertPointListEquals(self.derived.Shape(32).Points(),
93			[[(-15.082174301147461, 66.27738189697265),
94			(-15.026350021362305, 66.27339172363281)]])
95	bh	1536
96
97
98			class TestDerivedShapeStoreExceptions(unittest.TestCase):
99
100			"""Test DerivedShapeStore exceptions"""
101
102			def test_table_with_wrong_size(self):
103			"""Test DerivedShapeStore() with a table with the wrong number of lines
104			"""
105			filename = os.path.join("..", "Data", "iceland", "roads-line.shp")
106			session = Session("TestDerivedShapeStore Session")
107			store = session.OpenShapefile(filename)
108
109			table = MemoryTable([("type", FIELDTYPE_STRING),
110			("value", FIELDTYPE_DOUBLE),
111			("code", FIELDTYPE_INT)],
112			[("UNKNOWN", 0.0, 0),
113			("Foo", 0.5, -1),
114			("Foo", 0.25, 100),
115			("bar", 1e10, 17)])
116
117			# Trying to create a DerivedShapeStore where the number of lines
118			# in the table is not the same as the number of shapes in the
119			# shapefile raises a ValueError
120			self.assertRaises(ValueError, DerivedShapeStore, store, table)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision