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 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			def test_dependencies(self):
50			"""Test DerivedShapeStore dependencies"""
51			# The shapestore itself depends on nothing else
52			self.assertEquals(self.derived.Dependencies(),
53			(self.store, self.table))
54
55			def test_orig_shapestore(self):
56			"""Test DerivedShapeStore.OrigShapeStore()"""
57			self.assertEquals(self.derived.OrigShapeStore(), self.store)
58
59			def test_shape_type(self):
60			"""Test DerivedShapeStore.ShapeType() with arc shapes"""
61			self.assertEquals(self.derived.ShapeType(), SHAPETYPE_ARC)
62
63	bh	1564	def test_raw_format(self):
64			"""Test DerivedShapeStore.RawShapeFormat() with shapefiles"""
65			self.assertEquals(self.derived.RawShapeFormat(), RAW_SHAPEFILE)
66
67	bh	1536	def test_boundingbox(self):
68			"""Test DerivedShapeStore.BoundingBox() with arc shapes"""
69			self.assertFloatSeqEqual(self.derived.BoundingBox(),
70			[-24.450359344482422, 63.426830291748047,
71			-13.55668830871582, 66.520111083984375])
72
73			def test_num_shapes(self):
74			"""Test DerivedShapeStore.NumShapes() with arc shapes"""
75			self.assertEquals(self.derived.NumShapes(), 839)
76
77			def test_shapes_in_region(self):
78			"""Test DerivedShapeStore.ShapesInRegion() with arc shapes"""
79			self.assertEquals(self.derived.ShapesInRegion((-24.0, 64.0,
80			-23.75, 64.25)),
81			[613, 726, 838])
82
83			def test_shape(self):
84			"""Test DerivedShapeStore.Shape() with arc shapes"""
85	bh	1551	self.assertPointListEquals(self.derived.Shape(32).Points(),
86			[[(-15.082174301147461, 66.27738189697265),
87			(-15.026350021362305, 66.27339172363281)]])
88	bh	1536
89
90
91			class TestDerivedShapeStoreExceptions(unittest.TestCase):
92
93			"""Test DerivedShapeStore exceptions"""
94
95			def test_table_with_wrong_size(self):
96			"""Test DerivedShapeStore() with a table with the wrong number of lines
97			"""
98			filename = os.path.join("..", "Data", "iceland", "roads-line.shp")
99			session = Session("TestDerivedShapeStore Session")
100			store = session.OpenShapefile(filename)
101
102			table = MemoryTable([("type", FIELDTYPE_STRING),
103			("value", FIELDTYPE_DOUBLE),
104			("code", FIELDTYPE_INT)],
105			[("UNKNOWN", 0.0, 0),
106			("Foo", 0.5, -1),
107			("Foo", 0.25, 100),
108			("bar", 1e10, 17)])
109
110			# Trying to create a DerivedShapeStore where the number of lines
111			# in the table is not the same as the number of shapes in the
112			# shapefile raises a ValueError
113			self.assertRaises(ValueError, DerivedShapeStore, store, table)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision