Converted encoding to UTF-8.

[philipp/winterrodeln/wrpylib.git] / tests / test_wrvalidators.py

diff --git a/tests/test_wrvalidators.py b/tests/test_wrvalidators.py
index 8cc33e636f46d92fd2c352cd460fbb5da34b1721..8b2fd82bf1980dc3891443e19fd6bdc42b0f9b8f 100644 (file)
--- a/tests/test_wrvalidators.py
+++ b/tests/test_wrvalidators.py
@@ -1,30 +1,210 @@
 #!/usr/bin/python3.4
 #!/usr/bin/python3.4

-# -*- coding: iso-8859-15 -*-
-import collections
-import wrpylib.wrvalidators
-import formencode

 import unittest
 from wrpylib.wrvalidators import *
 
 import unittest
 from wrpylib.wrvalidators import *
 

+# optional converter
+# ------------------

 
 

-class TestConverter(unittest.TestCase):
+class TestOpt(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(Converter.from_str('abc'), 'abc')
-        self.assertEqual(Converter.from_str(''), '')
+        self.assertEqual(None, opt_from_str('', str_from_str))
+        self.assertEqual('abc', opt_from_str('abc', str_from_str))
+        self.assertEqual(None, opt_from_str('', int_from_str))
+        self.assertEqual(4, opt_from_str('4', int_from_str))

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(Converter.to_str('abc'), 'abc')
-        self.assertEqual(Converter.to_str(''), '')
-        self.assertEqual(Converter.to_str(42), '42')
+        self.assertEqual('', opt_to_str(None, str_to_str))
+        self.assertEqual('abc', opt_to_str('abc', str_to_str))
+        self.assertEqual('', opt_to_str(None, int_to_str))
+        self.assertEqual('4', opt_to_str(4, int_to_str))

 
 
 
 

+# "no" converter
+# --------------
+
+class TestNoGermanConverter(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual((True, 'abc'), no_german_from_str('abc', req_str_from_str))
+        self.assertEqual((False, None), no_german_from_str('Nein', req_str_from_str))
+        with self.assertRaises(ValueError):
+            no_german_from_str('', req_str_from_str)
+
+    def test_to_str(self):
+        self.assertEqual('abc', no_german_to_str((True, 'abc'), str_to_str))
+        self.assertEqual('Nein', no_german_to_str((False, None), str_to_str))
+
+
+# "optional"/"no" converter
+# -------------------------
+
+class TestOptNoGerman(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual((True, 'abc'), opt_no_german_from_str('abc', str_from_str))
+        self.assertEqual((False, None), opt_no_german_from_str('Nein', str_from_str))
+        self.assertEqual((None, None), opt_no_german_from_str('', str_from_str))
+
+    def test_to_str(self):
+        self.assertEqual('abc', opt_no_german_to_str((True, 'abc'), str_to_str))
+        self.assertEqual('Nein', opt_no_german_to_str((False, None), str_to_str))
+        self.assertEqual('', opt_no_german_to_str((None, None), str_to_str))
+
+
+# choice converter
+# ----------------
+
+class TestCoice(unittest.TestCase):
+    def setUp(self):
+        self.choices = ['abc', 'def', 'ghi']
+
+    def test_from_str(self):
+        self.assertEqual('abc', choice_from_str('abc', self.choices))
+        self.assertEqual('ghi', choice_from_str('ghi', self.choices))
+        with self.assertRaises(ValueError):
+            choice_from_str('jkl', self.choices)
+
+
+# dictkey converter
+# -----------------
+
+class TestDictkey(unittest.TestCase):
+    def setUp(self):
+        self.choices = {'abc': '1', 'def': '2', 'ghi': '3'}
+
+    def test_from_str(self):
+        self.assertEqual('abc', dictkey_from_str('1', self.choices))
+        self.assertEqual('ghi', dictkey_from_str('3', self.choices))
+        with self.assertRaises(ValueError):
+            dictkey_from_str('4', self.choices)
+
+    def test_to_str(self):
+        self.assertEqual('1', dictkey_to_str('abc', self.choices))
+        self.assertEqual('3', dictkey_to_str('ghi', self.choices))
+
+
+# enum/"list" converter
+# ---------------------
+
+class TestEnumConverter(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual([], enum_from_str('', str_from_str))
+        self.assertEqual(['abc'], enum_from_str('abc', str_from_str))
+        self.assertEqual(['abc', 'def'], enum_from_str('abc; def', str_from_str))
+        self.assertEqual(['abc', 'def', 'ghi'], enum_from_str('abc; def;ghi', str_from_str))
+
+    def test_to_str(self):
+        self.assertEqual('abc; def; ghi', enum_to_str(['abc', 'def', 'ghi'], str_to_str))
+        self.assertEqual('abc', enum_to_str(['abc'], str_to_str))
+        self.assertEqual('', enum_to_str([''], str_to_str))
+        self.assertEqual('', enum_to_str([], str_to_str))
+
+
+# value/comment converter
+# -----------------------
+
+class TestValueCommentConverter(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual(('abc', 'defg'), value_comment_from_str('abc (defg)', str_from_str, str_from_str))
+        self.assertEqual(('abc', ''), value_comment_from_str('abc ()', str_from_str, str_from_str))
+        self.assertEqual(('', 'def'), value_comment_from_str('(def)', str_from_str, str_from_str))
+        self.assertEqual(('ab', '(cd)'), value_comment_from_str('ab ((cd))', str_from_str, str_from_str))
+        self.assertEqual(('ab', '(c(d)[(]))'), value_comment_from_str('ab ((c(d)[(])))', str_from_str, str_from_str))
+        self.assertEqual(('ab(', 'cd'), value_comment_from_str('ab( (cd)', str_from_str, str_from_str))
+        self.assertEqual(('abcd ', 'ef'), value_comment_from_str('abcd  (ef)', str_from_str, str_from_str))
+        self.assertEqual(('abc', ''), value_comment_from_str('abc', str_from_str, str_from_str, comment_optional=True))
+        self.assertEqual(('a(bc)de', 'fg'), value_comment_from_str('a(bc)de (fg)', str_from_str, str_from_str))
+        self.assertEqual(('a(bc)de', 'fg'), value_comment_from_str('a(bc)de (fg)', str_from_str, str_from_str, comment_optional=True))
+        self.assertEqual(('a(bc)de', 'f(g)'), value_comment_from_str('a(bc)de (f(g))', str_from_str, str_from_str))
+        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))
+        self.assertEqual(('a(bc)de', None), value_comment_from_str('a(bc)de', str_from_str, opt_str_from_str, comment_optional=True))
+        with self.assertRaises(ValueError):
+            value_comment_from_str('abc (', str_from_str, str_from_str)
+        with self.assertRaises(ValueError):
+            value_comment_from_str('abc )', str_from_str, str_from_str)
+        with self.assertRaises(ValueError):
+            value_comment_from_str('abc (def)g', str_from_str, str_from_str)
+        with self.assertRaises(ValueError):
+            value_comment_from_str('abc (b))', str_from_str, str_from_str)
+        with self.assertRaises(ValueError):
+            value_comment_from_str('abc', str_from_str, str_from_str)
+        with self.assertRaises(ValueError):
+            value_comment_from_str('abc(def)', str_from_str, str_from_str)
+
+    def test_to_str(self):
+        self.assertEqual('abc (defg)', value_comment_to_str(('abc', 'defg'), str_to_str, str_to_str))
+        self.assertEqual('abc ()', value_comment_to_str(('abc', ''), str_to_str, str_to_str))
+        self.assertEqual('(def)', value_comment_to_str(('', 'def'), str_to_str, str_to_str))
+        self.assertEqual('ab ((cd))', value_comment_to_str(('ab', '(cd)'), str_to_str, str_to_str))
+        self.assertEqual('ab ((c(d)[(])))', value_comment_to_str(('ab', '(c(d)[(]))'), str_to_str, str_to_str))
+        self.assertEqual('ab( (cd)', value_comment_to_str(('ab(', 'cd'), str_to_str, str_to_str))
+        self.assertEqual('abcd (ef)', value_comment_to_str(('abcd', 'ef'), str_to_str, str_to_str))
+        self.assertEqual('abc', value_comment_to_str(('abc', ''), str_to_str, str_to_str, comment_optional=True))
+        self.assertEqual('a(bc)de (fg)', value_comment_to_str(('a(bc)de', 'fg'), str_to_str, str_to_str))
+        self.assertEqual('a(bc)de (fg)', value_comment_to_str(('a(bc)de', 'fg'), str_to_str, str_to_str, comment_optional=True))
+        self.assertEqual('a(bc)de (f(g))', value_comment_to_str(('a(bc)de', 'f(g)'), str_to_str, str_to_str))
+        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))
+        self.assertEqual('a(bc)de', value_comment_to_str(('a(bc)de', None), str_to_str, opt_str_to_str, comment_optional=True))
+
+
+# string converter
+# ----------------
+
+class TestStr(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual('', str_from_str(''))
+        self.assertEqual('abc', str_from_str('abc'))
+
+    def test_to_str(self):
+        self.assertEqual('', str_to_str(''))
+        self.assertEqual('abc', str_to_str('abc'))
+
+
+class TestReqStr(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual('abc', req_str_from_str('abc'))
+        self.assertEqual(' ', req_str_from_str(' '))
+        with self.assertRaises(ValueError):
+            req_str_from_str('')
+
+
+class TestOptStr(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual('abc', opt_str_from_str('abc'))
+        self.assertEqual(' ', opt_str_from_str(' '))
+        self.assertEqual(None, opt_str_from_str(''))
+
+    def test_to_str(self):
+        self.assertEqual('abc', opt_str_to_str('abc'))
+        self.assertEqual(' ', opt_str_to_str(' '))
+        self.assertEqual('', opt_str_to_str(None))
+
+
+# optional no or string converter
+# -------------------------------
+
+class TestOptNoOrStr(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual((False, None), opt_no_or_str_from_str('Nein'))
+        self.assertEqual((True, 'Nur Wochenende'), opt_no_or_str_from_str('Nur Wochenende'))
+        self.assertEqual((True, 'Ja'), opt_no_or_str_from_str('Ja'))
+        self.assertEqual((None, None), opt_no_or_str_from_str(''))
+
+    def test_to_str(self):
+        self.assertEqual('Nein', opt_no_or_str_to_str((False, None)))
+        self.assertEqual('Nur Wochenende', opt_no_or_str_to_str((True, 'Nur Wochenende')))
+        self.assertEqual('Ja', opt_no_or_str_to_str((True, 'Ja')))
+        self.assertEqual('', opt_no_or_str_to_str((None, None)))
+
+
+# integer converter
+# -----------------
+

 class TestInt(unittest.TestCase):
     def test_from_str(self):
 class TestInt(unittest.TestCase):
     def test_from_str(self):

-        self.assertEqual(int_from_str('42'), 42)
-        self.assertEqual(int_from_str('+42'), 42)
-        self.assertEqual(int_from_str('-20'), -20)
-        self.assertEqual(int_from_str('0', min=0), 0)
-        self.assertEqual(int_from_str('10', max=10), 10)
+        self.assertEqual(42, int_from_str('42'))
+        self.assertEqual(42, int_from_str('+42'))
+        self.assertEqual(-20, int_from_str('-20'))
+        self.assertEqual(0, int_from_str('0', min=0))
+        self.assertEqual(10, int_from_str('10', max=10))

         with self.assertRaises(ValueError):
             int_from_str('abc')
         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):
             int_from_str('abc')
         with self.assertRaises(ValueError):


@@ -39,17 +219,17 @@ class TestInt(unittest.TestCase):
             int_from_str('0d')
 
     def test_to_str(self):
             int_from_str('0d')
 
     def test_to_str(self):

-        self.assertEqual(int_to_str(20), '20')
-        self.assertEqual(int_to_str(-20), '-20')
-        self.assertEqual(int_to_str(0), '0')
+        self.assertEqual('20', int_to_str(20))
+        self.assertEqual('-20', int_to_str(-20))
+        self.assertEqual('0', int_to_str(0))

 
 
 class TestOptInt(unittest.TestCase):
     def test_from_str(self):
 
 
 class TestOptInt(unittest.TestCase):
     def test_from_str(self):

-        self.assertEqual(opt_int_from_str('42'), 42)
-        self.assertEqual(opt_int_from_str('+42'), 42)
-        self.assertEqual(opt_int_from_str('-20'), -20)
-        self.assertEqual(opt_int_from_str(''), None)
+        self.assertEqual(42, opt_int_from_str('42'))
+        self.assertEqual(42, opt_int_from_str('+42'))
+        self.assertEqual(-20, opt_int_from_str('-20'))
+        self.assertEqual(None, opt_int_from_str(''))

         with self.assertRaises(ValueError):
             opt_int_from_str('abc')
         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):
             opt_int_from_str('abc')
         with self.assertRaises(ValueError):


@@ -58,357 +238,521 @@ class TestOptInt(unittest.TestCase):
             opt_int_from_str('0d')
 
     def test_to_str(self):
             opt_int_from_str('0d')
 
     def test_to_str(self):

-        self.assertEqual(opt_int_to_str(20), '20')
-        self.assertEqual(opt_int_to_str(-20), '-20')
-        self.assertEqual(opt_int_to_str(0), '0')
-        self.assertEqual(opt_int_to_str(None), '')
+        self.assertEqual('20', opt_int_to_str(20))
+        self.assertEqual('-20', opt_int_to_str(-20))
+        self.assertEqual('0', opt_int_to_str(0))
+        self.assertEqual('', opt_int_to_str(None))

 
 
 
 

-class TestEnumConverter(unittest.TestCase):
+class TestOptUInt(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(enum_from_str(''), [])
-        self.assertEqual(enum_from_str('abc'), ['abc'])
-        self.assertEqual(enum_from_str('abc; def'), ['abc', 'def'])
-        self.assertEqual(enum_from_str('abc; def;ghi'), ['abc', 'def', 'ghi'])
+        self.assertEqual(42, opt_uint_from_str('42'))
+        self.assertEqual(0, opt_uint_from_str('0'))
+        self.assertEqual(None, opt_uint_from_str(''))
+        with self.assertRaises(ValueError):
+            opt_uint_from_str('-1')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(enum_to_str(['abc', 'def', 'ghi']), 'abc; def; ghi')
-        self.assertEqual(enum_to_str(['abc']), 'abc')
-        self.assertEqual(enum_to_str(['']), '')
-        self.assertEqual(enum_to_str([]), '')
+        self.assertEqual('20', opt_uint_to_str(20))
+        self.assertEqual('0', opt_uint_to_str(0))
+        self.assertEqual('', opt_uint_to_str(None))

 
 
 
 

-class TestDateTime(unittest.TestCase):
-    def test_from_str(self):
-        self.assertEqual(DateTime.from_str('2015-12-31 23:07:42'), datetime.datetime(2015, 12, 31, 23, 7, 42))
+# bool converter
+# --------------

 
 

-    def test_to_str(self):
-        self.assertEqual(DateTime.to_str(datetime.datetime(2015, 12, 31, 23, 7, 42)), '2015-12-31 23:07:42')
-
-
-class TestDifficultyGerman(unittest.TestCase):
+class TestBoolGerman(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(difficulty_german_from_str('leicht'), 1)
-        self.assertEqual(difficulty_german_from_str('mittel'), 2)
+        self.assertEqual(True, bool_german_from_str('Ja'))
+        self.assertEqual(True, opt_bool_german_from_str('Ja'))
+        self.assertEqual(False, bool_german_from_str('Nein'))
+        self.assertEqual(False, opt_bool_german_from_str('Nein'))
+        self.assertEqual(None, opt_bool_german_from_str(''))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            difficulty_german_from_str('dontknow')
-        with self.assertRaises(ValueError):
-            difficulty_german_from_str('')
+            bool_german_from_str('Vielleicht')
+            opt_bool_german_from_str('Vielleicht')
+            bool_german_from_str('')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(difficulty_german_to_str(1), 'leicht')
+        self.assertEqual('Ja', bool_german_to_str(True))
+        self.assertEqual('Ja', opt_bool_german_to_str(True))
+        self.assertEqual('Nein', bool_german_to_str(False))
+        self.assertEqual('Nein', opt_bool_german_to_str(False))
+        self.assertEqual('', opt_bool_german_to_str(None))

 
 
 
 

+# tristate converter
+# ------------------
+

 class TestTristateGerman(unittest.TestCase):
     def test_from_str(self):
 class TestTristateGerman(unittest.TestCase):
     def test_from_str(self):

-        self.assertEqual(tristate_german_from_str('Ja'), 1.0)
-        self.assertEqual(tristate_german_from_str('Teilweise'), 0.5)
-        self.assertEqual(tristate_german_from_str('Nein'), 0)
+        self.assertEqual(1.0, tristate_german_from_str('Ja'))
+        self.assertEqual(0.5, tristate_german_from_str('Teilweise'))
+        self.assertEqual(0, tristate_german_from_str('Nein'))

         with self.assertRaises(ValueError):
             tristate_german_from_str('')
         with self.assertRaises(ValueError):
             tristate_german_from_str('Vielleicht')
 
     def test_to_str(self):
         with self.assertRaises(ValueError):
             tristate_german_from_str('')
         with self.assertRaises(ValueError):
             tristate_german_from_str('Vielleicht')
 
     def test_to_str(self):

-        self.assertEqual(tristate_german_to_str(1.0), 'Ja')
-        self.assertEqual(tristate_german_to_str(0.5), 'Teilweise')
-        self.assertEqual(tristate_german_to_str(0.0), 'Nein')
+        self.assertEqual('Ja', tristate_german_to_str(1.0))
+        self.assertEqual('Teilweise', tristate_german_to_str(0.5))
+        self.assertEqual('Nein', tristate_german_to_str(0.0))

 
 
 class TestOptTristateGerman(unittest.TestCase):
     def test_from_str(self):
 
 
 class TestOptTristateGerman(unittest.TestCase):
     def test_from_str(self):

-        self.assertEqual(opt_tristate_german_from_str('Ja'), 1.0)
-        self.assertEqual(opt_tristate_german_from_str('Teilweise'), 0.5)
-        self.assertEqual(opt_tristate_german_from_str('Nein'), 0)
-        self.assertEqual(opt_tristate_german_from_str(''), None)
+        self.assertEqual(1.0, opt_tristate_german_from_str('Ja'))
+        self.assertEqual(0.5, opt_tristate_german_from_str('Teilweise'))
+        self.assertEqual(0, opt_tristate_german_from_str('Nein'))
+        self.assertEqual(None, opt_tristate_german_from_str(''))

         with self.assertRaises(ValueError):
             opt_tristate_german_from_str('Vielleicht')
 
     def test_to_str(self):
         with self.assertRaises(ValueError):
             opt_tristate_german_from_str('Vielleicht')
 
     def test_to_str(self):

-        self.assertEqual(opt_tristate_german_to_str(1.0), 'Ja')
-        self.assertEqual(opt_tristate_german_to_str(0.5), 'Teilweise')
-        self.assertEqual(opt_tristate_german_to_str(0.0), 'Nein')
-        self.assertEqual(opt_tristate_german_to_str(None), '')
+        self.assertEqual('Ja', opt_tristate_german_to_str(1.0))
+        self.assertEqual('Teilweise', opt_tristate_german_to_str(0.5))
+        self.assertEqual('Nein', opt_tristate_german_to_str(0.0))
+        self.assertEqual('', opt_tristate_german_to_str(None))
+

 
 

+# tristate with comment converter
+# -------------------------------

 
 class TestOptTristateGermanComment(unittest.TestCase):
     def test_from_str(self):
 
 class TestOptTristateGermanComment(unittest.TestCase):
     def test_from_str(self):

-        self.assertEqual(opt_tristate_german_comment_from_str('Ja'), (1.0, None))
-        self.assertEqual(opt_tristate_german_comment_from_str('Teilweise'), (0.5, None))
-        self.assertEqual(opt_tristate_german_comment_from_str('Nein'), (0, None))
-        self.assertEqual(opt_tristate_german_comment_from_str('Teilweise (nur ganz oben nicht)'), (0.5, 'nur ganz oben nicht'))
-        self.assertEqual(opt_tristate_german_comment_from_str(''), (None, None))
+        self.assertEqual((1.0, None), opt_tristate_german_comment_from_str('Ja'))
+        self.assertEqual((0.5, None), opt_tristate_german_comment_from_str('Teilweise'))
+        self.assertEqual((0, None), opt_tristate_german_comment_from_str('Nein'))
+        self.assertEqual((0.5, 'nur ganz oben nicht'), opt_tristate_german_comment_from_str('Teilweise (nur ganz oben nicht)'))
+        self.assertEqual((None, None), opt_tristate_german_comment_from_str(''))

         with self.assertRaises(ValueError):
             opt_tristate_german_from_str('Vielleicht')
         with self.assertRaises(ValueError):
             opt_tristate_german_from_str('(Ja)')
 
     def test_to_str(self):
         with self.assertRaises(ValueError):
             opt_tristate_german_from_str('Vielleicht')
         with self.assertRaises(ValueError):
             opt_tristate_german_from_str('(Ja)')
 
     def test_to_str(self):

-        self.assertEqual(opt_tristate_german_comment_to_str((1.0, None)), 'Ja')
-        self.assertEqual(opt_tristate_german_comment_to_str((0.5, None)), 'Teilweise')
-        self.assertEqual(opt_tristate_german_comment_to_str((0.0, None)), 'Nein')
-        self.assertEqual(opt_tristate_german_comment_to_str((None, None)), '')
+        self.assertEqual('Ja', opt_tristate_german_comment_to_str((1.0, None)))
+        self.assertEqual('Teilweise', opt_tristate_german_comment_to_str((0.5, None)))
+        self.assertEqual('Nein', opt_tristate_german_comment_to_str((0.0, None)))
+        self.assertEqual('', opt_tristate_german_comment_to_str((None, None)))

 
 
 
 

-class TestLonLat(unittest.TestCase):
+# url converter
+# -------------
+
+class TestUrl(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(lonlat_from_str('47.076207 N 11.453553 E'), LonLat(11.453553, 47.076207))
+        self.assertEqual('http://www.winterrodeln.org/wiki/Arzler_Alm/', url_from_str('http://www.winterrodeln.org/wiki/Arzler_Alm/'))
+        self.assertEqual('http://www.winterrodeln.org/wiki/Nösslachhütte/', url_from_str('http://www.winterrodeln.org/wiki/Nösslachhütte/'))
+        self.assertEqual('https://www.winterrodeln.org/wiki/Nösslachhütte/', url_from_str('https://www.winterrodeln.org/wiki/Nösslachhütte/'))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            lonlat_from_str('47.076207 N 11.453553')
+            url_from_str('mailto:office@example.com')
+        with self.assertRaises(ValueError):
+            url_from_str('/wiki/Arzler_Alm/')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(lonlat_to_str(LonLat(11.453553, 47.076207)), '47.076207 N 11.453553 E')
+        self.assertEqual('http://www.winterrodeln.org/wiki/Arzler_Alm/', url_to_str('http://www.winterrodeln.org/wiki/Arzler_Alm/'))
+        self.assertEqual('http://www.winterrodeln.org/wiki/Nösslachhütte/', url_to_str('http://www.winterrodeln.org/wiki/Nösslachhütte/'))
+        self.assertEqual('https://www.winterrodeln.org/wiki/Nösslachhütte/', url_to_str('https://www.winterrodeln.org/wiki/Nösslachhütte/'))

 
 
 
 

-class TestValueCommentConverter(unittest.TestCase):
+# webauskunft converter
+# ---------------------
+
+class TestWebauskunft(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(value_comment_from_str('abc (defg)'), ('abc', 'defg'))
-        self.assertEqual(value_comment_from_str('abc ()'), ('abc', ''))
-        self.assertEqual(value_comment_from_str('(def)'), ('', 'def'))
-        self.assertEqual(value_comment_from_str('ab((cd))'), ('ab', '(cd)'))
-        self.assertEqual(value_comment_from_str('ab((c(d)[(])))'), ('ab', '(c(d)[(]))'))
-        self.assertEqual(value_comment_from_str('ab((cd)'), ('ab(', 'cd'))
-        self.assertEqual(value_comment_from_str('abcd  (ef) '), ('abcd', 'ef'))
-        self.assertEqual(value_comment_from_str('abc', comment_optional=True), ('abc', ''))
-        with self.assertRaises(ValueError):
-            value_comment_from_str('abc (')
-        with self.assertRaises(ValueError):
-            value_comment_from_str('abc )')
+        self.assertEqual((True, 'http://www.example.com/current'), webauskunft_from_str('http://www.example.com/current'))
+        self.assertEqual((None, None), webauskunft_from_str(''))
+        self.assertEqual((False, None), webauskunft_from_str('Nein'))
+
+    def test_to_str(self):
+        self.assertEqual('http://www.example.com/current', webauskunft_to_str((True, 'http://www.example.com/current')))
+        self.assertEqual('', webauskunft_to_str((None, None)))
+        self.assertEqual('Nein', webauskunft_to_str((False, None)))
+
+
+# wikipage converter
+# ------------------
+
+class TestWikipage(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual('[[Birgitzer Alm]]', wikipage_from_str('[[Birgitzer Alm]]'))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            value_comment_from_str('abc (def)g')
+            wikipage_from_str('[[')

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            value_comment_from_str('abc (b))')
+            wikipage_from_str('')

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            value_comment_from_str('abc')
+            wikipage_from_str('Birgitzer Alm')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(value_comment_to_str(('abc', 'defg')), 'abc (defg)')
-        self.assertEqual(value_comment_to_str(('abc', '')), 'abc ()')
-        self.assertEqual(value_comment_to_str(('', 'def')), '(def)')
-        self.assertEqual(value_comment_to_str(('ab', '(cd)')), 'ab ((cd))')
-        self.assertEqual(value_comment_to_str(('ab', '(c(d)[(]))')), 'ab ((c(d)[(])))')
-        self.assertEqual(value_comment_to_str(('ab(', 'cd')), 'ab( (cd)')
-        self.assertEqual(value_comment_to_str(('abcd', 'ef')), 'abcd (ef)')
-        self.assertEqual(value_comment_to_str(('abc', ''), comment_optional=True), 'abc')
+        self.assertEqual('[[Birgitzer Alm]]', wikipage_to_str('[[Birgitzer Alm]]'))

 
 
 
 

-class TestNoGermanConverter(unittest.TestCase):
+class TestOptWikipageEnum(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(no_german_from_str('abc'), (True, 'abc'))
-        self.assertEqual(no_german_from_str('Nein'), (False, None))
-        with self.assertRaises(ValueError):
-            no_german_from_str('')
+        self.assertEqual(['[[Birgitzer Alm]]', '[[Kemater Alm]]'], opt_wikipage_enum_from_str('[[Birgitzer Alm]]; [[Kemater Alm]]'))
+        self.assertEqual(['[[Birgitzer Alm]]'], opt_wikipage_enum_from_str('[[Birgitzer Alm]]'))
+        self.assertEqual([], opt_wikipage_enum_from_str('Nein'))
+        self.assertEqual(None, opt_wikipage_enum_from_str(''))

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(no_german_to_str((True, 'abc')), 'abc')
-        self.assertEqual(no_german_to_str((False, None)), 'Nein')
+        self.assertEqual('[[Birgitzer Alm]]; [[Kemater Alm]]', opt_wikipage_enum_to_str(['[[Birgitzer Alm]]', '[[Kemater Alm]]']))
+        self.assertEqual('[[Birgitzer Alm]]', opt_wikipage_enum_to_str(['[[Birgitzer Alm]]']))
+        self.assertEqual('Nein', opt_wikipage_enum_to_str([]))
+        self.assertEqual('', opt_wikipage_enum_to_str(None))

 
 
 
 

-class TestOptNoGerman(unittest.TestCase):
+# email converter
+# ---------------
+
+class TestEmail(unittest.TestCase):
+    def setUp(self):
+        self.good_addresses = ['office@example.com', 'winter+rodeln@localhost', 'joe.doe@exämple.com']
+        self.bad_addresses = ['öffice@example.com', 'winter rodeln@localhost', 'www.winterrodeln.org', 'mailto:info@example.com', 'info@example.com.']
+

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(opt_no_german_from_str('abc'), (True, 'abc'))
-        self.assertEqual(opt_no_german_from_str('Nein'), (False, None))
-        self.assertEqual(opt_no_german_from_str(''), (None, None))
+        for value in self.good_addresses:
+            self.assertEqual(value, email_from_str(value))
+        for value in self.bad_addresses:
+            with self.assertRaises(ValueError):
+                email_from_str(value)

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(opt_no_german_to_str((True, 'abc')), 'abc')
-        self.assertEqual(opt_no_german_to_str((False, None)), 'Nein')
-        self.assertEqual(opt_no_german_to_str((None, None)), '')
+        for value in self.good_addresses:
+            self.assertEqual(value, email_to_str(value))

 
 
 
 

-class TestLiftGermanValidator(unittest.TestCase):
+class TestMaskedEmail(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(lift_german_from_str(''), None)
-        self.assertEqual(lift_german_from_str('Nein'), [])
-        self.assertEqual(lift_german_from_str('Sessellift'), [('Sessellift', None)])
-        self.assertEqual(lift_german_from_str('Gondel (nur bis zur Hälfte)'), [('Gondel', 'nur bis zur Hälfte')])
-        self.assertEqual(lift_german_from_str('Sessellift; Taxi'), [('Sessellift', None), ('Taxi', None)])
-        self.assertEqual(lift_german_from_str('Sessellift (Wochenende); Taxi (6 Euro)'), [('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')])
+        self.assertEqual(('office@example.com', False), masked_email_from_str('office@example.com'))
+        self.assertEqual(('office@example.com', True), masked_email_from_str('office(at)example.com'))
+        with self.assertRaises(ValueError):
+            masked_email_from_str('office@example.com', masked_only=True)
+        with self.assertRaises(ValueError):
+            masked_email_from_str('off ice@example.com')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(lift_german_to_str(None), '')
-        self.assertEqual(lift_german_to_str([]), 'Nein')
-        self.assertEqual(lift_german_to_str([('Sessellift', None)]), 'Sessellift')
-        self.assertEqual(lift_german_to_str([('Gondel', 'nur bis zur Hälfte')]), 'Gondel (nur bis zur Hälfte)')
-        self.assertEqual(lift_german_to_str([('Sessellift', None), ('Taxi', None)]), 'Sessellift; Taxi')
-        self.assertEqual(lift_german_to_str([('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')]), 'Sessellift (Wochenende); Taxi (6 Euro)')
+        self.assertEqual('office@example.com', masked_email_to_str(('office@example.com', False)))
+        self.assertEqual('office(at)example.com', masked_email_to_str(('office@example.com', True)))
+        self.assertEqual('office()example.com', masked_email_to_str(('office@example.com', True), '()'))

 
 
 
 

-class TestNightLightDays(unittest.TestCase):
+class TestEmails(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(nightlightdays_from_str(''), (None, None))
-        self.assertEqual(nightlightdays_from_str('2 (Mo, Di)'), (2, 'Mo, Di'))
-        self.assertEqual(nightlightdays_from_str('7'), (7, None))
-        self.assertEqual(nightlightdays_from_str('0'), (0, None))
-        self.assertEqual(nightlightdays_from_str('(keine Ahnung)'), (None, 'keine Ahnung'))
+        self.assertEqual(None, emails_from_str(''))
+        self.assertEqual([], emails_from_str('Nein'))
+        self.assertEqual([(('info@example.com', False), None)], emails_from_str('info@example.com'))
+        self.assertEqual([(('info@example.com', True), None)], emails_from_str('info(at)example.com'))
+        self.assertEqual([(('info@example.com', False), 'Office')], emails_from_str('info@example.com (Office)'))
+        self.assertEqual([(('info@example.com', False), None), (('home@example.com', False), 'Privat')], emails_from_str('info@example.com; home@example.com (Privat)'))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            nightlightdays_from_str('8')
-        with self.assertRaises(ValueError):
-            nightlightdays_from_str('5 (Montag')
+            emails_from_str('nein')

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            nightlightdays_from_str('5.2')
+            emails_from_str('info@example.com; ho me@example.com (Privat)')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(nightlightdays_to_str((None, None)), '')
-        self.assertEqual(nightlightdays_to_str((2, 'Mo, Di')), '2 (Mo, Di)')
-        self.assertEqual(nightlightdays_to_str((7, None)), '7')
-        self.assertEqual(nightlightdays_to_str((0, None)), '0')
+        self.assertEqual('', emails_to_str(None))
+        self.assertEqual('Nein', emails_to_str([]))
+        self.assertEqual('info@example.com', emails_to_str([(('info@example.com', False), None)]))
+        self.assertEqual('info@example.com (Office)', emails_to_str([(('info@example.com', False), 'Office')]))
+        self.assertEqual('info@example.com; home@example.com (Privat)', emails_to_str([(('info@example.com', False), None), (('home@example.com', False), 'Privat')]))
+

 
 

+# phone converter
+# ---------------

 
 

-class TestSledRental(unittest.TestCase):
+class TestPhoneNumber(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(sledrental_from_str(''), None)
-        self.assertEqual(sledrental_from_str('Nein'), [])
-        self.assertEqual(sledrental_from_str('Talstation'), [('Talstation', None)])
-        self.assertEqual(sledrental_from_str('Talstation (unten)'), [('Talstation', 'unten')])
-        self.assertEqual(sledrental_from_str('Talstation (unten); Mittelstation'), [('Talstation', 'unten'), ('Mittelstation', None)])
+        self.assertEqual('+43-699-123456789', phone_number_from_str('+43-699-123456789'))
+        self.assertEqual('+43-69945', phone_number_from_str('+43-69945'))
+        self.assertEqual('+43-512-507-6418', phone_number_from_str('+43-512-507-6418'))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            sledrental_from_str('(unten)')
+            phone_number_from_str('+43-')

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            sledrental_from_str('Talstation (unten); ; Mittelstation')
+            phone_number_from_str('0512123456789')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(sledrental_to_str(None), '')
-        self.assertEqual(sledrental_to_str([]), 'Nein')
-        self.assertEqual(sledrental_to_str([('Talstation', None)]), 'Talstation')
-        self.assertEqual(sledrental_to_str([('Talstation', 'unten')]), 'Talstation (unten)')
-        self.assertEqual(sledrental_to_str([('Talstation', 'unten'), ('Mittelstation', None)]), 'Talstation (unten); Mittelstation')
+        self.assertEqual('+43-699-123456789', phone_number_to_str('+43-699-123456789'))
+        self.assertEqual('+43-69945', phone_number_to_str('+43-69945'))
+        self.assertEqual('+43-512-507-6418', phone_number_to_str('+43-512-507-6418'))

 
 
 
 

-class TestSingleCachet(unittest.TestCase):
+class TestOptPhoneCommentEnum(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel'))
-        self.assertEqual(single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'))
+        self.assertEqual(opt_phone_comment_enum_from_str(''), None)
+        self.assertEqual([], opt_phone_comment_enum_from_str('Nein'))
+        self.assertEqual([('+43-512-123456', 'untertags')], opt_phone_comment_enum_from_str('+43-512-123456 (untertags)'))
+        self.assertEqual([('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')], opt_phone_comment_enum_from_str('+43-512-1234 (untertags); +43-664-123456 (Alm)'))
+        self.assertEqual([('+43-512-1234', None), ('+43-664-123456', 'Sommer')], opt_phone_comment_enum_from_str('+43-512-1234; +43-664-123456 (Sommer)', True))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            single_cachet_german_from_str('')
+            opt_phone_comment_enum_from_str('+43-512-123456+ (untertags)')

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            single_cachet_german_from_str('Salzburger Naturrodelbahn-Gütesiegel 2013 schwer')
+            opt_phone_comment_enum_from_str('+43-512-123456')
+
+    def test_to_str(self):
+        self.assertEqual('', opt_phone_comment_enum_to_str(None))
+        self.assertEqual('Nein', opt_phone_comment_enum_to_str([]))
+        self.assertEqual('+43-512-123456 (untertags)', opt_phone_comment_enum_to_str([('+43-512-123456', 'untertags')]))
+        self.assertEqual('+43-512-1234 (untertags); +43-664-123456 (Alm)', opt_phone_comment_enum_to_str([('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')]))
+        self.assertEqual('+43-512-1234; +43-664-123456 (Sommer)', opt_phone_comment_enum_to_str([('+43-512-1234', None), ('+43-664-123456', 'Sommer')], True))
+
+
+# longitude/latitude converter
+# ----------------------------
+
+class TestLonLat(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual(LonLat(11.453553, 47.076207), lonlat_from_str('47.076207 N 11.453553 E'))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 4013 schwer')
+            lonlat_from_str('47.076207 N 11.453553')
+
+    def test_to_str(self):
+        self.assertEqual('47.076207 N 11.453553 E', lonlat_to_str(LonLat(11.453553, 47.076207)))
+
+
+# difficulty converter
+# --------------------
+
+class TestDifficultyGerman(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual(1, difficulty_german_from_str('leicht'))
+        self.assertEqual(2, difficulty_german_from_str('mittel'))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 13 schwer')
+            difficulty_german_from_str('dontknow')

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwerer')
+            difficulty_german_from_str('')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')), 'Tiroler Naturrodelbahn-Gütesiegel 2009 mittel')
-        self.assertEqual(single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer')), 'Tiroler Naturrodelbahn-Gütesiegel 2013 schwer')
+        self.assertEqual('leicht', difficulty_german_to_str(1))

 
 
 
 

-class TestCachetGerman(unittest.TestCase):
+# avalanches converter
+# --------------------
+
+class TestAvalancesGermanConverter(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(cachet_german_from_str(''), None)
-        self.assertEqual(cachet_german_from_str('Nein'), [])
-        self.assertEqual(cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'), [('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')])
-        self.assertEqual(cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer; Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'),
-            [('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')])
+        self.assertEqual(1, avalanches_german_from_str('kaum'))
+        self.assertEqual(1, opt_avalanches_german_from_str('kaum'))
+        self.assertEqual(2, avalanches_german_from_str('selten'))
+        self.assertEqual(2, opt_avalanches_german_from_str('selten'))
+        self.assertEqual(3, avalanches_german_from_str('gelegentlich'))
+        self.assertEqual(3, opt_avalanches_german_from_str('gelegentlich'))
+        self.assertEqual(4, avalanches_german_from_str('häufig'))
+        self.assertEqual(4, opt_avalanches_german_from_str('häufig'))
+        self.assertEqual(None, opt_avalanches_german_from_str(''))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            cachet_german_from_str('Ja')
+            avalanches_german_from_str('immer')
+        with self.assertRaises(ValueError):
+            opt_avalanches_german_from_str('immer')

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer Tiroler Naturrodelbahn-Gütesiegel 2009 mittel')
+            avalanches_german_from_str('')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(cachet_german_to_str(None), '')
-        self.assertEqual(cachet_german_to_str([]), 'Nein')
-        self.assertEqual(cachet_german_to_str([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]), 'Tiroler Naturrodelbahn-Gütesiegel 2009 mittel')
-        self.assertEqual(cachet_german_to_str([('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]),
-            'Tiroler Naturrodelbahn-Gütesiegel 2013 schwer; Tiroler Naturrodelbahn-Gütesiegel 2009 mittel')
+        self.assertEqual('kaum', avalanches_german_to_str(1))
+        self.assertEqual('kaum', opt_avalanches_german_to_str(1))
+        self.assertEqual('selten', avalanches_german_to_str(2))
+        self.assertEqual('selten', opt_avalanches_german_to_str(2))
+        self.assertEqual('gelegentlich', avalanches_german_to_str(3))
+        self.assertEqual('gelegentlich', opt_avalanches_german_to_str(3))
+        self.assertEqual('häufig', avalanches_german_to_str(4))
+        self.assertEqual('häufig', opt_avalanches_german_to_str(4))
+        self.assertEqual('', opt_avalanches_german_to_str(None))

 
 
 
 

-class TestUrl(unittest.TestCase):
+# lift converter
+# --------------
+
+class TestLiftGermanValidator(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(url_from_str('http://www.winterrodeln.org/wiki/Arzler_Alm/'), 'http://www.winterrodeln.org/wiki/Arzler_Alm/')
-        self.assertEqual(url_from_str('http://www.winterrodeln.org/wiki/Nösslachhütte/'), 'http://www.winterrodeln.org/wiki/Nösslachhütte/')
-        self.assertEqual(url_from_str('https://www.winterrodeln.org/wiki/Nösslachhütte/'), 'https://www.winterrodeln.org/wiki/Nösslachhütte/')
+        self.assertEqual(lift_german_from_str(''), None)
+        self.assertEqual([], lift_german_from_str('Nein'))
+        self.assertEqual([('Sessellift', None)], lift_german_from_str('Sessellift'))
+        self.assertEqual([('Gondel', 'nur bis zur Hälfte')], lift_german_from_str('Gondel (nur bis zur Hälfte)'))
+        self.assertEqual([('Sessellift', None), ('Taxi', None)], lift_german_from_str('Sessellift; Taxi'))
+        self.assertEqual([('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')], lift_german_from_str('Sessellift (Wochenende); Taxi (6 Euro)'))
+
+    def test_to_str(self):
+        self.assertEqual('', lift_german_to_str(None))
+        self.assertEqual('Nein', lift_german_to_str([]))
+        self.assertEqual('Sessellift', lift_german_to_str([('Sessellift', None)]))
+        self.assertEqual('Gondel (nur bis zur Hälfte)', lift_german_to_str([('Gondel', 'nur bis zur Hälfte')]))
+        self.assertEqual('Sessellift; Taxi', lift_german_to_str([('Sessellift', None), ('Taxi', None)]))
+        self.assertEqual('Sessellift (Wochenende); Taxi (6 Euro)', lift_german_to_str([('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')]))
+
+
+# public transport converter
+# --------------------------
+
+class TestPublicTransportGerman(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual(1, public_transport_german_from_str('Sehr gut'))
+        self.assertEqual(1, opt_public_transport_german_from_str('Sehr gut'))
+        self.assertEqual(2, public_transport_german_from_str('Gut'))
+        self.assertEqual(2, opt_public_transport_german_from_str('Gut'))
+        self.assertEqual(3, public_transport_german_from_str('Mittelmäßig'))
+        self.assertEqual(3, opt_public_transport_german_from_str('Mittelmäßig'))
+        self.assertEqual(4, public_transport_german_from_str('Schlecht'))
+        self.assertEqual(4, opt_public_transport_german_from_str('Schlecht'))
+        self.assertEqual(5, public_transport_german_from_str('Nein'))
+        self.assertEqual(5, opt_public_transport_german_from_str('Nein'))
+        self.assertEqual(6, public_transport_german_from_str('Ja'))
+        self.assertEqual(6, opt_public_transport_german_from_str('Ja'))
+        self.assertEqual(None, opt_public_transport_german_from_str(''))
+        with self.assertRaises(ValueError):
+            public_transport_german_from_str('')
+        with self.assertRaises(ValueError):
+            public_transport_german_from_str('Naja')
+        with self.assertRaises(ValueError):
+            opt_public_transport_german_from_str('Naja')
+
+    def test_to_str(self):
+        self.assertEqual('Sehr gut', public_transport_german_to_str(1))
+        self.assertEqual('Sehr gut', opt_public_transport_german_to_str(1))
+        self.assertEqual('Gut', public_transport_german_to_str(2))
+        self.assertEqual('Gut', opt_public_transport_german_to_str(2))
+        self.assertEqual('Mittelmäßig', public_transport_german_to_str(3))
+        self.assertEqual('Mittelmäßig', opt_public_transport_german_to_str(3))
+        self.assertEqual('Schlecht', public_transport_german_to_str(4))
+        self.assertEqual('Schlecht', opt_public_transport_german_to_str(4))
+        self.assertEqual('Nein', public_transport_german_to_str(5))
+        self.assertEqual('Nein', opt_public_transport_german_to_str(5))
+        self.assertEqual('Ja', public_transport_german_to_str(6))
+        self.assertEqual('Ja', opt_public_transport_german_to_str(6))
+        self.assertEqual('', opt_public_transport_german_to_str(None))
+
+
+# cachet converter
+# ----------------
+
+class TestSingleCachet(unittest.TestCase):
+    def test_from_str(self):
+        self.assertEqual(('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel'), single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'))
+        self.assertEqual(('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer'))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            url_from_str('mailto:office@example.com')
+            single_cachet_german_from_str('')

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            url_from_str('/wiki/Arzler_Alm/')
+            single_cachet_german_from_str('Salzburger Naturrodelbahn-Gütesiegel 2013 schwer')
+        with self.assertRaises(ValueError):
+            single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 4013 schwer')
+        with self.assertRaises(ValueError):
+            single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 13 schwer')
+        with self.assertRaises(ValueError):
+            single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwerer')
+        with self.assertRaises(ValueError):
+            single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel schwer')
+        with self.assertRaises(ValueError):
+            single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(url_to_str('http://www.winterrodeln.org/wiki/Arzler_Alm/'), 'http://www.winterrodeln.org/wiki/Arzler_Alm/')
-        self.assertEqual(url_to_str('http://www.winterrodeln.org/wiki/Nösslachhütte/'), 'http://www.winterrodeln.org/wiki/Nösslachhütte/')
-        self.assertEqual(url_to_str('https://www.winterrodeln.org/wiki/Nösslachhütte/'), 'https://www.winterrodeln.org/wiki/Nösslachhütte/')
+        self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel', single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')))
+        self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer', single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer')))

 
 
 
 

-class TestWebauskunft(unittest.TestCase):
+class TestCachetGerman(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(webauskunft_from_str('http://www.example.com/current'), (True, 'http://www.example.com/current'))
-        self.assertEqual(webauskunft_from_str(''), (None, None))
-        self.assertEqual(webauskunft_from_str('Nein'), (False, None))
+        self.assertEqual(cachet_german_from_str(''), None)
+        self.assertEqual([], cachet_german_from_str('Nein'))
+        self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')], cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'))
+        self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')], 
+                         cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer; Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'))
+        with self.assertRaises(ValueError):
+            cachet_german_from_str('Ja')
+        with self.assertRaises(ValueError):
+            cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer Tiroler Naturrodelbahn-Gütesiegel 2009 mittel')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(webauskunft_to_str((True, 'http://www.example.com/current')), 'http://www.example.com/current')
-        self.assertEqual(webauskunft_to_str((None, None)), '')
-        self.assertEqual(webauskunft_to_str((False, None)), 'Nein')
+        self.assertEqual('', cachet_german_to_str(None))
+        self.assertEqual('Nein', cachet_german_to_str([]))
+        self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel', cachet_german_to_str([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]))
+        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')]))

 
 
 
 

-class TestPhoneNumber(unittest.TestCase):
+# night light days converter
+# --------------------------
+
+class TestNightLightDays(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(phone_number_from_str('+43-699-123456789'), '+43-699-123456789')
-        self.assertEqual(phone_number_from_str('+43-69945'), '+43-69945')
-        self.assertEqual(phone_number_from_str('+43-512-507-6418'), '+43-512-507-6418')
+        self.assertEqual((None, None), nightlightdays_from_str(''))
+        self.assertEqual((2, 'Mo, Di'), nightlightdays_from_str('2 (Mo, Di)'))
+        self.assertEqual((7, None), nightlightdays_from_str('7'))
+        self.assertEqual((0, None), nightlightdays_from_str('0'))
+        self.assertEqual((None, 'keine Ahnung'), nightlightdays_from_str('(keine Ahnung)'))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            phone_number_from_str('+43-')
+            nightlightdays_from_str('8')

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            phone_number_from_str('0512123456789')
+            nightlightdays_from_str('5 (Montag')
+        with self.assertRaises(ValueError):
+            nightlightdays_from_str('5.2')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(phone_number_to_str('+43-699-123456789'), '+43-699-123456789')
-        self.assertEqual(phone_number_to_str('+43-69945'), '+43-69945')
-        self.assertEqual(phone_number_to_str('+43-512-507-6418'), '+43-512-507-6418')
+        self.assertEqual('', nightlightdays_to_str((None, None)))
+        self.assertEqual('2 (Mo, Di)', nightlightdays_to_str((2, 'Mo, Di')))
+        self.assertEqual('7', nightlightdays_to_str((7, None)))
+        self.assertEqual('0', nightlightdays_to_str((0, None)))
+

 
 

+# string with optional comment enum/list converter
+# ------------------------------------------------

 
 

-class TestTelefonauskunft(unittest.TestCase):
+class TestOptStrOptCommentEnum(unittest.TestCase):

     def test_from_str(self):
     def test_from_str(self):

-        self.assertEqual(telefonauskunft_from_str(''), None)
-        self.assertEqual(telefonauskunft_from_str('Nein'), [])
-        self.assertEqual(telefonauskunft_from_str('+43-512-123456 (untertags)'), [('+43-512-123456', 'untertags')])
-        self.assertEqual(telefonauskunft_from_str('+43-512-1234 (untertags); +43-664-123456 (Alm)'), [('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')])
+        self.assertEqual(None, opt_str_opt_comment_enum_from_str(''))
+        self.assertEqual([], opt_str_opt_comment_enum_from_str('Nein'))
+        self.assertEqual([('Talstation', None)], opt_str_opt_comment_enum_from_str('Talstation'))
+        self.assertEqual([('Talstation', 'unten')], opt_str_opt_comment_enum_from_str('Talstation (unten)'))
+        self.assertEqual([('Talstation', 'unten'), ('Mittelstation', None)], opt_str_opt_comment_enum_from_str('Talstation (unten); Mittelstation'))

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            telefonauskunft_from_str('+43-512-123456+ (untertags)')
+            opt_str_opt_comment_enum_from_str('(unten)')

         with self.assertRaises(ValueError):
         with self.assertRaises(ValueError):

-            telefonauskunft_from_str('+43-512-123456')
+            opt_str_opt_comment_enum_from_str('Talstation (unten); ; Mittelstation')

 
     def test_to_str(self):
 
     def test_to_str(self):

-        self.assertEqual(telefonauskunft_to_str(None), '')
-        self.assertEqual(telefonauskunft_to_str([]), 'Nein')
-        self.assertEqual(telefonauskunft_to_str([('+43-512-123456', 'untertags')]), '+43-512-123456 (untertags)')
-        self.assertEqual(telefonauskunft_to_str([('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')]), '+43-512-1234 (untertags); +43-664-123456 (Alm)')
+        self.assertEqual('', opt_str_opt_comment_enum_to_str(None))
+        self.assertEqual('Nein', opt_str_opt_comment_enum_to_str([]))
+        self.assertEqual('Talstation', opt_str_opt_comment_enum_to_str([('Talstation', None)]))
+        self.assertEqual('Talstation (unten)', opt_str_opt_comment_enum_to_str([('Talstation', 'unten')]))
+        self.assertEqual('Talstation (unten); Mittelstation', opt_str_opt_comment_enum_to_str([('Talstation', 'unten'), ('Mittelstation', None)]))
+

 
 

+# wikibox converter
+# -----------------

 
 

-class TestBox(unittest.TestCase):
+class TestWikibox(unittest.TestCase):

     def test_from_str(self):
         value = '{{MyTemplate|apple=2|banana=5}}'
     def test_from_str(self):
         value = '{{MyTemplate|apple=2|banana=5}}'

-        converter_dict = OrderedDict([('apple', opt_int_converter), ('banana', opt_int_converter)])
-        result = box_from_str(value, 'MyTemplate', converter_dict)
-        self.assertEqual(result['apple'], 2)
-        self.assertEqual(result['banana'], 5)
+        converter_dict = OrderedDict([('apple', opt_uint_converter), ('banana', opt_uint_converter)])
+        result = wikibox_from_str(value, 'MyTemplate', converter_dict)
+        self.assertEqual(2, result['apple'])
+        self.assertEqual(5, result['banana'])

 
         value = '{{MyTemplate\n | apple = 2 \n| banana = 5 }}'
 
         value = '{{MyTemplate\n | apple = 2 \n| banana = 5 }}'

-        result = box_from_str(value, 'MyTemplate', converter_dict)
-        self.assertEqual(result['apple'], 2)
-        self.assertEqual(result['banana'], 5)
+        result = wikibox_from_str(value, 'MyTemplate', converter_dict)
+        self.assertEqual(2, result['apple'])
+        self.assertEqual(5, result['banana'])

 
         with self.assertRaises(ValueError):
 
         with self.assertRaises(ValueError):

-            box_from_str(value, 'myTemplate', converter_dict)
+            wikibox_from_str(value, 'myTemplate', converter_dict)

         with self.assertRaises(ValueError):
             value = '{{MyTemplate|apple=2|banana=five}}'
         with self.assertRaises(ValueError):
             value = '{{MyTemplate|apple=2|banana=five}}'

-            box_from_str(value, 'MyTemplate', converter_dict)
+            wikibox_from_str(value, 'MyTemplate', converter_dict)

         with self.assertRaises(ValueError):
             value = '{{MyTemplate|apple=2}}'
         with self.assertRaises(ValueError):
             value = '{{MyTemplate|apple=2}}'

-            box_from_str(value, 'MyTemplate', converter_dict)
+            wikibox_from_str(value, 'MyTemplate', converter_dict)

         with self.assertRaises(ValueError):
             value = '{{MyTemplate|apple=2|banana=5|cherry=6}}'
         with self.assertRaises(ValueError):
             value = '{{MyTemplate|apple=2|banana=5|cherry=6}}'

-            box_from_str(value, 'MyTemplate', converter_dict)
+            wikibox_from_str(value, 'MyTemplate', converter_dict)

 
     def test_to_str(self):
         value = OrderedDict([('apple', 2), ('banana', 5)])
 
     def test_to_str(self):
         value = OrderedDict([('apple', 2), ('banana', 5)])

-        converter_dict = OrderedDict([('apple', opt_int_converter), ('banana', opt_int_converter)])
-        result = box_to_str(value, 'MyTemplate', converter_dict)
-        self.assertEqual(result, '{{MyTemplate|apple=2|banana=5}}')
+        converter_dict = OrderedDict([('apple', opt_uint_converter), ('banana', opt_uint_converter)])
+        result = wikibox_to_str(value, 'MyTemplate', converter_dict)
+        self.assertEqual('{{MyTemplate|apple=2|banana=5}}', result)

 
 
 
 

+# Rodelbahnbox converter
+# ----------------------
+

 class TestRodelbahnbox(unittest.TestCase):
     def setUp(self):
         self.maxDiff = None
 class TestRodelbahnbox(unittest.TestCase):
     def setUp(self):
         self.maxDiff = None


@@ -416,164 +760,135 @@ class TestRodelbahnbox(unittest.TestCase):
 '''{{Rodelbahnbox
 | Position             = 46.807218 N 12.806522 E
 | Position oben        = 46.799014 N 12.818658 E
 '''{{Rodelbahnbox
 | Position             = 46.807218 N 12.806522 E
 | Position oben        = 46.799014 N 12.818658 E

-| Höhe oben            = 1046
+| Höhe oben            = 1046

 | Position unten       =
 | Position unten       =

-| Höhe unten           =
-| Länge                = 3500
+| Höhe unten           =
+| Länge                = 3500

 | Schwierigkeit        = mittel
 | Lawinen              = kaum
 | Schwierigkeit        = mittel
 | Lawinen              = kaum

-| Betreiber            = Bringungsgemeinschaft Kreithof-Dolomitenhütte
-| Öffentliche Anreise  = Schlecht
-| Aufstieg möglich     = Ja
+| Betreiber            = Bringungsgemeinschaft Kreithof-Dolomitenhütte
+| Öffentliche Anreise  = Schlecht
+| Aufstieg möglich     = Ja

 | Aufstieg getrennt    = Teilweise
 | Gehzeit              = 75
 | Aufstiegshilfe       = Taxi; Sonstige (PKW bis Kreithof)
 | Beleuchtungsanlage   = Ja
 | Beleuchtungstage     = 7
 | Rodelverleih         = Nein
 | Aufstieg getrennt    = Teilweise
 | Gehzeit              = 75
 | Aufstiegshilfe       = Taxi; Sonstige (PKW bis Kreithof)
 | Beleuchtungsanlage   = Ja
 | Beleuchtungstage     = 7
 | Rodelverleih         = Nein

-| Gütesiegel           = Tiroler Naturrodelbahn-Gütesiegel 2009 mittel
+| Gütesiegel           = Tiroler Naturrodelbahn-Gütesiegel 2009 mittel

 | Webauskunft          = http://www.lienzerdolomiten.info/at/tobogorpt.html
 | Webauskunft          = http://www.lienzerdolomiten.info/at/tobogorpt.html

-| Telefonauskunft      = +43-664-2253782 (Dolomitenhütte)
+| Telefonauskunft      = +43-664-2253782 (Dolomitenhütte)

 | Bild                 = Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg
 | Bild                 = Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg

-| In Übersichtskarte   = Ja
+| In Übersichtskarte   = Ja

 | Forumid              = 139
 }}'''
 
     def test_from_str(self):
         value = rodelbahnbox_from_str(self.value)
 | Forumid              = 139
 }}'''
 
     def test_from_str(self):
         value = rodelbahnbox_from_str(self.value)

-        self.assertEqual(value['Position'], LonLat(12.806522, 46.807218))
-        self.assertEqual(value['Position oben'], LonLat(12.818658, 46.799014))
-        self.assertEqual(value['Höhe oben'], 1046)
-        self.assertEqual(value['Position unten'], LonLat(None, None))
-        self.assertEqual(value['Höhe unten'], None)
-        self.assertEqual(value['Länge'], 3500)
-        self.assertEqual(value['Schwierigkeit'], 2)
-        self.assertEqual(value['Lawinen'], 1)
-        self.assertEqual(value['Betreiber'], 'Bringungsgemeinschaft Kreithof-Dolomitenhütte')
-        self.assertEqual(value['Öffentliche Anreise'], 4)
-        self.assertEqual(value['Aufstieg möglich'], True)
-        self.assertEqual(value['Aufstieg getrennt'], (0.5, None))
-        self.assertEqual(value['Gehzeit'], 75)
-        self.assertEqual(value['Aufstiegshilfe'], [('Taxi', None), ('Sonstige', 'PKW bis Kreithof')])
-        self.assertEqual(value['Beleuchtungsanlage'], (1.0, None))
-        self.assertEqual(value['Beleuchtungstage'], (7, None))
-        self.assertEqual(value['Rodelverleih'], [])
-        self.assertEqual(value['Gütesiegel'], [('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')])
-        self.assertEqual(value['Webauskunft'], (True, 'http://www.lienzerdolomiten.info/at/tobogorpt.html'))
-        self.assertEqual(value['Telefonauskunft'], [('+43-664-2253782', 'Dolomitenhütte')])
-        self.assertEqual(value['Bild'], 'Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg')
-        self.assertEqual(value['In Übersichtskarte'], True)
-        self.assertEqual(value['Forumid'], 139)
+        self.assertEqual(LonLat(12.806522, 46.807218), value['Position'])
+        self.assertEqual(LonLat(12.818658, 46.799014), value['Position oben'])
+        self.assertEqual(1046, value['Höhe oben'])
+        self.assertEqual(LonLat(None, None), value['Position unten'])
+        self.assertEqual(None, value['Höhe unten'])
+        self.assertEqual(3500, value['Länge'])
+        self.assertEqual(2, value['Schwierigkeit'])
+        self.assertEqual(1, value['Lawinen'])
+        self.assertEqual('Bringungsgemeinschaft Kreithof-Dolomitenhütte', value['Betreiber'])
+        self.assertEqual(4, value['Öffentliche Anreise'])
+        self.assertEqual(True, value['Aufstieg möglich'])
+        self.assertEqual((0.5, None), value['Aufstieg getrennt'])
+        self.assertEqual(75, value['Gehzeit'])
+        self.assertEqual([('Taxi', None), ('Sonstige', 'PKW bis Kreithof')], value['Aufstiegshilfe'])
+        self.assertEqual((1.0, None), value['Beleuchtungsanlage'])
+        self.assertEqual((7, None), value['Beleuchtungstage'])
+        self.assertEqual([], value['Rodelverleih'])
+        self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')], value['Gütesiegel'])
+        self.assertEqual((True, 'http://www.lienzerdolomiten.info/at/tobogorpt.html'), value['Webauskunft'])
+        self.assertEqual([('+43-664-2253782', 'Dolomitenhütte')], value['Telefonauskunft'])
+        self.assertEqual('Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg', value['Bild'])
+        self.assertEqual(True, value['In Übersichtskarte'])
+        self.assertEqual(139, value['Forumid'])

 
     def test_to_str(self):
         value = OrderedDict([
             ('Position', LonLat(12.806522, 46.807218)),
             ('Position oben', LonLat(12.818658, 46.799014)),
 
     def test_to_str(self):
         value = OrderedDict([
             ('Position', LonLat(12.806522, 46.807218)),
             ('Position oben', LonLat(12.818658, 46.799014)),

-            ('Höhe oben', 1046),
+            ('Höhe oben', 1046),

             ('Position unten', LonLat(None, None)),
             ('Position unten', LonLat(None, None)),

-            ('Höhe unten', None),
-            ('Länge', 3500),
+            ('Höhe unten', None),
+            ('Länge', 3500),

             ('Schwierigkeit', 2),
             ('Lawinen', 1),
             ('Schwierigkeit', 2),
             ('Lawinen', 1),

-            ('Betreiber', 'Bringungsgemeinschaft Kreithof-Dolomitenhütte'),
-            ('Öffentliche Anreise', 4),
-            ('Aufstieg möglich', True),
+            ('Betreiber', 'Bringungsgemeinschaft Kreithof-Dolomitenhütte'),
+            ('Öffentliche Anreise', 4),
+            ('Aufstieg möglich', True),

             ('Aufstieg getrennt', (0.5, None)),
             ('Gehzeit', 75),
             ('Aufstiegshilfe', [('Taxi', None), ('Sonstige', 'PKW bis Kreithof')]),
             ('Beleuchtungsanlage', (1.0, None)),
             ('Beleuchtungstage', (7, None)),
             ('Rodelverleih', []),
             ('Aufstieg getrennt', (0.5, None)),
             ('Gehzeit', 75),
             ('Aufstiegshilfe', [('Taxi', None), ('Sonstige', 'PKW bis Kreithof')]),
             ('Beleuchtungsanlage', (1.0, None)),
             ('Beleuchtungstage', (7, None)),
             ('Rodelverleih', []),

-            ('Gütesiegel', [('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]),
+            ('Gütesiegel', [('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]),

             ('Webauskunft', (True, 'http://www.lienzerdolomiten.info/at/tobogorpt.html')),
             ('Webauskunft', (True, 'http://www.lienzerdolomiten.info/at/tobogorpt.html')),

-            ('Telefonauskunft', [('+43-664-2253782', 'Dolomitenhütte')]),
+            ('Telefonauskunft', [('+43-664-2253782', 'Dolomitenhütte')]),

             ('Bild', 'Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg'),
             ('Bild', 'Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg'),

-            ('In Übersichtskarte', True),
+            ('In Übersichtskarte', True),

             ('Forumid', 139)])
             ('Forumid', 139)])

-        self.assertEqual(rodelbahnbox_to_str(value), self.value)
-
-
-class TestWrValidators(unittest.TestCase):
-    def test_ValueCommentListNeinLoopNone(self):
-        v = wrpylib.wrvalidators.ValueCommentListNeinLoopNone()
-        assert v.to_python('') == None
-        assert v.to_python('Nein') == 'Nein'
-        assert v.to_python('T-Mobile (gut); A1') == 'T-Mobile (gut); A1'
-        assert v.from_python(None) == ''
-        assert v.from_python('Nein') == 'Nein'
-        assert v.from_python('T-Mobile (gut); A1') == 'T-Mobile (gut); A1'
-
-
-    def test_PhoneCommentListNeinLoopNone(self):
-        v = wrpylib.wrvalidators.PhoneCommentListNeinLoopNone(comments_are_optional=True)
-        assert v.to_python('') == None
-        assert v.to_python('Nein') == 'Nein'
-        assert v.to_python('+43-699-1234567 (nicht nach 20:00 Uhr); +43-512-123456') == '+43-699-1234567 (nicht nach 20:00 Uhr); +43-512-123456'
-        assert v.from_python(None) == ''
-        assert v.from_python('Nein') == 'Nein'
-        assert v.from_python('+43-699-1234567 (nicht nach 20:00 Uhr); +43-512-123456') == '+43-699-1234567 (nicht nach 20:00 Uhr); +43-512-123456'
-
-
-    def test_MaskedEmail(self):
-        v = wrpylib.wrvalidators.MaskedEmail()
-        assert v.to_python('') == (None, None)
-        assert v.to_python('abc.def@example.com') == ('abc.def@example.com', False)
-        assert v.to_python('abc.def(at)example.com') == ('abc.def@example.com', True)
-        assert v.from_python((None, None)) == ''
-        assert v.from_python(('abc.def@example.com', False)) == 'abc.def@example.com'
-        assert v.from_python(('abc.def@example.com', True)) == 'abc.def(at)example.com'
-
-
-    def test_EmailCommentListNeinLoopNone(self):
-        v = wrpylib.wrvalidators.EmailCommentListNeinLoopNone()
-        assert v.to_python('') == None
-        assert v.to_python('Nein') == 'Nein'
-        assert v.to_python('first@example.com') == 'first@example.com'
-        assert v.to_python('first@example.com (Nur Winter); second@example.com') == 'first@example.com (Nur Winter); second@example.com'
-        assert v.from_python(None) == ''
-        assert v.from_python('Nein') == 'Nein'
-        assert v.from_python('first@example.com') == 'first@example.com'
-        assert v.from_python('first@example.com (Nur Winter); second@example.com') == 'first@example.com (Nur Winter); second@example.com'
-        testvalue = 'abc.def(at)example.com (comment)'
-        try:
-            v.to_python(testvalue)
-            assert False
-        except formencode.Invalid:
-            pass
-        try:
-            v.from_python(testvalue)
-            assert False
-        except formencode.Invalid:
-            pass
-        v = wrpylib.wrvalidators.EmailCommentListNeinLoopNone(allow_masked_email=True)
-        assert v.to_python(testvalue) == testvalue
-        assert v.from_python(testvalue) == testvalue
-
-
-    def test_WikiPageListLoopNone(self):
-        v = wrpylib.wrvalidators.WikiPageListLoopNone()
-        assert v.to_python('') == None
-        assert v.to_python('[[Birgitzer Alm]]; [[Kemater Alm]]') == '[[Birgitzer Alm]]; [[Kemater Alm]]'
-        assert v.from_python(None) == ''
-        assert v.from_python('[[Birgitzer Alm]]; [[Kemater Alm]]') == '[[Birgitzer Alm]]; [[Kemater Alm]]'
-
-
-    def test_GasthausboxDictValidator(self):
-        v = wrpylib.wrvalidators.GasthausboxDictValidator()
-        other = collections.OrderedDict([
-            ('Position', '47.295549 N 9.986970 E'),
-            ('Höhe', '1250'),
-            ('Betreiber', ''),
-            ('Sitzplätze', ''),
-            ('Übernachtung', ''),
-            ('Rauchfrei', 'Nein'),
-            ('Rodelverleih', ''),
-            ('Handyempfang', 'A1; T-Mobile/Telering'),
-            ('Homepage', 'http://www.bergkristallhuette.com/'),
-            ('E-Mail', 'bergkristallhuette@gmx.at'),
-            ('Telefon', '+43-664-1808482'),
-            ('Bild', 'Bergkritsallhütte 2009-02-07.JPG'),
-            ('Rodelbahnen', '[[Bergkristallhütte]]')])
-        python = v.to_python(other, None)
-        other2 = v.from_python(python, None)
-        assert other == other2
+        self.assertEqual(self.value, rodelbahnbox_to_str(value))
+
+
+# Gasthausbox converter
+# ---------------------
+
+class TestGasthausbox(unittest.TestCase):
+    def setUp(self):
+        self.maxDiff = None
+        self.value = \
+"""{{Gasthausbox
+| Position          = 47.123456 N 11.123456 E
+| Höhe              = 1808
+| Betreiber         = Max Mustermann
+| Sitzplätze        = 50
+| Übernachtung      = 20 Matrazenlager, 3 Doppelzimmer
+| Rauchfrei         = Ja
+| Rodelverleih      = 2 Euro (Ausweis erforderlich)
+| Handyempfang      = A1; T-Mobile A
+| Homepage          = http://www.birgitzeralm.at/
+| E-Mail            = Nein
+| Telefon           = +43-664-5487520; +43-512-123456 (wenn geschlossen)
+| Bild              = Gasthaus_Birgitzer_Alm_03.jpg
+| Rodelbahnen       = [[Birgitzer Alm (vom Adelshof)]]; [[Birgitzer Alm (von Birgitz)]]
+}}"""
+
+    def test_from_str(self):
+        value = gasthausbox_from_str(self.value)
+        self.assertEqual(LonLat(11.123456, 47.123456), value['Position'])
+        self.assertEqual(1808, value['Höhe'])
+        self.assertEqual('Max Mustermann', value['Betreiber'])
+        self.assertEqual(50, value['Sitzplätze'])
+        self.assertEqual((True, '20 Matrazenlager, 3 Doppelzimmer'), value['Übernachtung'])
+        self.assertEqual((True, '2 Euro (Ausweis erforderlich)'), value['Rodelverleih'])
+        self.assertEqual(1.0, value['Rauchfrei'])
+        self.assertEqual([('A1', None), ('T-Mobile A', None)], value['Handyempfang'])
+        self.assertEqual((True, 'http://www.birgitzeralm.at/'), value['Homepage'])
+        self.assertEqual([], value['E-Mail'])
+        self.assertEqual([('+43-664-5487520', None), ('+43-512-123456', 'wenn geschlossen')], value['Telefon'])
+        self.assertEqual('Gasthaus_Birgitzer_Alm_03.jpg', value['Bild'])
+        self.assertEqual(['[[Birgitzer Alm (vom Adelshof)]]', '[[Birgitzer Alm (von Birgitz)]]'], value['Rodelbahnen'])
+
+    def test_to_str(self):
+        value = OrderedDict([
+            ('Position', LonLat(11.123456, 47.123456)),
+            ('Höhe', 1808),
+            ('Betreiber', 'Max Mustermann'),
+            ('Sitzplätze', 50),
+            ('Übernachtung', (True, '20 Matrazenlager, 3 Doppelzimmer')),
+            ('Rodelverleih', (True, '2 Euro (Ausweis erforderlich)')),
+            ('Rauchfrei', 1.0),
+            ('Handyempfang', [('A1', None), ('T-Mobile A', None)]),
+            ('Homepage', (True, 'http://www.birgitzeralm.at/')),
+            ('E-Mail', []),
+            ('Telefon', [('+43-664-5487520', None), ('+43-512-123456', 'wenn geschlossen')]),
+            ('Bild', 'Gasthaus_Birgitzer_Alm_03.jpg'),
+            ('Rodelbahnen', ['[[Birgitzer Alm (vom Adelshof)]]', '[[Birgitzer Alm (von Birgitz)]]'])])
+        self.assertEqual(self.value, gasthausbox_to_str(value))