winzer/elwig
2
1
Fork 0
Code Issues 8 Pull Requests Actions Releases 85 Activity
Files
155a599878c73ea350c8af6aeb3864eb334eee32
elwig/Tests/UnitTests/HelperTests/NormalizerTest.cs
T

2809 lines
200 KiB
C#
Raw Blame History

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"));
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink