public void UnicodeCategoryByFlagPatternGenerationsTest()
{
for (RegexUnicodeCategoryFlag flag = RegexUnicodeCategoryFlag.Lo; flag < RegexUnicodeCategoryFlag.Z; flag = (RegexUnicodeCategoryFlag)((int)flag << 1))
{
// Arrange
var expectedPattern = $@"\p{{{flag}}}+";
var regexGenerator = new RegexGenerator(RegexLanguage.DotNet)
.AddUnicodeCategory(flag, min: 1);
// Act
var actualPattern = regexGenerator.ToString();
// Assert
Assert.Equal(expectedPattern, actualPattern);
}
}
public void UnicodeCategoryByFlagPatternGenerationsTest()
{
for (RegexUnicodeCategoryFlag flag = RegexUnicodeCategoryFlag.Lo; flag < RegexUnicodeCategoryFlag.Z; flag = (RegexUnicodeCategoryFlag)((int)flag << 1))
{
// Arrange
var pattern = $@"\p{{{flag}}}+";
var expectedPattern = $"/{pattern}/";
Assert.Throws <UnicodeCategoryNotSupportedException>(() =>
{
var regexGenerator = new RegexGenerator(RegexLanguage.ECMAScript)
.AddUnicodeCategory(flag, min: 1);
// Act
var actualPattern = regexGenerator.ToString();
// Assert
Assert.Equal(expectedPattern, actualPattern);
});
}
}
/// <summary>
/// Create and add <see cref="RegexUnicodeCategoryNode"/> to the generator.
/// <seealso cref="RegexUnicodeCategoryNode(RegexUnicodeCategoryFlag, bool, int?, int?, RegexQuantifierOption)"/>
/// <seealso cref="AddUnicodeCategory(RegexUnicodeCategoryNode)"/>
/// </summary>
/// <param name="unicodeCategory">Value from <see cref="RegexUnicodeCategoryFlag"/>.</param>
/// <param name="negative">Optional value to determine if negate the category.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
/// <returns><see cref="RegexGenerator"/></returns>
/// <exception cref="UnicodeCategoryNotSupportedException">Unicode category is not supported by <see cref="RegexLanguage"/>.</exception>
public RegexGenerator AddUnicodeCategory(RegexUnicodeCategoryFlag unicodeCategory, bool negative = false, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
{
var unicodeCategoryNode = new RegexUnicodeCategoryNode(unicodeCategory, negative, min, max, quantifierOption);
return(AddUnicodeCategory(unicodeCategoryNode));
}
/// <summary>
/// Initialize an instance of <see cref="RegexUnicodeCategoryNode"/> with flag <see cref="RegexUnicodeCategoryFlag"/>.
/// <para>Internally call <see cref="Enum.ToString()"/>. Therefore, only use one value from <see cref="RegexUnicodeCategoryFlag"/> while using this constructor;
/// Use <see cref="RegexUnicodeCategoryNode(string, bool, int?, int?, RegexQuantifierOption)"/> instead for named unicode block.</para>
/// <seealso cref="RegexUnicodeCategoryNode(string, bool, int?, int?, RegexQuantifierOption)"/>
/// </summary>
/// <remarks>
/// <code>
/// (RegexUnicodeCategoryFlag.Lu | RegexUnicodeCategoryFlag.Ll).ToString() // will generate "Lu, Ll", which is a invalid form.
/// </code>
/// </remarks>
/// <param name="unicodeCategory">Value from <see cref="RegexUnicodeCategoryFlag"/>.</param>
/// <param name="negative">Optional value to determine if negate the category.</param>
/// <param name="min">Optional minimum number of occurance.</param>
/// <param name="max">Optional maximum number of occurance.</param>
/// <param name="quantifierOption">Optional quantifier option.</param>
public RegexUnicodeCategoryNode(RegexUnicodeCategoryFlag unicodeCategory, bool negative = false, int?min = null, int?max = null, RegexQuantifierOption quantifierOption = RegexQuantifierOption.Greedy)
: base(unicodeCategory.ToString(), min, max, quantifierOption)
{
Negative = negative;
}
public void UnicodeCategoryByFlagMatchesTest()
{
var textDict = new Dictionary <RegexUnicodeCategoryFlag, string>()
{
{ RegexUnicodeCategoryFlag.Lu, "A" }, // U+0041
{ RegexUnicodeCategoryFlag.Ll, "a" }, // U+0061
{ RegexUnicodeCategoryFlag.Lt, "Dž" }, // U+01C5
//{ RegexUnicodeCategoryFlag.LC, "AaDž" },
{ RegexUnicodeCategoryFlag.Lm, "ʰ" }, // U+02B0
{ RegexUnicodeCategoryFlag.Lo, "ƻ" }, // U+01BB
//{ RegexUnicodeCategoryFlag.L, "AaDžʰƻ" }.
{ RegexUnicodeCategoryFlag.Mn, "\u033A" }, // U+033A
{ RegexUnicodeCategoryFlag.Mc, "\u0903" }, // U+0903
{ RegexUnicodeCategoryFlag.Me, "\u20E0" }, // U+20E0
//{ RegexUnicodeCategoryFlag.M, "\u033A\U0001D16F\u20E0" },
{ RegexUnicodeCategoryFlag.Nd, "0" }, // U+0030
{ RegexUnicodeCategoryFlag.Nl, "〡" }, // U+3021
{ RegexUnicodeCategoryFlag.No, "¼" }, // U+00BC
//{ RegexUnicodeCategoryFlag.N, "0〡¼" },
{ RegexUnicodeCategoryFlag.Pc, "_" }, // U+005F
{ RegexUnicodeCategoryFlag.Pd, "-" }, // U+002D
{ RegexUnicodeCategoryFlag.Ps, "(" }, // U+0028
{ RegexUnicodeCategoryFlag.Pe, ")" }, // U+0029
{ RegexUnicodeCategoryFlag.Pi, "«" }, // U+00AB
{ RegexUnicodeCategoryFlag.Pf, "»" }, // U+00BB
{ RegexUnicodeCategoryFlag.Po, "!" }, // U+0021
//{ RegexUnicodeCategoryFlag.P, "_-()«»!" },
{ RegexUnicodeCategoryFlag.Sm, "+" }, // U+002B
{ RegexUnicodeCategoryFlag.Sc, "$" }, // U+0024
{ RegexUnicodeCategoryFlag.Sk, "^" }, // U+005E
{ RegexUnicodeCategoryFlag.So, "⚡" }, // U+26A1
//{ RegexUnicodeCategoryFlag.S, "+$^⚡" },
{ RegexUnicodeCategoryFlag.Zs, " " }, // U+0020
{ RegexUnicodeCategoryFlag.Zl, "\u2028" }, // U+2028
{ RegexUnicodeCategoryFlag.Zp, "\u2029" }, // U+2029
//{ RegexUnicodeCategoryFlag.Z, " \u2028\u2029" },
{ RegexUnicodeCategoryFlag.Cc, "\u0000" }, // U+0000
{ RegexUnicodeCategoryFlag.Cf, "\u00AD" }, // U+00AD
{ RegexUnicodeCategoryFlag.Cs, "\uD800" }, // U+D800
{ RegexUnicodeCategoryFlag.Co, "\uE000" }, // U+E000
//{ RegexUnicodeCategoryFlag.Cn, "" }, // nothing
//{ RegexUnicodeCategoryFlag.C, "\u0000\u00AD\uD800\uE000" }
};
for (RegexUnicodeCategoryFlag flag = RegexUnicodeCategoryFlag.Lu; flag < RegexUnicodeCategoryFlag.Cn; flag = (RegexUnicodeCategoryFlag)((int)flag << 1))
{
// Arrange
var text = textDict[flag];
var regex = new Regex($@"\p{{{flag}}}+");
var expectedMatch = regex.Match(text);
var regexGenerator = new RegexGenerator(RegexLanguage.DotNet)
.AddUnicodeCategory(flag, min: 1);
// Act
var generatedRegex = regexGenerator.Create();
var actualMatch = generatedRegex.Match(text);
// Assert
Assert.True(expectedMatch.Success);
Assert.True(actualMatch.Success);
Assert.Equal(expectedMatch.Value, actualMatch.Value);
}
}
