Changed file encoding for setup.py to UTF-8.
[philipp/winterrodeln/wrpylib.git] / tests / test_wrvalidators.py
1 #!/usr/bin/python3.4
2 import unittest
3 from wrpylib.wrvalidators import *
4
5 # optional converter
6 # ------------------
7
8 class TestOpt(unittest.TestCase):
9     def test_from_str(self):
10         self.assertEqual(None, opt_from_str('', str_from_str))
11         self.assertEqual('abc', opt_from_str('abc', str_from_str))
12         self.assertEqual(None, opt_from_str('', int_from_str))
13         self.assertEqual(4, opt_from_str('4', int_from_str))
14
15     def test_to_str(self):
16         self.assertEqual('', opt_to_str(None, str_to_str))
17         self.assertEqual('abc', opt_to_str('abc', str_to_str))
18         self.assertEqual('', opt_to_str(None, int_to_str))
19         self.assertEqual('4', opt_to_str(4, int_to_str))
20
21
22 # "no" converter
23 # --------------
24
25 class TestNoGermanConverter(unittest.TestCase):
26     def test_from_str(self):
27         self.assertEqual((True, 'abc'), no_german_from_str('abc', req_str_from_str))
28         self.assertEqual((False, None), no_german_from_str('Nein', req_str_from_str))
29         with self.assertRaises(ValueError):
30             no_german_from_str('', req_str_from_str)
31
32     def test_to_str(self):
33         self.assertEqual('abc', no_german_to_str((True, 'abc'), str_to_str))
34         self.assertEqual('Nein', no_german_to_str((False, None), str_to_str))
35
36
37 # "optional"/"no" converter
38 # -------------------------
39
40 class TestOptNoGerman(unittest.TestCase):
41     def test_from_str(self):
42         self.assertEqual((True, 'abc'), opt_no_german_from_str('abc', str_from_str))
43         self.assertEqual((False, None), opt_no_german_from_str('Nein', str_from_str))
44         self.assertEqual((None, None), opt_no_german_from_str('', str_from_str))
45
46     def test_to_str(self):
47         self.assertEqual('abc', opt_no_german_to_str((True, 'abc'), str_to_str))
48         self.assertEqual('Nein', opt_no_german_to_str((False, None), str_to_str))
49         self.assertEqual('', opt_no_german_to_str((None, None), str_to_str))
50
51
52 # choice converter
53 # ----------------
54
55 class TestChoice(unittest.TestCase):
56     def setUp(self):
57         self.choices = ['abc', 'def', 'ghi']
58
59     def test_from_str(self):
60         self.assertEqual('abc', choice_from_str('abc', self.choices))
61         self.assertEqual('ghi', choice_from_str('ghi', self.choices))
62         with self.assertRaises(ValueError):
63             choice_from_str('jkl', self.choices)
64
65
66 # dictkey converter
67 # -----------------
68
69 class TestDictkey(unittest.TestCase):
70     def setUp(self):
71         self.choices = {'abc': '1', 'def': '2', 'ghi': '3'}
72
73     def test_from_str(self):
74         self.assertEqual('abc', dictkey_from_str('1', self.choices))
75         self.assertEqual('ghi', dictkey_from_str('3', self.choices))
76         with self.assertRaises(ValueError):
77             dictkey_from_str('4', self.choices)
78
79     def test_to_str(self):
80         self.assertEqual('1', dictkey_to_str('abc', self.choices))
81         self.assertEqual('3', dictkey_to_str('ghi', self.choices))
82
83
84 # enum/"list" converter
85 # ---------------------
86
87 class TestEnumConverter(unittest.TestCase):
88     def test_from_str(self):
89         self.assertEqual([], enum_from_str('', str_from_str))
90         self.assertEqual(['abc'], enum_from_str('abc', str_from_str))
91         self.assertEqual(['abc', 'def'], enum_from_str('abc; def', str_from_str))
92         self.assertEqual(['abc', 'def', 'ghi'], enum_from_str('abc; def;ghi', str_from_str))
93
94     def test_to_str(self):
95         self.assertEqual('abc; def; ghi', enum_to_str(['abc', 'def', 'ghi'], str_to_str))
96         self.assertEqual('abc', enum_to_str(['abc'], str_to_str))
97         self.assertEqual('', enum_to_str([''], str_to_str))
98         self.assertEqual('', enum_to_str([], str_to_str))
99
100
101 # value/comment converter
102 # -----------------------
103
104 class TestValueCommentConverter(unittest.TestCase):
105     def test_from_str(self):
106         self.assertEqual(('abc', 'defg'), value_comment_from_str('abc (defg)', str_from_str, str_from_str))
107         self.assertEqual(('abc', ''), value_comment_from_str('abc ()', str_from_str, str_from_str))
108         self.assertEqual(('', 'def'), value_comment_from_str('(def)', str_from_str, str_from_str))
109         self.assertEqual(('ab', '(cd)'), value_comment_from_str('ab ((cd))', str_from_str, str_from_str))
110         self.assertEqual(('ab', '(c(d)[(]))'), value_comment_from_str('ab ((c(d)[(])))', str_from_str, str_from_str))
111         self.assertEqual(('ab(', 'cd'), value_comment_from_str('ab( (cd)', str_from_str, str_from_str))
112         self.assertEqual(('abcd ', 'ef'), value_comment_from_str('abcd  (ef)', str_from_str, str_from_str))
113         self.assertEqual(('abc', ''), value_comment_from_str('abc', str_from_str, str_from_str, comment_optional=True))
114         self.assertEqual(('a(bc)de', 'fg'), value_comment_from_str('a(bc)de (fg)', str_from_str, str_from_str))
115         self.assertEqual(('a(bc)de', 'fg'), value_comment_from_str('a(bc)de (fg)', str_from_str, str_from_str, comment_optional=True))
116         self.assertEqual(('a(bc)de', 'f(g)'), value_comment_from_str('a(bc)de (f(g))', str_from_str, str_from_str))
117         self.assertEqual(('a(bc)de', 'f(g)'), value_comment_from_str('a(bc)de (f(g))', str_from_str, str_from_str, comment_optional=True))
118         self.assertEqual(('a(bc)de', None), value_comment_from_str('a(bc)de', str_from_str, opt_str_from_str, comment_optional=True))
119         with self.assertRaises(ValueError):
120             value_comment_from_str('abc (', str_from_str, str_from_str)
121         with self.assertRaises(ValueError):
122             value_comment_from_str('abc )', str_from_str, str_from_str)
123         with self.assertRaises(ValueError):
124             value_comment_from_str('abc (def)g', str_from_str, str_from_str)
125         with self.assertRaises(ValueError):
126             value_comment_from_str('abc (b))', str_from_str, str_from_str)
127         with self.assertRaises(ValueError):
128             value_comment_from_str('abc', str_from_str, str_from_str)
129         with self.assertRaises(ValueError):
130             value_comment_from_str('abc(def)', str_from_str, str_from_str)
131
132     def test_to_str(self):
133         self.assertEqual('abc (defg)', value_comment_to_str(('abc', 'defg'), str_to_str, str_to_str))
134         self.assertEqual('abc ()', value_comment_to_str(('abc', ''), str_to_str, str_to_str))
135         self.assertEqual('(def)', value_comment_to_str(('', 'def'), str_to_str, str_to_str))
136         self.assertEqual('ab ((cd))', value_comment_to_str(('ab', '(cd)'), str_to_str, str_to_str))
137         self.assertEqual('ab ((c(d)[(])))', value_comment_to_str(('ab', '(c(d)[(]))'), str_to_str, str_to_str))
138         self.assertEqual('ab( (cd)', value_comment_to_str(('ab(', 'cd'), str_to_str, str_to_str))
139         self.assertEqual('abcd (ef)', value_comment_to_str(('abcd', 'ef'), str_to_str, str_to_str))
140         self.assertEqual('abc', value_comment_to_str(('abc', ''), str_to_str, str_to_str, comment_optional=True))
141         self.assertEqual('a(bc)de (fg)', value_comment_to_str(('a(bc)de', 'fg'), str_to_str, str_to_str))
142         self.assertEqual('a(bc)de (fg)', value_comment_to_str(('a(bc)de', 'fg'), str_to_str, str_to_str, comment_optional=True))
143         self.assertEqual('a(bc)de (f(g))', value_comment_to_str(('a(bc)de', 'f(g)'), str_to_str, str_to_str))
144         self.assertEqual('a(bc)de (f(g))', value_comment_to_str(('a(bc)de', 'f(g)'), str_to_str, str_to_str, comment_optional=True))
145         self.assertEqual('a(bc)de', value_comment_to_str(('a(bc)de', None), str_to_str, opt_str_to_str, comment_optional=True))
146
147
148 # string converter
149 # ----------------
150
151 class TestStr(unittest.TestCase):
152     def test_from_str(self):
153         self.assertEqual('', str_from_str(''))
154         self.assertEqual('abc', str_from_str('abc'))
155
156     def test_to_str(self):
157         self.assertEqual('', str_to_str(''))
158         self.assertEqual('abc', str_to_str('abc'))
159
160
161 class TestReqStr(unittest.TestCase):
162     def test_from_str(self):
163         self.assertEqual('abc', req_str_from_str('abc'))
164         self.assertEqual(' ', req_str_from_str(' '))
165         with self.assertRaises(ValueError):
166             req_str_from_str('')
167
168
169 class TestOptStr(unittest.TestCase):
170     def test_from_str(self):
171         self.assertEqual('abc', opt_str_from_str('abc'))
172         self.assertEqual(' ', opt_str_from_str(' '))
173         self.assertEqual(None, opt_str_from_str(''))
174
175     def test_to_str(self):
176         self.assertEqual('abc', opt_str_to_str('abc'))
177         self.assertEqual(' ', opt_str_to_str(' '))
178         self.assertEqual('', opt_str_to_str(None))
179
180
181 # optional no or string converter
182 # -------------------------------
183
184 class TestOptNoOrStr(unittest.TestCase):
185     def test_from_str(self):
186         self.assertEqual((False, None), opt_no_or_str_from_str('Nein'))
187         self.assertEqual((True, 'Nur Wochenende'), opt_no_or_str_from_str('Nur Wochenende'))
188         self.assertEqual((True, 'Ja'), opt_no_or_str_from_str('Ja'))
189         self.assertEqual((None, None), opt_no_or_str_from_str(''))
190
191     def test_to_str(self):
192         self.assertEqual('Nein', opt_no_or_str_to_str((False, None)))
193         self.assertEqual('Nur Wochenende', opt_no_or_str_to_str((True, 'Nur Wochenende')))
194         self.assertEqual('Ja', opt_no_or_str_to_str((True, 'Ja')))
195         self.assertEqual('', opt_no_or_str_to_str((None, None)))
196
197
198 # integer converter
199 # -----------------
200
201 class TestInt(unittest.TestCase):
202     def test_from_str(self):
203         self.assertEqual(42, int_from_str('42'))
204         self.assertEqual(42, int_from_str('+42'))
205         self.assertEqual(-20, int_from_str('-20'))
206         self.assertEqual(0, int_from_str('0', min=0))
207         self.assertEqual(10, int_from_str('10', max=10))
208         with self.assertRaises(ValueError):
209             int_from_str('abc')
210         with self.assertRaises(ValueError):
211             int_from_str('')
212         with self.assertRaises(ValueError):
213             int_from_str('-1', min=0)
214         with self.assertRaises(ValueError):
215             int_from_str('11', max=10)
216         with self.assertRaises(ValueError):
217             int_from_str('10.0')
218         with self.assertRaises(ValueError):
219             int_from_str('0d')
220
221     def test_to_str(self):
222         self.assertEqual('20', int_to_str(20))
223         self.assertEqual('-20', int_to_str(-20))
224         self.assertEqual('0', int_to_str(0))
225
226
227 class TestOptInt(unittest.TestCase):
228     def test_from_str(self):
229         self.assertEqual(42, opt_int_from_str('42'))
230         self.assertEqual(42, opt_int_from_str('+42'))
231         self.assertEqual(-20, opt_int_from_str('-20'))
232         self.assertEqual(None, opt_int_from_str(''))
233         with self.assertRaises(ValueError):
234             opt_int_from_str('abc')
235         with self.assertRaises(ValueError):
236             opt_int_from_str('10.0')
237         with self.assertRaises(ValueError):
238             opt_int_from_str('0d')
239
240     def test_to_str(self):
241         self.assertEqual('20', opt_int_to_str(20))
242         self.assertEqual('-20', opt_int_to_str(-20))
243         self.assertEqual('0', opt_int_to_str(0))
244         self.assertEqual('', opt_int_to_str(None))
245
246
247 class TestOptUInt(unittest.TestCase):
248     def test_from_str(self):
249         self.assertEqual(42, opt_uint_from_str('42'))
250         self.assertEqual(0, opt_uint_from_str('0'))
251         self.assertEqual(None, opt_uint_from_str(''))
252         with self.assertRaises(ValueError):
253             opt_uint_from_str('-1')
254
255     def test_to_str(self):
256         self.assertEqual('20', opt_uint_to_str(20))
257         self.assertEqual('0', opt_uint_to_str(0))
258         self.assertEqual('', opt_uint_to_str(None))
259
260
261 # bool converter
262 # --------------
263
264 class TestBoolGerman(unittest.TestCase):
265     def test_from_str(self):
266         self.assertEqual(True, bool_german_from_str('Ja'))
267         self.assertEqual(True, opt_bool_german_from_str('Ja'))
268         self.assertEqual(False, bool_german_from_str('Nein'))
269         self.assertEqual(False, opt_bool_german_from_str('Nein'))
270         self.assertEqual(None, opt_bool_german_from_str(''))
271         with self.assertRaises(ValueError):
272             bool_german_from_str('Vielleicht')
273             opt_bool_german_from_str('Vielleicht')
274             bool_german_from_str('')
275
276     def test_to_str(self):
277         self.assertEqual('Ja', bool_german_to_str(True))
278         self.assertEqual('Ja', opt_bool_german_to_str(True))
279         self.assertEqual('Nein', bool_german_to_str(False))
280         self.assertEqual('Nein', opt_bool_german_to_str(False))
281         self.assertEqual('', opt_bool_german_to_str(None))
282
283
284 # tristate converter
285 # ------------------
286
287 class TestTristateGerman(unittest.TestCase):
288     def test_from_str(self):
289         self.assertEqual(1.0, tristate_german_from_str('Ja'))
290         self.assertEqual(0.5, tristate_german_from_str('Teilweise'))
291         self.assertEqual(0, tristate_german_from_str('Nein'))
292         with self.assertRaises(ValueError):
293             tristate_german_from_str('')
294         with self.assertRaises(ValueError):
295             tristate_german_from_str('Vielleicht')
296
297     def test_to_str(self):
298         self.assertEqual('Ja', tristate_german_to_str(1.0))
299         self.assertEqual('Teilweise', tristate_german_to_str(0.5))
300         self.assertEqual('Nein', tristate_german_to_str(0.0))
301
302
303 class TestOptTristateGerman(unittest.TestCase):
304     def test_from_str(self):
305         self.assertEqual(1.0, opt_tristate_german_from_str('Ja'))
306         self.assertEqual(0.5, opt_tristate_german_from_str('Teilweise'))
307         self.assertEqual(0, opt_tristate_german_from_str('Nein'))
308         self.assertEqual(None, opt_tristate_german_from_str(''))
309         with self.assertRaises(ValueError):
310             opt_tristate_german_from_str('Vielleicht')
311
312     def test_to_str(self):
313         self.assertEqual('Ja', opt_tristate_german_to_str(1.0))
314         self.assertEqual('Teilweise', opt_tristate_german_to_str(0.5))
315         self.assertEqual('Nein', opt_tristate_german_to_str(0.0))
316         self.assertEqual('', opt_tristate_german_to_str(None))
317
318
319 # tristate with comment converter
320 # -------------------------------
321
322 class TestOptTristateGermanComment(unittest.TestCase):
323     def test_from_str(self):
324         self.assertEqual((1.0, None), opt_tristate_german_comment_from_str('Ja'))
325         self.assertEqual((0.5, None), opt_tristate_german_comment_from_str('Teilweise'))
326         self.assertEqual((0, None), opt_tristate_german_comment_from_str('Nein'))
327         self.assertEqual((0.5, 'nur ganz oben nicht'), opt_tristate_german_comment_from_str('Teilweise (nur ganz oben nicht)'))
328         self.assertEqual((None, None), opt_tristate_german_comment_from_str(''))
329         with self.assertRaises(ValueError):
330             opt_tristate_german_from_str('Vielleicht')
331         with self.assertRaises(ValueError):
332             opt_tristate_german_from_str('(Ja)')
333
334     def test_to_str(self):
335         self.assertEqual('Ja', opt_tristate_german_comment_to_str((1.0, None)))
336         self.assertEqual('Teilweise', opt_tristate_german_comment_to_str((0.5, None)))
337         self.assertEqual('Nein', opt_tristate_german_comment_to_str((0.0, None)))
338         self.assertEqual('', opt_tristate_german_comment_to_str((None, None)))
339
340
341 # url converter
342 # -------------
343
344 class TestUrl(unittest.TestCase):
345     def test_from_str(self):
346         self.assertEqual('http://www.winterrodeln.org/wiki/Arzler_Alm/', url_from_str('http://www.winterrodeln.org/wiki/Arzler_Alm/'))
347         self.assertEqual('http://www.winterrodeln.org/wiki/Nösslachhütte/', url_from_str('http://www.winterrodeln.org/wiki/Nösslachhütte/'))
348         self.assertEqual('https://www.winterrodeln.org/wiki/Nösslachhütte/', url_from_str('https://www.winterrodeln.org/wiki/Nösslachhütte/'))
349         with self.assertRaises(ValueError):
350             url_from_str('mailto:office@example.com')
351         with self.assertRaises(ValueError):
352             url_from_str('/wiki/Arzler_Alm/')
353         with self.assertRaises(ValueError):
354             url_from_str('www.winterrodeln.org/wiki/Arzler_Alm/')
355
356     def test_to_str(self):
357         self.assertEqual('http://www.winterrodeln.org/wiki/Arzler_Alm/', url_to_str('http://www.winterrodeln.org/wiki/Arzler_Alm/'))
358         self.assertEqual('http://www.winterrodeln.org/wiki/Nösslachhütte/', url_to_str('http://www.winterrodeln.org/wiki/Nösslachhütte/'))
359         self.assertEqual('https://www.winterrodeln.org/wiki/Nösslachhütte/', url_to_str('https://www.winterrodeln.org/wiki/Nösslachhütte/'))
360
361
362 # webauskunft converter
363 # ---------------------
364
365 class TestWebauskunft(unittest.TestCase):
366     def test_from_str(self):
367         self.assertEqual((True, 'http://www.example.com/current'), webauskunft_from_str('http://www.example.com/current'))
368         self.assertEqual((None, None), webauskunft_from_str(''))
369         self.assertEqual((False, None), webauskunft_from_str('Nein'))
370
371     def test_to_str(self):
372         self.assertEqual('http://www.example.com/current', webauskunft_to_str((True, 'http://www.example.com/current')))
373         self.assertEqual('', webauskunft_to_str((None, None)))
374         self.assertEqual('Nein', webauskunft_to_str((False, None)))
375
376
377 # wikipage converter
378 # ------------------
379
380 class TestWikipage(unittest.TestCase):
381     def test_from_str(self):
382         self.assertEqual('[[Birgitzer Alm]]', wikipage_from_str('[[Birgitzer Alm]]'))
383         with self.assertRaises(ValueError):
384             wikipage_from_str('[[')
385         with self.assertRaises(ValueError):
386             wikipage_from_str('')
387         with self.assertRaises(ValueError):
388             wikipage_from_str('Birgitzer Alm')
389
390     def test_to_str(self):
391         self.assertEqual('[[Birgitzer Alm]]', wikipage_to_str('[[Birgitzer Alm]]'))
392
393
394 class TestOptWikipageEnum(unittest.TestCase):
395     def test_from_str(self):
396         self.assertEqual(['[[Birgitzer Alm]]', '[[Kemater Alm]]'], opt_wikipage_enum_from_str('[[Birgitzer Alm]]; [[Kemater Alm]]'))
397         self.assertEqual(['[[Birgitzer Alm]]'], opt_wikipage_enum_from_str('[[Birgitzer Alm]]'))
398         self.assertEqual([], opt_wikipage_enum_from_str('Nein'))
399         self.assertEqual(None, opt_wikipage_enum_from_str(''))
400
401     def test_to_str(self):
402         self.assertEqual('[[Birgitzer Alm]]; [[Kemater Alm]]', opt_wikipage_enum_to_str(['[[Birgitzer Alm]]', '[[Kemater Alm]]']))
403         self.assertEqual('[[Birgitzer Alm]]', opt_wikipage_enum_to_str(['[[Birgitzer Alm]]']))
404         self.assertEqual('Nein', opt_wikipage_enum_to_str([]))
405         self.assertEqual('', opt_wikipage_enum_to_str(None))
406
407
408 # email converter
409 # ---------------
410
411 class TestEmail(unittest.TestCase):
412     def setUp(self):
413         self.good_addresses = ['office@example.com', 'winter+rodeln@localhost', 'joe.doe@exämple.com']
414         self.bad_addresses = ['öffice@example.com', 'winter rodeln@localhost', 'www.winterrodeln.org', 'mailto:info@example.com', 'info@example.com.']
415
416     def test_from_str(self):
417         for value in self.good_addresses:
418             self.assertEqual(value, email_from_str(value))
419         for value in self.bad_addresses:
420             with self.assertRaises(ValueError):
421                 email_from_str(value)
422
423     def test_to_str(self):
424         for value in self.good_addresses:
425             self.assertEqual(value, email_to_str(value))
426
427
428 class TestMaskedEmail(unittest.TestCase):
429     def test_from_str(self):
430         self.assertEqual(('office@example.com', False), masked_email_from_str('office@example.com'))
431         self.assertEqual(('office@example.com', True), masked_email_from_str('office(at)example.com'))
432         with self.assertRaises(ValueError):
433             masked_email_from_str('office@example.com', masked_only=True)
434         with self.assertRaises(ValueError):
435             masked_email_from_str('off ice@example.com')
436
437     def test_to_str(self):
438         self.assertEqual('office@example.com', masked_email_to_str(('office@example.com', False)))
439         self.assertEqual('office(at)example.com', masked_email_to_str(('office@example.com', True)))
440         self.assertEqual('office()example.com', masked_email_to_str(('office@example.com', True), '()'))
441
442
443 class TestEmails(unittest.TestCase):
444     def test_from_str(self):
445         self.assertEqual(None, emails_from_str(''))
446         self.assertEqual([], emails_from_str('Nein'))
447         self.assertEqual([(('info@example.com', False), None)], emails_from_str('info@example.com'))
448         self.assertEqual([(('info@example.com', True), None)], emails_from_str('info(at)example.com'))
449         self.assertEqual([(('info@example.com', False), 'Office')], emails_from_str('info@example.com (Office)'))
450         self.assertEqual([(('info@example.com', False), None), (('home@example.com', False), 'Privat')], emails_from_str('info@example.com; home@example.com (Privat)'))
451         with self.assertRaises(ValueError):
452             emails_from_str('nein')
453         with self.assertRaises(ValueError):
454             emails_from_str('info@example.com; ho me@example.com (Privat)')
455
456     def test_to_str(self):
457         self.assertEqual('', emails_to_str(None))
458         self.assertEqual('Nein', emails_to_str([]))
459         self.assertEqual('info@example.com', emails_to_str([(('info@example.com', False), None)]))
460         self.assertEqual('info@example.com (Office)', emails_to_str([(('info@example.com', False), 'Office')]))
461         self.assertEqual('info@example.com; home@example.com (Privat)', emails_to_str([(('info@example.com', False), None), (('home@example.com', False), 'Privat')]))
462
463
464 # phone converter
465 # ---------------
466
467 class TestPhoneNumber(unittest.TestCase):
468     def test_from_str(self):
469         self.assertEqual('+43-699-123456789', phone_number_from_str('+43-699-123456789'))
470         self.assertEqual('+43-69945', phone_number_from_str('+43-69945'))
471         self.assertEqual('+43-512-507-6418', phone_number_from_str('+43-512-507-6418'))
472         with self.assertRaises(ValueError):
473             phone_number_from_str('+43-')
474         with self.assertRaises(ValueError):
475             phone_number_from_str('0512123456789')
476
477     def test_to_str(self):
478         self.assertEqual('+43-699-123456789', phone_number_to_str('+43-699-123456789'))
479         self.assertEqual('+43-69945', phone_number_to_str('+43-69945'))
480         self.assertEqual('+43-512-507-6418', phone_number_to_str('+43-512-507-6418'))
481
482
483 class TestOptPhoneCommentEnum(unittest.TestCase):
484     def test_from_str(self):
485         self.assertEqual(opt_phone_comment_enum_from_str(''), None)
486         self.assertEqual([], opt_phone_comment_enum_from_str('Nein'))
487         self.assertEqual([('+43-512-123456', 'untertags')], opt_phone_comment_enum_from_str('+43-512-123456 (untertags)'))
488         self.assertEqual([('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')], opt_phone_comment_enum_from_str('+43-512-1234 (untertags); +43-664-123456 (Alm)'))
489         self.assertEqual([('+43-512-1234', None), ('+43-664-123456', 'Sommer')], opt_phone_comment_enum_from_str('+43-512-1234; +43-664-123456 (Sommer)', True))
490         with self.assertRaises(ValueError):
491             opt_phone_comment_enum_from_str('+43-512-123456+ (untertags)')
492         with self.assertRaises(ValueError):
493             opt_phone_comment_enum_from_str('+43-512-123456')
494
495     def test_to_str(self):
496         self.assertEqual('', opt_phone_comment_enum_to_str(None))
497         self.assertEqual('Nein', opt_phone_comment_enum_to_str([]))
498         self.assertEqual('+43-512-123456 (untertags)', opt_phone_comment_enum_to_str([('+43-512-123456', 'untertags')]))
499         self.assertEqual('+43-512-1234 (untertags); +43-664-123456 (Alm)', opt_phone_comment_enum_to_str([('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')]))
500         self.assertEqual('+43-512-1234; +43-664-123456 (Sommer)', opt_phone_comment_enum_to_str([('+43-512-1234', None), ('+43-664-123456', 'Sommer')], True))
501
502
503 # longitude/latitude converter
504 # ----------------------------
505
506 class TestLonLat(unittest.TestCase):
507     def test_from_str(self):
508         self.assertEqual(LonLat(11.453553, 47.076207), lonlat_from_str('47.076207 N 11.453553 E'))
509         with self.assertRaises(ValueError):
510             lonlat_from_str('47.076207 N 11.453553')
511
512     def test_to_str(self):
513         self.assertEqual('47.076207 N 11.453553 E', lonlat_to_str(LonLat(11.453553, 47.076207)))
514
515
516 # difficulty converter
517 # --------------------
518
519 class TestDifficultyGerman(unittest.TestCase):
520     def test_from_str(self):
521         self.assertEqual(1, difficulty_german_from_str('leicht'))
522         self.assertEqual(2, difficulty_german_from_str('mittel'))
523         with self.assertRaises(ValueError):
524             difficulty_german_from_str('dontknow')
525         with self.assertRaises(ValueError):
526             difficulty_german_from_str('')
527
528     def test_to_str(self):
529         self.assertEqual('leicht', difficulty_german_to_str(1))
530
531
532 # avalanches converter
533 # --------------------
534
535 class TestAvalanchesGermanConverter(unittest.TestCase):
536     def test_from_str(self):
537         self.assertEqual(1, avalanches_german_from_str('kaum'))
538         self.assertEqual(1, opt_avalanches_german_from_str('kaum'))
539         self.assertEqual(2, avalanches_german_from_str('selten'))
540         self.assertEqual(2, opt_avalanches_german_from_str('selten'))
541         self.assertEqual(3, avalanches_german_from_str('gelegentlich'))
542         self.assertEqual(3, opt_avalanches_german_from_str('gelegentlich'))
543         self.assertEqual(4, avalanches_german_from_str('häufig'))
544         self.assertEqual(4, opt_avalanches_german_from_str('häufig'))
545         self.assertEqual(None, opt_avalanches_german_from_str(''))
546         with self.assertRaises(ValueError):
547             avalanches_german_from_str('immer')
548         with self.assertRaises(ValueError):
549             opt_avalanches_german_from_str('immer')
550         with self.assertRaises(ValueError):
551             avalanches_german_from_str('')
552
553     def test_to_str(self):
554         self.assertEqual('kaum', avalanches_german_to_str(1))
555         self.assertEqual('kaum', opt_avalanches_german_to_str(1))
556         self.assertEqual('selten', avalanches_german_to_str(2))
557         self.assertEqual('selten', opt_avalanches_german_to_str(2))
558         self.assertEqual('gelegentlich', avalanches_german_to_str(3))
559         self.assertEqual('gelegentlich', opt_avalanches_german_to_str(3))
560         self.assertEqual('häufig', avalanches_german_to_str(4))
561         self.assertEqual('häufig', opt_avalanches_german_to_str(4))
562         self.assertEqual('', opt_avalanches_german_to_str(None))
563
564
565 # lift converter
566 # --------------
567
568 class TestLiftGermanValidator(unittest.TestCase):
569     def test_from_str(self):
570         self.assertEqual(lift_german_from_str(''), None)
571         self.assertEqual([], lift_german_from_str('Nein'))
572         self.assertEqual([('Sessellift', None)], lift_german_from_str('Sessellift'))
573         self.assertEqual([('Gondel', 'nur bis zur Hälfte')], lift_german_from_str('Gondel (nur bis zur Hälfte)'))
574         self.assertEqual([('Sessellift', None), ('Taxi', None)], lift_german_from_str('Sessellift; Taxi'))
575         self.assertEqual([('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')], lift_german_from_str('Sessellift (Wochenende); Taxi (6 Euro)'))
576
577     def test_to_str(self):
578         self.assertEqual('', lift_german_to_str(None))
579         self.assertEqual('Nein', lift_german_to_str([]))
580         self.assertEqual('Sessellift', lift_german_to_str([('Sessellift', None)]))
581         self.assertEqual('Gondel (nur bis zur Hälfte)', lift_german_to_str([('Gondel', 'nur bis zur Hälfte')]))
582         self.assertEqual('Sessellift; Taxi', lift_german_to_str([('Sessellift', None), ('Taxi', None)]))
583         self.assertEqual('Sessellift (Wochenende); Taxi (6 Euro)', lift_german_to_str([('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')]))
584
585
586 # public transport converter
587 # --------------------------
588
589 class TestPublicTransportGerman(unittest.TestCase):
590     def test_from_str(self):
591         self.assertEqual(1, public_transport_german_from_str('Sehr gut'))
592         self.assertEqual(1, opt_public_transport_german_from_str('Sehr gut'))
593         self.assertEqual(2, public_transport_german_from_str('Gut'))
594         self.assertEqual(2, opt_public_transport_german_from_str('Gut'))
595         self.assertEqual(3, public_transport_german_from_str('Mittelmäßig'))
596         self.assertEqual(3, opt_public_transport_german_from_str('Mittelmäßig'))
597         self.assertEqual(4, public_transport_german_from_str('Schlecht'))
598         self.assertEqual(4, opt_public_transport_german_from_str('Schlecht'))
599         self.assertEqual(5, public_transport_german_from_str('Nein'))
600         self.assertEqual(5, opt_public_transport_german_from_str('Nein'))
601         self.assertEqual(6, public_transport_german_from_str('Ja'))
602         self.assertEqual(6, opt_public_transport_german_from_str('Ja'))
603         self.assertEqual(None, opt_public_transport_german_from_str(''))
604         with self.assertRaises(ValueError):
605             public_transport_german_from_str('')
606         with self.assertRaises(ValueError):
607             public_transport_german_from_str('Naja')
608         with self.assertRaises(ValueError):
609             opt_public_transport_german_from_str('Naja')
610
611     def test_to_str(self):
612         self.assertEqual('Sehr gut', public_transport_german_to_str(1))
613         self.assertEqual('Sehr gut', opt_public_transport_german_to_str(1))
614         self.assertEqual('Gut', public_transport_german_to_str(2))
615         self.assertEqual('Gut', opt_public_transport_german_to_str(2))
616         self.assertEqual('Mittelmäßig', public_transport_german_to_str(3))
617         self.assertEqual('Mittelmäßig', opt_public_transport_german_to_str(3))
618         self.assertEqual('Schlecht', public_transport_german_to_str(4))
619         self.assertEqual('Schlecht', opt_public_transport_german_to_str(4))
620         self.assertEqual('Nein', public_transport_german_to_str(5))
621         self.assertEqual('Nein', opt_public_transport_german_to_str(5))
622         self.assertEqual('Ja', public_transport_german_to_str(6))
623         self.assertEqual('Ja', opt_public_transport_german_to_str(6))
624         self.assertEqual('', opt_public_transport_german_to_str(None))
625
626
627 # cachet converter
628 # ----------------
629
630 class TestSingleCachet(unittest.TestCase):
631     def test_from_str(self):
632         self.assertEqual(('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel'), single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'))
633         self.assertEqual(('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer'))
634         with self.assertRaises(ValueError):
635             single_cachet_german_from_str('')
636         with self.assertRaises(ValueError):
637             single_cachet_german_from_str('Salzburger Naturrodelbahn-Gütesiegel 2013 schwer')
638         with self.assertRaises(ValueError):
639             single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 4013 schwer')
640         with self.assertRaises(ValueError):
641             single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 13 schwer')
642         with self.assertRaises(ValueError):
643             single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwerer')
644         with self.assertRaises(ValueError):
645             single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel schwer')
646         with self.assertRaises(ValueError):
647             single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013')
648
649     def test_to_str(self):
650         self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel', single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')))
651         self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer', single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer')))
652
653
654 class TestCachetGerman(unittest.TestCase):
655     def test_from_str(self):
656         self.assertEqual(cachet_german_from_str(''), None)
657         self.assertEqual([], cachet_german_from_str('Nein'))
658         self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')], cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'))
659         self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')], 
660                          cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer; Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'))
661         with self.assertRaises(ValueError):
662             cachet_german_from_str('Ja')
663         with self.assertRaises(ValueError):
664             cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer Tiroler Naturrodelbahn-Gütesiegel 2009 mittel')
665
666     def test_to_str(self):
667         self.assertEqual('', cachet_german_to_str(None))
668         self.assertEqual('Nein', cachet_german_to_str([]))
669         self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel', cachet_german_to_str([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]))
670         self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer; Tiroler Naturrodelbahn-Gütesiegel 2009 mittel', cachet_german_to_str([('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]))
671
672
673 # night light days converter
674 # --------------------------
675
676 class TestNightLightDays(unittest.TestCase):
677     def test_from_str(self):
678         self.assertEqual((None, None), nightlightdays_from_str(''))
679         self.assertEqual((2, 'Mo, Di'), nightlightdays_from_str('2 (Mo, Di)'))
680         self.assertEqual((7, None), nightlightdays_from_str('7'))
681         self.assertEqual((0, None), nightlightdays_from_str('0'))
682         self.assertEqual((None, 'keine Ahnung'), nightlightdays_from_str('(keine Ahnung)'))
683         with self.assertRaises(ValueError):
684             nightlightdays_from_str('8')
685         with self.assertRaises(ValueError):
686             nightlightdays_from_str('5 (Montag')
687         with self.assertRaises(ValueError):
688             nightlightdays_from_str('5.2')
689
690     def test_to_str(self):
691         self.assertEqual('', nightlightdays_to_str((None, None)))
692         self.assertEqual('2 (Mo, Di)', nightlightdays_to_str((2, 'Mo, Di')))
693         self.assertEqual('7', nightlightdays_to_str((7, None)))
694         self.assertEqual('0', nightlightdays_to_str((0, None)))
695
696
697 # string with optional comment enum/list converter
698 # ------------------------------------------------
699
700 class TestOptStrOptCommentEnum(unittest.TestCase):
701     def test_from_str(self):
702         self.assertEqual(None, opt_str_opt_comment_enum_from_str(''))
703         self.assertEqual([], opt_str_opt_comment_enum_from_str('Nein'))
704         self.assertEqual([('Talstation', None)], opt_str_opt_comment_enum_from_str('Talstation'))
705         self.assertEqual([('Talstation', 'unten')], opt_str_opt_comment_enum_from_str('Talstation (unten)'))
706         self.assertEqual([('Talstation', 'unten'), ('Mittelstation', None)], opt_str_opt_comment_enum_from_str('Talstation (unten); Mittelstation'))
707         with self.assertRaises(ValueError):
708             opt_str_opt_comment_enum_from_str('(unten)')
709         with self.assertRaises(ValueError):
710             opt_str_opt_comment_enum_from_str('Talstation (unten); ; Mittelstation')
711
712     def test_to_str(self):
713         self.assertEqual('', opt_str_opt_comment_enum_to_str(None))
714         self.assertEqual('Nein', opt_str_opt_comment_enum_to_str([]))
715         self.assertEqual('Talstation', opt_str_opt_comment_enum_to_str([('Talstation', None)]))
716         self.assertEqual('Talstation (unten)', opt_str_opt_comment_enum_to_str([('Talstation', 'unten')]))
717         self.assertEqual('Talstation (unten); Mittelstation', opt_str_opt_comment_enum_to_str([('Talstation', 'unten'), ('Mittelstation', None)]))
718
719
720 # wikibox converter
721 # -----------------
722
723 class TestWikibox(unittest.TestCase):
724     def test_from_str(self):
725         value = '{{MyTemplate|apple=2|banana=5}}'
726         converter_dict = OrderedDict([('apple', opt_uint_converter), ('banana', opt_uint_converter)])
727         result = wikibox_from_str(value, 'MyTemplate', converter_dict)
728         self.assertEqual(2, result['apple'])
729         self.assertEqual(5, result['banana'])
730
731         value = '{{MyTemplate\n | apple = 2 \n| banana = 5 }}'
732         result = wikibox_from_str(value, 'MyTemplate', converter_dict)
733         self.assertEqual(2, result['apple'])
734         self.assertEqual(5, result['banana'])
735
736         with self.assertRaises(ValueError):
737             wikibox_from_str(value, 'myTemplate', converter_dict)
738         with self.assertRaises(ValueError):
739             value = '{{MyTemplate|apple=2|banana=five}}'
740             wikibox_from_str(value, 'MyTemplate', converter_dict)
741         with self.assertRaises(ValueError):
742             value = '{{MyTemplate|apple=2}}'
743             wikibox_from_str(value, 'MyTemplate', converter_dict)
744         with self.assertRaises(ValueError):
745             value = '{{MyTemplate|apple=2|banana=5|cherry=6}}'
746             wikibox_from_str(value, 'MyTemplate', converter_dict)
747
748     def test_to_str(self):
749         value = OrderedDict([('apple', 2), ('banana', 5)])
750         converter_dict = OrderedDict([('apple', opt_uint_converter), ('banana', opt_uint_converter)])
751         result = wikibox_to_str(value, 'MyTemplate', converter_dict)
752         self.assertEqual('{{MyTemplate|apple=2|banana=5}}', result)
753
754
755 # Rodelbahnbox converter
756 # ----------------------
757
758 class TestRodelbahnbox(unittest.TestCase):
759     def setUp(self):
760         self.maxDiff = None
761         self.value = \
762 '''{{Rodelbahnbox
763 | Position             = 46.807218 N 12.806522 E
764 | Position oben        = 46.799014 N 12.818658 E
765 | Höhe oben            = 1046
766 | Position unten       =
767 | Höhe unten           =
768 | Länge                = 3500
769 | Schwierigkeit        = mittel
770 | Lawinen              = kaum
771 | Betreiber            = Bringungsgemeinschaft Kreithof-Dolomitenhütte
772 | Öffentliche Anreise  = Schlecht
773 | Aufstieg möglich     = Ja
774 | Aufstieg getrennt    = Teilweise
775 | Gehzeit              = 75
776 | Aufstiegshilfe       = Taxi; Sonstige (PKW bis Kreithof)
777 | Beleuchtungsanlage   = Ja
778 | Beleuchtungstage     = 7
779 | Rodelverleih         = Nein
780 | Gütesiegel           = Tiroler Naturrodelbahn-Gütesiegel 2009 mittel
781 | Webauskunft          = http://www.lienzerdolomiten.info/at/tobogorpt.html
782 | Telefonauskunft      = +43-664-2253782 (Dolomitenhütte)
783 | Bild                 = Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg
784 | In Übersichtskarte   = Ja
785 | Forumid              = 139
786 }}'''
787
788     def test_from_str(self):
789         value = rodelbahnbox_from_str(self.value)
790         self.assertEqual(LonLat(12.806522, 46.807218), value['Position'])
791         self.assertEqual(LonLat(12.818658, 46.799014), value['Position oben'])
792         self.assertEqual(1046, value['Höhe oben'])
793         self.assertEqual(LonLat(None, None), value['Position unten'])
794         self.assertEqual(None, value['Höhe unten'])
795         self.assertEqual(3500, value['Länge'])
796         self.assertEqual(2, value['Schwierigkeit'])
797         self.assertEqual(1, value['Lawinen'])
798         self.assertEqual('Bringungsgemeinschaft Kreithof-Dolomitenhütte', value['Betreiber'])
799         self.assertEqual(4, value['Öffentliche Anreise'])
800         self.assertEqual(True, value['Aufstieg möglich'])
801         self.assertEqual((0.5, None), value['Aufstieg getrennt'])
802         self.assertEqual(75, value['Gehzeit'])
803         self.assertEqual([('Taxi', None), ('Sonstige', 'PKW bis Kreithof')], value['Aufstiegshilfe'])
804         self.assertEqual((1.0, None), value['Beleuchtungsanlage'])
805         self.assertEqual((7, None), value['Beleuchtungstage'])
806         self.assertEqual([], value['Rodelverleih'])
807         self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')], value['Gütesiegel'])
808         self.assertEqual((True, 'http://www.lienzerdolomiten.info/at/tobogorpt.html'), value['Webauskunft'])
809         self.assertEqual([('+43-664-2253782', 'Dolomitenhütte')], value['Telefonauskunft'])
810         self.assertEqual('Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg', value['Bild'])
811         self.assertEqual(True, value['In Übersichtskarte'])
812         self.assertEqual(139, value['Forumid'])
813
814     def test_to_str(self):
815         value = OrderedDict([
816             ('Position', LonLat(12.806522, 46.807218)),
817             ('Position oben', LonLat(12.818658, 46.799014)),
818             ('Höhe oben', 1046),
819             ('Position unten', LonLat(None, None)),
820             ('Höhe unten', None),
821             ('Länge', 3500),
822             ('Schwierigkeit', 2),
823             ('Lawinen', 1),
824             ('Betreiber', 'Bringungsgemeinschaft Kreithof-Dolomitenhütte'),
825             ('Öffentliche Anreise', 4),
826             ('Aufstieg möglich', True),
827             ('Aufstieg getrennt', (0.5, None)),
828             ('Gehzeit', 75),
829             ('Aufstiegshilfe', [('Taxi', None), ('Sonstige', 'PKW bis Kreithof')]),
830             ('Beleuchtungsanlage', (1.0, None)),
831             ('Beleuchtungstage', (7, None)),
832             ('Rodelverleih', []),
833             ('Gütesiegel', [('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]),
834             ('Webauskunft', (True, 'http://www.lienzerdolomiten.info/at/tobogorpt.html')),
835             ('Telefonauskunft', [('+43-664-2253782', 'Dolomitenhütte')]),
836             ('Bild', 'Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg'),
837             ('In Übersichtskarte', True),
838             ('Forumid', 139)])
839         self.assertEqual(self.value, rodelbahnbox_to_str(value))
840
841
842 # Gasthausbox converter
843 # ---------------------
844
845 class TestGasthausbox(unittest.TestCase):
846     def setUp(self):
847         self.maxDiff = None
848         self.value = \
849 """{{Gasthausbox
850 | Position          = 47.123456 N 11.123456 E
851 | Höhe              = 1808
852 | Betreiber         = Max Mustermann
853 | Sitzplätze        = 50
854 | Übernachtung      = 20 Matrazenlager, 3 Doppelzimmer
855 | Rauchfrei         = Ja
856 | Rodelverleih      = 2 Euro (Ausweis erforderlich)
857 | Handyempfang      = A1; T-Mobile A
858 | Homepage          = http://www.birgitzeralm.at/
859 | E-Mail            = Nein
860 | Telefon           = +43-664-5487520; +43-512-123456 (wenn geschlossen)
861 | Bild              = Gasthaus_Birgitzer_Alm_03.jpg
862 | Rodelbahnen       = [[Birgitzer Alm (vom Adelshof)]]; [[Birgitzer Alm (von Birgitz)]]
863 }}"""
864
865     def test_from_str(self):
866         value = gasthausbox_from_str(self.value)
867         self.assertEqual(LonLat(11.123456, 47.123456), value['Position'])
868         self.assertEqual(1808, value['Höhe'])
869         self.assertEqual('Max Mustermann', value['Betreiber'])
870         self.assertEqual(50, value['Sitzplätze'])
871         self.assertEqual((True, '20 Matrazenlager, 3 Doppelzimmer'), value['Übernachtung'])
872         self.assertEqual((True, '2 Euro (Ausweis erforderlich)'), value['Rodelverleih'])
873         self.assertEqual(1.0, value['Rauchfrei'])
874         self.assertEqual([('A1', None), ('T-Mobile A', None)], value['Handyempfang'])
875         self.assertEqual((True, 'http://www.birgitzeralm.at/'), value['Homepage'])
876         self.assertEqual([], value['E-Mail'])
877         self.assertEqual([('+43-664-5487520', None), ('+43-512-123456', 'wenn geschlossen')], value['Telefon'])
878         self.assertEqual('Gasthaus_Birgitzer_Alm_03.jpg', value['Bild'])
879         self.assertEqual(['[[Birgitzer Alm (vom Adelshof)]]', '[[Birgitzer Alm (von Birgitz)]]'], value['Rodelbahnen'])
880
881     def test_to_str(self):
882         value = OrderedDict([
883             ('Position', LonLat(11.123456, 47.123456)),
884             ('Höhe', 1808),
885             ('Betreiber', 'Max Mustermann'),
886             ('Sitzplätze', 50),
887             ('Übernachtung', (True, '20 Matrazenlager, 3 Doppelzimmer')),
888             ('Rodelverleih', (True, '2 Euro (Ausweis erforderlich)')),
889             ('Rauchfrei', 1.0),
890             ('Handyempfang', [('A1', None), ('T-Mobile A', None)]),
891             ('Homepage', (True, 'http://www.birgitzeralm.at/')),
892             ('E-Mail', []),
893             ('Telefon', [('+43-664-5487520', None), ('+43-512-123456', 'wenn geschlossen')]),
894             ('Bild', 'Gasthaus_Birgitzer_Alm_03.jpg'),
895             ('Rodelbahnen', ['[[Birgitzer Alm (vom Adelshof)]]', '[[Birgitzer Alm (von Birgitz)]]'])])
896         self.assertEqual(self.value, gasthausbox_to_str(value))