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] [Ignore("Not needed")] public void Test_NormalizeStreetName_Vienna_PlaceNames() { using (Assert.EnterMultipleScope()) { Assert_NormalizeStreetName("Aderklaaer Straße"); Assert_NormalizeStreetName("Alberner Straße"); Assert_NormalizeStreetName("Alsegger Straße"); Assert_NormalizeStreetName("Alser Straße"); Assert_NormalizeStreetName("Alte Laaer Straße"); Assert_NormalizeStreetName("Alter Wiener Weg"); Assert_NormalizeStreetName("Altmannsdorfer Straße"); Assert_NormalizeStreetName("Angerer Straße"); Assert_NormalizeStreetName("Atzgersdorfer Platz"); Assert_NormalizeStreetName("Atzgersdorfer Straße"); Assert_NormalizeStreetName("Basler Gasse"); Assert_NormalizeStreetName("Berliner Hof"); Assert_NormalizeStreetName("Bieler Hof"); Assert_NormalizeStreetName("Breitenfelder Gasse"); Assert_NormalizeStreetName("Breitenfurter Straße"); Assert_NormalizeStreetName("Breitenleer Straße"); Assert_NormalizeStreetName("Breitenseer Straße"); Assert_NormalizeStreetName("Brunner Straße"); Assert_NormalizeStreetName("Brünner Straße"); Assert_NormalizeStreetName("Donaufelder Straße"); Assert_NormalizeStreetName("Dornbacher Straße"); Assert_NormalizeStreetName("Dresdner Straße"); Assert_NormalizeStreetName("Eipeldauer Straße"); Assert_NormalizeStreetName("Erdberger Hof"); Assert_NormalizeStreetName("Erlaaer Platz"); Assert_NormalizeStreetName("Erlaaer Straße"); Assert_NormalizeStreetName("Floridsdorfer Markt"); Assert_NormalizeStreetName("Gerasdorfer Straße"); Assert_NormalizeStreetName("Gersthofer Markt"); Assert_NormalizeStreetName("Gersthofer Straße"); Assert_NormalizeStreetName("Grinzinger Steig"); Assert_NormalizeStreetName("Grinzinger Straße"); Assert_NormalizeStreetName("Groß-Enzersdorfer Straße"); Assert_NormalizeStreetName("Großer Ring"); Assert_NormalizeStreetName("Gumpendorfer Straße"); Assert_NormalizeStreetName("Hackinger Hof"); Assert_NormalizeStreetName("Hackinger Kai"); Assert_NormalizeStreetName("Hackinger Straße"); Assert_NormalizeStreetName("Hagenbrunner Straße"); Assert_NormalizeStreetName("Hainburger Straße"); Assert_NormalizeStreetName("Heiligenkreuzer Hof"); Assert_NormalizeStreetName("Heiligenstädter Straße"); Assert_NormalizeStreetName("Hetzendorfer Straße"); Assert_NormalizeStreetName("Hietzinger Kai"); Assert_NormalizeStreetName("Himberger Straße"); Assert_NormalizeStreetName("Hirschstettner Platz"); Assert_NormalizeStreetName("Hirschstettner Straße"); Assert_NormalizeStreetName("Hoher Markt"); Assert_NormalizeStreetName("Hütteldorfer Straße"); Assert_NormalizeStreetName("Inzersdorfer Straße"); Assert_NormalizeStreetName("Jedlersdorfer Platz"); Assert_NormalizeStreetName("Jedlersdorfer Straße"); Assert_NormalizeStreetName("Jedleseer Straße"); Assert_NormalizeStreetName("Josefstädter Straße"); Assert_NormalizeStreetName("Kagraner Platz"); Assert_NormalizeStreetName("Kahlenberger Straße"); Assert_NormalizeStreetName("Kaiser-Ebersdorfer Straße"); Assert_NormalizeStreetName("Kalksburger Straße"); Assert_NormalizeStreetName("Kaltenleutgebner Straße"); Assert_NormalizeStreetName("Kärntner Ring"); Assert_NormalizeStreetName("Kärntner Straße"); Assert_NormalizeStreetName("Klausenburger Straße"); Assert_NormalizeStreetName("Klederinger Straße"); Assert_NormalizeStreetName("Kleiner Ring"); Assert_NormalizeStreetName("Klosterneuburger Straße"); Assert_NormalizeStreetName("Krakauer Straße"); Assert_NormalizeStreetName("Lainzer Straße"); Assert_NormalizeStreetName("Langenzersdorfer Straße"); Assert_NormalizeStreetName("Laxenburger Straße"); Assert_NormalizeStreetName("Leipziger Platz"); Assert_NormalizeStreetName("Leipziger Straße"); Assert_NormalizeStreetName("Leopoldauer Platz"); Assert_NormalizeStreetName("Leopoldauer Straße"); Assert_NormalizeStreetName("Leopoldsdorfer Straße"); Assert_NormalizeStreetName("Lerchenfelder Straße"); Assert_NormalizeStreetName("Lichtentaler Gasse"); Assert_NormalizeStreetName("Liechtenwerder Platz"); Assert_NormalizeStreetName("Liesinger Platz"); Assert_NormalizeStreetName("Linzer Straße"); Assert_NormalizeStreetName("Lundenburger Gasse"); Assert_NormalizeStreetName("Mannswörther Straße"); Assert_NormalizeStreetName("Mariabrunner Straße"); Assert_NormalizeStreetName("Mariahilfer Straße"); Assert_NormalizeStreetName("Marx-Meidlinger Straße"); Assert_NormalizeStreetName("Matzleinsdorfer Platz"); Assert_NormalizeStreetName("Meidlinger Markt"); Assert_NormalizeStreetName("Meidlinger Platzl"); Assert_NormalizeStreetName("Meinhartsdorfer Gasse"); Assert_NormalizeStreetName("Metzleinstaler Hof"); Assert_NormalizeStreetName("Mölker Gasse"); Assert_NormalizeStreetName("Mölker Steig"); Assert_NormalizeStreetName("Neuer Markt"); Assert_NormalizeStreetName("Neulerchenfelder Straße"); Assert_NormalizeStreetName("Neuwaldegger Straße"); Assert_NormalizeStreetName("Nikolsburger Gasse"); Assert_NormalizeStreetName("Nikolsdorfer Gasse"); Assert_NormalizeStreetName("Nottendorfer Gasse"); Assert_NormalizeStreetName("Nußdorfer Markt"); Assert_NormalizeStreetName("Nußdorfer Platz"); Assert_NormalizeStreetName("Nußdorfer Straße"); Assert_NormalizeStreetName("Ober-Laaer Platz"); Assert_NormalizeStreetName("Oberlaaer Straße"); Assert_NormalizeStreetName("Ödenburger Straße"); Assert_NormalizeStreetName("Ottakringer Platz"); Assert_NormalizeStreetName("Ottakringer Straße"); Assert_NormalizeStreetName("Passage Mariahilfer Straße"); Assert_NormalizeStreetName("Passage Triester Straße"); Assert_NormalizeStreetName("Passauer Platz"); Assert_NormalizeStreetName("Penzinger Straße"); Assert_NormalizeStreetName("Perchtoldsdorfer Straße"); Assert_NormalizeStreetName("Pottendorfer Straße"); Assert_NormalizeStreetName("Pottendorfer Weg"); Assert_NormalizeStreetName("Pötzleinsdorfer Straße"); Assert_NormalizeStreetName("Prager Straße"); Assert_NormalizeStreetName("Preßburger Gasse"); Assert_NormalizeStreetName("Rabensburger Straße"); Assert_NormalizeStreetName("Reinprechtsdorfer Straße"); Assert_NormalizeStreetName("Rodauner Straße"); Assert_NormalizeStreetName("Roßauer Gasse"); Assert_NormalizeStreetName("Roter Hof"); Assert_NormalizeStreetName("Rothneusiedler Gasse"); Assert_NormalizeStreetName("Salmannsdorfer Straße"); Assert_NormalizeStreetName("Schloßhofer Straße"); Assert_NormalizeStreetName("Schönbrunner Straße"); Assert_NormalizeStreetName("Schwarzer Weg"); Assert_NormalizeStreetName("Sechshauser Straße"); Assert_NormalizeStreetName("Seyringer Straße"); Assert_NormalizeStreetName("Sieveringer Straße"); Assert_NormalizeStreetName("Simmeringer Platz"); Assert_NormalizeStreetName("Speisinger Straße"); Assert_NormalizeStreetName("Spittelauer Platz"); Assert_NormalizeStreetName("Stadlauer Straße"); Assert_NormalizeStreetName("Stammersdorfer Straße"); Assert_NormalizeStreetName("Stockholmer Platz"); Assert_NormalizeStreetName("Strebersdorfer Platz"); Assert_NormalizeStreetName("Strebersdorfer Straße"); Assert_NormalizeStreetName("St. Veiter Tor"); Assert_NormalizeStreetName("Südtiroler Hof"); Assert_NormalizeStreetName("Südtiroler Platz"); Assert_NormalizeStreetName("Süßenbrunner Platz"); Assert_NormalizeStreetName("Süßenbrunner Straße"); Assert_NormalizeStreetName("Tiroler Gasse"); Assert_NormalizeStreetName("Triester Straße"); Assert_NormalizeStreetName("Tyrnauer Gasse"); Assert_NormalizeStreetName("Unterlaaer Platz"); Assert_NormalizeStreetName("Unter-Laaer Straße"); Assert_NormalizeStreetName("Unter-Meidlinger Straße"); Assert_NormalizeStreetName("Vösendorfer Straße"); Assert_NormalizeStreetName("Wachauer Hof"); Assert_NormalizeStreetName("Wagramer Straße"); Assert_NormalizeStreetName("Währinger Straße"); Assert_NormalizeStreetName("Weimarer Straße"); Assert_NormalizeStreetName("Weinhauser Gasse"); Assert_NormalizeStreetName("Wiener Gasse"); Assert_NormalizeStreetName("Willendorfer Gasse"); Assert_NormalizeStreetName("Znaimer Gasse"); Assert_NormalizeStreetName("Zürcher Hof"); } } [Test] [Ignore("Not needed")] public void Test_NormalizeStreetName_Vienna_PersonalNames() { using (Assert.EnterMultipleScope()) { Assert_NormalizeStreetName("Haidequerstraße"); Assert_NormalizeStreetName("Achamergasse"); Assert_NormalizeStreetName("Achtergasse"); Assert_NormalizeStreetName("Achtundvierzigerplatz"); Assert_NormalizeStreetName("Ackerweg"); Assert_NormalizeStreetName("Adambergergasse"); Assert_NormalizeStreetName("Afrikanergasse"); Assert_NormalizeStreetName("Ahornergasse"); Assert_NormalizeStreetName("Aignerstraße"); Assert_NormalizeStreetName("Albrechtsbergergasse"); Assert_NormalizeStreetName("Altdorferstraße"); Assert_NormalizeStreetName("Altmüttergasse"); Assert_NormalizeStreetName("Alxingergasse"); Assert_NormalizeStreetName("Amalgergasse"); Assert_NormalizeStreetName("Ambergergasse"); Assert_NormalizeStreetName("Ammerweg"); Assert_NormalizeStreetName("Ampferergasse"); Assert_NormalizeStreetName("Amstergasse"); Assert_NormalizeStreetName("Andergasse"); Assert_NormalizeStreetName("Andlergasse"); Assert_NormalizeStreetName("Angergasse"); Assert_NormalizeStreetName("Angermayergasse"); Assert_NormalizeStreetName("Anglerweg"); Assert_NormalizeStreetName("Anningerweg"); Assert_NormalizeStreetName("Anreitergasse"); Assert_NormalizeStreetName("Anzengrubergasse"); Assert_NormalizeStreetName("Anzengruberstraße"); Assert_NormalizeStreetName("Arbeitergasse"); Assert_NormalizeStreetName("Arbeiterstrandbadstraße"); Assert_NormalizeStreetName("Argauergasse"); Assert_NormalizeStreetName("Argentinierstraße"); Assert_NormalizeStreetName("Armbrustergasse"); Assert_NormalizeStreetName("Arnezhoferstraße"); Assert_NormalizeStreetName("Arthaberplatz"); Assert_NormalizeStreetName("Arzbergergasse"); Assert_NormalizeStreetName("Aschergasse"); Assert_NormalizeStreetName("Aßmayergasse"); Assert_NormalizeStreetName("Ateliergasse"); Assert_NormalizeStreetName("Atzlergasse"); Assert_NormalizeStreetName("Auckenthalergasse"); Assert_NormalizeStreetName("Auenbruggergasse"); Assert_NormalizeStreetName("Auernheimergasse"); Assert_NormalizeStreetName("Augustinerstraße"); Assert_NormalizeStreetName("Autokaderstraße"); Assert_NormalizeStreetName("Babenbergerstraße"); Assert_NormalizeStreetName("Bacherplatz"); Assert_NormalizeStreetName("Bäckerstraße"); Assert_NormalizeStreetName("Bambergergasse"); Assert_NormalizeStreetName("Baumeistergasse"); Assert_NormalizeStreetName("Baumergasse"); Assert_NormalizeStreetName("Beerhof"); Assert_NormalizeStreetName("Belghofergasse"); Assert_NormalizeStreetName("Berglergasse"); Assert_NormalizeStreetName("Bergmillergasse"); Assert_NormalizeStreetName("Bernreiterplatz"); Assert_NormalizeStreetName("Bessemerstraße"); Assert_NormalizeStreetName("Biberstraße"); Assert_NormalizeStreetName("Biedergasse"); Assert_NormalizeStreetName("Billergasse"); Assert_NormalizeStreetName("Bindergasse"); Assert_NormalizeStreetName("Birneckergasse"); Assert_NormalizeStreetName("Birnersteig"); Assert_NormalizeStreetName("Bleichergasse"); Assert_NormalizeStreetName("Bleichsteinerstraße"); Assert_NormalizeStreetName("Blumauergasse"); Assert_NormalizeStreetName("Blümelhubergasse"); Assert_NormalizeStreetName("Blumenbindergasse"); Assert_NormalizeStreetName("Bockbergergasse"); Assert_NormalizeStreetName("Bockkellerstraße"); Assert_NormalizeStreetName("Bodmergasse"); Assert_NormalizeStreetName("Bognergasse"); Assert_NormalizeStreetName("Börnergasse"); Assert_NormalizeStreetName("Bösendorferstraße"); Assert_NormalizeStreetName("Böttgerweg"); Assert_NormalizeStreetName("Brammergasse"); Assert_NormalizeStreetName("Brandmayergasse"); Assert_NormalizeStreetName("Brauergasse"); Assert_NormalizeStreetName("Braumüllergasse"); Assert_NormalizeStreetName("Bräunerstraße"); Assert_NormalizeStreetName("Braunhubergasse"); Assert_NormalizeStreetName("Brausewettergasse"); Assert_NormalizeStreetName("Brechergasse"); Assert_NormalizeStreetName("Breiteneckergasse"); Assert_NormalizeStreetName("Brennergasse"); Assert_NormalizeStreetName("Bretschneidergasse"); Assert_NormalizeStreetName("Breuergasse"); Assert_NormalizeStreetName("Brosamergasse"); Assert_NormalizeStreetName("Brucknerstraße"); Assert_NormalizeStreetName("Brunnerweg"); Assert_NormalizeStreetName("Brunngraberhof"); Assert_NormalizeStreetName("Bubergasse"); Assert_NormalizeStreetName("Buchbindergasse"); Assert_NormalizeStreetName("Büchnergasse"); Assert_NormalizeStreetName("Büdingergasse"); Assert_NormalizeStreetName("Bühlerweg"); Assert_NormalizeStreetName("Bundesländerhof"); Assert_NormalizeStreetName("Bundesländerplatz"); Assert_NormalizeStreetName("Bürgergasse"); Assert_NormalizeStreetName("Bürgermeisterweg"); Assert_NormalizeStreetName("Büttnergasse"); Assert_NormalizeStreetName("Camillianergasse"); Assert_NormalizeStreetName("Carlbergergasse"); Assert_NormalizeStreetName("Chrudnergasse"); Assert_NormalizeStreetName("Claretinergasse"); Assert_NormalizeStreetName("Computerstraße"); Assert_NormalizeStreetName("Cooperweg"); Assert_NormalizeStreetName("Cuviergasse"); Assert_NormalizeStreetName("Czubergasse"); Assert_NormalizeStreetName("Dadlergasse"); Assert_NormalizeStreetName("Daffingerstraße"); Assert_NormalizeStreetName("Dammäckergasse"); Assert_NormalizeStreetName("Danhausergasse"); Assert_NormalizeStreetName("Danningerweg"); Assert_NormalizeStreetName("Danzergasse"); Assert_NormalizeStreetName("Daringergasse"); Assert_NormalizeStreetName("Dattlergasse"); Assert_NormalizeStreetName("Deckergasse"); Assert_NormalizeStreetName("Defreggerstraße"); Assert_NormalizeStreetName("Deißenhofergasse"); Assert_NormalizeStreetName("Demmergasse"); Assert_NormalizeStreetName("Dempschergasse"); Assert_NormalizeStreetName("Denglergasse"); Assert_NormalizeStreetName("Dettergasse"); Assert_NormalizeStreetName("Deublergasse"); Assert_NormalizeStreetName("Deutschmeisterhof"); Assert_NormalizeStreetName("Deutschmeisterplatz"); Assert_NormalizeStreetName("Diesterweggasse"); Assert_NormalizeStreetName("Dißlergasse"); Assert_NormalizeStreetName("Ditscheinergasse"); Assert_NormalizeStreetName("Döblergasse"); Assert_NormalizeStreetName("Döblerhofstraße"); Assert_NormalizeStreetName("Doderergasse"); Assert_NormalizeStreetName("Doeltergasse"); Assert_NormalizeStreetName("Dollinergasse"); Assert_NormalizeStreetName("Dominikanergasse"); Assert_NormalizeStreetName("Dommayergasse"); Assert_NormalizeStreetName("Donhofergasse"); Assert_NormalizeStreetName("Donnergasse"); Assert_NormalizeStreetName("Dopplergasse"); Assert_NormalizeStreetName("Dorfmeistergasse"); Assert_NormalizeStreetName("Dornerplatz"); Assert_NormalizeStreetName("Dorotheergasse"); Assert_NormalizeStreetName("Dragonerweg"); Assert_NormalizeStreetName("Drechslergasse"); Assert_NormalizeStreetName("Dreherstraße"); Assert_NormalizeStreetName("Dumreichergasse"); Assert_NormalizeStreetName("Dunklergasse"); Assert_NormalizeStreetName("Dürauergasse"); Assert_NormalizeStreetName("Dürergasse"); Assert_NormalizeStreetName("Dürrnbacherstraße"); Assert_NormalizeStreetName("Ebendorferstraße"); Assert_NormalizeStreetName("Eberstorferweg"); Assert_NormalizeStreetName("Eckmüllnergasse"); Assert_NormalizeStreetName("Eckpergasse"); Assert_NormalizeStreetName("Edergasse"); Assert_NormalizeStreetName("Effingergasse"); Assert_NormalizeStreetName("Eibesbrunnergasse"); Assert_NormalizeStreetName("Eibesbrunnerweg"); Assert_NormalizeStreetName("Eichfeldergasse"); Assert_NormalizeStreetName("Eiflerhof"); Assert_NormalizeStreetName("Einsiedlergasse"); Assert_NormalizeStreetName("Einsiedlerplatz"); Assert_NormalizeStreetName("Einzingergasse"); Assert_NormalizeStreetName("Eisenmengergasse"); Assert_NormalizeStreetName("Eisnergasse"); Assert_NormalizeStreetName("Eitelbergergasse"); Assert_NormalizeStreetName("Eitnergasse"); Assert_NormalizeStreetName("Elfingerweg"); Assert_NormalizeStreetName("Ellmingergasse"); Assert_NormalizeStreetName("Elsbeergasse"); Assert_NormalizeStreetName("Elßlergasse"); Assert_NormalizeStreetName("Elsterweg"); Assert_NormalizeStreetName("Empergergasse"); Assert_NormalizeStreetName("Endergasse"); Assert_NormalizeStreetName("Endlichergasse"); Assert_NormalizeStreetName("Ennemosergasse"); Assert_NormalizeStreetName("Enzelsbergergasse"); Assert_NormalizeStreetName("Enzingergasse"); Assert_NormalizeStreetName("Erbacherweg"); Assert_NormalizeStreetName("Etschnerweg"); Assert_NormalizeStreetName("Exenbergerweg"); Assert_NormalizeStreetName("Eyblergasse"); Assert_NormalizeStreetName("Eyslergasse"); Assert_NormalizeStreetName("Fabergasse"); Assert_NormalizeStreetName("Faberhof"); Assert_NormalizeStreetName("Faistauergasse"); Assert_NormalizeStreetName("Fallmerayerweg"); Assert_NormalizeStreetName("Falschlehnerweg"); Assert_NormalizeStreetName("Fännergasse"); Assert_NormalizeStreetName("Färbergasse"); Assert_NormalizeStreetName("Faßziehergasse"); Assert_NormalizeStreetName("Fechtergasse"); Assert_NormalizeStreetName("Fehlingergasse"); Assert_NormalizeStreetName("Feilergasse"); Assert_NormalizeStreetName("Feitsingergasse"); Assert_NormalizeStreetName("Felberstraße"); Assert_NormalizeStreetName("Felbigergasse"); Assert_NormalizeStreetName("Felderstraße"); Assert_NormalizeStreetName("Feldkellergasse"); Assert_NormalizeStreetName("Fellnergasse"); Assert_NormalizeStreetName("Felmayergasse"); Assert_NormalizeStreetName("Ferchenbauergasse"); Assert_NormalizeStreetName("Ferchergasse"); Assert_NormalizeStreetName("Feßlergasse"); Assert_NormalizeStreetName("Fiakerplatz"); Assert_NormalizeStreetName("Fichtnergasse"); Assert_NormalizeStreetName("Fillgradergasse"); Assert_NormalizeStreetName("Fimbingergasse"); Assert_NormalizeStreetName("Fingergasse"); Assert_NormalizeStreetName("Finsterergasse"); Assert_NormalizeStreetName("Fischergasse"); Assert_NormalizeStreetName("Fischerstiege"); Assert_NormalizeStreetName("Fischingergasse"); Assert_NormalizeStreetName("Fischottergasse"); Assert_NormalizeStreetName("Flandorferweg"); Assert_NormalizeStreetName("Fleischhackergasse"); Assert_NormalizeStreetName("Fliederhof"); Assert_NormalizeStreetName("Fliederweg"); Assert_NormalizeStreetName("Fliegerweg"); Assert_NormalizeStreetName("Flötzersteig"); Assert_NormalizeStreetName("Forchheimergasse"); Assert_NormalizeStreetName("Förstergasse"); Assert_NormalizeStreetName("Forstmeistergasse"); Assert_NormalizeStreetName("Forstnergasse"); Assert_NormalizeStreetName("Forstnerhof"); Assert_NormalizeStreetName("Fourniergasse"); Assert_NormalizeStreetName("Franziskanerplatz"); Assert_NormalizeStreetName("Frauenfelderstraße"); Assert_NormalizeStreetName("Fraungrubergasse"); Assert_NormalizeStreetName("Freisingergasse"); Assert_NormalizeStreetName("Freumbichlerweg"); Assert_NormalizeStreetName("Frimbergergasse"); Assert_NormalizeStreetName("Fuchsthallergasse"); Assert_NormalizeStreetName("Fügergasse"); Assert_NormalizeStreetName("Fundergasse"); Assert_NormalizeStreetName("Fürstenhoferstraße"); Assert_NormalizeStreetName("Furtmüllerhof"); Assert_NormalizeStreetName("Furtwänglerplatz"); Assert_NormalizeStreetName("Füsterweg"); Assert_NormalizeStreetName("Fütterergasse"); Assert_NormalizeStreetName("Gabelsbergergasse"); Assert_NormalizeStreetName("Gadnergasse"); Assert_NormalizeStreetName("Gallmeyergasse"); Assert_NormalizeStreetName("Gamandergasse"); Assert_NormalizeStreetName("Ganghofergasse"); Assert_NormalizeStreetName("Ganglbauergasse"); Assert_NormalizeStreetName("Gänsbachergasse"); Assert_NormalizeStreetName("Gansterergasse"); Assert_NormalizeStreetName("Garbergasse"); Assert_NormalizeStreetName("Gärtnergasse"); Assert_NormalizeStreetName("Gärtnerstraße"); Assert_NormalizeStreetName("Gassergasse"); Assert_NormalizeStreetName("Gasteigergasse"); Assert_NormalizeStreetName("Gatterederstraße"); Assert_NormalizeStreetName("Gattergasse"); Assert_NormalizeStreetName("Gaulhofergasse"); Assert_NormalizeStreetName("Gaullachergasse"); Assert_NormalizeStreetName("Gebauergasse"); Assert_NormalizeStreetName("Geblergasse"); Assert_NormalizeStreetName("Geigergasse"); Assert_NormalizeStreetName("Geistingergasse"); Assert_NormalizeStreetName("Gelbsilberweg"); Assert_NormalizeStreetName("Gerbergasse"); Assert_NormalizeStreetName("Geringergasse"); Assert_NormalizeStreetName("Gerspergasse"); Assert_NormalizeStreetName("Gerstmayerweg"); Assert_NormalizeStreetName("Gerstnerstraße"); Assert_NormalizeStreetName("Geyergasse"); Assert_NormalizeStreetName("Geymüllergasse"); Assert_NormalizeStreetName("Geyschlägergasse"); Assert_NormalizeStreetName("Gfrornergasse"); Assert_NormalizeStreetName("Gierstergasse"); Assert_NormalizeStreetName("Gießergasse"); Assert_NormalizeStreetName("Giffingergasse"); Assert_NormalizeStreetName("Gigergasse"); Assert_NormalizeStreetName("Gillingerweg"); Assert_NormalizeStreetName("Ginsterweg"); Assert_NormalizeStreetName("Giselhergasse"); Assert_NormalizeStreetName("Gitlbauergasse"); Assert_NormalizeStreetName("Glasauergasse"); Assert_NormalizeStreetName("Glasergasse"); Assert_NormalizeStreetName("Gobergasse"); Assert_NormalizeStreetName("Goldammerweg"); Assert_NormalizeStreetName("Goldhammergasse"); Assert_NormalizeStreetName("Göllnergasse"); Assert_NormalizeStreetName("Göttweihergasse"); Assert_NormalizeStreetName("Grabnergasse"); Assert_NormalizeStreetName("Gradingergasse"); Assert_NormalizeStreetName("Graedenergasse"); Assert_NormalizeStreetName("Graedenerweg"); Assert_NormalizeStreetName("Gräffergasse"); Assert_NormalizeStreetName("Granergasse"); Assert_NormalizeStreetName("Grasbergergasse"); Assert_NormalizeStreetName("Grassingerhof"); Assert_NormalizeStreetName("Gredlerstraße"); Assert_NormalizeStreetName("Greinergasse"); Assert_NormalizeStreetName("Greiseneckergasse"); Assert_NormalizeStreetName("Grenadierweg"); Assert_NormalizeStreetName("Grenzackerstraße"); Assert_NormalizeStreetName("Greyledergasse"); Assert_NormalizeStreetName("Griesingergasse"); Assert_NormalizeStreetName("Grießergasse"); Assert_NormalizeStreetName("Grillparzerstraße"); Assert_NormalizeStreetName("Grobeckergasse"); Assert_NormalizeStreetName("Grohnergasse"); Assert_NormalizeStreetName("Großbauerstraße"); Assert_NormalizeStreetName("Grosserweg"); Assert_NormalizeStreetName("Grubergasse"); Assert_NormalizeStreetName("Grüllemeiergasse"); Assert_NormalizeStreetName("Grünangergasse"); Assert_NormalizeStreetName("Grundäckergasse"); Assert_NormalizeStreetName("Gschwandnergasse"); Assert_NormalizeStreetName("Gsellhofergasse"); Assert_NormalizeStreetName("Gundackergasse"); Assert_NormalizeStreetName("Günthergasse"); Assert_NormalizeStreetName("Guntherstraße"); Assert_NormalizeStreetName("Guschelbauergasse"); Assert_NormalizeStreetName("Gusenleithnergasse"); Assert_NormalizeStreetName("Gussenbauergasse"); Assert_NormalizeStreetName("Gusterergasse"); Assert_NormalizeStreetName("Gutraterplatz"); Assert_NormalizeStreetName("Haberergasse"); Assert_NormalizeStreetName("Habichergasse"); Assert_NormalizeStreetName("Habsburgergasse"); Assert_NormalizeStreetName("Hackergasse"); Assert_NormalizeStreetName("Hackhofergasse"); Assert_NormalizeStreetName("Haebergasse"); Assert_NormalizeStreetName("Haffnergasse"); Assert_NormalizeStreetName("Hafnergasse"); Assert_NormalizeStreetName("Hafnersteig"); Assert_NormalizeStreetName("Hagenmüllergasse"); Assert_NormalizeStreetName("Haidackergasse"); Assert_NormalizeStreetName("Haidingergasse"); Assert_NormalizeStreetName("Haizingergasse"); Assert_NormalizeStreetName("Halbrittergasse"); Assert_NormalizeStreetName("Hallergasse"); Assert_NormalizeStreetName("Hamburgerstraße"); Assert_NormalizeStreetName("Hannovergasse"); Assert_NormalizeStreetName("Hannovermarkt"); Assert_NormalizeStreetName("Hanreitergasse"); Assert_NormalizeStreetName("Hanselmayergasse"); Assert_NormalizeStreetName("Hantzenbergergasse"); Assert_NormalizeStreetName("Harlacherweg"); Assert_NormalizeStreetName("Hartäckerstraße"); Assert_NormalizeStreetName("Harthausergasse"); Assert_NormalizeStreetName("Haselbrunnerstraße"); Assert_NormalizeStreetName("Hasenauerstraße"); Assert_NormalizeStreetName("Hasibederstraße"); Assert_NormalizeStreetName("Haslingergasse"); Assert_NormalizeStreetName("Hasnergasse"); Assert_NormalizeStreetName("Hasnerstraße"); Assert_NormalizeStreetName("Haspelmeistergasse"); Assert_NormalizeStreetName("Haspingergasse"); Assert_NormalizeStreetName("Haspingerplatz"); Assert_NormalizeStreetName("Hassingergasse"); Assert_NormalizeStreetName("Haßlwanderweg"); Assert_NormalizeStreetName("Haßreitersteig"); Assert_NormalizeStreetName("Hauerweg"); Assert_NormalizeStreetName("Haugerstraße"); Assert_NormalizeStreetName("Haulerstraße"); Assert_NormalizeStreetName("Hausergasse"); Assert_NormalizeStreetName("Haydlergasse"); Assert_NormalizeStreetName("Hedorferhof"); Assert_NormalizeStreetName("Hegergasse"); Assert_NormalizeStreetName("Heimkehrergasse"); Assert_NormalizeStreetName("Heistergasse"); Assert_NormalizeStreetName("Helferstorferstraße"); Assert_NormalizeStreetName("Hellmesbergergasse"); Assert_NormalizeStreetName("Helmergasse"); Assert_NormalizeStreetName("Henslerstraße"); Assert_NormalizeStreetName("Herderplatz"); Assert_NormalizeStreetName("Hernstorferstraße"); Assert_NormalizeStreetName("Herthergasse"); Assert_NormalizeStreetName("Herweghhof"); Assert_NormalizeStreetName("Hettenkofergasse"); Assert_NormalizeStreetName("Heubergergasse"); Assert_NormalizeStreetName("Hillerstraße"); Assert_NormalizeStreetName("Hilschergasse"); Assert_NormalizeStreetName("Himmelmutterweg"); Assert_NormalizeStreetName("Hintzerstraße"); Assert_NormalizeStreetName("Hochstettergasse"); Assert_NormalizeStreetName("Hochwassergasse"); Assert_NormalizeStreetName("Hofbauergasse"); Assert_NormalizeStreetName("Hofenedergasse"); Assert_NormalizeStreetName("Höfergasse"); Assert_NormalizeStreetName("Hoferstiege"); Assert_NormalizeStreetName("Hofferplatz"); Assert_NormalizeStreetName("Hoffingergasse"); Assert_NormalizeStreetName("Hoffmeistergasse"); Assert_NormalizeStreetName("Hofjägerstraße"); Assert_NormalizeStreetName("Hofzinsergasse"); Assert_NormalizeStreetName("Högelmüllergasse"); Assert_NormalizeStreetName("Hohenauergasse"); Assert_NormalizeStreetName("Hollergasse"); Assert_NormalizeStreetName("Hollitzergasse"); Assert_NormalizeStreetName("Holochergasse"); Assert_NormalizeStreetName("Holzergasse"); Assert_NormalizeStreetName("Holzhausergasse"); Assert_NormalizeStreetName("Holzmeistergasse"); Assert_NormalizeStreetName("Höpflergasse"); Assert_NormalizeStreetName("Hopfnerweg"); Assert_NormalizeStreetName("Höritzergasse"); Assert_NormalizeStreetName("Hubergasse"); Assert_NormalizeStreetName("Hueberhof"); Assert_NormalizeStreetName("Hühnersteig"); Assert_NormalizeStreetName("Hühnersteigstraße"); Assert_NormalizeStreetName("Hustergasse"); Assert_NormalizeStreetName("Hüttenbrennergasse"); Assert_NormalizeStreetName("Hüttergasse"); Assert_NormalizeStreetName("Hutterplatz"); Assert_NormalizeStreetName("Illnerstraße"); Assert_NormalizeStreetName("Ispergasse"); Assert_NormalizeStreetName("Jägerstätterstraße"); Assert_NormalizeStreetName("Jägerstraße"); Assert_NormalizeStreetName("Jägerweggasse"); Assert_NormalizeStreetName("Jakobergasse"); Assert_NormalizeStreetName("Jaunerstraße"); Assert_NormalizeStreetName("Jedletzbergerstraße"); Assert_NormalizeStreetName("Jeitnerweg"); Assert_NormalizeStreetName("Jennerplatz"); Assert_NormalizeStreetName("Joachimsthalerplatz"); Assert_NormalizeStreetName("Johannitergasse"); Assert_NormalizeStreetName("Jörgerstraße"); Assert_NormalizeStreetName("Jungbauerweg"); Assert_NormalizeStreetName("Jupiterweg"); Assert_NormalizeStreetName("Jüptnergasse"); Assert_NormalizeStreetName("Kahlergasse"); Assert_NormalizeStreetName("Kaisersteiggasse"); Assert_NormalizeStreetName("Kaiserstraße"); Assert_NormalizeStreetName("Kallbrunnergasse"); Assert_NormalizeStreetName("Kalsergasse"); Assert_NormalizeStreetName("Kammerergasse"); Assert_NormalizeStreetName("Kantnergasse"); Assert_NormalizeStreetName("Kapellergasse"); Assert_NormalizeStreetName("Kärchergasse"); Assert_NormalizeStreetName("Kargergasse"); Assert_NormalizeStreetName("Karlingergasse"); Assert_NormalizeStreetName("Karmelitergasse"); Assert_NormalizeStreetName("Karmeliterhofgasse"); Assert_NormalizeStreetName("Karmelitermarkt"); Assert_NormalizeStreetName("Karmeliterplatz"); Assert_NormalizeStreetName("Kärntnertorpassage"); Assert_NormalizeStreetName("Karthäuserstraße"); Assert_NormalizeStreetName("Kaschauerplatz"); Assert_NormalizeStreetName("Käsmayergasse"); Assert_NormalizeStreetName("Kastnergasse"); Assert_NormalizeStreetName("Kastnersiedlung"); Assert_NormalizeStreetName("Katzlergasse"); Assert_NormalizeStreetName("Kauergasse"); Assert_NormalizeStreetName("Kauerhof"); Assert_NormalizeStreetName("Kefergasse"); Assert_NormalizeStreetName("Keinergasse"); Assert_NormalizeStreetName("Keißlergasse"); Assert_NormalizeStreetName("Keldorfergasse"); Assert_NormalizeStreetName("Kendlerstraße"); Assert_NormalizeStreetName("Kennergasse"); Assert_NormalizeStreetName("Keplergasse"); Assert_NormalizeStreetName("Keplerplatz"); Assert_NormalizeStreetName("Keplingergasse"); Assert_NormalizeStreetName("Kermaunerweg"); Assert_NormalizeStreetName("Kerschensteinergasse"); Assert_NormalizeStreetName("Kestnerweg"); Assert_NormalizeStreetName("Ketzergasse"); Assert_NormalizeStreetName("KGA Anningerweg"); Assert_NormalizeStreetName("Khemetergasse"); Assert_NormalizeStreetName("Khevenhüllerstraße"); Assert_NormalizeStreetName("Kienmayergasse"); Assert_NormalizeStreetName("Kiesewettergasse"); Assert_NormalizeStreetName("Kieslerweg"); Assert_NormalizeStreetName("Kiningergasse"); Assert_NormalizeStreetName("Kinzerplatz"); Assert_NormalizeStreetName("Kirchmeyergasse"); Assert_NormalizeStreetName("Klagergasse"); Assert_NormalizeStreetName("Klaghofergasse"); Assert_NormalizeStreetName("Klammergasse"); Assert_NormalizeStreetName("Klebindergasse"); Assert_NormalizeStreetName("Klettenhofergasse"); Assert_NormalizeStreetName("Kliebergasse"); Assert_NormalizeStreetName("Kliergasse"); Assert_NormalizeStreetName("Klingerstraße"); Assert_NormalizeStreetName("Kloepferstraße"); Assert_NormalizeStreetName("Klostergasse"); Assert_NormalizeStreetName("Klugerhof"); Assert_NormalizeStreetName("Kneidingergasse"); Assert_NormalizeStreetName("Knollergasse"); Assert_NormalizeStreetName("Kobingergasse"); Assert_NormalizeStreetName("Koflergasse"); Assert_NormalizeStreetName("Köglergasse"); Assert_NormalizeStreetName("Köhlergasse"); Assert_NormalizeStreetName("Kolbetergasse"); Assert_NormalizeStreetName("Kollergasse"); Assert_NormalizeStreetName("Kollmayergasse"); Assert_NormalizeStreetName("Köllnerhofgasse"); Assert_NormalizeStreetName("Königsklostergasse"); Assert_NormalizeStreetName("Koppreitergasse"); Assert_NormalizeStreetName("Korbergasse"); Assert_NormalizeStreetName("Körberstraße"); Assert_NormalizeStreetName("Körblergasse"); Assert_NormalizeStreetName("Korianderweg"); Assert_NormalizeStreetName("Körnergasse"); Assert_NormalizeStreetName("Korntheuergasse"); Assert_NormalizeStreetName("Koschakergasse"); Assert_NormalizeStreetName("Koschiergasse"); Assert_NormalizeStreetName("Köstlergasse"); Assert_NormalizeStreetName("Kramergasse"); Assert_NormalizeStreetName("Kramreitergasse"); Assert_NormalizeStreetName("Krautackergasse"); Assert_NormalizeStreetName("Kreitnergasse"); Assert_NormalizeStreetName("Kremsergasse"); Assert_NormalizeStreetName("Kreutzingergasse"); Assert_NormalizeStreetName("Krieglergasse"); Assert_NormalizeStreetName("Kriehubergasse"); Assert_NormalizeStreetName("Kronawettergasse"); Assert_NormalizeStreetName("Kroneggergasse"); Assert_NormalizeStreetName("Krotenthallergasse"); Assert_NormalizeStreetName("Krötzlergasse"); Assert_NormalizeStreetName("Krugerstraße"); Assert_NormalizeStreetName("Krügerweg"); Assert_NormalizeStreetName("Krütznergasse"); Assert_NormalizeStreetName("Küchelbeckergasse"); Assert_NormalizeStreetName("Kuffnergasse"); Assert_NormalizeStreetName("Kummergasse"); Assert_NormalizeStreetName("Künstlergasse"); Assert_NormalizeStreetName("Kupelwiesergasse"); Assert_NormalizeStreetName("Kupfergasse"); Assert_NormalizeStreetName("Kürassierweg"); Assert_NormalizeStreetName("Kürnbergergasse"); Assert_NormalizeStreetName("Kürschnergasse"); Assert_NormalizeStreetName("Kurzbauergasse"); Assert_NormalizeStreetName("Kutschkergasse"); Assert_NormalizeStreetName("Kutschkermarkt"); Assert_NormalizeStreetName("Kuttelwascherweg"); Assert_NormalizeStreetName("Labersteig"); Assert_NormalizeStreetName("Lackierergasse"); Assert_NormalizeStreetName("Lacknergasse"); Assert_NormalizeStreetName("Lagergasse"); Assert_NormalizeStreetName("Laimäckergasse"); Assert_NormalizeStreetName("Lainergasse"); Assert_NormalizeStreetName("Landsteinergasse"); Assert_NormalizeStreetName("Langackergasse"); Assert_NormalizeStreetName("Langauergasse"); Assert_NormalizeStreetName("Lannerstraße"); Assert_NormalizeStreetName("Lassingleithnerplatz"); Assert_NormalizeStreetName("Laufbergergasse"); Assert_NormalizeStreetName("Lautenschlägergasse"); Assert_NormalizeStreetName("Lavaterstraße"); Assert_NormalizeStreetName("Layerweg"); Assert_NormalizeStreetName("Leberstraße"); Assert_NormalizeStreetName("Leberweg"); Assert_NormalizeStreetName("Lebingergasse"); Assert_NormalizeStreetName("Lebnergasse"); Assert_NormalizeStreetName("Lecherweg"); Assert_NormalizeStreetName("Lechnerstraße"); Assert_NormalizeStreetName("Lechthalergasse"); Assert_NormalizeStreetName("Lederergasse"); Assert_NormalizeStreetName("Ledererhof"); Assert_NormalizeStreetName("Lehnergasse"); Assert_NormalizeStreetName("Leinmüllergasse"); Assert_NormalizeStreetName("Leitermayergasse"); Assert_NormalizeStreetName("Lesergasse"); Assert_NormalizeStreetName("Leuthnerhof"); Assert_NormalizeStreetName("Lexergasse"); Assert_NormalizeStreetName("Leyserstraße"); Assert_NormalizeStreetName("Lichtenauergasse"); Assert_NormalizeStreetName("Liebleitnergasse"); Assert_NormalizeStreetName("Lieglerstraße"); Assert_NormalizeStreetName("Lienfeldergasse"); Assert_NormalizeStreetName("Lindauergasse"); Assert_NormalizeStreetName("Lindenbauergasse"); Assert_NormalizeStreetName("Linke Wasserzeile"); Assert_NormalizeStreetName("Linsbauerweg"); Assert_NormalizeStreetName("Linzackergasse"); Assert_NormalizeStreetName("Lißbauergasse"); Assert_NormalizeStreetName("Lodererweg"); Assert_NormalizeStreetName("Löfflergasse"); Assert_NormalizeStreetName("Lohnergasse"); Assert_NormalizeStreetName("Löhnergasse"); Assert_NormalizeStreetName("Loimerweg"); Assert_NormalizeStreetName("Lorbeergasse"); Assert_NormalizeStreetName("Lothringerstraße"); Assert_NormalizeStreetName("Lutherplatz"); Assert_NormalizeStreetName("Maderspergerstraße"); Assert_NormalizeStreetName("Maderstraße"); Assert_NormalizeStreetName("Mahlerstraße"); Assert_NormalizeStreetName("Mailergasse"); Assert_NormalizeStreetName("Maireckergasse"); Assert_NormalizeStreetName("Mantlergasse"); Assert_NormalizeStreetName("Marderweg"); Assert_NormalizeStreetName("Marksteinergasse"); Assert_NormalizeStreetName("Marokkanergasse"); Assert_NormalizeStreetName("Maroltingergasse"); Assert_NormalizeStreetName("Marschnergasse"); Assert_NormalizeStreetName("Marxergasse"); Assert_NormalizeStreetName("Maßholdergasse"); Assert_NormalizeStreetName("Matzingerstraße"); Assert_NormalizeStreetName("Matznergasse"); Assert_NormalizeStreetName("Maulbeergasse"); Assert_NormalizeStreetName("Mauthnergasse"); Assert_NormalizeStreetName("Mayergasse"); Assert_NormalizeStreetName("Mayerhofgasse"); Assert_NormalizeStreetName("Mayredergasse"); Assert_NormalizeStreetName("Maysedergasse"); Assert_NormalizeStreetName("Medlergasse"); Assert_NormalizeStreetName("Mehlführergasse"); Assert_NormalizeStreetName("Meillergasse"); Assert_NormalizeStreetName("Meisgeyergasse"); Assert_NormalizeStreetName("Meißauergasse"); Assert_NormalizeStreetName("Meißnergasse"); Assert_NormalizeStreetName("Meistergasse"); Assert_NormalizeStreetName("Meitnergasse"); Assert_NormalizeStreetName("Meixnerweg"); Assert_NormalizeStreetName("Mellergasse"); Assert_NormalizeStreetName("Mengergasse"); Assert_NormalizeStreetName("Mentergasse"); Assert_NormalizeStreetName("Meranerweg"); Assert_NormalizeStreetName("Mergenthalerplatz"); Assert_NormalizeStreetName("Messenhausergasse"); Assert_NormalizeStreetName("Meyerbeergasse"); Assert_NormalizeStreetName("Michaelerplatz"); Assert_NormalizeStreetName("Michaelerstraße"); Assert_NormalizeStreetName("Michtnergasse"); Assert_NormalizeStreetName("Millergasse"); Assert_NormalizeStreetName("Millöckergasse"); Assert_NormalizeStreetName("Miltnerweg"); Assert_NormalizeStreetName("Mithlingerhof"); Assert_NormalizeStreetName("Mitterhofergasse"); Assert_NormalizeStreetName("Mittermayergasse"); Assert_NormalizeStreetName("Mittersteig"); Assert_NormalizeStreetName("Mitterweg"); Assert_NormalizeStreetName("Mitterwurzergasse"); Assert_NormalizeStreetName("Mitterwurzerweg"); Assert_NormalizeStreetName("Modecenterstraße"); Assert_NormalizeStreetName("Möhnergasse"); Assert_NormalizeStreetName("Möllergasse"); Assert_NormalizeStreetName("Moosbruggergasse"); Assert_NormalizeStreetName("Moschingergasse"); Assert_NormalizeStreetName("Mosergasse"); Assert_NormalizeStreetName("Mosheimergasse"); Assert_NormalizeStreetName("Moßbachergasse"); Assert_NormalizeStreetName("Müglendergasse"); Assert_NormalizeStreetName("Mühlbachergasse"); Assert_NormalizeStreetName("Mühlhausergasse"); Assert_NormalizeStreetName("Mühlsangergasse"); Assert_NormalizeStreetName("Mühlwasserpromenade"); Assert_NormalizeStreetName("Mühlwasserstraße"); Assert_NormalizeStreetName("Muhrhoferweg"); Assert_NormalizeStreetName("Mukenthalerweg"); Assert_NormalizeStreetName("Müllnergasse"); Assert_NormalizeStreetName("Münichreiterstraße"); Assert_NormalizeStreetName("Musgergasse"); Assert_NormalizeStreetName("Musketierweg"); Assert_NormalizeStreetName("Naderstraße"); Assert_NormalizeStreetName("Nadlergasse"); Assert_NormalizeStreetName("Naglergasse"); Assert_NormalizeStreetName("Nästlbergergasse"); Assert_NormalizeStreetName("Nattergasse"); Assert_NormalizeStreetName("Nauheimergasse"); Assert_NormalizeStreetName("Neblingergasse"); Assert_NormalizeStreetName("Nedergasse"); Assert_NormalizeStreetName("Neuburgergasse"); Assert_NormalizeStreetName("Neudeggergasse"); Assert_NormalizeStreetName("Neudorfergasse"); Assert_NormalizeStreetName("Neugebauerweg"); Assert_NormalizeStreetName("Neusserplatz"); Assert_NormalizeStreetName("Niederauergasse"); Assert_NormalizeStreetName("Niederhofstraße"); Assert_NormalizeStreetName("Niedermeierweg"); Assert_NormalizeStreetName("Niedermoserstraße"); Assert_NormalizeStreetName("Niernbergergasse"); Assert_NormalizeStreetName("Obere Weißgerberstraße"); Assert_NormalizeStreetName("Oberhummergasse"); Assert_NormalizeStreetName("Obermüllnerstraße"); Assert_NormalizeStreetName("Obersteinergasse"); Assert_NormalizeStreetName("Oberzellergasse"); Assert_NormalizeStreetName("Obkirchergasse"); Assert_NormalizeStreetName("Odoakergasse"); Assert_NormalizeStreetName("Oehlenschlägergasse"); Assert_NormalizeStreetName("Oellacherweg"); Assert_NormalizeStreetName("Ofnergasse"); Assert_NormalizeStreetName("Oleandergasse"); Assert_NormalizeStreetName("Öppingerweg"); Assert_NormalizeStreetName("Oppolzergasse"); Assert_NormalizeStreetName("Ortnergasse"); Assert_NormalizeStreetName("Osergasse"); Assert_NormalizeStreetName("Otterweg"); Assert_NormalizeStreetName("Ottillingerplatz"); Assert_NormalizeStreetName("Pachmayergasse"); Assert_NormalizeStreetName("Pachmüllergasse"); Assert_NormalizeStreetName("Pantzergasse"); Assert_NormalizeStreetName("Papiergasse"); Assert_NormalizeStreetName("Parhamerplatz"); Assert_NormalizeStreetName("Parisergasse"); Assert_NormalizeStreetName("Paulanergasse"); Assert_NormalizeStreetName("Pausingergasse"); Assert_NormalizeStreetName("Payergasse"); Assert_NormalizeStreetName("Pernerstorfergasse"); Assert_NormalizeStreetName("Pernerstorferhof"); Assert_NormalizeStreetName("Perntergasse"); Assert_NormalizeStreetName("Peuckerstraße"); Assert_NormalizeStreetName("Pfadenhauergasse"); Assert_NormalizeStreetName("Pfeffergasse"); Assert_NormalizeStreetName("Pfefferhofgasse"); Assert_NormalizeStreetName("Pfeiffenbergergasse"); Assert_NormalizeStreetName("Pfeiffergasse"); Assert_NormalizeStreetName("Pfendlergasse"); Assert_NormalizeStreetName("Pfitznergasse"); Assert_NormalizeStreetName("Pflieglergasse"); Assert_NormalizeStreetName("Philharmonikerstraße"); Assert_NormalizeStreetName("Piccaverweg"); Assert_NormalizeStreetName("Pichelmayergasse"); Assert_NormalizeStreetName("Pichelwangergasse"); Assert_NormalizeStreetName("Pichlergasse"); Assert_NormalizeStreetName("Pillergasse"); Assert_NormalizeStreetName("Pionierweg"); Assert_NormalizeStreetName("Pirkebnerstraße"); Assert_NormalizeStreetName("Plankenbüchlergasse"); Assert_NormalizeStreetName("Plattensteinergasse"); Assert_NormalizeStreetName("Platzergasse"); Assert_NormalizeStreetName("Plenergasse"); Assert_NormalizeStreetName("Plunkergasse"); Assert_NormalizeStreetName("Pölleritzergasse"); Assert_NormalizeStreetName("Pollitzergasse"); Assert_NormalizeStreetName("Pölzerhof"); Assert_NormalizeStreetName("Pombergerweg"); Assert_NormalizeStreetName("Pönningerweg"); Assert_NormalizeStreetName("Portnergasse"); Assert_NormalizeStreetName("Possannergasse"); Assert_NormalizeStreetName("Possingergasse"); Assert_NormalizeStreetName("Pramergasse"); Assert_NormalizeStreetName("Praterstraße"); Assert_NormalizeStreetName("Predigergasse"); Assert_NormalizeStreetName("Prehausergasse"); Assert_NormalizeStreetName("Preleuthnersteig"); Assert_NormalizeStreetName("Premlechnergasse"); Assert_NormalizeStreetName("Premreinergasse"); Assert_NormalizeStreetName("Preyergasse"); Assert_NormalizeStreetName("Puffergasse"); Assert_NormalizeStreetName("Pühringergasse"); Assert_NormalizeStreetName("Putzendoplergasse"); Assert_NormalizeStreetName("Pyrkergasse"); Assert_NormalizeStreetName("Rabenlechnerweg"); Assert_NormalizeStreetName("Radelmayergasse"); Assert_NormalizeStreetName("Radingerstraße"); Assert_NormalizeStreetName("Rädtnergasse"); Assert_NormalizeStreetName("Raffelspergergasse"); Assert_NormalizeStreetName("Rainergasse"); Assert_NormalizeStreetName("Ramperstorffergasse"); Assert_NormalizeStreetName("Randhartingergasse"); Assert_NormalizeStreetName("Ranningergasse"); Assert_NormalizeStreetName("Ranzenhofergasse"); Assert_NormalizeStreetName("Rathmayergasse"); Assert_NormalizeStreetName("Ratzenhofergasse"); Assert_NormalizeStreetName("Rauchfangkehrergasse"); Assert_NormalizeStreetName("Rauscherstraße"); Assert_NormalizeStreetName("Rechte Wasserzeile"); Assert_NormalizeStreetName("Redergasse"); Assert_NormalizeStreetName("Redtenbachergasse"); Assert_NormalizeStreetName("Reglergasse"); Assert_NormalizeStreetName("Regnerweg"); Assert_NormalizeStreetName("Reibergasse"); Assert_NormalizeStreetName("Reiherweg"); Assert_NormalizeStreetName("Reiningerweg"); Assert_NormalizeStreetName("Reischergasse"); Assert_NormalizeStreetName("Reisingergasse"); Assert_NormalizeStreetName("Reisnerstraße"); Assert_NormalizeStreetName("Reithofferplatz"); Assert_NormalizeStreetName("Richtergasse"); Assert_NormalizeStreetName("Riemenschneidergasse"); Assert_NormalizeStreetName("Riemergasse"); Assert_NormalizeStreetName("Riglergasse"); Assert_NormalizeStreetName("Rimplergasse"); Assert_NormalizeStreetName("Rittergasse"); Assert_NormalizeStreetName("Rittingergasse"); Assert_NormalizeStreetName("Rittlergasse"); Assert_NormalizeStreetName("Rittnergasse"); Assert_NormalizeStreetName("Rodlergasse"); Assert_NormalizeStreetName("Roesnergasse"); Assert_NormalizeStreetName("Rögergasse"); Assert_NormalizeStreetName("Rohrbacherstraße"); Assert_NormalizeStreetName("Rohrergasse"); Assert_NormalizeStreetName("Rohrhofergasse"); Assert_NormalizeStreetName("Rohrwassergasse"); Assert_NormalizeStreetName("Rollingergasse"); Assert_NormalizeStreetName("Römergasse"); Assert_NormalizeStreetName("Roseggergasse"); Assert_NormalizeStreetName("Rosenackerstraße"); Assert_NormalizeStreetName("Rößlergasse"); Assert_NormalizeStreetName("Rothergasse"); Assert_NormalizeStreetName("Rötzergasse"); Assert_NormalizeStreetName("Ruckergasse"); Assert_NormalizeStreetName("Rüdigergasse"); Assert_NormalizeStreetName("Rudolfinergasse"); Assert_NormalizeStreetName("Rueberstraße"); Assert_NormalizeStreetName("Rugierstraße"); Assert_NormalizeStreetName("Ruhrhofergasse"); Assert_NormalizeStreetName("Rumplerweg"); Assert_NormalizeStreetName("Ruthnergasse"); Assert_NormalizeStreetName("Rysergasse"); Assert_NormalizeStreetName("Sagedergasse"); Assert_NormalizeStreetName("Saileräckergasse"); Assert_NormalizeStreetName("Salamandergasse"); Assert_NormalizeStreetName("Salesianergasse"); Assert_NormalizeStreetName("Saligergasse"); Assert_NormalizeStreetName("Salmhoferstraße"); Assert_NormalizeStreetName("Salvatorianerplatz"); Assert_NormalizeStreetName("Salzergasse"); Assert_NormalizeStreetName("Samhaberplatz"); Assert_NormalizeStreetName("Samptwandnergasse"); Assert_NormalizeStreetName("Sandauergasse"); Assert_NormalizeStreetName("Sandtnergasse"); Assert_NormalizeStreetName("Sängergasse"); Assert_NormalizeStreetName("Santifallerstraße"); Assert_NormalizeStreetName("Satzingerweg"); Assert_NormalizeStreetName("Sauergasse"); Assert_NormalizeStreetName("Sautergasse"); Assert_NormalizeStreetName("Schablergasse"); Assert_NormalizeStreetName("Schachnerstraße"); Assert_NormalizeStreetName("Schäffergasse"); Assert_NormalizeStreetName("Schafflerhofstraße"); Assert_NormalizeStreetName("Schallautzerstraße"); Assert_NormalizeStreetName("Schallergasse"); Assert_NormalizeStreetName("Schauflergasse"); Assert_NormalizeStreetName("Schaumburgergasse"); Assert_NormalizeStreetName("Schaurhofergasse"); Assert_NormalizeStreetName("Scheffeneggergasse"); Assert_NormalizeStreetName("Scheibelreitergasse"); Assert_NormalizeStreetName("Scheiterplatzl"); Assert_NormalizeStreetName("Schellhammergasse"); Assert_NormalizeStreetName("Schembergasse"); Assert_NormalizeStreetName("Schererstraße"); Assert_NormalizeStreetName("Scherzergasse"); Assert_NormalizeStreetName("Schiergasse"); Assert_NormalizeStreetName("Schikanedergasse"); Assert_NormalizeStreetName("Schilchergasse"); Assert_NormalizeStreetName("Schillerplatz"); Assert_NormalizeStreetName("Schillerpromenade"); Assert_NormalizeStreetName("Schillingergasse"); Assert_NormalizeStreetName("Schillwasserweg"); Assert_NormalizeStreetName("Schindlergasse"); Assert_NormalizeStreetName("Schippergasse"); Assert_NormalizeStreetName("Schlachthammerstraße"); Assert_NormalizeStreetName("Schlagergasse"); Assert_NormalizeStreetName("Schlägergasse"); Assert_NormalizeStreetName("Schleiergasse"); Assert_NormalizeStreetName("Schlenthergasse"); Assert_NormalizeStreetName("Schlesingerplatz"); Assert_NormalizeStreetName("Schlettergasse"); Assert_NormalizeStreetName("Schlingerhof"); Assert_NormalizeStreetName("Schlossergasse"); Assert_NormalizeStreetName("Schluckergasse"); Assert_NormalizeStreetName("Schmalerweg"); Assert_NormalizeStreetName("Schmätzerweg"); Assert_NormalizeStreetName("Schmidlergasse"); Assert_NormalizeStreetName("Schmiegergasse"); Assert_NormalizeStreetName("Schmutzergasse"); Assert_NormalizeStreetName("Schneidergasse"); Assert_NormalizeStreetName("Schnitterweg"); Assert_NormalizeStreetName("Schnitzlerhof"); Assert_NormalizeStreetName("Schöberweg"); Assert_NormalizeStreetName("Schödlbergergasse"); Assert_NormalizeStreetName("Schoellerhofgasse"); Assert_NormalizeStreetName("Schöneckergasse"); Assert_NormalizeStreetName("Schongauergasse"); Assert_NormalizeStreetName("Schönthalergasse"); Assert_NormalizeStreetName("Schopenhauerstraße"); Assert_NormalizeStreetName("Schöpfergasse"); Assert_NormalizeStreetName("Schöpfleuthnergasse"); Assert_NormalizeStreetName("Schrebergasse"); Assert_NormalizeStreetName("Schreiberweg"); Assert_NormalizeStreetName("Schreinerweg"); Assert_NormalizeStreetName("Schrekergasse"); Assert_NormalizeStreetName("Schrödingerhof"); Assert_NormalizeStreetName("Schrödingerplatz"); Assert_NormalizeStreetName("Schroederweg"); Assert_NormalizeStreetName("Schröttergasse"); Assert_NormalizeStreetName("Schrottgießergasse"); Assert_NormalizeStreetName("Schuhbrechergasse"); Assert_NormalizeStreetName("Schuhmeierhof"); Assert_NormalizeStreetName("Schuhmeierplatz"); Assert_NormalizeStreetName("Schulerstraße"); Assert_NormalizeStreetName("Schultergasse"); Assert_NormalizeStreetName("Schumpeterweg"); Assert_NormalizeStreetName("Schwagergasse"); Assert_NormalizeStreetName("Schwaigergasse"); Assert_NormalizeStreetName("Schwarzgrubergasse"); Assert_NormalizeStreetName("Schwarzingergasse"); Assert_NormalizeStreetName("Schwarzspanierstraße"); Assert_NormalizeStreetName("Schweglerstraße"); Assert_NormalizeStreetName("Schwemmäckergasse"); Assert_NormalizeStreetName("Schwemmingergasse"); Assert_NormalizeStreetName("Schwendergasse"); Assert_NormalizeStreetName("Schwendermarkt"); Assert_NormalizeStreetName("Sechtergasse"); Assert_NormalizeStreetName("Seeadlerweg"); Assert_NormalizeStreetName("Seefeldergasse"); Assert_NormalizeStreetName("Seemüllergasse"); Assert_NormalizeStreetName("Seglerweg"); Assert_NormalizeStreetName("Segnerstraße"); Assert_NormalizeStreetName("Seilergasse"); Assert_NormalizeStreetName("Seiseneggergasse"); Assert_NormalizeStreetName("Seitzergasse"); Assert_NormalizeStreetName("Sellingergasse"); Assert_NormalizeStreetName("Selzergasse"); Assert_NormalizeStreetName("Semperstraße"); Assert_NormalizeStreetName("Senderstraße"); Assert_NormalizeStreetName("Sendnergasse"); Assert_NormalizeStreetName("Senefeldergasse"); Assert_NormalizeStreetName("Seuttergasse"); Assert_NormalizeStreetName("Severhof"); Assert_NormalizeStreetName("Siebenbürgerstraße"); Assert_NormalizeStreetName("Silberergasse"); Assert_NormalizeStreetName("Silbergasse"); Assert_NormalizeStreetName("Sillergasse"); Assert_NormalizeStreetName("Sillerplatz"); Assert_NormalizeStreetName("Sillerstraße"); Assert_NormalizeStreetName("Singerstraße"); Assert_NormalizeStreetName("Singrienergasse"); Assert_NormalizeStreetName("Soesergasse"); Assert_NormalizeStreetName("Sollingergasse"); Assert_NormalizeStreetName("Sommerergasse"); Assert_NormalizeStreetName("Sommergasse"); Assert_NormalizeStreetName("Sommerweg"); Assert_NormalizeStreetName("Sonnergasse"); Assert_NormalizeStreetName("Sonnleithnergasse"); Assert_NormalizeStreetName("Speckbachergasse"); Assert_NormalizeStreetName("Spengergasse"); Assert_NormalizeStreetName("Sperbergasse"); Assert_NormalizeStreetName("Sperkergasse"); Assert_NormalizeStreetName("Spetterbrücke"); Assert_NormalizeStreetName("Spießhammergasse"); Assert_NormalizeStreetName("Spindeleggergasse"); Assert_NormalizeStreetName("Spindlerweg"); Assert_NormalizeStreetName("Spitzackergasse"); Assert_NormalizeStreetName("Spitzergasse"); Assert_NormalizeStreetName("Spötterweg"); Assert_NormalizeStreetName("Sprengersteig"); Assert_NormalizeStreetName("Springergasse"); Assert_NormalizeStreetName("Stadlergasse"); Assert_NormalizeStreetName("Stammersdorfer Kellergasse"); Assert_NormalizeStreetName("Stampfergasse"); Assert_NormalizeStreetName("Staribacherstraße"); Assert_NormalizeStreetName("Stättermayergasse"); Assert_NormalizeStreetName("Staudingergasse"); Assert_NormalizeStreetName("Stauffergasse"); Assert_NormalizeStreetName("Stavangergasse"); Assert_NormalizeStreetName("Stegmayergasse"); Assert_NormalizeStreetName("Steinackergasse"); Assert_NormalizeStreetName("Steinamangergasse"); Assert_NormalizeStreetName("Steinbauergasse"); Assert_NormalizeStreetName("Steinbrechergasse"); Assert_NormalizeStreetName("Steinergasse"); Assert_NormalizeStreetName("Steiningergasse"); Assert_NormalizeStreetName("Steinklammergasse"); Assert_NormalizeStreetName("Steinlechnergasse"); Assert_NormalizeStreetName("Steinmüllergasse"); Assert_NormalizeStreetName("Stelzhamergasse"); Assert_NormalizeStreetName("Steyrerhof"); Assert_NormalizeStreetName("Stiegergasse"); Assert_NormalizeStreetName("Stieglergasse"); Assert_NormalizeStreetName("Stifterbrücke"); Assert_NormalizeStreetName("Stöbergasse"); Assert_NormalizeStreetName("Stöberplatz"); Assert_NormalizeStreetName("Stolzenthalergasse"); Assert_NormalizeStreetName("Stowassergasse"); Assert_NormalizeStreetName("Stralehnergasse"); Assert_NormalizeStreetName("Strampfergasse"); Assert_NormalizeStreetName("Straßäckergasse"); Assert_NormalizeStreetName("Straßergasse"); Assert_NormalizeStreetName("Straßgschwandtnerstraße"); Assert_NormalizeStreetName("Straßmeyergasse"); Assert_NormalizeStreetName("Streckerplatz"); Assert_NormalizeStreetName("Streichergasse"); Assert_NormalizeStreetName("Strohmayergasse"); Assert_NormalizeStreetName("Stuhlhofergasse"); Assert_NormalizeStreetName("Stummergasse"); Assert_NormalizeStreetName("Stumpergasse"); Assert_NormalizeStreetName("Stürzergasse"); Assert_NormalizeStreetName("Stuwerstraße"); Assert_NormalizeStreetName("Suttingergasse"); Assert_NormalizeStreetName("Symphonikerstraße"); Assert_NormalizeStreetName("Taggergasse"); Assert_NormalizeStreetName("Taglieberstraße"); Assert_NormalizeStreetName("Tannhäuserplatz"); Assert_NormalizeStreetName("Tartergasse"); Assert_NormalizeStreetName("Taubergasse"); Assert_NormalizeStreetName("Technikerstraße"); Assert_NormalizeStreetName("Teichackergasse"); Assert_NormalizeStreetName("Teiläckergasse"); Assert_NormalizeStreetName("Tendlergasse"); Assert_NormalizeStreetName("Teschnergasse"); Assert_NormalizeStreetName("Tetmajergasse"); Assert_NormalizeStreetName("Teybergasse"); Assert_NormalizeStreetName("Thalhaimergasse"); Assert_NormalizeStreetName("Thallergasse"); Assert_NormalizeStreetName("Theergasse"); Assert_NormalizeStreetName("Theuergasse"); Assert_NormalizeStreetName("Theumermarkt"); Assert_NormalizeStreetName("Tiefendorfergasse"); Assert_NormalizeStreetName("Tigergasse"); Assert_NormalizeStreetName("Tilgnergasse"); Assert_NormalizeStreetName("Tilgnerstraße"); Assert_NormalizeStreetName("Tinterstraße"); Assert_NormalizeStreetName("Toeplerhof"); Assert_NormalizeStreetName("Töllergasse"); Assert_NormalizeStreetName("Trambauerstraße"); Assert_NormalizeStreetName("Traminergasse"); Assert_NormalizeStreetName("Trattnerhof"); Assert_NormalizeStreetName("Trefferweg"); Assert_NormalizeStreetName("Trillergasse"); Assert_NormalizeStreetName("Trogergasse"); Assert_NormalizeStreetName("Trözmüllergasse"); Assert_NormalizeStreetName("Trunnerstraße"); Assert_NormalizeStreetName("Tschörnerweg"); Assert_NormalizeStreetName("Tulzergasse"); Assert_NormalizeStreetName("Turnergasse"); Assert_NormalizeStreetName("Überreiterweg"); Assert_NormalizeStreetName("Uferweg"); Assert_NormalizeStreetName("Ungerhof"); Assert_NormalizeStreetName("Unterbergergasse"); Assert_NormalizeStreetName("Unterer Schreiberweg"); Assert_NormalizeStreetName("Untere Weißgerberstraße"); Assert_NormalizeStreetName("Veitingergasse"); Assert_NormalizeStreetName("Vierthalergasse"); Assert_NormalizeStreetName("Voigtländergasse"); Assert_NormalizeStreetName("Volkergasse"); Assert_NormalizeStreetName("Vollnhoferplatz"); Assert_NormalizeStreetName("Vormosergasse"); Assert_NormalizeStreetName("Vöschergasse"); Assert_NormalizeStreetName("Wacholderweg"); Assert_NormalizeStreetName("Wächtergasse"); Assert_NormalizeStreetName("Waidäckergasse"); Assert_NormalizeStreetName("Walcherstraße"); Assert_NormalizeStreetName("Waldmeistergasse"); Assert_NormalizeStreetName("Waldmüllergasse"); Assert_NormalizeStreetName("Waldschafferweg"); Assert_NormalizeStreetName("Waldviertlerweg"); Assert_NormalizeStreetName("Walkergasse"); Assert_NormalizeStreetName("Wallishaussergasse"); Assert_NormalizeStreetName("Wallnerstraße"); Assert_NormalizeStreetName("Wallnerweg"); Assert_NormalizeStreetName("Waltenbergergasse"); Assert_NormalizeStreetName("Waltergasse"); Assert_NormalizeStreetName("Wambachergasse"); Assert_NormalizeStreetName("Wankläckergasse"); Assert_NormalizeStreetName("Wannemachergasse"); Assert_NormalizeStreetName("Wanthalerweg"); Assert_NormalizeStreetName("Wasnergasse"); Assert_NormalizeStreetName("Wasserburgergasse"); Assert_NormalizeStreetName("Wassergasse"); Assert_NormalizeStreetName("Wasserweg"); Assert_NormalizeStreetName("Webergasse"); Assert_NormalizeStreetName("Wegelergasse"); Assert_NormalizeStreetName("Weidingergasse"); Assert_NormalizeStreetName("Weinbergerplatz"); Assert_NormalizeStreetName("Weindorfergasse"); Assert_NormalizeStreetName("Weinheimergasse"); Assert_NormalizeStreetName("Weinlechnergasse"); Assert_NormalizeStreetName("Weinrothergasse"); Assert_NormalizeStreetName("Weinzingergasse"); Assert_NormalizeStreetName("Weiskirchnerstraße"); Assert_NormalizeStreetName("Weißingergasse"); Assert_NormalizeStreetName("Weitmosergasse"); Assert_NormalizeStreetName("Weixelbergergasse"); Assert_NormalizeStreetName("Welingergasse"); Assert_NormalizeStreetName("Welzenbachergasse"); Assert_NormalizeStreetName("Werdertorgasse"); Assert_NormalizeStreetName("Wernergasse"); Assert_NormalizeStreetName("Westermayergasse"); Assert_NormalizeStreetName("Weyringergasse"); Assert_NormalizeStreetName("Wichnergasse"); Assert_NormalizeStreetName("Widerhofergasse"); Assert_NormalizeStreetName("Widerhoferplatz"); Assert_NormalizeStreetName("Wiedenhoferhof"); Assert_NormalizeStreetName("Wienerbergerplatz"); Assert_NormalizeStreetName("Wieningerplatz"); Assert_NormalizeStreetName("Wiesingerstraße"); Assert_NormalizeStreetName("Wiesnergasse"); Assert_NormalizeStreetName("Wildauergasse"); Assert_NormalizeStreetName("Wildnergasse"); Assert_NormalizeStreetName("Willergasse"); Assert_NormalizeStreetName("Wimbergergasse"); Assert_NormalizeStreetName("Wimmergasse"); Assert_NormalizeStreetName("Windhabergasse"); Assert_NormalizeStreetName("Winkeläckerstraße"); Assert_NormalizeStreetName("Winkeläckerweg"); Assert_NormalizeStreetName("Winklergasse"); Assert_NormalizeStreetName("Winterburgergasse"); Assert_NormalizeStreetName("Winterweg"); Assert_NormalizeStreetName("Winzerstraße"); Assert_NormalizeStreetName("Wipplingerstraße"); Assert_NormalizeStreetName("Wirerstraße"); Assert_NormalizeStreetName("Witthauergasse"); Assert_NormalizeStreetName("Wittmayergasse"); Assert_NormalizeStreetName("Witzelsbergergasse"); Assert_NormalizeStreetName("Wöbergasse"); Assert_NormalizeStreetName("Wögingergasse"); Assert_NormalizeStreetName("Wöhlergasse"); Assert_NormalizeStreetName("Wolfsgrubergasse"); Assert_NormalizeStreetName("Wollergasse"); Assert_NormalizeStreetName("Woltergasse"); Assert_NormalizeStreetName("Wurlitzergasse"); Assert_NormalizeStreetName("Wurmsergasse"); Assert_NormalizeStreetName("Würtzlerstraße"); Assert_NormalizeStreetName("Wurzingergasse"); Assert_NormalizeStreetName("Zallingergasse"); Assert_NormalizeStreetName("Zaunergasse"); Assert_NormalizeStreetName("Zehetbauergasse"); Assert_NormalizeStreetName("Zehetnergasse"); Assert_NormalizeStreetName("Zeidlergasse"); Assert_NormalizeStreetName("Zeilingerweg"); Assert_NormalizeStreetName("Zeillergasse"); Assert_NormalizeStreetName("Zeinlhofergasse"); Assert_NormalizeStreetName("Zellwekergasse"); Assert_NormalizeStreetName("Zennergasse"); Assert_NormalizeStreetName("Zennerstraße"); Assert_NormalizeStreetName("Ziedlergasse"); Assert_NormalizeStreetName("Zieglergasse"); Assert_NormalizeStreetName("Ziehrerplatz"); Assert_NormalizeStreetName("Zifferergasse"); Assert_NormalizeStreetName("Zillbauerplatz"); Assert_NormalizeStreetName("Zillbauerweg"); Assert_NormalizeStreetName("Zillingergasse"); Assert_NormalizeStreetName("Zinnergasse"); Assert_NormalizeStreetName("Zippererstraße"); Assert_NormalizeStreetName("Zitterhofergasse"); Assert_NormalizeStreetName("Zöchbauerstraße"); Assert_NormalizeStreetName("Zollergasse"); Assert_NormalizeStreetName("Zwerchäckerweg"); Assert_NormalizeStreetName("Zwölfergasse"); } } [Test] [Ignore("Not needed")] public void Test_NormalizeStreetName_Vienna_FullPersonalNames() { using (Assert.EnterMultipleScope()) { Assert_NormalizeStreetName("Adalbert-Stifter-Straße"); Assert_NormalizeStreetName("Adolf-Blamauer-Gasse"); Assert_NormalizeStreetName("Adolf-Gstöttner-Gasse"); Assert_NormalizeStreetName("Adolf-Scharner-Hof"); Assert_NormalizeStreetName("Adolf-Unger-Gasse"); Assert_NormalizeStreetName("Adrienne-Gessner-Gasse"); Assert_NormalizeStreetName("Albert-Schweitzer-Gasse"); Assert_NormalizeStreetName("Alfred-Adler-Straße"); Assert_NormalizeStreetName("Alfred-Dallinger-Platz"); Assert_NormalizeStreetName("Alfred-Wegener-Gasse"); Assert_NormalizeStreetName("Alice-und-Heinrich-Scheuer-Hof"); Assert_NormalizeStreetName("Alma-Seidler-Weg"); Assert_NormalizeStreetName("Alois-Höfler-Gasse"); Assert_NormalizeStreetName("Andreas-Hofer-Straße"); Assert_NormalizeStreetName("Andreas-Huger-Gasse"); Assert_NormalizeStreetName("Andreas-Lechner-Straße"); Assert_NormalizeStreetName("Anita-Berber-Gasse"); Assert_NormalizeStreetName("Anna-Frauer-Gasse"); Assert_NormalizeStreetName("Anna-Müller-Weg"); Assert_NormalizeStreetName("Anni-Haider-Weg"); Assert_NormalizeStreetName("Anton-Anderer-Platz"); Assert_NormalizeStreetName("Anton-Balzer-Weg"); Assert_NormalizeStreetName("Anton-Baumgartner-Straße"); Assert_NormalizeStreetName("Anton-Dengler-Gasse"); Assert_NormalizeStreetName("Anton-Geiger-Weg"); Assert_NormalizeStreetName("Anton-Heger-Platz"); Assert_NormalizeStreetName("Antonie-Platzer-Gasse"); Assert_NormalizeStreetName("Anton-Krieger-Gasse"); Assert_NormalizeStreetName("Anton-Langer-Gasse"); Assert_NormalizeStreetName("Anton-Mayer-Gasse"); Assert_NormalizeStreetName("Anton-Ochsenhofer-Gasse"); Assert_NormalizeStreetName("Anton-Sattler-Gasse"); Assert_NormalizeStreetName("Anton-Strutzenberger-Weg"); Assert_NormalizeStreetName("Arthur-Schnitzler-Platz"); Assert_NormalizeStreetName("August-Kronberger-Gasse"); Assert_NormalizeStreetName("Beer-Hofmann-Gasse"); Assert_NormalizeStreetName("Beer-Hofmann-Weg"); Assert_NormalizeStreetName("Benedikt-Schellinger-Gasse"); Assert_NormalizeStreetName("Bertha-von-Suttner-Gasse"); Assert_NormalizeStreetName("Bertha-von-Suttner-Hof"); Assert_NormalizeStreetName("Betty-Fischer-Weg"); Assert_NormalizeStreetName("Biljan-Bilger-Gasse"); Assert_NormalizeStreetName("Billy-Wilder-Promenade"); Assert_NormalizeStreetName("Bischof-Faber-Platz"); Assert_NormalizeStreetName("Bloch-Bauer-Promenade"); Assert_NormalizeStreetName("Brigitte-Neumeister-Platz"); Assert_NormalizeStreetName("Bruno-Walter-Gasse"); Assert_NormalizeStreetName("Christian-Bucher-Gasse"); Assert_NormalizeStreetName("Christian-Petzlberger-Weg"); Assert_NormalizeStreetName("Cilli-Löwinger-Weg"); Assert_NormalizeStreetName("Clemens-Hofbauer-Platz"); Assert_NormalizeStreetName("Clemens-Holzmeister-Straße"); Assert_NormalizeStreetName("De-Quer-Gasse"); Assert_NormalizeStreetName("Dolfi-Gruber-Weg"); Assert_NormalizeStreetName("Dr.-Andreas-Zailer-Gasse"); Assert_NormalizeStreetName("Dr.-Boehringer-Gasse"); Assert_NormalizeStreetName("Dr.-Franz-Pauer-Hof"); Assert_NormalizeStreetName("Dr.-Heinrich-Maier-Straße"); Assert_NormalizeStreetName("Dr.-Heinrich-Müller-Gasse"); Assert_NormalizeStreetName("Dr.-Josef-Bayer-Hof"); Assert_NormalizeStreetName("Dr.-Karl-Lueger-Platz"); Assert_NormalizeStreetName("Dr.-Karl-Renner-Ring"); Assert_NormalizeStreetName("Dr.-Kronawetter-Hof"); Assert_NormalizeStreetName("Dr.-Natterer-Gasse"); Assert_NormalizeStreetName("Dr.-Pirnitzer-Platz"); Assert_NormalizeStreetName("Dr.-Schober-Straße"); Assert_NormalizeStreetName("Dr.-Schreber-Gasse"); Assert_NormalizeStreetName("Dr.-Schreber-Weg"); Assert_NormalizeStreetName("Edi-Finger-Straße"); Assert_NormalizeStreetName("Edith-Kramer-Weg"); Assert_NormalizeStreetName("Eduard-Brückner-Gasse"); Assert_NormalizeStreetName("Eduard-Gaertner-Gasse"); Assert_NormalizeStreetName("Eduard-Jaeger-Gasse"); Assert_NormalizeStreetName("Eduard-Kittenberger-Gasse"); Assert_NormalizeStreetName("Eduard-Reyer-Gasse"); Assert_NormalizeStreetName("Eduard-Schlesinger-Hof"); Assert_NormalizeStreetName("Edwin-Schuster-Hof"); Assert_NormalizeStreetName("Elisabeth-Bergner-Weg"); Assert_NormalizeStreetName("Elisabeth-Schilder-Gasse"); Assert_NormalizeStreetName("Elise-Richter-Weg"); Assert_NormalizeStreetName("Elsa-Plainacher-Gasse"); Assert_NormalizeStreetName("Emmerich-Sailer-Hof"); Assert_NormalizeStreetName("Erich-Deschermaier-Hof"); Assert_NormalizeStreetName("Erika-Mitterer-Weg"); Assert_NormalizeStreetName("Erne-Seder-Gasse"); Assert_NormalizeStreetName("Ernst-Burger-Gasse"); Assert_NormalizeStreetName("Ernst-Karl-Winter-Hof"); Assert_NormalizeStreetName("Ernst-Karl-Winter-Weg"); Assert_NormalizeStreetName("Ernst-Kirchweger-Hof"); Assert_NormalizeStreetName("Ernst-Reuter-Hof"); Assert_NormalizeStreetName("Ernst-Theumer-Hof"); Assert_NormalizeStreetName("Eva-Popper-Weg"); Assert_NormalizeStreetName("Eva-Zilcher-Gasse"); Assert_NormalizeStreetName("Ewald-Balser-Gasse"); Assert_NormalizeStreetName("Ferdinand-Platzer-Gasse"); Assert_NormalizeStreetName("Florian-Geyer-Gasse"); Assert_NormalizeStreetName("Florian-Hedorfer-Straße"); Assert_NormalizeStreetName("Franz-Adelpoller-Hof"); Assert_NormalizeStreetName("Franz-Asenbauer-Gasse"); Assert_NormalizeStreetName("Franz-Bauer-Hof"); Assert_NormalizeStreetName("Franz-Bretschneider-Hof"); Assert_NormalizeStreetName("Franz-Fellner-Gasse"); Assert_NormalizeStreetName("Franz-Glaserer-Hof"); Assert_NormalizeStreetName("Franz-Glaser-Gasse"); Assert_NormalizeStreetName("Franz-Graßler-Gasse"); Assert_NormalizeStreetName("Franz-Heider-Gasse"); Assert_NormalizeStreetName("Franz-Hochedlinger-Gasse"); Assert_NormalizeStreetName("Franz-Petter-Gasse"); Assert_NormalizeStreetName("Franz-Pixner-Weg"); Assert_NormalizeStreetName("Franz-Reitlinger-Gasse"); Assert_NormalizeStreetName("Franz-Rosenberger-Hof"); Assert_NormalizeStreetName("Franz-Salmhofer-Platz"); Assert_NormalizeStreetName("Franz-Schreiner-Hof"); Assert_NormalizeStreetName("Franz-Schreker-Gasse"); Assert_NormalizeStreetName("Franz-Schuhmeier-Gasse"); Assert_NormalizeStreetName("Franz-Schuster-Gasse"); Assert_NormalizeStreetName("Franz-Schuster-Hof"); Assert_NormalizeStreetName("Franz-Seitler-Hof"); Assert_NormalizeStreetName("Franz-Silberer-Hof"); Assert_NormalizeStreetName("Franz-Siller-Gasse"); Assert_NormalizeStreetName("Franz-Siller-Weg"); Assert_NormalizeStreetName("Franz-Weber-Hof"); Assert_NormalizeStreetName("Friederike-Klauner-Gasse"); Assert_NormalizeStreetName("Friedrich-Adler-Weg"); Assert_NormalizeStreetName("Friedrich-Kaiser-Gasse"); Assert_NormalizeStreetName("Friedrich-Knauer-Gasse"); Assert_NormalizeStreetName("Friedrich-Lieder-Weg"); Assert_NormalizeStreetName("Friedrich-Teller-Gasse"); Assert_NormalizeStreetName("Friedrich-Wagner-Gasse"); Assert_NormalizeStreetName("Fritz-Kastner-Weg"); Assert_NormalizeStreetName("Gabor-Steiner-Weg"); Assert_NormalizeStreetName("Georgine-Steininger-Weg"); Assert_NormalizeStreetName("Georg-Wiesmayer-Gasse"); Assert_NormalizeStreetName("Gerhard-Bronner-Straße"); Assert_NormalizeStreetName("Gertrud-Bodenwieser-Gasse"); Assert_NormalizeStreetName("Gertrude-Fröhlich-Sandner-Straße"); Assert_NormalizeStreetName("Geschwister-Spitzer-Weg"); Assert_NormalizeStreetName("Gottfried-Alber-Gasse"); Assert_NormalizeStreetName("Gottfried-Keller-Gasse"); Assert_NormalizeStreetName("Gottfried-Schenker-Straße"); Assert_NormalizeStreetName("Gottfried-Sennholzer-Gasse"); Assert_NormalizeStreetName("Greta-Keller-Gasse"); Assert_NormalizeStreetName("Grete-Zimmer-Gasse"); Assert_NormalizeStreetName("Guido-Lammer-Gasse"); Assert_NormalizeStreetName("Gustav-Brünner-Gasse"); Assert_NormalizeStreetName("Gutheil-Schoder-Gasse"); Assert_NormalizeStreetName("Hans-Binder-Hof"); Assert_NormalizeStreetName("Hans-Richter-Gasse"); Assert_NormalizeStreetName("Hans-Steger-Gasse"); Assert_NormalizeStreetName("Hans-Weber-Hof"); Assert_NormalizeStreetName("Harry-Glöckner-Hof"); Assert_NormalizeStreetName("Heinrich-Lefler-Gasse"); Assert_NormalizeStreetName("Heinrich-Müller-Weg"); Assert_NormalizeStreetName("Heinrich-Zeder-Weg"); Assert_NormalizeStreetName("Helene-Lieser-Platz"); Assert_NormalizeStreetName("Helene-Richter-Gasse"); Assert_NormalizeStreetName("Helen-Keller-Gasse"); Assert_NormalizeStreetName("Helmut-Qualtinger-Gasse"); Assert_NormalizeStreetName("Helmut-Qualtinger-Hof"); Assert_NormalizeStreetName("Hermann-Fischer-Hof"); Assert_NormalizeStreetName("Hermann-Gebauer-Straße"); Assert_NormalizeStreetName("Hermann-Pacher-Gasse"); Assert_NormalizeStreetName("Hermann-Pacher-Weg"); Assert_NormalizeStreetName("Hermine-Cloeter-Gasse"); Assert_NormalizeStreetName("Hertha-Kräftner-Gasse"); Assert_NormalizeStreetName("Hubert-Eder-Weg"); Assert_NormalizeStreetName("Hugo-Wiener-Weg"); Assert_NormalizeStreetName("Ida-Pfeiffer-Weg"); Assert_NormalizeStreetName("Ignaz-Binder-Platz"); Assert_NormalizeStreetName("Ing.-Körner-Gasse"); Assert_NormalizeStreetName("Jakob-Gremdlinger-Straße"); Assert_NormalizeStreetName("Jakob-Sommerbauer-Straße"); Assert_NormalizeStreetName("Jakob-Stainer-Gasse"); Assert_NormalizeStreetName("Jeannie-Ebner-Weg"); Assert_NormalizeStreetName("Johann-Blobner-Gasse"); Assert_NormalizeStreetName("Johann-Holzer-Hof"); Assert_NormalizeStreetName("Johann-Hörbiger-Gasse"); Assert_NormalizeStreetName("Johann-Josef-Krätzer-Gasse"); Assert_NormalizeStreetName("Johann-Laufner-Gasse"); Assert_NormalizeStreetName("Johann-Nepomuk-Berger-Platz"); Assert_NormalizeStreetName("Johann-Pölzer-Gasse"); Assert_NormalizeStreetName("Johann-Schauhuber-Hof"); Assert_NormalizeStreetName("Johann-Treixler-Gasse"); Assert_NormalizeStreetName("Johann-Weber-Straße"); Assert_NormalizeStreetName("Josef-Bindtner-Gasse"); Assert_NormalizeStreetName("Josef-Endlweber-Gasse"); Assert_NormalizeStreetName("Josef-Flandorfer-Straße"); Assert_NormalizeStreetName("Josef-Kainzmayer-Gasse"); Assert_NormalizeStreetName("Josef-Meder-Gasse"); Assert_NormalizeStreetName("Josef-Moser-Gasse"); Assert_NormalizeStreetName("Josef-Österreicher-Gasse"); Assert_NormalizeStreetName("Josef-Pfeifer-Hof"); Assert_NormalizeStreetName("Josef-Pommer-Gasse"); Assert_NormalizeStreetName("Josef-Schlesinger-Straße"); Assert_NormalizeStreetName("Josef-Schober-Hof"); Assert_NormalizeStreetName("Josef-Schuster-Gasse"); Assert_NormalizeStreetName("Josef-Sickinger-Gasse"); Assert_NormalizeStreetName("Josef-Weinheber-Platz"); Assert_NormalizeStreetName("Josepha-Auernhammer-Gasse"); Assert_NormalizeStreetName("Joseph-Lister-Gasse"); Assert_NormalizeStreetName("Judith-Holzmeister-Weg"); Assert_NormalizeStreetName("Julius-Berger-Gasse"); Assert_NormalizeStreetName("Julius-Ficker-Straße"); Assert_NormalizeStreetName("Julius-Ofner-Hof"); Assert_NormalizeStreetName("Julius-Payer-Gasse"); Assert_NormalizeStreetName("Julius-Tandler-Platz"); Assert_NormalizeStreetName("Jura-Soyfer-Gasse"); Assert_NormalizeStreetName("Kardinal-Innitzer-Platz"); Assert_NormalizeStreetName("Kardinal-Rauscher-Platz"); Assert_NormalizeStreetName("Karl-Aschenbrenner-Gasse"); Assert_NormalizeStreetName("Karl-Diener-Gasse"); Assert_NormalizeStreetName("Karl-Drescher-Gasse"); Assert_NormalizeStreetName("Karl-Höger-Hof"); Assert_NormalizeStreetName("Karl-Humenberger-Gasse"); Assert_NormalizeStreetName("Karl-Leeder-Gasse"); Assert_NormalizeStreetName("Karl-Lothringer-Straße"); Assert_NormalizeStreetName("Karl-Mader-Weg"); Assert_NormalizeStreetName("Karl-Popper-Straße"); Assert_NormalizeStreetName("Karl-Schäfer-Straße"); Assert_NormalizeStreetName("Karl-Scheiber-Gasse"); Assert_NormalizeStreetName("Karl-Schweighofer-Gasse"); Assert_NormalizeStreetName("Karl-Waldbrunner-Hof"); Assert_NormalizeStreetName("Karl-Waldbrunner-Platz"); Assert_NormalizeStreetName("Karl-Walther-Gasse"); Assert_NormalizeStreetName("Katharina-Scheiter-Gasse"); Assert_NormalizeStreetName("Käthe-Königstetter-Hof"); Assert_NormalizeStreetName("Käthe-Leichter-Gasse"); Assert_NormalizeStreetName("Kolo-Moser-Gasse"); Assert_NormalizeStreetName("Konrad-Thurnher-Gasse"); Assert_NormalizeStreetName("Kramer-Glöckner-Straße"); Assert_NormalizeStreetName("Kurt-Heller-Hof"); Assert_NormalizeStreetName("Kurt-Steyrer-Hof"); Assert_NormalizeStreetName("Lee-Miller-Promenade"); Assert_NormalizeStreetName("Leo-Lehner-Gasse"); Assert_NormalizeStreetName("Leo-Mathauser-Gasse"); Assert_NormalizeStreetName("Leon-Kellner-Weg"); Assert_NormalizeStreetName("Leonore-Brecher-Weg"); Assert_NormalizeStreetName("Leopoldine-Schlinger-Gasse"); Assert_NormalizeStreetName("Leopold-Mayrhofer-Hof"); Assert_NormalizeStreetName("Leopold-Rister-Gasse"); Assert_NormalizeStreetName("Leopold-Steiner-Gasse"); Assert_NormalizeStreetName("Leopold-Thaller-Hof"); Assert_NormalizeStreetName("Lorenz-Bayer-Platz"); Assert_NormalizeStreetName("Lorenz-Böhler-Gasse"); Assert_NormalizeStreetName("Lorenz-Kellner-Gasse"); Assert_NormalizeStreetName("Lorenz-Müller-Gasse"); Assert_NormalizeStreetName("Lorenz-Reiter-Straße"); Assert_NormalizeStreetName("Louis-Häfliger-Gasse"); Assert_NormalizeStreetName("Ludwig-Gruber-Weg"); Assert_NormalizeStreetName("Ludwig-Kirschner-Gasse"); Assert_NormalizeStreetName("Ludwig-Koeßler-Platz"); Assert_NormalizeStreetName("Lydia-Sicher-Gasse"); Assert_NormalizeStreetName("Margit-Doppler-Gasse"); Assert_NormalizeStreetName("Maria-Hirschler-Weg"); Assert_NormalizeStreetName("Maria-Rekker-Gasse"); Assert_NormalizeStreetName("Maria-und-Rudolf-Fischer-Hof"); Assert_NormalizeStreetName("Markgraf-Rüdiger-Straße"); Assert_NormalizeStreetName("Marlen-Haushofer-Weg"); Assert_NormalizeStreetName("Martin-Gaunersdorfer-Gasse"); Assert_NormalizeStreetName("Martin-Schneider-Gasse"); Assert_NormalizeStreetName("Matthias-Schönerer-Gasse"); Assert_NormalizeStreetName("Matthias-Wagner-Gasse"); Assert_NormalizeStreetName("Max-Fleischer-Gasse"); Assert_NormalizeStreetName("Maximilian-Schober-Gasse"); Assert_NormalizeStreetName("Max-Tober-Hof"); Assert_NormalizeStreetName("Max-Winter-Platz"); Assert_NormalizeStreetName("Mela-Köhler-Straße"); Assert_NormalizeStreetName("Mizzi-Günther-Weg"); Assert_NormalizeStreetName("Mona-Lisa-Steiner-Weg"); Assert_NormalizeStreetName("Moritz-Dreger-Gasse"); Assert_NormalizeStreetName("Moritz-Seeler-Gasse"); Assert_NormalizeStreetName("Oskar-Helmer-Hof"); Assert_NormalizeStreetName("Oskar-Pilzer-Platz"); Assert_NormalizeStreetName("Oskar-Werner-Hof"); Assert_NormalizeStreetName("Otto-Bauer-Gasse"); Assert_NormalizeStreetName("Otto-Bründlmayer-Weg"); Assert_NormalizeStreetName("Otto-Geißler-Platz"); Assert_NormalizeStreetName("Ottokar-Fischer-Gasse"); Assert_NormalizeStreetName("Otto-Mauer-Gasse"); Assert_NormalizeStreetName("Otto-Preminger-Straße"); Assert_NormalizeStreetName("Otto-Wagner-Platz"); Assert_NormalizeStreetName("Otto-Weber-Gasse"); Assert_NormalizeStreetName("Otto-Weininger-Gasse"); Assert_NormalizeStreetName("Pater-Zeininger-Platz"); Assert_NormalizeStreetName("Paul-Hopfner-Gasse"); Assert_NormalizeStreetName("Paul-Hörbiger-Weg"); Assert_NormalizeStreetName("Paul-Katzberger-Gasse"); Assert_NormalizeStreetName("Paul-Richter-Hof"); Assert_NormalizeStreetName("Paul-Speiser-Hof"); Assert_NormalizeStreetName("Paul-Wagner-Gasse"); Assert_NormalizeStreetName("Peter-Alexander-Platz"); Assert_NormalizeStreetName("Peter-Berner-Straße"); Assert_NormalizeStreetName("Peter-Kaiser-Gasse"); Assert_NormalizeStreetName("Peter-Strasser-Hof"); Assert_NormalizeStreetName("Pfarrer-Pasecker-Gasse"); Assert_NormalizeStreetName("Raimund-Zoder-Gasse"); Assert_NormalizeStreetName("Reinhardt-Brandstätter-Platz"); Assert_NormalizeStreetName("Richard-Wagner-Platz"); Assert_NormalizeStreetName("Robert-Erber-Hof"); Assert_NormalizeStreetName("Robert-Parzer-Weg"); Assert_NormalizeStreetName("Roland-Rainer-Platz"); Assert_NormalizeStreetName("Romy-Schneider-Gasse"); Assert_NormalizeStreetName("Rosa-Fischer-Gasse"); Assert_NormalizeStreetName("Rosi-Schweizer-Promenade"); Assert_NormalizeStreetName("R.-Platzer-Hof"); Assert_NormalizeStreetName("Rudolf-Hammer-Gasse"); Assert_NormalizeStreetName("Rudolf-Hausner-Gasse"); Assert_NormalizeStreetName("Rudolf-Hitzinger-Hof"); Assert_NormalizeStreetName("Rudolf-Huber-Weg"); Assert_NormalizeStreetName("Rudolf-Kassner-Gasse"); Assert_NormalizeStreetName("Rudolf-Krammer-Hof"); Assert_NormalizeStreetName("Rudolf-Sallinger-Platz"); Assert_NormalizeStreetName("Rudolf-Zeller-Gasse"); Assert_NormalizeStreetName("Rudolf-Zöhrer-Weg"); Assert_NormalizeStreetName("Sabine-Oberhauser-Straße"); Assert_NormalizeStreetName("Schenk-Danzinger-Gasse"); Assert_NormalizeStreetName("Sebastian-Brunner-Gasse"); Assert_NormalizeStreetName("Sepp-Fellner-Gasse"); Assert_NormalizeStreetName("Severin-Schreiber-Gasse"); Assert_NormalizeStreetName("Sissy-Löwinger-Weg"); Assert_NormalizeStreetName("Stefan-Fadinger-Platz"); Assert_NormalizeStreetName("Stefan-Koblinger-Gasse"); Assert_NormalizeStreetName("St.-Peter-Gasse"); Assert_NormalizeStreetName("Stüber-Gunther-Gasse"); Assert_NormalizeStreetName("Theodor-Körner-Gasse"); Assert_NormalizeStreetName("Theodor-Körner-Hof"); Assert_NormalizeStreetName("Theodor-Kramer-Straße"); Assert_NormalizeStreetName("Therese-Schlesinger-Hof"); Assert_NormalizeStreetName("Thomas-Münzer-Gasse"); Assert_NormalizeStreetName("Uzzi-Förster-Weg"); Assert_NormalizeStreetName("Viktor-Adler-Hof"); Assert_NormalizeStreetName("Viktor-Adler-Markt"); Assert_NormalizeStreetName("Viktor-Adler-Platz"); Assert_NormalizeStreetName("Viktor-Wittner-Gasse"); Assert_NormalizeStreetName("Walter-Schwarzacher-Gasse"); Assert_NormalizeStreetName("Wilhelm-Dachauer-Straße"); Assert_NormalizeStreetName("Wilhelm-Exner-Gasse"); Assert_NormalizeStreetName("Wilhelm-Legler-Gasse"); Assert_NormalizeStreetName("Wilhelm-Stemmer-Weg"); Assert_NormalizeStreetName("Wilhelm-Weber-Hof"); Assert_NormalizeStreetName("Wilhelm-Weber-Weg"); Assert_NormalizeStreetName("Willibald-Fischer-Weg"); Assert_NormalizeStreetName("Wolfgang-Mühlwanger-Straße"); } } [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("Ableidingerstraß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("Sechshauserstraß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")); } } } }