← Back to branch summary

~widelands-dev/widelands-website/django_staticfiles

« back to all changes in this revision

Viewing changes to widelandslib/test/test_map.py

  • Committer: franku
  • Date: 2016-04-18 13:29:23 UTC
  • mto: This revision was merged to the branch mainline in revision 409.
  • Revision ID: somal@arcor.de-20160418132923-bfzkb5mvdr7l8mz4
added migrations to each app

Show diffs side-by-side

added added

removed removed

Lines of Context:
widelandslib/test/test_map.py
3
3
#
4
4
 
5
5
import sys
6
 
sys.path.append('..')
 
6
sys.path.append("..")
7
7
 
8
8
from numpy import *
9
9
import unittest
15
15
 
16
16
# General base class for tests that raise
17
17
# an exception
18
 
 
19
 
 
20
 
class _WLSetup(unittest.TestCase):
21
 
 
22
 
    def setUp(self):
23
 
        self.m = WidelandsMap()
24
 
 
25
 
 
26
 
# {{{ Elemental package
27
 
class _WLElemental_Base(unittest.TestCase):
28
 
 
29
 
    def setUp(self):
30
 
        self.m = WidelandsMap()
31
 
        self.m._read_elemental(StringIO(self.input))
 
18
class _WLSetup( unittest.TestCase ):
 
19
    def setUp(self):
 
20
        self.m = WidelandsMap()
 
21
 
 
22
 
 
23
# {{{ Elemental package 
 
24
class _WLElemental_Base( unittest.TestCase ):
 
25
    def setUp(self):
 
26
        self.m = WidelandsMap()
 
27
        self.m._read_elemental( StringIO(self.input) )
32
28
#################
33
29
# Working Tests #
34
30
#################
35
 
 
36
 
 
37
 
class TestElementalReading_ValidInput_ExceptCorrectResult(_WLElemental_Base):
 
31
class TestElementalReading_ValidInput_ExceptCorrectResult( _WLElemental_Base ):
38
32
    # {{{ Data
39
33
    input = """[global]
40
34
packet_version=1
47
41
descr=_"The breath-taking beauty of these ..."
48
42
"""
49
43
    # }}}
50
 
 
51
 
    def testDimensions(self):
52
 
        self.assertEqual(self.m.w, 160)
53
 
        self.assertEqual(self.m.h, 132)
54
 
        self.assertEqual(self.m.dim, (132, 160))
55
 
 
56
 
    def testNrPlayers(self):
57
 
        self.assertEqual(self.m.nr_players, 4)
58
 
 
59
 
    def testWorldName(self):
60
 
        self.assertEqual(self.m.world_name, 'greenland')
61
 
 
 
44
    def testDimensions( self ):
 
45
        self.assertEqual( self.m.w, 160 )
 
46
        self.assertEqual( self.m.h, 132 )
 
47
        self.assertEqual( self.m.dim, (132,160) )
 
48
    def testNrPlayers( self ):
 
49
        self.assertEqual( self.m.nr_players, 4 )
 
50
    def testWorldName( self ):
 
51
        self.assertEqual( self.m.world_name, "greenland" )
62
52
    def testName(self):
63
 
        self.assertEqual(self.m.name, 'Elven Forests')
64
 
 
 
53
        self.assertEqual( self.m.name, "Elven Forests")
65
54
    def testAuthor(self):
66
 
        self.assertEqual(self.m.author, 'Winterwind')
67
 
 
 
55
        self.assertEqual( self.m.author, "Winterwind" )
68
56
    def testDescr(self):
69
 
        self.assertEqual(self.m.descr, 'The breath-taking beauty of these ...')
 
57
        self.assertEqual( self.m.descr, "The breath-taking beauty of these ..." )
70
58
 
71
59
##########
72
60
# Raises #
73
61
##########
74
 
 
75
 
 
76
 
class TestElementalReading_TestMissingSection_ExceptRaises(_WLSetup):
 
62
class TestElementalReading_TestMissingSection_ExceptRaises(_WLSetup ):
77
63
    # {{{ Data
78
 
    input = """[globalnoglbale]
 
64
    input="""[globalnoglbale]
79
65
blah = 1
80
66
"""
81
67
    # }}}
82
 
 
83
68
    def runTest(self):
84
 
        self.assertRaises(InvalidMapPackage, self.m._read_elemental,
85
 
                          StringIO(self.input))
 
69
        self.assertRaises( InvalidMapPackage, self.m._read_elemental,
 
70
                          StringIO(self.input) )
86
71
# }}}
87
72
 
88
73
# {{{ Height package tests
89
 
 
90
 
 
91
 
class _WLHeight_Base(unittest.TestCase):
92
 
 
 
74
class _WLHeight_Base( unittest.TestCase ):
93
75
    def setUp(self):
94
76
        self.m = WidelandsMap()
95
77
        self.m._dim = self.dim
96
 
        self.m._read_heights(StringIO(self.input))
97
 
 
98
 
 
99
 
class _WLHeight_Setup(unittest.TestCase):
100
 
 
 
78
        self.m._read_heights( StringIO(self.input) )
 
79
class _WLHeight_Setup( unittest.TestCase ):
101
80
    def setUp(self):
102
81
        self.m = WidelandsMap()
103
82
        self.m._dim = self.dim
106
85
#################
107
86
# Working Tests #
108
87
#################
109
 
 
110
 
 
111
 
class TestHeightReading_ValidInput_ExceptCorrectResult(_WLHeight_Base):
 
88
class TestHeightReading_ValidInput_ExceptCorrectResult( _WLHeight_Base ):
112
89
    # {{{ Data
113
 
    dim = (4, 6)  # w6, h4
114
 
    input = '\x01\x00)!\x08*\x0b1\x18-0\x1d\x03\x08.\x1e\x01\x19\x1f\x1d\x17\x17\x1c\x07#5'
 
90
    dim = (4,6) # w6, h4
 
91
    input = "\x01\x00)!\x08*\x0b1\x18-0\x1d\x03\x08.\x1e\x01\x19\x1f\x1d\x17\x17\x1c\x07#5"
115
92
    wanted = array([[41, 33,  8, 42, 11, 49],
116
 
                    [24, 45, 48, 29,  3,  8],
117
 
                    [46, 30,  1, 25, 31, 29],
118
 
                    [23, 23, 28,  7, 35, 53]])
 
93
           [24, 45, 48, 29,  3,  8],
 
94
           [46, 30,  1, 25, 31, 29],
 
95
           [23, 23, 28,  7, 35, 53]])
119
96
    # }}}
120
 
 
121
97
    def runTest(self):
122
 
        self.assertTrue(all(self.wanted == self.m.heights))
 
98
        self.assertTrue( all(self.wanted == self.m.heights ) )
123
99
 
124
100
##########
125
101
# Raises #
126
102
##########
127
 
 
128
 
 
129
 
class TestHeightReading_WrongVersion_ExceptRaises(_WLHeight_Setup):
130
 
    dim = (5, 7)
131
 
    input = '\x00\x02jdhf'
132
 
 
133
 
    def runTest(self):
134
 
        self.assertRaises(InvalidMapPackage, self.m._read_heights, self.input)
135
 
 
136
 
 
137
 
class TestHeightReading_PackageToShort_ExceptRaises(_WLHeight_Setup):
138
 
    dim = (5, 7)
139
 
    input = '\x01\x00jdhf'
140
 
 
141
 
    def runTest(self):
142
 
        self.assertRaises(InvalidMapPackage, self.m._read_heights, self.input)
143
 
 
144
 
 
145
 
class TestHeightReading_PackageToLong(_WLHeight_Setup):
146
 
    dim = (2, 2)
147
 
    input = '\x01\x00jdhkkf'
148
 
 
149
 
    def runTest(self):
150
 
        self.assertRaises(InvalidMapPackage, self.m._read_heights, self.input)
 
103
class TestHeightReading_WrongVersion_ExceptRaises(_WLHeight_Setup ):
 
104
    dim = (5,7)
 
105
    input = "\x00\x02jdhf"
 
106
    def runTest(self):
 
107
        self.assertRaises( InvalidMapPackage, self.m._read_heights, self.input )
 
108
class TestHeightReading_PackageToShort_ExceptRaises(_WLHeight_Setup ):
 
109
    dim = (5,7)
 
110
    input = "\x01\x00jdhf"
 
111
    def runTest(self):
 
112
        self.assertRaises( InvalidMapPackage, self.m._read_heights, self.input )
 
113
class TestHeightReading_PackageToLong(_WLHeight_Setup ):
 
114
    dim = (2,2)
 
115
    input = "\x01\x00jdhkkf"
 
116
    def runTest(self):
 
117
        self.assertRaises( InvalidMapPackage, self.m._read_heights, self.input )
151
118
# }}}
152
119
 
153
120
# {{{ Terrain package tests
154
 
 
155
 
 
156
 
class _WLTerrain_Base(unittest.TestCase):
157
 
 
 
121
class _WLTerrain_Base( unittest.TestCase ):
158
122
    def setUp(self):
159
123
        self.m = WidelandsMap()
160
124
        self.m._dim = self.dim
161
 
        self.m._read_terrains(StringIO(self.input))
162
 
 
163
 
 
164
 
class _WLTerrain_Setup(unittest.TestCase):
165
 
 
 
125
        self.m._read_terrains( StringIO(self.input) )
 
126
class _WLTerrain_Setup( unittest.TestCase ):
166
127
    def setUp(self):
167
128
        self.m = WidelandsMap()
168
129
        self.m._dim = self.dim
171
132
#################
172
133
# Working Tests #
173
134
#################
174
 
 
175
 
 
176
 
class TestTerrainReading_ValidInput_ExceptCorrectResult(_WLTerrain_Base):
 
135
class TestTerrainReading_ValidInput_ExceptCorrectResult( _WLTerrain_Base ):
177
136
    # {{{ Data
178
 
    dim = (1, 2)  # w6, h4
179
 
    input = ('\x01\x00' +  # Package version
180
 
             '\x02\x00' +  # Nr of terrain types
181
 
             '\x00\x00Baum\x00\x01\x00Haus\x00' +  # Terrains (id,Name\x00)
182
 
             '\x01\x00\x00\x01'  # Terrain data (ter_r,ter_d)*nr_of_fields
183
 
             )
184
 
    ter_r_names = array([['Haus', 'Baum']])
185
 
    ter_d_names = array([['Baum', 'Haus']])
 
137
    dim = (1,2) # w6, h4
 
138
    input = ("\x01\x00" + # Package version
 
139
            "\x02\x00" +  # Nr of terrain types
 
140
            "\x00\x00Baum\x00\x01\x00Haus\x00" + # Terrains (id,Name\x00)
 
141
            "\x01\x00\x00\x01" # Terrain data (ter_r,ter_d)*nr_of_fields
 
142
    )
 
143
    ter_r_names = array([[ "Haus", "Baum" ]] )
 
144
    ter_d_names = array([[ "Baum", "Haus" ]] )
186
145
    # }}}
187
 
 
188
146
    def test_R(self):
189
 
        r = [i.name == j for i, j in izip(
190
 
            self.m.ter_r.flat, self.ter_r_names.flat)]
191
 
        self.assertTrue(all(r))
192
 
 
 
147
        r = [ i.name == j for i,j in izip(self.m.ter_r.flat,self.ter_r_names.flat) ]
 
148
        self.assertTrue( all(r))
193
149
    def test_D(self):
194
 
        d = [i.name == j for i, j in izip(
195
 
            self.m.ter_d.flat, self.ter_d_names.flat)]
196
 
        self.assertTrue(all(d))
 
150
        d = [ i.name == j for i,j in izip(self.m.ter_d.flat,self.ter_d_names.flat) ]
 
151
        self.assertTrue( all(d))
197
152
 
198
153
##########
199
154
# Raises #
200
155
##########
201
 
 
202
 
 
203
 
class TestTerrainReading_WrongVersion_ExceptRaises(_WLTerrain_Setup):
204
 
    dim = (5, 7)
205
 
    input = '\x00\x02jdhf'
206
 
 
207
 
    def runTest(self):
208
 
        self.assertRaises(InvalidMapPackage, self.m._read_terrains, self.input)
209
 
 
210
 
 
211
 
class TestTerrainReading_PackageToShort_ExceptRaises(_WLTerrain_Setup):
212
 
    dim = (5, 7)
213
 
    input = '\x01\x00jdhf'
214
 
 
215
 
    def runTest(self):
216
 
        self.assertRaises(InvalidMapPackage, self.m._read_terrains, self.input)
217
 
 
218
 
 
219
 
class TestTerrainReading_PackageToLong(_WLTerrain_Setup):
220
 
    dim = (1, 2)  # w6, h4
221
 
    input = ('\x01\x00' +  # Package version
222
 
             '\x02\x00' +  # Nr of terrain types
223
 
             '\x00\x00Baum\x00\x01\x00Haus\x00' +  # Terrains (id,Name\x00)
224
 
             # Terrain data (ter_r,ter_d)*nr_of_fields
225
 
             '\x02\x03\x04\x00\x00\x01'
226
 
             )
227
 
    ter_r_names = array([['Haus', 'Baum']])
228
 
    ter_d_names = array([['Baum', 'Haus']])
229
 
 
230
 
    def runTest(self):
231
 
        self.assertRaises(InvalidMapPackage, self.m._read_terrains, self.input)
232
 
 
233
 
 
234
 
class TestTerrainReading_WrongTerrainId(_WLTerrain_Setup):
235
 
    dim = (1, 2)  # w6, h4
236
 
    input = ('\x01\x00' +  # Package version
237
 
             '\x02\x00' +  # Nr of terrain types
238
 
             '\x00\x00Baum\x00\x01\x00Haus\x00' +  # Terrains (id,Name\x00)
239
 
             '\x00\x00\x02\x00'  # Terrain data (ter_r,ter_d)*nr_of_fields
240
 
             )
241
 
 
242
 
    def runTest(self):
243
 
        self.assertRaises(InvalidMapPackage, self.m._read_terrains, self.input)
 
156
class TestTerrainReading_WrongVersion_ExceptRaises(_WLTerrain_Setup ):
 
157
    dim = (5,7)
 
158
    input = "\x00\x02jdhf"
 
159
    def runTest(self):
 
160
        self.assertRaises( InvalidMapPackage, self.m._read_terrains, self.input )
 
161
class TestTerrainReading_PackageToShort_ExceptRaises(_WLTerrain_Setup ):
 
162
    dim = (5,7)
 
163
    input = "\x01\x00jdhf"
 
164
    def runTest(self):
 
165
        self.assertRaises( InvalidMapPackage, self.m._read_terrains, self.input )
 
166
class TestTerrainReading_PackageToLong(_WLTerrain_Setup ):
 
167
    dim = (1,2) # w6, h4
 
168
    input = ("\x01\x00" + # Package version
 
169
            "\x02\x00" +  # Nr of terrain types
 
170
            "\x00\x00Baum\x00\x01\x00Haus\x00" + # Terrains (id,Name\x00)
 
171
            "\x02\x03\x04\x00\x00\x01" # Terrain data (ter_r,ter_d)*nr_of_fields
 
172
    )
 
173
    ter_r_names = array([[ "Haus", "Baum" ]] )
 
174
    ter_d_names = array([[ "Baum", "Haus" ]] )
 
175
    def runTest(self):
 
176
        self.assertRaises( InvalidMapPackage, self.m._read_terrains, self.input )
 
177
class TestTerrainReading_WrongTerrainId(_WLTerrain_Setup ):
 
178
    dim = (1,2) # w6, h4
 
179
    input = ("\x01\x00" + # Package version
 
180
            "\x02\x00" +  # Nr of terrain types
 
181
            "\x00\x00Baum\x00\x01\x00Haus\x00" + # Terrains (id,Name\x00)
 
182
            "\x00\x00\x02\x00" # Terrain data (ter_r,ter_d)*nr_of_fields
 
183
    )
 
184
    def runTest(self):
 
185
        self.assertRaises( InvalidMapPackage, self.m._read_terrains, self.input )
244
186
# }}}