elwig/Tests/UnitTests/HelperTests/NormalizerTest.cs

using Elwig.Helpers;

namespace Tests.UnitTests.HelperTests {
    [TestFixture]
    public class NormalizerTest {

        private static void Assert_NormalizeStreetName(string name) {
            Assert.That(Normalizer.NormalizeStreetName(name), Is.EqualTo(name));
        }

        [Test]
        public void Test_NormalizeStreetName_Vienna_2() {
            // Das erste Wort eines Straßennamens wird groß geschrieben,
            // ebenso jedes zum Namen gehörende Eigenschafts- oder Zahlwort.
            // Das gilt auch, wenn zu Eigenschafts- und Hauptwort Präpositionen hinzutreten.
            using (Assert.EnterMultipleScope()) {
                Assert_NormalizeStreetName("Lange Gasse");
                Assert_NormalizeStreetName("An den Alten Schanzen");

            }
        }

        [Test]
        public void Test_NormalizeStreetName_Vienna_3_1() {
            // Zusammen schreibt man Zusammensetzungen aus einem einfachen oder zusammengesetzten Hauptwort (auch Eigennamen) und einem Grundwort
            // sowie Zusammensetzungen aus einem ungebeugten Eigenschaftswort und einem Grundwort.
            using (Assert.EnterMultipleScope()) {
                Assert_NormalizeStreetName("Thaliastraße");
                Assert_NormalizeStreetName("Aspernbrückengasse");
                Assert_NormalizeStreetName("Beethovengang");
                Assert_NormalizeStreetName("Hochstraße");
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Vienna_3_2() {
            // Zusammen schreibt man auch Verkehrsflächenbezeichnungen nach geografischen Namen, die auf -er enden,
            // oder wenn Ableitungen solcher Namen Personen bezeichnen.
            using (Assert.EnterMultipleScope()) {
                Assert_NormalizeStreetName("Hannovergasse");
                Assert_NormalizeStreetName("Lothringerstraße");
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Vienna_4() {
            // Getrennt und ohne Bindestrich schreibt man Zusammensetzungen eines Grundwortes mit einem gebeugten Eigenschaftswort
            // oder einer adjektivischen Ableitung eines Orts- oder Ländernamens auf -er oder -isch.
            using (Assert.EnterMultipleScope()) {
                Assert_NormalizeStreetName("Kurze Gasse");
                Assert_NormalizeStreetName("Währinger Straße");
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Vienna_5_1() {
            // Der Bindestrich steht, wenn die Bestimmung zum Grundwort aus mehreren Wörtern besteht.
            // Das kann bei Eigennamen und bei Bezeichnungen, die topographische Situationen wiedergeben der Fall sein.
            using (Assert.EnterMultipleScope()) {
                Assert_NormalizeStreetName("Johann-Nepomuk-Berger-Platz");
                Assert_NormalizeStreetName("Stock-im-Eisen-Platz");
                Assert_NormalizeStreetName("Laaer-Berg-Straße");
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Vienna_5_2() {
            // Der Bindestrich steht nicht, wenn die Bestimmung aus einer Wortgruppe besteht und kein Grundwort vorhanden ist,
            // oder in Fällen, in denen die Verbindung von Bestimmungs- und Grundwort durch ein Eigenschaftswort näher definiert wird.
            using (Assert.EnterMultipleScope()) {
                Assert_NormalizeStreetName("Am Hof");
                Assert_NormalizeStreetName("An den Langen Lüssen");
                Assert_NormalizeStreetName("Obere Donaustraße");
                Assert_NormalizeStreetName("Linke Wienzeile");
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Duden_D161() {
            // Das erste Wort eines Straßennamens wird großgeschrieben, ebenso alle zum Namen gehörenden Adjektive und Zahlwörter.
            using (Assert.EnterMultipleScope()) {
                Assert_NormalizeStreetName("Im Trutz");
                Assert_NormalizeStreetName("Am Alten Lindenbaum");
                Assert_NormalizeStreetName("Kleine Bockenheimer Straße");
                Assert_NormalizeStreetName("An den Drei Tannen");
                Assert_NormalizeStreetName("Von-Repkow-Platz");
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Duden_D162_1() {
            // Zusammengesetzte Straßennamen schreibt man zusammen.
            using (Assert.EnterMultipleScope()) {
                Assert_NormalizeStreetName("Bahnhofstraße");
                Assert_NormalizeStreetName("Rathausgasse");
                Assert_NormalizeStreetName("Bismarckring");
                Assert_NormalizeStreetName("Beethovenplatz");
                Assert_NormalizeStreetName("Schlossallee");
                Assert_NormalizeStreetName("Neumarkt");
                Assert_NormalizeStreetName("Langgasse");
                Assert_NormalizeStreetName("Hochstraße");
                Assert_NormalizeStreetName("Neuer Markt");
                Assert_NormalizeStreetName("Lange Gasse");
                Assert_NormalizeStreetName("Hohe Straße");
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Duden_D162_2() {
            // Getrennt schreibt man jedoch, wenn eine Ableitung auf -er von einem Orts- oder Ländernamen vorliegt.
            using (Assert.EnterMultipleScope()) {
                Assert_NormalizeStreetName("Leipziger Straße");
                Assert_NormalizeStreetName("Am Saarbrücker Tor");
                Assert_NormalizeStreetName("Thüringer Platz");
                Assert_NormalizeStreetName("Beethovenplatz");
                Assert_NormalizeStreetName("Kalk-Deutzer Straße");
                Assert_NormalizeStreetName("Bad Homburger Weg");
                Assert_NormalizeStreetName("Drusweilerweg");
                Assert_NormalizeStreetName("Römerplatz");
                Assert_NormalizeStreetName("Herderstraße");
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Duden_D162_3() {
            // Straßennamen, die mit mehrteiligen Namen zusammengesetzt sind, schreibt man mit Bindestrichen.
            using (Assert.EnterMultipleScope()) {
                Assert_NormalizeStreetName("Bertha-von-Suttner-Platz");
                Assert_NormalizeStreetName("Georg-Büchner-Straße");
                Assert_NormalizeStreetName("Kaiser-Friedrich-Ring");
                Assert_NormalizeStreetName("Van-Dyck-Weg");
                Assert_NormalizeStreetName("E.-T.-A.-Hoffmann-Straße");
                Assert_NormalizeStreetName("Berliner-Tor-Platz");
                Assert_NormalizeStreetName("Am St.-Georgs-Kirchhof");
                Assert_NormalizeStreetName("Bad-Kissingen-Straße");
                Assert_NormalizeStreetName("St.-Blasien-Weg");
                Assert_NormalizeStreetName("Bürgermeister-Dr.-Meier-Allee");
            }
        }

        [Test]
        public void Test_NormalizeStreetName_LocalityPrefix() {
            using (Assert.EnterMultipleScope()) {
                Assert_NormalizeStreetName("Groß");
                Assert_NormalizeStreetName("Großa");
                Assert_NormalizeStreetName("Großaigen");
                Assert_NormalizeStreetName("Kleinaigen");
                Assert_NormalizeStreetName("Großau");
                Assert_NormalizeStreetName("Kleinau");
                Assert_NormalizeStreetName("Kleinbaumgarten");
                Assert_NormalizeStreetName("Kleinberg");
                Assert_NormalizeStreetName("Groß Burgstall");
                Assert_NormalizeStreetName("Kleinburgstall");
                Assert_NormalizeStreetName("Kleindurlas");
                Assert_NormalizeStreetName("Großeberharts");
                Assert_NormalizeStreetName("Klein Eberharts");
                Assert_NormalizeStreetName("Großebersdorf");
                Assert_NormalizeStreetName("Kleinebersdorf");
                Assert_NormalizeStreetName("Großegg");
                Assert_NormalizeStreetName("Großeibenstein");
                Assert_NormalizeStreetName("Kleineibenstein");
                Assert_NormalizeStreetName("Großenberg");
                Assert_NormalizeStreetName("Großengersdorf");
                Assert_NormalizeStreetName("Klein-Engersdorf");
                Assert_NormalizeStreetName("Groß-Enzersdorf");
                Assert_NormalizeStreetName("Kleinenzersdorf");
                Assert_NormalizeStreetName("Klein-Erlauf");
                Assert_NormalizeStreetName("Kleinfeld");
                Assert_NormalizeStreetName("Großgerharts");
                Assert_NormalizeStreetName("Kleingerharts");
                Assert_NormalizeStreetName("Groß Gerungs");
                Assert_NormalizeStreetName("Kleingerungs");
                Assert_NormalizeStreetName("Großglobnitz");
                Assert_NormalizeStreetName("Kleingloms");
                Assert_NormalizeStreetName("Kleingöpfritz");
                Assert_NormalizeStreetName("Großgöttfritz");
                Assert_NormalizeStreetName("Kleingöttfritz");
                Assert_NormalizeStreetName("Großgraben");
                Assert_NormalizeStreetName("Kleingraben");
                Assert_NormalizeStreetName("Klein Gundholz");
                Assert_NormalizeStreetName("Kleinhadersdorf");
                Assert_NormalizeStreetName("Großhain");
                Assert_NormalizeStreetName("Kleinhain");
                Assert_NormalizeStreetName("Großharmanns");
                Assert_NormalizeStreetName("Kleinharmanns");
                Assert_NormalizeStreetName("Großharras");
                Assert_NormalizeStreetName("Klein-Harras");
                Assert_NormalizeStreetName("Großhaselbach");
                Assert_NormalizeStreetName("Großhaslau");
                Assert_NormalizeStreetName("Kleinhaslau");
                Assert_NormalizeStreetName("Kleinhaugsdorf");
                Assert_NormalizeStreetName("Großheinrichschlag");
                Assert_NormalizeStreetName("Klein-Heinrichschlag");
                Assert_NormalizeStreetName("Groß-Höbarten");
                Assert_NormalizeStreetName("Großhofen");
                Assert_NormalizeStreetName("Kleinhöflein");
                Assert_NormalizeStreetName("Großinzersdorf");
                Assert_NormalizeStreetName("Klein-Jetzelsdorf");
                Assert_NormalizeStreetName("Großkadolz");
                Assert_NormalizeStreetName("Kleinkadolz");
                Assert_NormalizeStreetName("Großkainraths");
                Assert_NormalizeStreetName("Kleinkamp");
                Assert_NormalizeStreetName("Kleinkirchberg");
                Assert_NormalizeStreetName("Großkrut");
                Assert_NormalizeStreetName("Großmaierhof");
                Assert_NormalizeStreetName("Kleinmaierhof");
                Assert_NormalizeStreetName("Klein-Mariazell");
                Assert_NormalizeStreetName("Groß Meinharts");
                Assert_NormalizeStreetName("Kleinmeinharts");
                Assert_NormalizeStreetName("Großmeiseldorf");
                Assert_NormalizeStreetName("Klein-Meiseldorf");
                Assert_NormalizeStreetName("Großmittel");
                Assert_NormalizeStreetName("Großmotten");
                Assert_NormalizeStreetName("Kleinmotten");
                Assert_NormalizeStreetName("Großmugl");
                Assert_NormalizeStreetName("Groß-Neusiedl");
                Assert_NormalizeStreetName("Klein-Neusiedl");
                Assert_NormalizeStreetName("Großnondorf");
                Assert_NormalizeStreetName("Kleinnondorf");
                Assert_NormalizeStreetName("Großotten");
                Assert_NormalizeStreetName("Kleinotten");
                Assert_NormalizeStreetName("Großpertenschlag");
                Assert_NormalizeStreetName("Kleinpertenschlag");
                Assert_NormalizeStreetName("Kleinpertholz");
                Assert_NormalizeStreetName("Klein-Pöchlarn");
                Assert_NormalizeStreetName("Kleinpoppen");
                Assert_NormalizeStreetName("Großpriel");
                Assert_NormalizeStreetName("Großprolling");
                Assert_NormalizeStreetName("Kleinprolling");
                Assert_NormalizeStreetName("Kleinraabs");
                Assert_NormalizeStreetName("Groß-Radischen");
                Assert_NormalizeStreetName("Klein-Radischen");
                Assert_NormalizeStreetName("Groß Raßberg");
                Assert_NormalizeStreetName("Großreichenbach");
                Assert_NormalizeStreetName("Kleinreichenbach");
                Assert_NormalizeStreetName("Großreinprechts");
                Assert_NormalizeStreetName("Klein Reinprechts");
                Assert_NormalizeStreetName("Klein-Reinprechtsdorf");
                Assert_NormalizeStreetName("Groß-Reipersdorf");
                Assert_NormalizeStreetName("Kleinreith");
                Assert_NormalizeStreetName("Großriedenthal");
                Assert_NormalizeStreetName("Kleinriedenthal");
                Assert_NormalizeStreetName("Kleinrötz");
                Assert_NormalizeStreetName("Großrupprechts");
                Assert_NormalizeStreetName("Klein-Ruprechts");
                Assert_NormalizeStreetName("Großrußbach");
                Assert_NormalizeStreetName("Großrust");
                Assert_NormalizeStreetName("Kleinrust");
                Assert_NormalizeStreetName("Groß-Schollach");
                Assert_NormalizeStreetName("Klein-Schollach");
                Assert_NormalizeStreetName("Großschönau");
                Assert_NormalizeStreetName("Kleinschönau");
                Assert_NormalizeStreetName("Kleinschönbichl");
                Assert_NormalizeStreetName("Groß-Schweinbarth");
                Assert_NormalizeStreetName("Kleinschweinbarth");
                Assert_NormalizeStreetName("Groß-Siegharts");
                Assert_NormalizeStreetName("Klein-Siegharts");
                Assert_NormalizeStreetName("Kleinsierndorf");
                Assert_NormalizeStreetName("Groß Sierning");
                Assert_NormalizeStreetName("Kleinsierning");
                Assert_NormalizeStreetName("Kleinsitzendorf");
                Assert_NormalizeStreetName("Großstelzendorf");
                Assert_NormalizeStreetName("Kleinstelzendorf");
                Assert_NormalizeStreetName("Kleinstetteldorf");
                Assert_NormalizeStreetName("Großtaxen");
                Assert_NormalizeStreetName("Kleintaxen");
                Assert_NormalizeStreetName("Klein-Ulrichschlag");
                Assert_NormalizeStreetName("Großweichselbach");
                Assert_NormalizeStreetName("Kleinweichselbach");
                Assert_NormalizeStreetName("Großweikersdorf");
                Assert_NormalizeStreetName("Kleinweikersdorf");
                Assert_NormalizeStreetName("Klein Weinberg");
                Assert_NormalizeStreetName("Großweißenbach");
                Assert_NormalizeStreetName("Kleinweißenbach");
                Assert_NormalizeStreetName("Großwetzdorf");
                Assert_NormalizeStreetName("Kleinwetzdorf");
                Assert_NormalizeStreetName("Klein Wetzles");
                Assert_NormalizeStreetName("Klein-Wien");
                Assert_NormalizeStreetName("Großwiesendorf");
                Assert_NormalizeStreetName("Kleinwiesendorf");
                Assert_NormalizeStreetName("Kleinwilfersdorf");
                Assert_NormalizeStreetName("Großwolfgers");
                Assert_NormalizeStreetName("Kleinwolfgers");
                Assert_NormalizeStreetName("Kleinwolfstein");
                Assert_NormalizeStreetName("Kleinwolkersdorf");
                Assert_NormalizeStreetName("Kleinzell");
                Assert_NormalizeStreetName("Kleinzwettl");
            }
        }

        [Test]
        public void Test_NormalizeStreetName_1_Simple() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("hauptstrasse"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstr."), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Bundesstraße"), Is.EqualTo("Bundesstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Wienerstraße"), Is.EqualTo("Wiener Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Brünnerstraße"), Is.EqualTo("Brünner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Straße des 1.Mai"), Is.EqualTo("Straße des 1. Mai"));
                Assert.That(Normalizer.NormalizeStreetName("Langgasse"), Is.EqualTo("Langgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Lange gasse"), Is.EqualTo("Lange Gasse"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_2_Advanced() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Triester Bundes Straße"), Is.EqualTo("Triester Bundesstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Triesterbundesstraße"), Is.EqualTo("Triester Bundesstraße"));

                Assert.That(Normalizer.NormalizeStreetName("St.-Agnes-Gasse"), Is.EqualTo("St.-Agnes-Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Sankt-Agnes-Gasse"), Is.EqualTo("St.-Agnes-Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Van der Nüll-Gasse"), Is.EqualTo("Van-der-Nüll-Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Korneuburger Straße"), Is.EqualTo("Korneuburger Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Habsburgerstraße"), Is.EqualTo("Habsburgerstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Unter den Linden"), Is.EqualTo("Unter den Linden"));

                Assert.That(Normalizer.NormalizeStreetName("Drei-Frauen-Weg"), Is.EqualTo("Drei-Frauen-Weg"));
                Assert.That(Normalizer.NormalizeStreetName("Drei-Häuser-Weg"), Is.EqualTo("Drei-Häuser-Weg"));
                Assert.That(Normalizer.NormalizeStreetName("Hohe-Wand-Straße"), Is.EqualTo("Hohe-Wand-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Hohewandstraße"), Is.EqualTo("Hohe-Wand-Straße"));

                Assert.That(Normalizer.NormalizeStreetName("St.Pöltnerstraße"), Is.EqualTo("St. Pöltner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("St.-Pöltner-straße"), Is.EqualTo("St. Pöltner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Wr.Neustädterstraße"), Is.EqualTo("Wiener Neustädter Straße"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_3_Nr() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Nr.", "Schöngrabern"), Is.EqualTo("Schöngrabern"));
                Assert.That(Normalizer.NormalizeStreetName("Nr.", "Immendorf"), Is.EqualTo("Immendorf"));
                Assert.That(Normalizer.NormalizeStreetName("Nr.", "Nappersdorf"), Is.EqualTo("Nappersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Nr.", "Mailberg"), Is.EqualTo("Mailberg"));
                Assert.That(Normalizer.NormalizeStreetName("Nr.", "Dürnleis"), Is.EqualTo("Dürnleis"));
                Assert.That(Normalizer.NormalizeStreetName("nr.", "Groß-Nondorf"), Is.EqualTo("Großnondorf"));
                Assert.That(Normalizer.NormalizeStreetName("nr.", "Obritz"), Is.EqualTo("Obritz"));
                Assert.That(Normalizer.NormalizeStreetName("nr.", "Grafenberg"), Is.EqualTo("Grafenberg"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_4_Special() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Kl.Reinprechtsdorf"), Is.EqualTo("Klein-Reinprechtsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Klein Reinprechtsdorf"), Is.EqualTo("Klein-Reinprechtsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Klein-Reinprechtsdorf"), Is.EqualTo("Klein-Reinprechtsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Kleinreinprechtsdorf"), Is.EqualTo("Klein-Reinprechtsdorf"));

                Assert.That(Normalizer.NormalizeStreetName("Gr.Inzersdorf"), Is.EqualTo("Großinzersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Groß Inzersdorf"), Is.EqualTo("Großinzersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Großinzersdorf"), Is.EqualTo("Großinzersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Groß-inzersdorf"), Is.EqualTo("Großinzersdorf"));

                Assert.That(Normalizer.NormalizeStreetName("Untere Hauptstraße in Tresdorf"), Is.EqualTo("Untere Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Ried Saubergen"), Is.EqualTo("Ried Saubergen"));

                Assert.That(Normalizer.NormalizeAddress("Winzerstraße 100, 2223 Martinsdorf"), Is.EqualTo("Winzerstraße 100"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_1XXX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Falkestraße"), Is.EqualTo("Falkestraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hafnergasse"), Is.EqualTo("Hafnergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hollandstraße"), Is.EqualTo("Hollandstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Holubstraße"), Is.EqualTo("Holubstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Radingerstraße"), Is.EqualTo("Radingerstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Rochusgasse"), Is.EqualTo("Rochusgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Sandwirtgasse"), Is.EqualTo("Sandwirtgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Schellinggasse"), Is.EqualTo("Schellinggasse"));
                Assert.That(Normalizer.NormalizeStreetName("Vorgartenstraße"), Is.EqualTo("Vorgartenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Guntherstraße"), Is.EqualTo("Guntherstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hardtmuthgasse"), Is.EqualTo("Hardtmuthgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Neubaugürtel"), Is.EqualTo("Neubaugürtel"));
                Assert.That(Normalizer.NormalizeStreetName("Weidmanngasse"), Is.EqualTo("Weidmanngasse"));
                Assert.That(Normalizer.NormalizeStreetName("Amtsstraße"), Is.EqualTo("Amtsstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Clessgasse"), Is.EqualTo("Clessgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Dirndlgasse"), Is.EqualTo("Dirndlgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Endemanngasse"), Is.EqualTo("Endemanngasse"));
                Assert.That(Normalizer.NormalizeStreetName("Freiheitsplatz"), Is.EqualTo("Freiheitsplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Grellgasse"), Is.EqualTo("Grellgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Herrenholzgasse"), Is.EqualTo("Herrenholzgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hochfeldstraße"), Is.EqualTo("Hochfeldstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Kinzerplatz"), Is.EqualTo("Kinzerplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Leopoldauer Platz"), Is.EqualTo("Leopoldauer Platz"));
                Assert.That(Normalizer.NormalizeStreetName("Nordmanngasse"), Is.EqualTo("Nordmanngasse"));
                Assert.That(Normalizer.NormalizeStreetName("Nussbaumweg"), Is.EqualTo("Nussbaumweg"));
                Assert.That(Normalizer.NormalizeStreetName("Rudolf-Virchow-Straße"), Is.EqualTo("Rudolf-Virchow-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Stammersdorfer Straße"), Is.EqualTo("Stammersdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Taglieberstraße"), Is.EqualTo("Taglieberstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Untere Weißgerber Straße"), Is.EqualTo("Untere Weißgerberstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Wallensteinstraße"), Is.EqualTo("Wallensteinstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Wehlistraße"), Is.EqualTo("Wehlistraße"));
                Assert.That(Normalizer.NormalizeStreetName("Weibelstraße"), Is.EqualTo("Weibelstraße"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_20XX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Alberndorf"), Is.EqualTo("Alberndorf"));
                Assert.That(Normalizer.NormalizeStreetName("Altbach"), Is.EqualTo("Altbach"));
                Assert.That(Normalizer.NormalizeStreetName("Altenmarkt"), Is.EqualTo("Altenmarkt"));
                Assert.That(Normalizer.NormalizeStreetName("Altstadt"), Is.EqualTo("Altstadt"));
                Assert.That(Normalizer.NormalizeStreetName("Am Anger"), Is.EqualTo("Am Anger"));
                Assert.That(Normalizer.NormalizeStreetName("Am Sandberg"), Is.EqualTo("Am Sandberg"));
                Assert.That(Normalizer.NormalizeStreetName("Aschendorf"), Is.EqualTo("Aschendorf"));
                Assert.That(Normalizer.NormalizeStreetName("Auggenthal"), Is.EqualTo("Auggenthal"));
                Assert.That(Normalizer.NormalizeStreetName("Berggasse"), Is.EqualTo("Berggasse"));
                Assert.That(Normalizer.NormalizeStreetName("Brunntalgasse"), Is.EqualTo("Brunntalgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Bundesstr."), Is.EqualTo("Bundesstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Bundesstraße"), Is.EqualTo("Bundesstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Deinzendorf"), Is.EqualTo("Deinzendorf"));
                Assert.That(Normalizer.NormalizeStreetName("Dürnleis"), Is.EqualTo("Dürnleis"));
                Assert.That(Normalizer.NormalizeStreetName("Eitzersthal"), Is.EqualTo("Eitzersthal"));
                Assert.That(Normalizer.NormalizeStreetName("Elsa-Brandström-Straße"), Is.EqualTo("Elsa-Brandström-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Feldgasse"), Is.EqualTo("Feldgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Florianigasse"), Is.EqualTo("Florianigasse"));
                Assert.That(Normalizer.NormalizeStreetName("Franz-Ecker-Siedlung"), Is.EqualTo("Franz-Ecker-Siedlung"));
                Assert.That(Normalizer.NormalizeStreetName("Franz-von-Zülow-Straße"), Is.EqualTo("Franz-von-Zülow-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Groß"), Is.EqualTo("Groß"));
                Assert.That(Normalizer.NormalizeStreetName("Großharras"), Is.EqualTo("Großharras"));
                Assert.That(Normalizer.NormalizeStreetName("Großnondorf"), Is.EqualTo("Großnondorf"));
                Assert.That(Normalizer.NormalizeStreetName("Gschmeidlerstraße"), Is.EqualTo("Gschmeidlerstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Guntersdorf"), Is.EqualTo("Guntersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Hadres"), Is.EqualTo("Hadres"));
                Assert.That(Normalizer.NormalizeStreetName("Haugsdorf"), Is.EqualTo("Haugsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptplatz"), Is.EqualTo("Hauptplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstr."), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstraße"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Heringgasse"), Is.EqualTo("Heringgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Herrengasse"), Is.EqualTo("Herrengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hollabrunner Straße"), Is.EqualTo("Hollabrunner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Holzgasse"), Is.EqualTo("Holzgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Immendorf"), Is.EqualTo("Immendorf"));
                Assert.That(Normalizer.NormalizeStreetName("Jahnstraße"), Is.EqualTo("Jahnstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Jetzelsdorf"), Is.EqualTo("Jetzelsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Josef-Fürnkranz-Siedlung"), Is.EqualTo("Josef-Fürnkranz-Siedlung"));
                Assert.That(Normalizer.NormalizeStreetName("Kalladorf"), Is.EqualTo("Kalladorf"));
                Assert.That(Normalizer.NormalizeStreetName("Kammersdorf"), Is.EqualTo("Kammersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Karlsdorf"), Is.EqualTo("Karlsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Kellergasse"), Is.EqualTo("Kellergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kellerstraße"), Is.EqualTo("Kellerstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchengasse"), Is.EqualTo("Kirchengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchensteig"), Is.EqualTo("Kirchensteig"));
                Assert.That(Normalizer.NormalizeStreetName("Kleedorf"), Is.EqualTo("Kleedorf"));
                Assert.That(Normalizer.NormalizeStreetName("Kleinhaugsdorf"), Is.EqualTo("Kleinhaugsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Kleinhöflein"), Is.EqualTo("Kleinhöflein"));
                Assert.That(Normalizer.NormalizeStreetName("Kleinriedenthal"), Is.EqualTo("Kleinriedenthal"));
                Assert.That(Normalizer.NormalizeStreetName("Kleinstelzendorf"), Is.EqualTo("Kleinstelzendorf"));
                Assert.That(Normalizer.NormalizeStreetName("Kleinstetteldorf"), Is.EqualTo("Kleinstetteldorf"));
                Assert.That(Normalizer.NormalizeStreetName("Kleinweikersdorf"), Is.EqualTo("Kleinweikersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Laaer Straße"), Is.EqualTo("Laaer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Leopold-Leuthner-Straße"), Is.EqualTo("Leopold-Leuthner-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Lindengasse"), Is.EqualTo("Lindengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Mailberg"), Is.EqualTo("Mailberg"));
                Assert.That(Normalizer.NormalizeStreetName("Maltesersiedlung"), Is.EqualTo("Maltesersiedlung"));
                Assert.That(Normalizer.NormalizeStreetName("Mariathal"), Is.EqualTo("Mariathal"));
                Assert.That(Normalizer.NormalizeStreetName("Merkersdorf"), Is.EqualTo("Merkersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Michael-Gruber-Weg"), Is.EqualTo("Michael-Gruber-Weg"));
                Assert.That(Normalizer.NormalizeStreetName("Mittergrabern"), Is.EqualTo("Mittergrabern"));
                Assert.That(Normalizer.NormalizeStreetName("Nappersdorf"), Is.EqualTo("Nappersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Neugasse"), Is.EqualTo("Neugasse"));
                Assert.That(Normalizer.NormalizeStreetName("Oberfellabrunn"), Is.EqualTo("Oberfellabrunn"));
                Assert.That(Normalizer.NormalizeStreetName("Obergrabern"), Is.EqualTo("Obergrabern"));
                Assert.That(Normalizer.NormalizeStreetName("Obermarkersdorf"), Is.EqualTo("Obermarkersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Oberort"), Is.EqualTo("Oberort"));
                Assert.That(Normalizer.NormalizeStreetName("Oberparschenbrunn"), Is.EqualTo("Oberparschenbrunn"));
                Assert.That(Normalizer.NormalizeStreetName("Obersteinabrunn"), Is.EqualTo("Obersteinabrunn"));
                Assert.That(Normalizer.NormalizeStreetName("Oberstinkenbrunn"), Is.EqualTo("Oberstinkenbrunn"));
                Assert.That(Normalizer.NormalizeStreetName("Obritz"), Is.EqualTo("Obritz"));
                Assert.That(Normalizer.NormalizeStreetName("Parkgasse"), Is.EqualTo("Parkgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Peigarten"), Is.EqualTo("Peigarten"));
                Assert.That(Normalizer.NormalizeStreetName("Pernersdorf"), Is.EqualTo("Pernersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Pfaffendorf"), Is.EqualTo("Pfaffendorf"));
                Assert.That(Normalizer.NormalizeStreetName("Pfarrgasse"), Is.EqualTo("Pfarrgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Puch"), Is.EqualTo("Puch"));
                Assert.That(Normalizer.NormalizeStreetName("Ragelsdorf"), Is.EqualTo("Ragelsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Retzer Straße"), Is.EqualTo("Retzer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Reucklstraße"), Is.EqualTo("Reucklstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Satzer Kellergasse"), Is.EqualTo("Satzer Kellergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Schalladorf"), Is.EqualTo("Schalladorf"));
                Assert.That(Normalizer.NormalizeStreetName("Schöngrabern"), Is.EqualTo("Schöngrabern"));
                Assert.That(Normalizer.NormalizeStreetName("Schulgasse"), Is.EqualTo("Schulgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Seefeld"), Is.EqualTo("Seefeld"));
                Assert.That(Normalizer.NormalizeStreetName("Seefeldergasse"), Is.EqualTo("Seefeldergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Seefeldgasse"), Is.EqualTo("Seefeldgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Siedlung"), Is.EqualTo("Siedlung"));
                Assert.That(Normalizer.NormalizeStreetName("Sonnleitenweg"), Is.EqualTo("Sonnleitenweg"));
                Assert.That(Normalizer.NormalizeStreetName("Stelzendorfer Straße"), Is.EqualTo("Stelzendorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Sterngasse"), Is.EqualTo("Sterngasse"));
                Assert.That(Normalizer.NormalizeStreetName("Suttenbrunn"), Is.EqualTo("Suttenbrunn"));
                Assert.That(Normalizer.NormalizeStreetName("Trumauer Straße"), Is.EqualTo("Trumauer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Tullner Straße"), Is.EqualTo("Tullner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Untergrub"), Is.EqualTo("Untergrub"));
                Assert.That(Normalizer.NormalizeStreetName("Untermarkersdorf"), Is.EqualTo("Untermarkersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Unterort"), Is.EqualTo("Unterort"));
                Assert.That(Normalizer.NormalizeStreetName("Unterparschenbrunn"), Is.EqualTo("Unterparschenbrunn"));
                Assert.That(Normalizer.NormalizeStreetName("Waitzendorf"), Is.EqualTo("Waitzendorf"));
                Assert.That(Normalizer.NormalizeStreetName("Watzelsdorf"), Is.EqualTo("Watzelsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Weinstraße"), Is.EqualTo("Weinstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Wiener Straße"), Is.EqualTo("Wiener Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Windpassing"), Is.EqualTo("Windpassing"));
                Assert.That(Normalizer.NormalizeStreetName("Winterseite"), Is.EqualTo("Winterseite"));
                Assert.That(Normalizer.NormalizeStreetName("Zeile"), Is.EqualTo("Zeile"));
                Assert.That(Normalizer.NormalizeStreetName("Zellerndorf"), Is.EqualTo("Zellerndorf"));
                Assert.That(Normalizer.NormalizeStreetName("Ziegelofengasse"), Is.EqualTo("Ziegelofengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Znaimer Straße"), Is.EqualTo("Znaimer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Zwingendorf"), Is.EqualTo("Zwingendorf"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_21XX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Adlergasse"), Is.EqualTo("Adlergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Alleegasse"), Is.EqualTo("Alleegasse"));
                Assert.That(Normalizer.NormalizeStreetName("Alter Markt"), Is.EqualTo("Alter Markt"));
                Assert.That(Normalizer.NormalizeStreetName("Am Anger"), Is.EqualTo("Am Anger"));
                Assert.That(Normalizer.NormalizeStreetName("Am Graben"), Is.EqualTo("Am Graben"));
                Assert.That(Normalizer.NormalizeStreetName("Am Rußbach"), Is.EqualTo("Am Rußbach"));
                Assert.That(Normalizer.NormalizeStreetName("Am Schulberg"), Is.EqualTo("Am Schulberg"));
                Assert.That(Normalizer.NormalizeStreetName("Am Stiegl"), Is.EqualTo("Am Stiegl"));
                Assert.That(Normalizer.NormalizeStreetName("Annagasse"), Is.EqualTo("Annagasse"));
                Assert.That(Normalizer.NormalizeStreetName("Antoniusgasse"), Is.EqualTo("Antoniusgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Bachgasse"), Is.EqualTo("Bachgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Badgasse"), Is.EqualTo("Badgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Bahnstraße"), Is.EqualTo("Bahnstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Bei der Gösslmühle"), Is.EqualTo("Bei der Gösslmühle"));
                Assert.That(Normalizer.NormalizeStreetName("Berggasse"), Is.EqualTo("Berggasse"));
                Assert.That(Normalizer.NormalizeStreetName("Birkengasse"), Is.EqualTo("Birkengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Bogenneusiedl"), Is.EqualTo("Bogenneusiedl"));
                Assert.That(Normalizer.NormalizeStreetName("Bründlgasse"), Is.EqualTo("Bründlgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Brunnengasse"), Is.EqualTo("Brunnengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Brünner Straße"), Is.EqualTo("Brünner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Dobermannsdorfer Straße"), Is.EqualTo("Dobermannsdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Dorfstraße"), Is.EqualTo("Dorfstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Dr.-Josef-Levit-Straße"), Is.EqualTo("Dr.-Josef-Levit-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Feldgasse"), Is.EqualTo("Feldgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Feldweg"), Is.EqualTo("Feldweg"));
                Assert.That(Normalizer.NormalizeStreetName("Große Zeile"), Is.EqualTo("Große Zeile"));
                Assert.That(Normalizer.NormalizeStreetName("Harrersdorf"), Is.EqualTo("Harrersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstr."), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstraße"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hausgärten"), Is.EqualTo("Hausgärten"));
                Assert.That(Normalizer.NormalizeStreetName("Hauskirchen"), Is.EqualTo("Hauskirchen"));
                Assert.That(Normalizer.NormalizeStreetName("Herrengasse"), Is.EqualTo("Herrengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hintere Dorfstraße"), Is.EqualTo("Hintere Dorfstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hintere Gasse"), Is.EqualTo("Hintere Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hochleitenstraße"), Is.EqualTo("Hochleitenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hödlgasse"), Is.EqualTo("Hödlgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hohe Schule"), Is.EqualTo("Hohe Schule"));
                Assert.That(Normalizer.NormalizeStreetName("Im Wiesthal"), Is.EqualTo("Im Wiesthal"));
                Assert.That(Normalizer.NormalizeStreetName("In Auern"), Is.EqualTo("In Auern"));
                Assert.That(Normalizer.NormalizeStreetName("In der Trift"), Is.EqualTo("In der Trift"));
                Assert.That(Normalizer.NormalizeStreetName("In Kirchbiegeln"), Is.EqualTo("In Kirchbiegeln"));
                Assert.That(Normalizer.NormalizeStreetName("Jochenhof"), Is.EqualTo("Jochenhof"));
                Assert.That(Normalizer.NormalizeStreetName("Johann-Degen-Gasse"), Is.EqualTo("Johann-Degen-Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Johannesgasse"), Is.EqualTo("Johannesgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kaiser-Franz-Josef-Platz"), Is.EqualTo("Kaiser-Franz-Josef-Platz"));
                Assert.That(Normalizer.NormalizeStreetName("Kaiser-Franz-Josef-Straße"), Is.EqualTo("Kaiser-Franz-Josef-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Kaiser-Josef-Straße"), Is.EqualTo("Kaiser-Josef-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Kapellenweg"), Is.EqualTo("Kapellenweg"));
                Assert.That(Normalizer.NormalizeStreetName("Karl-Katschthaler-Straße"), Is.EqualTo("Karl-Katschthaler-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Kellergasse"), Is.EqualTo("Kellergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchengasse"), Is.EqualTo("Kirchengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchenplatz"), Is.EqualTo("Kirchenplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchenstraße"), Is.EqualTo("Kirchenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Korneuburger Straße"), Is.EqualTo("Korneuburger Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Kreuttalstraße"), Is.EqualTo("Kreuttalstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Kühltal"), Is.EqualTo("Kühltal"));
                Assert.That(Normalizer.NormalizeStreetName("Lerchenaustraße"), Is.EqualTo("Lerchenaustraße"));
                Assert.That(Normalizer.NormalizeStreetName("Meierhofgasse"), Is.EqualTo("Meierhofgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Mühlratzstraße"), Is.EqualTo("Mühlratzstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Mühlstraße"), Is.EqualTo("Mühlstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Neuhäuselgasse"), Is.EqualTo("Neuhäuselgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Neusiedler Straße"), Is.EqualTo("Neusiedler Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Nussgasse"), Is.EqualTo("Nussgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Obere Hauptstraße"), Is.EqualTo("Obere Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Obersdorfer Straße"), Is.EqualTo("Obersdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Patzmannsdorf"), Is.EqualTo("Patzmannsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Pfarrgasse"), Is.EqualTo("Pfarrgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Pfösing"), Is.EqualTo("Pfösing"));
                Assert.That(Normalizer.NormalizeStreetName("Poysdorfer Straße"), Is.EqualTo("Poysdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Riedenthal"), Is.EqualTo("Riedenthal"));
                Assert.That(Normalizer.NormalizeStreetName("Rudolfgasse"), Is.EqualTo("Rudolfgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Rußbacher Straße"), Is.EqualTo("Rußbacher Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Rußbachgasse"), Is.EqualTo("Rußbachgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Rußbachstraße"), Is.EqualTo("Rußbachstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Schleinbacher Straße"), Is.EqualTo("Schleinbacher Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Schloßgasse"), Is.EqualTo("Schloßgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Schulgasse"), Is.EqualTo("Schulgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Schulstraße"), Is.EqualTo("Schulstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Schustergasse"), Is.EqualTo("Schustergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Seyringerstraße"), Is.EqualTo("Seyringer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Seyringer Straße"), Is.EqualTo("Seyringer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Sonnleiten"), Is.EqualTo("Sonnleiten"));
                Assert.That(Normalizer.NormalizeStreetName("Stammersdorfer Straße"), Is.EqualTo("Stammersdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Staribachergasse"), Is.EqualTo("Staribachergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Stiftgasse"), Is.EqualTo("Stiftgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Stronsdorf"), Is.EqualTo("Stronsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Traunfelder Straße"), Is.EqualTo("Traunfelder Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Tresdorfer Straße"), Is.EqualTo("Tresdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Umfahrungsstraße"), Is.EqualTo("Umfahrungsstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Untere Hauptstraße"), Is.EqualTo("Untere Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Untere Kellergasse"), Is.EqualTo("Untere Kellergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Unterolberndorf"), Is.EqualTo("Unterolberndorf"));
                Assert.That(Normalizer.NormalizeStreetName("Viehtrift"), Is.EqualTo("Viehtrift"));
                Assert.That(Normalizer.NormalizeStreetName("Viertelstraße"), Is.EqualTo("Viertelstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Waldgasse"), Is.EqualTo("Waldgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Waldstraße"), Is.EqualTo("Waldstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Waltersdorf"), Is.EqualTo("Waltersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Warendorfer Straße"), Is.EqualTo("Warendorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Wienerstr."), Is.EqualTo("Wiener Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Wiener Straße"), Is.EqualTo("Wiener Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Wilhelmsdorfer Str."), Is.EqualTo("Wilhelmsdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Wolkersdorfer Straße"), Is.EqualTo("Wolkersdorfer Straße"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_22XX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Ableidinger Straße"), Is.EqualTo("Ableidinger Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Alleeweg"), Is.EqualTo("Alleeweg"));
                Assert.That(Normalizer.NormalizeStreetName("Alte Marktstraße"), Is.EqualTo("Alte Marktstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Alter Markt"), Is.EqualTo("Alter Markt"));
                Assert.That(Normalizer.NormalizeStreetName("Am Anger"), Is.EqualTo("Am Anger"));
                Assert.That(Normalizer.NormalizeStreetName("Am Bach"), Is.EqualTo("Am Bach"));
                Assert.That(Normalizer.NormalizeStreetName("Am Berg"), Is.EqualTo("Am Berg"));
                Assert.That(Normalizer.NormalizeStreetName("Am Damm"), Is.EqualTo("Am Damm"));
                Assert.That(Normalizer.NormalizeStreetName("Am Friedhofberg"), Is.EqualTo("Am Friedhofberg"));
                Assert.That(Normalizer.NormalizeStreetName("Am Gießhübl"), Is.EqualTo("Am Gießhübl"));
                Assert.That(Normalizer.NormalizeStreetName("Am Hofstadl"), Is.EqualTo("Am Hofstadl"));
                Assert.That(Normalizer.NormalizeStreetName("Am Hundsturm"), Is.EqualTo("Am Hundsturm"));
                Assert.That(Normalizer.NormalizeStreetName("Am Königsberg"), Is.EqualTo("Am Königsberg"));
                Assert.That(Normalizer.NormalizeStreetName("Am Lüßfeld"), Is.EqualTo("Am Lüßfeld"));
                Assert.That(Normalizer.NormalizeStreetName("Am Rußbach"), Is.EqualTo("Am Rußbach"));
                Assert.That(Normalizer.NormalizeStreetName("Am Sportplatz"), Is.EqualTo("Am Sportplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Andreasgasse"), Is.EqualTo("Andreasgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Angern"), Is.EqualTo("Angern"));
                Assert.That(Normalizer.NormalizeStreetName("Angerner Straße"), Is.EqualTo("Angerner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Auersthaler Straße"), Is.EqualTo("Auersthaler Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Bachstraße"), Is.EqualTo("Bachstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Bahnallee"), Is.EqualTo("Bahnallee"));
                Assert.That(Normalizer.NormalizeStreetName("Bahngasse"), Is.EqualTo("Bahngasse"));
                Assert.That(Normalizer.NormalizeStreetName("Bahnhofstraße"), Is.EqualTo("Bahnhofstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Bahnsteiggasse"), Is.EqualTo("Bahnsteiggasse"));
                Assert.That(Normalizer.NormalizeStreetName("Bahnstraße"), Is.EqualTo("Bahnstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Baumgarten"), Is.EqualTo("Baumgarten"));
                Assert.That(Normalizer.NormalizeStreetName("Berggasse"), Is.EqualTo("Berggasse"));
                Assert.That(Normalizer.NormalizeStreetName("Blumenthal"), Is.EqualTo("Blumenthal"));
                Assert.That(Normalizer.NormalizeStreetName("Bockfließerstraße"), Is.EqualTo("Bockfließer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Bockfließer Straße"), Is.EqualTo("Bockfließer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Bodenzeile"), Is.EqualTo("Bodenzeile"));
                Assert.That(Normalizer.NormalizeStreetName("Bründlgasse"), Is.EqualTo("Bründlgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Brunnengasse"), Is.EqualTo("Brunnengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Brunnenplatz"), Is.EqualTo("Brunnenplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Brunnenstraße"), Is.EqualTo("Brunnenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Brunnenweg"), Is.EqualTo("Brunnenweg"));
                Assert.That(Normalizer.NormalizeStreetName("Brünner Straße"), Is.EqualTo("Brünner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Bürgthalstraße"), Is.EqualTo("Bürgthalstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Chimanistraße"), Is.EqualTo("Chimanistraße"));
                Assert.That(Normalizer.NormalizeStreetName("Dörfles"), Is.EqualTo("Dörfles"));
                Assert.That(Normalizer.NormalizeStreetName("Dörfleser Straße"), Is.EqualTo("Dörfleser Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Dorfstraße"), Is.EqualTo("Dorfstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Dr.-Peschl-Straße"), Is.EqualTo("Dr.-Peschl-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Dr.-Salzborn-Straße"), Is.EqualTo("Dr.-Salzborn-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Ebenthaler Straße"), Is.EqualTo("Ebenthaler Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Eibesbrunner Str."), Is.EqualTo("Eibesbrunner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Eibesbrunner Straße"), Is.EqualTo("Eibesbrunner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Eichhorn"), Is.EqualTo("Eichhorn"));
                Assert.That(Normalizer.NormalizeStreetName("Engersdorfer Straße"), Is.EqualTo("Engersdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Enzersfelderstraße"), Is.EqualTo("Enzersfelder Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Enzersfelder Straße"), Is.EqualTo("Enzersfelder Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Erdpreß"), Is.EqualTo("Erdpreß"));
                Assert.That(Normalizer.NormalizeStreetName("Fasangasse"), Is.EqualTo("Fasangasse"));
                Assert.That(Normalizer.NormalizeStreetName("Feldgasse"), Is.EqualTo("Feldgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Feldstraße"), Is.EqualTo("Feldstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Flurstraße"), Is.EqualTo("Flurstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Friedhofgasse"), Is.EqualTo("Friedhofgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Fürstengarten"), Is.EqualTo("Fürstengarten"));
                Assert.That(Normalizer.NormalizeStreetName("Gaiselberg"), Is.EqualTo("Gaiselberg"));
                Assert.That(Normalizer.NormalizeStreetName("Gänserndorfer Straße"), Is.EqualTo("Gänserndorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Gartengasse"), Is.EqualTo("Gartengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Gartenstadt"), Is.EqualTo("Gartenstadt"));
                Assert.That(Normalizer.NormalizeStreetName("Geergasse"), Is.EqualTo("Geergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Goldbergstraße"), Is.EqualTo("Goldbergstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Gösting"), Is.EqualTo("Gösting"));
                Assert.That(Normalizer.NormalizeStreetName("Graben"), Is.EqualTo("Graben"));
                Assert.That(Normalizer.NormalizeStreetName("Grabengasse"), Is.EqualTo("Grabengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Großebersdorfer Straße"), Is.EqualTo("Großebersdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Großinzersdorf"), Is.EqualTo("Großinzersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Groß-Inzersdorf"), Is.EqualTo("Großinzersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Grub"), Is.EqualTo("Grub"));
                Assert.That(Normalizer.NormalizeStreetName("Gruber Hauptstraße"), Is.EqualTo("Gruber Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Gschleifzeile"), Is.EqualTo("Gschleifzeile"));
                Assert.That(Normalizer.NormalizeStreetName("Hanggasse"), Is.EqualTo("Hanggasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hans-Wagner-Straße"), Is.EqualTo("Hans-Wagner-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Harraser Straße"), Is.EqualTo("Harraser Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptplatz"), Is.EqualTo("Hauptplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstraße"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Herrengasse"), Is.EqualTo("Herrengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hintere Bahnstraße"), Is.EqualTo("Hintere Bahnstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hochfeldstraße"), Is.EqualTo("Hochfeldstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hochleithengasse"), Is.EqualTo("Hochleithengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hochstraße"), Is.EqualTo("Hochstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hofkellergasse"), Is.EqualTo("Hofkellergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hofrat Döltl Straße"), Is.EqualTo("Hofrat-Döltl-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Hofrat-Döltl-Straße"), Is.EqualTo("Hofrat-Döltl-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Hofwiese"), Is.EqualTo("Hofwiese"));
                Assert.That(Normalizer.NormalizeStreetName("Hohenruppersdorf"), Is.EqualTo("Hohenruppersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Hohenruppersdorfer Straße"), Is.EqualTo("Hohenruppersdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Im Winkel"), Is.EqualTo("Im Winkel"));
                Assert.That(Normalizer.NormalizeStreetName("Jägerzeile"), Is.EqualTo("Jägerzeile"));
                Assert.That(Normalizer.NormalizeStreetName("Johannesgasse"), Is.EqualTo("Johannesgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Johann Steineck Gasse"), Is.EqualTo("Johann-Steineck-Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Josef-Seitz-Straße"), Is.EqualTo("Josef-Seitz-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Josef-Zuntich-Gasse"), Is.EqualTo("Josef-Zuntich-Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kastanienweg"), Is.EqualTo("Kastanienweg"));
                Assert.That(Normalizer.NormalizeStreetName("Kellerberg"), Is.EqualTo("Kellerberg"));
                Assert.That(Normalizer.NormalizeStreetName("Kellergasse"), Is.EqualTo("Kellergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kindergartengasse"), Is.EqualTo("Kindergartengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kindergartenstraße"), Is.EqualTo("Kindergartenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchengasse"), Is.EqualTo("Kirchengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchenplatz"), Is.EqualTo("Kirchenplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchenstraße"), Is.EqualTo("Kirchenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchfeldgasse"), Is.EqualTo("Kirchfeldgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kirschenstraße"), Is.EqualTo("Kirschenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Königsbrunner Straße"), Is.EqualTo("Königsbrunner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Korneuburger Straße"), Is.EqualTo("Korneuburger Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Kugelberg"), Is.EqualTo("Kugelberg"));
                Assert.That(Normalizer.NormalizeStreetName("Kurhausstraße"), Is.EqualTo("Kurhausstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Kurze Zeile"), Is.EqualTo("Kurze Zeile"));
                Assert.That(Normalizer.NormalizeStreetName("Kurzgasse"), Is.EqualTo("Kurzgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Landeshauptmann-Mayer-Platz"), Is.EqualTo("Landeshauptmann-Mayer-Platz"));
                Assert.That(Normalizer.NormalizeStreetName("Landstraße"), Is.EqualTo("Landstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Langstraße"), Is.EqualTo("Langstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Lindengasse"), Is.EqualTo("Lindengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Linke Vorstadt"), Is.EqualTo("Linke Vorstadt"));
                Assert.That(Normalizer.NormalizeStreetName("Loidesthaler Hauptstraße"), Is.EqualTo("Loidesthaler Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Manhartsbrunner Straße"), Is.EqualTo("Manhartsbrunner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Mannersdorf"), Is.EqualTo("Mannersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Marchfeldstraße"), Is.EqualTo("Marchfeldstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Marchgasse"), Is.EqualTo("Marchgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Maria-Lourd-Weg"), Is.EqualTo("Maria-Lourd-Weg"));
                Assert.That(Normalizer.NormalizeStreetName("Marktplatz"), Is.EqualTo("Marktplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Martinsdorf"), Is.EqualTo("Martinsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Matzner Straße"), Is.EqualTo("Matzner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Maustrenk"), Is.EqualTo("Maustrenk"));
                Assert.That(Normalizer.NormalizeStreetName("Meierhofgasse"), Is.EqualTo("Meierhofgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Milchhausstraße"), Is.EqualTo("Milchhausstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Mittelgasse"), Is.EqualTo("Mittelgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Mittelstraße"), Is.EqualTo("Mittelstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Mozartstraße"), Is.EqualTo("Mozartstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Mühlengasse"), Is.EqualTo("Mühlengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Mühlgasse"), Is.EqualTo("Mühlgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Mühlschüttelgasse"), Is.EqualTo("Mühlschüttelgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Mühlstraße"), Is.EqualTo("Mühlstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Münichsthaler Straße"), Is.EqualTo("Münichsthaler Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Neidlgasse"), Is.EqualTo("Neidlgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Neubaugasse"), Is.EqualTo("Neubaugasse"));
                Assert.That(Normalizer.NormalizeStreetName("Neue Gasse"), Is.EqualTo("Neue Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Neugasse"), Is.EqualTo("Neugasse"));
                Assert.That(Normalizer.NormalizeStreetName("Neustift"), Is.EqualTo("Neustift"));
                Assert.That(Normalizer.NormalizeStreetName("Niedersulz"), Is.EqualTo("Niedersulz"));
                Assert.That(Normalizer.NormalizeStreetName("Nordbahngasse"), Is.EqualTo("Nordbahngasse"));
                Assert.That(Normalizer.NormalizeStreetName("Obere Berggasse"), Is.EqualTo("Obere Berggasse"));
                Assert.That(Normalizer.NormalizeStreetName("Obere Hauptstraße"), Is.EqualTo("Obere Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Obersulz"), Is.EqualTo("Obersulz"));
                Assert.That(Normalizer.NormalizeStreetName("Ollersdorf"), Is.EqualTo("Ollersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Ollersdorfer Straße"), Is.EqualTo("Ollersdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Ortsstraße"), Is.EqualTo("Ortsstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Parkstraße"), Is.EqualTo("Parkstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Pfarrhofgasse"), Is.EqualTo("Pfarrhofgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Pillichsdorfer Straße"), Is.EqualTo("Pillichsdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Pirawarther Straße"), Is.EqualTo("Pirawarther Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Pratergasse"), Is.EqualTo("Pratergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Preußengasse"), Is.EqualTo("Preußengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Probstenzeil"), Is.EqualTo("Probstenzeil"));
                Assert.That(Normalizer.NormalizeStreetName("Quellenstraße"), Is.EqualTo("Quellenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Quentlußgasse"), Is.EqualTo("Quentlußgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Raggendorfer Straße"), Is.EqualTo("Raggendorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Raiffeisengasse"), Is.EqualTo("Raiffeisengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Rebschulgasse"), Is.EqualTo("Rebschulgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Reinberggasse"), Is.EqualTo("Reinberggasse"));
                Assert.That(Normalizer.NormalizeStreetName("Rennbahnweg"), Is.EqualTo("Rennbahnweg"));
                Assert.That(Normalizer.NormalizeStreetName("Resselgasse"), Is.EqualTo("Resselgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Rieslingweg"), Is.EqualTo("Rieslingweg"));
                Assert.That(Normalizer.NormalizeStreetName("Ritter-Zoppel-Straße"), Is.EqualTo("Ritter-Zoppel-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Robert-Stolz-Platz"), Is.EqualTo("Robert-Stolz-Platz"));
                Assert.That(Normalizer.NormalizeStreetName("Rochusgasse"), Is.EqualTo("Rochusgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Rohrweg"), Is.EqualTo("Rohrweg"));
                Assert.That(Normalizer.NormalizeStreetName("Rosenhügel"), Is.EqualTo("Rosenhügel"));
                Assert.That(Normalizer.NormalizeStreetName("Roßhaidgasse"), Is.EqualTo("Roßhaidgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Rudolfshöhe"), Is.EqualTo("Rudolfshöhe"));
                Assert.That(Normalizer.NormalizeStreetName("Runder Weg"), Is.EqualTo("Runder Weg"));
                Assert.That(Normalizer.NormalizeStreetName("Satzgasse"), Is.EqualTo("Satzgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Schloßgasse"), Is.EqualTo("Schloßgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Schubertgasse"), Is.EqualTo("Schubertgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Schulgasse"), Is.EqualTo("Schulgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Schulring"), Is.EqualTo("Schulring"));
                Assert.That(Normalizer.NormalizeStreetName("Schwämmäckergasse"), Is.EqualTo("Schwämmäckergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Schweinbarther Straße"), Is.EqualTo("Schweinbarther Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Sechshauser Straße"), Is.EqualTo("Sechshauser Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Seeweg"), Is.EqualTo("Seeweg"));
                Assert.That(Normalizer.NormalizeStreetName("Seifertgasse"), Is.EqualTo("Seifertgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Seyringer Straße"), Is.EqualTo("Seyringer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Sommerseite"), Is.EqualTo("Sommerseite"));
                Assert.That(Normalizer.NormalizeStreetName("Sommerzeile"), Is.EqualTo("Sommerzeile"));
                Assert.That(Normalizer.NormalizeStreetName("Sonnenberggasse"), Is.EqualTo("Sonnenberggasse"));
                Assert.That(Normalizer.NormalizeStreetName("Spannberger Straße"), Is.EqualTo("Spannberger Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Spitalgasse"), Is.EqualTo("Spitalgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Sportgasse"), Is.EqualTo("Sportgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Sportring"), Is.EqualTo("Sportring"));
                Assert.That(Normalizer.NormalizeStreetName("Stadtgrabengasse"), Is.EqualTo("Stadtgrabengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Stallberg"), Is.EqualTo("Stallberg"));
                Assert.That(Normalizer.NormalizeStreetName("Steinbergweg"), Is.EqualTo("Steinbergweg"));
                Assert.That(Normalizer.NormalizeStreetName("Stillfrieder Straße"), Is.EqualTo("Stillfrieder Straße"));
                Assert.That(Normalizer.NormalizeStreetName("St.-Laurentstraße"), Is.EqualTo("St.-Laurent-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Stögergasse"), Is.EqualTo("Stögergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Stripfing"), Is.EqualTo("Stripfing"));
                Assert.That(Normalizer.NormalizeStreetName("Strohgasse"), Is.EqualTo("Strohgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Sulzer Straße"), Is.EqualTo("Sulzer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Tallesbrunn"), Is.EqualTo("Tallesbrunn"));
                Assert.That(Normalizer.NormalizeStreetName("Tallesbrunner Straße"), Is.EqualTo("Tallesbrunner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Teichgasse"), Is.EqualTo("Teichgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Traungasse"), Is.EqualTo("Traungasse"));
                Assert.That(Normalizer.NormalizeStreetName("Traunstraße"), Is.EqualTo("Traunstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Untere Feldstraße"), Is.EqualTo("Untere Feldstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Untere Hauptstraße"), Is.EqualTo("Untere Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Untere Kellergasse"), Is.EqualTo("Untere Kellergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Villengasse"), Is.EqualTo("Villengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Vorstadt"), Is.EqualTo("Vorstadt"));
                Assert.That(Normalizer.NormalizeStreetName("Warthbergstraße"), Is.EqualTo("Warthbergstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Wassergasse"), Is.EqualTo("Wassergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Weidenbachgasse"), Is.EqualTo("Weidenbachgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Weinbergstraße"), Is.EqualTo("Weinbergstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Weingartenstraße"), Is.EqualTo("Weingartenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Weißer Kreuzweg"), Is.EqualTo("Weißer Kreuzweg"));
                Assert.That(Normalizer.NormalizeStreetName("Wienergasse"), Is.EqualTo("Wiener Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Wiener Straße"), Is.EqualTo("Wiener Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Wiesengasse"), Is.EqualTo("Wiesengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Wiesenweg"), Is.EqualTo("Wiesenweg"));
                Assert.That(Normalizer.NormalizeStreetName("Windisch-Baumgarten"), Is.EqualTo("Windisch-Baumgarten"));
                Assert.That(Normalizer.NormalizeStreetName("Wintergasse"), Is.EqualTo("Wintergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Winterseite"), Is.EqualTo("Winterseite"));
                Assert.That(Normalizer.NormalizeStreetName("Winterzeile"), Is.EqualTo("Winterzeile"));
                Assert.That(Normalizer.NormalizeStreetName("Winzergasse"), Is.EqualTo("Winzergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Winzerstraße"), Is.EqualTo("Winzerstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Winzerzeile"), Is.EqualTo("Winzerzeile"));
                Assert.That(Normalizer.NormalizeStreetName("Wolkersdorfer Straße"), Is.EqualTo("Wolkersdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Zeisselthal"), Is.EqualTo("Zeisselthal"));
                Assert.That(Normalizer.NormalizeStreetName("Zur Weide"), Is.EqualTo("Zur Weide"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_23XX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Hauptstraße"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hengstlstraße"), Is.EqualTo("Hengstlstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Möllersdorfer Straße"), Is.EqualTo("Möllersdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Mühlgasse"), Is.EqualTo("Mühlgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Paffstättner Straße"), Is.EqualTo("Paffstättner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Quellenstraße"), Is.EqualTo("Quellenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Raiffeisengasse"), Is.EqualTo("Raiffeisengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Richard"), Is.EqualTo("Richard"));
                Assert.That(Normalizer.NormalizeStreetName("Wiener Straße"), Is.EqualTo("Wiener Straße"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_24XX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Bahnstraße"), Is.EqualTo("Bahnstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Fischastraße"), Is.EqualTo("Fischastraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstraße"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hautpstraße"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchengasse"), Is.EqualTo("Kirchengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Pottendorfer Straße"), Is.EqualTo("Pottendorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Untere Ortsstrasse"), Is.EqualTo("Untere Ortsstraße"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_25XX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Albrechtsstraße"), Is.EqualTo("Albrechtsstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Albrechtstraße"), Is.EqualTo("Albrechtstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Am Felde"), Is.EqualTo("Am Felde"));
                Assert.That(Normalizer.NormalizeStreetName("Am Hang"), Is.EqualTo("Am Hang"));
                Assert.That(Normalizer.NormalizeStreetName("Annagasse"), Is.EqualTo("Annagasse"));
                Assert.That(Normalizer.NormalizeStreetName("Anton-Krenn-Straße"), Is.EqualTo("Anton-Krenn-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Anton-Rauch-Straße"), Is.EqualTo("Anton-Rauch-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Augasse"), Is.EqualTo("Augasse"));
                Assert.That(Normalizer.NormalizeStreetName("Augustinergasse"), Is.EqualTo("Augustinergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Aussiedlerhof"), Is.EqualTo("Aussiedlerhof"));
                Assert.That(Normalizer.NormalizeStreetName("Badnerberg"), Is.EqualTo("Badnerberg"));
                Assert.That(Normalizer.NormalizeStreetName("Badner Straße"), Is.EqualTo("Badner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Bahngasse"), Is.EqualTo("Bahngasse"));
                Assert.That(Normalizer.NormalizeStreetName("Bahnstraße"), Is.EqualTo("Bahnstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Bauernstraße"), Is.EqualTo("Bauernstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Berggasse"), Is.EqualTo("Berggasse"));
                Assert.That(Normalizer.NormalizeStreetName("Berndorfer Straße"), Is.EqualTo("Berndorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Billrothgasse"), Is.EqualTo("Billrothgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Boldrinigasse"), Is.EqualTo("Boldrinigasse"));
                Assert.That(Normalizer.NormalizeStreetName("Braitnerstraße"), Is.EqualTo("Braitnerstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Brandlgasse"), Is.EqualTo("Brandlgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Braungasse"), Is.EqualTo("Braungasse"));
                Assert.That(Normalizer.NormalizeStreetName("Breitegasse"), Is.EqualTo("Breitegasse"));
                Assert.That(Normalizer.NormalizeStreetName("Bremengasse"), Is.EqualTo("Bremengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Brunngasse"), Is.EqualTo("Brunngasse"));
                Assert.That(Normalizer.NormalizeStreetName("Dörflergasse"), Is.EqualTo("Dörflergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Dornauer Straße"), Is.EqualTo("Dornauer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Dr.-Dolp-Straße"), Is.EqualTo("Dr.-Dolp-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Dr.-Figl-Straße"), Is.EqualTo("Dr.-Figl-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Dr.Renner Platz"), Is.EqualTo("Dr.-Renner-Platz"));
                Assert.That(Normalizer.NormalizeStreetName("Dr.-Theodor-Körner-Straße"), Is.EqualTo("Dr.-Theodor-Körner-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Edgar Penzig Franz Str."), Is.EqualTo("Edgar-Penzig-Franz-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Edgar-Penzing-Franz-Straße"), Is.EqualTo("Edgar-Penzing-Franz-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Elisabethstraße"), Is.EqualTo("Elisabethstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Erzherzogin-Isabelle-Straße"), Is.EqualTo("Erzherzogin-Isabelle-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Fabriksstraße"), Is.EqualTo("Fabriksstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Falkstraße"), Is.EqualTo("Falkstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Feldgasse"), Is.EqualTo("Feldgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Ferdinand-Pichler-Gasse"), Is.EqualTo("Ferdinand-Pichler-Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Figlstraße"), Is.EqualTo("Figlstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Florianigasse"), Is.EqualTo("Florianigasse"));
                Assert.That(Normalizer.NormalizeStreetName("Flugfeldstraße"), Is.EqualTo("Flugfeldstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Franz-Borschek-Platz"), Is.EqualTo("Franz-Borschek-Platz"));
                Assert.That(Normalizer.NormalizeStreetName("Franz-Jonas-Straße"), Is.EqualTo("Franz-Jonas-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Friedrichstraße"), Is.EqualTo("Friedrichstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Gainfarnerstraße"), Is.EqualTo("Gainfarnerstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Gamingerberg"), Is.EqualTo("Gamingerberg"));
                Assert.That(Normalizer.NormalizeStreetName("Gartengasse"), Is.EqualTo("Gartengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Germergasse"), Is.EqualTo("Germergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Großauer Straße"), Is.EqualTo("Großauer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Gutenbrunner Straße"), Is.EqualTo("Gutenbrunner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Habsburgerstraße"), Is.EqualTo("Habsburgerstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Haidhofstraße"), Is.EqualTo("Haidhofstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Halsriegelstraße"), Is.EqualTo("Halsriegelstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hartergasse"), Is.EqualTo("Hartergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptplatz"), Is.EqualTo("Hauptplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptschulplatz"), Is.EqualTo("Hauptschulplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstr."), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstraße"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Heileggerstraße"), Is.EqualTo("Heileggerstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hernsteiner Straße"), Is.EqualTo("Hernsteiner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Heugasse"), Is.EqualTo("Heugasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hildegardgasse"), Is.EqualTo("Hildegardgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Jägerhausgasse"), Is.EqualTo("Jägerhausgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Johannesgasse"), Is.EqualTo("Johannesgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Josef Brunastraße"), Is.EqualTo("Josef-Bruna-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Josef-Bruna-Straße"), Is.EqualTo("Josef-Bruna-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Josefsthalerstraße"), Is.EqualTo("Josefsthaler Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Karl-Lange-Gasse"), Is.EqualTo("Karl-Lange-Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchengasse"), Is.EqualTo("Kirchengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchenplatz"), Is.EqualTo("Kirchenplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Klesheimstraße"), Is.EqualTo("Klesheimstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Kottingbrunnerweg"), Is.EqualTo("Kottingbrunner Weg"));
                Assert.That(Normalizer.NormalizeStreetName("Kurze Gasse"), Is.EqualTo("Kurze Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Leesdorfer Hauptstraße"), Is.EqualTo("Leesdorfer Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Leitzenbergerstraße"), Is.EqualTo("Leitzenbergerstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Leopold-Hörbiger-Straße"), Is.EqualTo("Leopold-Hörbiger-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Luydererstraße"), Is.EqualTo("Luydererstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Mariazellergasse"), Is.EqualTo("Mariazeller Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Melkergasse"), Is.EqualTo("Melkergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Millöckergasse"), Is.EqualTo("Millöckergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Mitterweg"), Is.EqualTo("Mitterweg"));
                Assert.That(Normalizer.NormalizeStreetName("Mühlfeldgasse"), Is.EqualTo("Mühlfeldgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Mühlgasse"), Is.EqualTo("Mühlgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Münchendorfer Straße"), Is.EqualTo("Münchendorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Neustiftgasse"), Is.EqualTo("Neustiftgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Obere Ödlitzer Straße"), Is.EqualTo("Obere Ödlitzer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Oberwaltersdorfer Straße"), Is.EqualTo("Oberwaltersdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Paffstättner Straße"), Is.EqualTo("Paffstättner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Palffygasse"), Is.EqualTo("Palffygasse"));
                Assert.That(Normalizer.NormalizeStreetName("Pelzgasse"), Is.EqualTo("Pelzgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Petzoldstraße"), Is.EqualTo("Petzoldstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Pottendorfer Straße"), Is.EqualTo("Pottendorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Raiffeisenplatz"), Is.EqualTo("Raiffeisenplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Resslgasse"), Is.EqualTo("Resslgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Rittergasse"), Is.EqualTo("Rittergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Rohrgasse"), Is.EqualTo("Rohrgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Römerberg"), Is.EqualTo("Römerberg"));
                Assert.That(Normalizer.NormalizeStreetName("Rudolf-Kaspar-Gasse"), Is.EqualTo("Rudolf-Kaspar-Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Rudolf-Zöllner-Gasse"), Is.EqualTo("Rudolf-Zöllner-Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Sängerhofgasse"), Is.EqualTo("Sängerhofgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Sängerhofstraße"), Is.EqualTo("Sängerhofstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Schloßallee"), Is.EqualTo("Schloßallee"));
                Assert.That(Normalizer.NormalizeStreetName("Schloßgasse"), Is.EqualTo("Schloßgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Schloßstraße"), Is.EqualTo("Schloßstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Schulgasse"), Is.EqualTo("Schulgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Schulstraße"), Is.EqualTo("Schulstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Schützengasse"), Is.EqualTo("Schützengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Siebenhauser Platz"), Is.EqualTo("Siebenhauser Platz"));
                Assert.That(Normalizer.NormalizeStreetName("Sollenauer Straße"), Is.EqualTo("Sollenauer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Spitalgasse"), Is.EqualTo("Spitalgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Sportplatzgasse"), Is.EqualTo("Sportplatzgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Steinfeldgasse"), Is.EqualTo("Steinfeldgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Stiftgasse"), Is.EqualTo("Stiftgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Teesdorfer Straße"), Is.EqualTo("Teesdorfer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Theodor Körnerstraße"), Is.EqualTo("Theodor-Körner-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Traiskirchner Straße"), Is.EqualTo("Traiskirchner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Tribuswinkler Straße"), Is.EqualTo("Tribuswinkler Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Triester Bundesstraße"), Is.EqualTo("Triester Bundesstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Triester Straße"), Is.EqualTo("Triester Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Trumauer Straße"), Is.EqualTo("Trumauer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Vöslauer Straße"), Is.EqualTo("Vöslauer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Waldandachtsstraße"), Is.EqualTo("Waldandachtsstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Waldgasse"), Is.EqualTo("Waldgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Wassergasse"), Is.EqualTo("Wassergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Weichselgasse"), Is.EqualTo("Weichselgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Weißgerberstraße"), Is.EqualTo("Weißgerberstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Wiener Neustädter Straße"), Is.EqualTo("Wiener Neustädter Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Wienersdorfer Hauptstraße"), Is.EqualTo("Wienersdorfer Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Wiener Straße"), Is.EqualTo("Wiener Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Wilhelmsring"), Is.EqualTo("Wilhelmsring"));
                Assert.That(Normalizer.NormalizeStreetName("Wörthgasse"), Is.EqualTo("Wörthgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Wüstegasse"), Is.EqualTo("Wüstegasse"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_26XX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Bahngasse"), Is.EqualTo("Bahngasse"));
                Assert.That(Normalizer.NormalizeStreetName("Blumauerstrasse"), Is.EqualTo("Blumauer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Edisongasse"), Is.EqualTo("Edisongasse"));
                Assert.That(Normalizer.NormalizeStreetName("Feldgasse"), Is.EqualTo("Feldgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptplatz"), Is.EqualTo("Hauptplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Industriestraße"), Is.EqualTo("Industriestraße"));
                Assert.That(Normalizer.NormalizeStreetName("Stiftergasse"), Is.EqualTo("Stiftergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Theresienfeld"), Is.EqualTo("Theresienfeld"));
                Assert.That(Normalizer.NormalizeStreetName("Wiener Neustädter Straße"), Is.EqualTo("Wiener Neustädter Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Wiener Straße"), Is.EqualTo("Wiener Straße"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_27XX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Badner Straße"), Is.EqualTo("Badner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Bahngasse"), Is.EqualTo("Bahngasse"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstraße"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hohewandstr."), Is.EqualTo("Hohe-Wand-Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchengasse"), Is.EqualTo("Kirchengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Puchberger Straße"), Is.EqualTo("Puchberger Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Staudiglgasse"), Is.EqualTo("Staudiglgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Teichplatz"), Is.EqualTo("Teichplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Viaduktstraße"), Is.EqualTo("Viaduktstraße"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_3XXX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Wintergasse"), Is.EqualTo("Wintergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Absberger Straße"), Is.EqualTo("Absberger Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstraße"), Is.EqualTo("Hauptstraße"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_37XX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Alte Postgasse"), Is.EqualTo("Alte Postgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Am Brunnen"), Is.EqualTo("Am Brunnen"));
                Assert.That(Normalizer.NormalizeStreetName("Am Schulberg"), Is.EqualTo("Am Schulberg"));
                Assert.That(Normalizer.NormalizeStreetName("Am Spitz"), Is.EqualTo("Am Spitz"));
                Assert.That(Normalizer.NormalizeStreetName("Am Tabor"), Is.EqualTo("Am Tabor"));
                Assert.That(Normalizer.NormalizeStreetName("Berggasse"), Is.EqualTo("Berggasse"));
                Assert.That(Normalizer.NormalizeStreetName("Bergstraße"), Is.EqualTo("Bergstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Birnzeile"), Is.EqualTo("Birnzeile"));
                Assert.That(Normalizer.NormalizeStreetName("Braunsdorf"), Is.EqualTo("Braunsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Dippersdorf"), Is.EqualTo("Dippersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Dorfstr."), Is.EqualTo("Dorfstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Dorfstraße"), Is.EqualTo("Dorfstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Ebersbrunn"), Is.EqualTo("Ebersbrunn"));
                Assert.That(Normalizer.NormalizeStreetName("Etzmannsdorf"), Is.EqualTo("Etzmannsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Fahndorf"), Is.EqualTo("Fahndorf"));
                Assert.That(Normalizer.NormalizeStreetName("Franz-Gilly-Gasse"), Is.EqualTo("Franz-Gilly-Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Frauendorf"), Is.EqualTo("Frauendorf"));
                Assert.That(Normalizer.NormalizeStreetName("Gaindorf"), Is.EqualTo("Gaindorf"));
                Assert.That(Normalizer.NormalizeStreetName("Gartenhaus"), Is.EqualTo("Gartenhaus"));
                Assert.That(Normalizer.NormalizeStreetName("Gettsdorf"), Is.EqualTo("Gettsdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Goggendorf"), Is.EqualTo("Goggendorf"));
                Assert.That(Normalizer.NormalizeStreetName("Großmeiseldorf"), Is.EqualTo("Großmeiseldorf"));
                Assert.That(Normalizer.NormalizeStreetName("Großreipersdorf"), Is.EqualTo("Groß-Reipersdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Großwetzdorf"), Is.EqualTo("Großwetzdorf"));
                Assert.That(Normalizer.NormalizeStreetName("Grübern"), Is.EqualTo("Grübern"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstraße"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hollabrunner Straße"), Is.EqualTo("Hollabrunner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Im Winkl"), Is.EqualTo("Im Winkl"));
                Assert.That(Normalizer.NormalizeStreetName("Kiblitz"), Is.EqualTo("Kiblitz"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchengasse"), Is.EqualTo("Kirchengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kurze Zeile"), Is.EqualTo("Kurze Zeile"));
                Assert.That(Normalizer.NormalizeStreetName("Lange Zeile"), Is.EqualTo("Lange Zeile"));
                Assert.That(Normalizer.NormalizeStreetName("Mühlbachstraße"), Is.EqualTo("Mühlbachstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Neustift"), Is.EqualTo("Neustift"));
                Assert.That(Normalizer.NormalizeStreetName("Neustiftgasse"), Is.EqualTo("Neustiftgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Niederschleinz"), Is.EqualTo("Niederschleinz"));
                Assert.That(Normalizer.NormalizeStreetName("Oberravelsbach"), Is.EqualTo("Oberravelsbach"));
                Assert.That(Normalizer.NormalizeStreetName("Oberthern"), Is.EqualTo("Oberthern"));
                Assert.That(Normalizer.NormalizeStreetName("Pfaffstetten"), Is.EqualTo("Pfaffstetten"));
                Assert.That(Normalizer.NormalizeStreetName("Radlbrunn"), Is.EqualTo("Radlbrunn"));
                Assert.That(Normalizer.NormalizeStreetName("Roggendorf"), Is.EqualTo("Roggendorf"));
                Assert.That(Normalizer.NormalizeStreetName("Roseldorf"), Is.EqualTo("Roseldorf"));
                Assert.That(Normalizer.NormalizeStreetName("Schmidatalstraße"), Is.EqualTo("Schmidatalstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Sitzenhart"), Is.EqualTo("Sitzenhart"));
                Assert.That(Normalizer.NormalizeStreetName("Stoitzendorf"), Is.EqualTo("Stoitzendorf"));
                Assert.That(Normalizer.NormalizeStreetName("Straning"), Is.EqualTo("Straning"));
                Assert.That(Normalizer.NormalizeStreetName("Tiefenthal"), Is.EqualTo("Tiefenthal"));
                Assert.That(Normalizer.NormalizeStreetName("Unterdürnbach"), Is.EqualTo("Unterdürnbach"));
                Assert.That(Normalizer.NormalizeStreetName("Unterthern"), Is.EqualTo("Unterthern"));
                Assert.That(Normalizer.NormalizeStreetName("Vorgartenstraße"), Is.EqualTo("Vorgartenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Wartberg"), Is.EqualTo("Wartberg"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_4XXX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Pernauer Straße"), Is.EqualTo("Pernauer Straße"));
            }
        }

        [Test]
        public void Test_NormalizeStreetName_Plz_71XX() {
            using (Assert.EnterMultipleScope()) {
                Assert.That(Normalizer.NormalizeStreetName("Am Lapp"), Is.EqualTo("Am Lapp"));
                Assert.That(Normalizer.NormalizeStreetName("Apetlonerstraße"), Is.EqualTo("Apetloner Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Bahnstraße"), Is.EqualTo("Bahnstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hauptstraße"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Hausgärten"), Is.EqualTo("Hausgärten"));
                Assert.That(Normalizer.NormalizeStreetName("Hautpstraße"), Is.EqualTo("Hauptstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Illmitzerstraße"), Is.EqualTo("Illmitzer Straße"));
                Assert.That(Normalizer.NormalizeStreetName("Kapellensiedlung"), Is.EqualTo("Kapellensiedlung"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchengasse"), Is.EqualTo("Kirchengasse"));
                Assert.That(Normalizer.NormalizeStreetName("Kirchenplatz"), Is.EqualTo("Kirchenplatz"));
                Assert.That(Normalizer.NormalizeStreetName("Kurze Gasse"), Is.EqualTo("Kurze Gasse"));
                Assert.That(Normalizer.NormalizeStreetName("Lerchenweg"), Is.EqualTo("Lerchenweg"));
                Assert.That(Normalizer.NormalizeStreetName("Marktstraße"), Is.EqualTo("Marktstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Mühlgasse"), Is.EqualTo("Mühlgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Preinergasse"), Is.EqualTo("Preinergasse"));
                Assert.That(Normalizer.NormalizeStreetName("Raiffeisenstraße"), Is.EqualTo("Raiffeisenstraße"));
                Assert.That(Normalizer.NormalizeStreetName("Schulgasse"), Is.EqualTo("Schulgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Sportplatzgasse"), Is.EqualTo("Sportplatzgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Triftgasse"), Is.EqualTo("Triftgasse"));
                Assert.That(Normalizer.NormalizeStreetName("Urbarialgasse"), Is.EqualTo("Urbarialgasse"));
            }
        }
    }
}