public void CleanStringLeadingChars()
{
var helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
// letters and digits are valid leading chars
IsTerm = (c, leading) => char.IsLetterOrDigit(c),
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '*',
}));
Assert.AreEqual("0123foo*bar*543*nil*321", helper.CleanString("0123foo_bar 543 nil 321", CleanStringType.Alias));
helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
// only letters are valid leading chars
IsTerm = (c, leading) => leading ? char.IsLetter(c) : char.IsLetterOrDigit(c),
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '*',
}));
Assert.AreEqual("foo*bar*543*nil*321", helper.CleanString("0123foo_bar 543 nil 321", CleanStringType.Alias));
Assert.AreEqual("foo*bar*543*nil*321", helper.CleanString("0123 foo_bar 543 nil 321", CleanStringType.Alias));
helper = new DefaultShortStringHelper(
new DefaultShortStringHelperConfig().WithDefault(new RequestHandlerSettings()));
Assert.AreEqual("child2", helper.CleanStringForSafeAlias("1child2"));
}
public void CleanStringAcronymOnNonUpper()
{
var helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
// non-uppercase letter means cut acronym
CutAcronymOnNonUpper = true,
Separator = '*',
}));
Assert.AreEqual("foo*BAR*Rnil", helper.CleanString("foo BARRnil", CleanStringType.Alias));
Assert.AreEqual("foo*BA*Rnil", helper.CleanString("foo BARnil", CleanStringType.Alias));
Assert.AreEqual("foo*BAnil", helper.CleanString("foo BAnil", CleanStringType.Alias));
Assert.AreEqual("foo*Bnil", helper.CleanString("foo Bnil", CleanStringType.Alias));
helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
// non-uppercase letter means word
CutAcronymOnNonUpper = false,
Separator = '*',
}));
Assert.AreEqual("foo*BARRnil", helper.CleanString("foo BARRnil", CleanStringType.Alias));
Assert.AreEqual("foo*BARnil", helper.CleanString("foo BARnil", CleanStringType.Alias));
Assert.AreEqual("foo*BAnil", helper.CleanString("foo BAnil", CleanStringType.Alias));
Assert.AreEqual("foo*Bnil", helper.CleanString("foo Bnil", CleanStringType.Alias));
}
public void CleanStringGreedyAcronyms()
{
var helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(
CleanStringType.Alias,
new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
CutAcronymOnNonUpper = true,
GreedyAcronyms = true,
Separator = '*',
}));
Assert.AreEqual("foo*BARR*nil", helper.CleanString("foo BARRnil", CleanStringType.Alias));
Assert.AreEqual("foo*BAR*nil", helper.CleanString("foo BARnil", CleanStringType.Alias));
Assert.AreEqual("foo*BA*nil", helper.CleanString("foo BAnil", CleanStringType.Alias));
Assert.AreEqual("foo*Bnil", helper.CleanString("foo Bnil", CleanStringType.Alias));
helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(
CleanStringType.Alias,
new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
CutAcronymOnNonUpper = true,
GreedyAcronyms = false,
Separator = '*',
}));
Assert.AreEqual("foo*BAR*Rnil", helper.CleanString("foo BARRnil", CleanStringType.Alias));
Assert.AreEqual("foo*BA*Rnil", helper.CleanString("foo BARnil", CleanStringType.Alias));
Assert.AreEqual("foo*BAnil", helper.CleanString("foo BAnil", CleanStringType.Alias));
Assert.AreEqual("foo*Bnil", helper.CleanString("foo Bnil", CleanStringType.Alias));
}
public void CleanStringEncoding()
{
var helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(
CleanStringType.Alias,
new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '*',
}));
Assert.AreEqual("中文测试", helper.CleanString("中文测试", CleanStringType.Alias));
Assert.AreEqual("léger*中文测试*ZÔRG", helper.CleanString("léger 中文测试 ZÔRG", CleanStringType.Alias));
helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(
CleanStringType.Alias,
new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Ascii | CleanStringType.Unchanged,
Separator = '*',
}));
Assert.AreEqual(string.Empty, helper.CleanString("中文测试", CleanStringType.Alias));
Assert.AreEqual("leger*ZORG", helper.CleanString("léger 中文测试 ZÔRG", CleanStringType.Alias));
}
public void CleanStringWithTypeAndCulture(string input, string expected, string culture, CleanStringType stringType)
{
var cinfo = culture == null ? CultureInfo.InvariantCulture : new CultureInfo(culture);
var separator = (stringType & CleanStringType.Url) == CleanStringType.Url ? '-' : char.MinValue;
var output = _helper.CleanString(input, stringType, separator, cinfo);
Assert.AreEqual(expected, output);
}
public void CleanStringWhiteSpace()
{
var helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig().WithDefault(new RequestHandlerSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '*'
}));
Assert.AreEqual("foo", helper.CleanString(" foo ", CleanStringType.Alias));
Assert.AreEqual("foo*bar", helper.CleanString(" foo bar ", CleanStringType.Alias));
}
public void CleanStringWhiteSpace()
{
var helper = new DefaultShortStringHelper(SettingsForTests.GetDefault())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelper.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '*'
});
Assert.AreEqual("foo", helper.CleanString(" foo ", CleanStringType.Alias));
Assert.AreEqual("foo*bar", helper.CleanString(" foo bar ", CleanStringType.Alias));
}
public void CleanStringUnderscoreInTerm()
{
var helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
// underscore is accepted within terms
IsTerm = (c, leading) => char.IsLetterOrDigit(c) || c == '_',
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '*',
}));
Assert.AreEqual("foo_bar*nil", helper.CleanString("foo_bar nil", CleanStringType.Alias));
helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
// underscore is not accepted within terms
IsTerm = (c, leading) => char.IsLetterOrDigit(c),
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '*',
}));
Assert.AreEqual("foo*bar*nil", helper.CleanString("foo_bar nil", CleanStringType.Alias));
}
public void CleanStringSeparator()
{
var helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig().WithDefault(SettingsForTests.GetDefaultUmbracoSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '*'
}));
Assert.AreEqual("foo*bar", helper.CleanString("foo bar", CleanStringType.Alias));
helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig().WithDefault(SettingsForTests.GetDefaultUmbracoSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = ' '
}));
Assert.AreEqual("foo bar", helper.CleanString("foo bar", CleanStringType.Alias));
helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig().WithDefault(SettingsForTests.GetDefaultUmbracoSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged
}));
Assert.AreEqual("foobar", helper.CleanString("foo bar", CleanStringType.Alias));
helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig().WithDefault(SettingsForTests.GetDefaultUmbracoSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '文'
}));
Assert.AreEqual("foo文bar", helper.CleanString("foo bar", CleanStringType.Alias));
}
public void CleanStringTermOnUpper()
{
var helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
// uppercase letter means new term
BreakTermsOnUpper = true,
Separator = '*',
}));
Assert.AreEqual("foo*Bar", helper.CleanString("fooBar", CleanStringType.Alias));
helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
// uppercase letter is part of term
BreakTermsOnUpper = false,
Separator = '*',
}));
Assert.AreEqual("fooBar", helper.CleanString("fooBar", CleanStringType.Alias));
}
public void CleanStringWithUnderscore(string input, string expected, bool allowUnderscoreInTerm)
{
var helper = new DefaultShortStringHelper()
.WithConfig(allowUnderscoreInTerm: allowUnderscoreInTerm);
var output = helper.CleanString(input, CleanStringType.Alias | CleanStringType.Ascii | CleanStringType.CamelCase);
Assert.AreEqual(expected, output);
}
public void CleanStringWithTypeAndCulture(string input, string expected, string culture, CleanStringType stringType)
{
// picks the proper config per culture
// and overrides some stringType params (ascii...)
var output = _helper.CleanString(input, stringType, culture);
Assert.AreEqual(expected, output);
}
public void CleanStringWithTypeAndCulture(string input, string expected, string culture, CleanStringType stringType)
{
var cinfo = culture == null ? CultureInfo.InvariantCulture : new CultureInfo(culture);
// picks the proper config per culture
// and overrides some stringType params (ascii...)
var output = _helper.CleanString(input, stringType, cinfo);
Assert.AreEqual(expected, output);
}
public void CleanStringEncoding()
{
var helper = new DefaultShortStringHelper(SettingsForTests.GetDefault())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelper.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '*'
});
Assert.AreEqual("中文测试", helper.CleanString("中文测试", CleanStringType.Alias));
Assert.AreEqual("léger*中文测试*ZÔRG", helper.CleanString("léger 中文测试 ZÔRG", CleanStringType.Alias));
helper = new DefaultShortStringHelper(SettingsForTests.GetDefault())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelper.Config
{
StringType = CleanStringType.Ascii | CleanStringType.Unchanged,
Separator = '*'
});
Assert.AreEqual("", helper.CleanString("中文测试", CleanStringType.Alias));
Assert.AreEqual("leger*ZORG", helper.CleanString("léger 中文测试 ZÔRG", CleanStringType.Alias));
}
public void CleanStringSymbols()
{
var helper = new DefaultShortStringHelper(SettingsForTests.GetDefault())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelper.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '*'
});
Assert.AreEqual("house*2", helper.CleanString("house (2)", CleanStringType.Alias));
// FIXME but for a filename we want to keep them!
// FIXME and what about a url?
}
public void CleanStringSymbols()
{
var helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig().WithDefault(new RequestHandlerSettings())
.WithConfig(CleanStringType.Alias, new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = '*'
}));
Assert.AreEqual("house*2", helper.CleanString("house (2)", CleanStringType.Alias));
// FIXME: but for a filename we want to keep them!
// FIXME: and what about a URL?
}
public void CleanStringCasing()
{
var helper = new DefaultShortStringHelper(new DefaultShortStringHelperConfig()
.WithDefault(new RequestHandlerSettings())
.WithConfig(
CleanStringType.Alias,
new DefaultShortStringHelperConfig.Config
{
StringType = CleanStringType.Utf8 | CleanStringType.Unchanged,
Separator = ' ',
}));
// BBB is an acronym
// E is a word (too short to be an acronym)
// FF is an acronym
// FIXME: "C" can't be an acronym
// FIXME: "DBXreview" = acronym?!
Assert.AreEqual(
"aaa BBB CCc Ddd E FF",
helper.CleanString("aaa BBB CCc Ddd E FF", CleanStringType.Alias)); // unchanged
Assert.AreEqual(
"aaa Bbb Ccc Ddd E FF",
helper.CleanString("aaa BBB CCc Ddd E FF", CleanStringType.Alias | CleanStringType.CamelCase));
Assert.AreEqual("Aaa Bbb Ccc Ddd E FF", helper.CleanString("aaa BBB CCc Ddd E FF", CleanStringType.Alias | CleanStringType.PascalCase));
Assert.AreEqual(
"aaa bbb ccc ddd e ff",
helper.CleanString("aaa BBB CCc Ddd E FF", CleanStringType.Alias | CleanStringType.LowerCase));
Assert.AreEqual(
"AAA BBB CCC DDD E FF",
helper.CleanString("aaa BBB CCc Ddd E FF", CleanStringType.Alias | CleanStringType.UpperCase));
Assert.AreEqual(
"aaa BBB CCc Ddd E FF",
helper.CleanString("aaa BBB CCc Ddd E FF", CleanStringType.Alias | CleanStringType.UmbracoCase));
// MS rules & guidelines:
// - Do capitalize both characters of two-character acronyms, except the first word of a camel-cased identifier.
// eg "DBRate" (pascal) or "ioHelper" (camel) - "SpecialDBRate" (pascal) or "specialIOHelper" (camel)
// - Do capitalize only the first character of acronyms with three or more characters, except the first word of a camel-cased identifier.
// eg "XmlWriter (pascal) or "htmlReader" (camel) - "SpecialXmlWriter" (pascal) or "specialHtmlReader" (camel)
// - Do not capitalize any of the characters of any acronyms, whatever their length, at the beginning of a camel-cased identifier.
// eg "xmlWriter" or "dbWriter" (camel)
Assert.AreEqual(
"aaa BB Ccc",
helper.CleanString("aaa BB ccc", CleanStringType.Alias | CleanStringType.CamelCase));
Assert.AreEqual(
"aa Bb Ccc",
helper.CleanString("AA bb ccc", CleanStringType.Alias | CleanStringType.CamelCase));
Assert.AreEqual(
"aaa Bb Ccc",
helper.CleanString("AAA bb ccc", CleanStringType.Alias | CleanStringType.CamelCase));
Assert.AreEqual("db Rate", helper.CleanString("DB rate", CleanStringType.Alias | CleanStringType.CamelCase));
Assert.AreEqual(
"special DB Rate",
helper.CleanString("special DB rate", CleanStringType.Alias | CleanStringType.CamelCase));
Assert.AreEqual(
"xml Writer",
helper.CleanString("XML writer", CleanStringType.Alias | CleanStringType.CamelCase));
Assert.AreEqual(
"special Xml Writer",
helper.CleanString("special XML writer", CleanStringType.Alias | CleanStringType.CamelCase));
Assert.AreEqual(
"Aaa BB Ccc",
helper.CleanString("aaa BB ccc", CleanStringType.Alias | CleanStringType.PascalCase));
Assert.AreEqual(
"AA Bb Ccc",
helper.CleanString("AA bb ccc", CleanStringType.Alias | CleanStringType.PascalCase));
Assert.AreEqual(
"Aaa Bb Ccc",
helper.CleanString("AAA bb ccc", CleanStringType.Alias | CleanStringType.PascalCase));
Assert.AreEqual("DB Rate", helper.CleanString("DB rate", CleanStringType.Alias | CleanStringType.PascalCase));
Assert.AreEqual(
"Special DB Rate",
helper.CleanString("special DB rate", CleanStringType.Alias | CleanStringType.PascalCase));
Assert.AreEqual(
"Xml Writer",
helper.CleanString("XML writer", CleanStringType.Alias | CleanStringType.PascalCase));
Assert.AreEqual(
"Special Xml Writer",
helper.CleanString("special XML writer", CleanStringType.Alias | CleanStringType.PascalCase));
}