← Back to branch summary

~widelands-dev/widelands-website/trunk

« back to all changes in this revision

Viewing changes to widelandslib/test/test_map.py

  • Committer: Holger Rapp
  • Date: 2019-06-21 18:34:42 UTC
  • mfrom: (540.1.3 update_ops_script)
  • Revision ID: sirver@gmx.de-20190621183442-y2ulybzr0rdvfefd
Adapt the update script for the new server.

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
10
10
import base64
11
 
from cStringIO import StringIO
 
11
from io import StringIO
12
12
from itertools import *
13
13
 
14
14
from map import *
15
15
 
16
16
# General base class for tests that raise
17
17
# an exception
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) )
 
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))
28
32
#################
29
33
# Working Tests #
30
34
#################
31
 
class TestElementalReading_ValidInput_ExceptCorrectResult( _WLElemental_Base ):
 
35
 
 
36
 
 
37
class TestElementalReading_ValidInput_ExceptCorrectResult(_WLElemental_Base):
32
38
    # {{{ Data
33
39
    input = """[global]
34
40
packet_version=1
41
47
descr=_"The breath-taking beauty of these ..."
42
48
"""
43
49
    # }}}
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" )
 
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
 
52
62
    def testName(self):
53
 
        self.assertEqual( self.m.name, "Elven Forests")
 
63
        self.assertEqual(self.m.name, 'Elven Forests')
 
64
 
54
65
    def testAuthor(self):
55
 
        self.assertEqual( self.m.author, "Winterwind" )
 
66
        self.assertEqual(self.m.author, 'Winterwind')
 
67
 
56
68
    def testDescr(self):
57
 
        self.assertEqual( self.m.descr, "The breath-taking beauty of these ..." )
 
69
        self.assertEqual(self.m.descr, 'The breath-taking beauty of these ...')
58
70
 
59
71
##########
60
72
# Raises #
61
73
##########
62
 
class TestElementalReading_TestMissingSection_ExceptRaises(_WLSetup ):
 
74
 
 
75
 
 
76
class TestElementalReading_TestMissingSection_ExceptRaises(_WLSetup):
63
77
    # {{{ Data
64
 
    input="""[globalnoglbale]
 
78
    input = """[globalnoglbale]
65
79
blah = 1
66
80
"""
67
81
    # }}}
 
82
 
68
83
    def runTest(self):
69
 
        self.assertRaises( InvalidMapPackage, self.m._read_elemental,
70
 
                          StringIO(self.input) )
 
84
        self.assertRaises(InvalidMapPackage, self.m._read_elemental,
 
85
                          StringIO(self.input))
71
86
# }}}
72
87
 
73
88
# {{{ Height package tests
74
 
class _WLHeight_Base( unittest.TestCase ):
 
89
 
 
90
 
 
91
class _WLHeight_Base(unittest.TestCase):
 
92
 
75
93
    def setUp(self):
76
94
        self.m = WidelandsMap()
77
95
        self.m._dim = self.dim
78
 
        self.m._read_heights( StringIO(self.input) )
79
 
class _WLHeight_Setup( unittest.TestCase ):
 
96
        self.m._read_heights(StringIO(self.input))
 
97
 
 
98
 
 
99
class _WLHeight_Setup(unittest.TestCase):
 
100
 
80
101
    def setUp(self):
81
102
        self.m = WidelandsMap()
82
103
        self.m._dim = self.dim
85
106
#################
86
107
# Working Tests #
87
108
#################
88
 
class TestHeightReading_ValidInput_ExceptCorrectResult( _WLHeight_Base ):
 
109
 
 
110
 
 
111
class TestHeightReading_ValidInput_ExceptCorrectResult(_WLHeight_Base):
89
112
    # {{{ Data
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"
 
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'
92
115
    wanted = array([[41, 33,  8, 42, 11, 49],
93
 
           [24, 45, 48, 29,  3,  8],
94
 
           [46, 30,  1, 25, 31, 29],
95
 
           [23, 23, 28,  7, 35, 53]])
 
116
                    [24, 45, 48, 29,  3,  8],
 
117
                    [46, 30,  1, 25, 31, 29],
 
118
                    [23, 23, 28,  7, 35, 53]])
96
119
    # }}}
 
120
 
97
121
    def runTest(self):
98
 
        self.assertTrue( all(self.wanted == self.m.heights ) )
 
122
        self.assertTrue(all(self.wanted == self.m.heights))
99
123
 
100
124
##########
101
125
# Raises #
102
126
##########
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 )
 
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)
118
151
# }}}
119
152
 
120
153
# {{{ Terrain package tests
121
 
class _WLTerrain_Base( unittest.TestCase ):
 
154
 
 
155
 
 
156
class _WLTerrain_Base(unittest.TestCase):
 
157
 
122
158
    def setUp(self):
123
159
        self.m = WidelandsMap()
124
160
        self.m._dim = self.dim
125
 
        self.m._read_terrains( StringIO(self.input) )
126
 
class _WLTerrain_Setup( unittest.TestCase ):
 
161
        self.m._read_terrains(StringIO(self.input))
 
162
 
 
163
 
 
164
class _WLTerrain_Setup(unittest.TestCase):
 
165
 
127
166
    def setUp(self):
128
167
        self.m = WidelandsMap()
129
168
        self.m._dim = self.dim
132
171
#################
133
172
# Working Tests #
134
173
#################
135
 
class TestTerrainReading_ValidInput_ExceptCorrectResult( _WLTerrain_Base ):
 
174
 
 
175
 
 
176
class TestTerrainReading_ValidInput_ExceptCorrectResult(_WLTerrain_Base):
136
177
    # {{{ Data
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" ]] )
 
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']])
145
186
    # }}}
 
187
 
146
188
    def test_R(self):
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))
 
189
        r = [i.name == j for i, j in zip(
 
190
            self.m.ter_r.flat, self.ter_r_names.flat)]
 
191
        self.assertTrue(all(r))
 
192
 
149
193
    def test_D(self):
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))
 
194
        d = [i.name == j for i, j in zip(
 
195
            self.m.ter_d.flat, self.ter_d_names.flat)]
 
196
        self.assertTrue(all(d))
152
197
 
153
198
##########
154
199
# Raises #
155
200
##########
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 )
 
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)
186
244
# }}}