public void should_split_string_up_to_given_part_count()
{
var re = new PcreRegex(@"\s+");
var result = re.Split("foo bar baz abc", 2).ToList();
Assert.That(result, Is.EqualTo(new[] { "foo", "bar", "baz abc" }));
}
public void should_check_subject_utf_validity()
{
var re = new PcreRegex(@"A");
var ex = Assert.Throws <PcreMatchException>(() => re.Match("A\uD800B"));
Assert.That(ex.Message, Contains.Substring("invalid low surrogate"));
}
public void should_return_pattern_and_options()
{
var re = new PcreRegex(@"foo\s+bar", PcreOptions.IgnoreCase);
Assert.That(re.PaternInfo.PatternString, Is.EqualTo(@"foo\s+bar"));
Assert.That(re.PaternInfo.Options, Is.EqualTo(PcreOptions.IgnoreCase));
}
public void should_match_starting_at_end_of_string()
{
var re = new PcreRegex(@"(?<=a)");
var matches = re.Matches("xxa", 3).ToList();
Assert.That(matches, Has.Count.EqualTo(1));
}
public void should_execute_passing_callout()
{
const string pattern = @"(a)(*MARK:foo)(x)?(?C42)(bc)";
var re = new PcreRegex(pattern);
var calls = 0;
var match = re.Match("abc", data =>
{
Assert.That(data.Number, Is.EqualTo(42));
Assert.That(data.CurrentOffset, Is.EqualTo(1));
Assert.That(data.PatternPosition, Is.EqualTo(pattern.IndexOf("(?C42)", StringComparison.Ordinal) + 6));
Assert.That(data.StartOffset, Is.EqualTo(0));
Assert.That(data.LastCapture, Is.EqualTo(1));
Assert.That(data.MaxCapture, Is.EqualTo(2));
Assert.That(data.NextPatternItemLength, Is.EqualTo(4));
Assert.That(data.Match.Value, Is.EqualTo("a"));
Assert.That(data.Match[1].Value, Is.EqualTo("a"));
Assert.That(data.Match[2].Success, Is.False);
Assert.That(data.Match[2].Value, Is.SameAs(String.Empty));
Assert.That(data.Match[3].Success, Is.False);
Assert.That(data.Match[3].Value, Is.SameAs(String.Empty));
Assert.That(data.Match.Mark, Is.EqualTo("foo"));
++calls;
return(PcreCalloutResult.Pass);
});
Assert.That(match, Is.Not.Null);
Assert.That(match.Success, Is.True);
Assert.That(calls, Is.EqualTo(1));
}
public void should_insert_nothing_if_no_group_matched()
{
var re = new PcreRegex(@"a+(b+)?");
var result = re.Replace("foo aabb bar baz", "<$+>");
Assert.That(result, Is.EqualTo("foo <bb> b<>r b<>z"));
}
public void should_insert_nothing_if_there_are_no_groups()
{
var re = new PcreRegex(@"a+");
var result = re.Replace("foo bar", "<$+>");
Assert.That(result, Is.EqualTo("foo b<>r"));
}
public void should_split_string()
{
var re = new PcreRegex(@"\s+");
var result = re.Split("foo bar baz").ToList();
Assert.That(result, Is.EqualTo(new[] { "foo", "bar", "baz" }));
}
public void should_split_on_empty_pattern()
{
var re = new PcreRegex(@"");
var result = re.Split("foo").ToList();
Assert.That(result, Is.EqualTo(new[] { "", "f", "o", "o", "" }));
}
public void should_not_include_captured_groups_in_result_if_not_specified()
{
var re = new PcreRegex(@"<(\d)?(.+?)>");
var result = re.Split("foo<bar>baz<42>a").ToList();
Assert.That(result, Is.EqualTo(new[] { "foo", "baz", "a" }));
}
public void should_include_empty_groups_in_result()
{
var re = new PcreRegex(@"<(\d?)(.+?)>");
var result = re.Split("foo<bar>baz<42>a", PcreSplitOptions.IncludeGroupValues).ToList();
Assert.That(result, Is.EqualTo(new[] { "foo", "", "bar", "baz", "4", "2", "a" }));
}
public void should_not_split_when_given_count_is_zero()
{
var re = new PcreRegex(@"\s+");
var result = re.Split("foo bar baz", 0).ToList();
Assert.That(result, Is.EqualTo(new[] { "foo bar baz" }));
}
public void should_split_string_starting_at_given_index_and_up_to_given_part_count()
{
var re = new PcreRegex(@"\s+");
var result = re.Split("foo bar baz abc def", 2, 6).ToList();
Assert.That(result, Is.EqualTo(new[] { "foo bar", "baz", "abc def" }));
}
public void should_split_string_starting_at_given_index()
{
var re = new PcreRegex(@"\s+");
var result = re.Split("foo bar baz abc def", -1, 12).ToList();
Assert.That(result, Is.EqualTo(new[] { "foo bar baz", "abc", "def" }));
}
public void should_insert_subject()
{
var re = new PcreRegex(@"a+(b+)", PcreOptions.IgnoreCase);
var result = re.Replace("foo aabb bar aaabbab baz", "<$_>");
Assert.That(result, Is.EqualTo("foo <foo aabb bar aaabbab baz> bar <foo aabb bar aaabbab baz><foo aabb bar aaabbab baz> baz"));
}
public void should_report_callout_exception_ref()
{
var re = new PcreRegex(@"a(?C1)");
var resultCount = 0;
Assert.Throws <PcreCalloutException>(() =>
{
re.Matches("aaa".AsSpan(), 0, callout =>
{
if (callout.StartOffset >= 2)
{
throw new InvalidOperationException("Simulated exception");
}
return(PcreCalloutResult.Pass);
}).ToList(i =>
{
++resultCount;
return(true);
});
});
Assert.That(resultCount, Is.EqualTo(2));
}
public void should_insert_last_matched_group()
{
var re = new PcreRegex(@"a+(b+)(c+)?", PcreOptions.IgnoreCase);
var result = re.Replace("foo aabb bar aaabbabcc baz", "<$+>");
Assert.That(result, Is.EqualTo("foo <bb> bar <bb><cc> baz"));
}
public void should_only_replace_given_count()
{
var re = new PcreRegex(@"a+", PcreOptions.IgnoreCase);
var result = re.Replace("foo aabb bar aaabbab baz", "X", 2);
Assert.That(result, Is.EqualTo("foo Xbb bXr aaabbab baz"));
}
public void should_replace_matches_with_callback()
{
var re = new PcreRegex(@"a+", PcreOptions.IgnoreCase);
var result = re.Replace("foo aaa bar aAAa baz", match => match.Length.ToString(CultureInfo.InvariantCulture));
Assert.That(result, Is.EqualTo("foo 3 b1r 4 b1z"));
}
public void should_not_replace_when_count_is_zero()
{
var re = new PcreRegex(@"a+", PcreOptions.IgnoreCase);
var result = re.Replace("foo aabb bar aaabbab baz", "X", 0);
Assert.That(result, Is.EqualTo("foo aabb bar aaabbab baz"));
}
public void should_match_from_index()
{
var re = new PcreRegex(@"a");
var matches = re.Matches("foo bar baz", 6).ToList();
Assert.That(matches, Has.Count.EqualTo(1));
}
public void should_start_at_given_index_and_replace_count()
{
var re = new PcreRegex(@"a+", PcreOptions.IgnoreCase);
var result = re.Replace("foo aabb bar aaabbab baz", "X", 2, 8);
Assert.That(result, Is.EqualTo("foo aabb bXr Xbbab baz"));
}
/// <summary>
/// Мапирует релиз сайта album-info в музыкальный релиз
/// </summary>
/// <param name="release">Релиз сайта album-info</param>
/// <returns>Музыкальный релиз</returns>
private DbMusic MapAlbumInfoReleaseToMusic(AlbumInfoRelease release)
{
var music = new DbMusic();
var releaseName = PcreRegex.Match(release.Name, Helper.ReleaseNamePattern).Value;
var releaseType = PcreRegex.Matches(release.Name, Helper.ReleaseTypePattern)
.Select(m => m.Value).LastOrDefault();
var releaseArtist = release.Name.Substring(0, release.Name.IndexOf(" - ", StringComparison.Ordinal));
var releaseGenres = PcreRegex.Matches(release.Genre, Helper.ReleaseGenrePattern).Select(m => m.Value);
var dateFormat = release.Date.Length > 4 ? Helper.LongDateFormat : Helper.ShortDateFormat;
var provider = CultureInfo.CreateSpecificCulture(Const.CultureInfoText);
var releaseDate = DateTime.ParseExact(release.Date, dateFormat, provider);
SaveMusician(music, releaseArtist);
SaveGenre(music, releaseGenres);
music.Title = string.IsNullOrEmpty(releaseName) ? Helper.UnknownName : releaseName;
music.ReleaseDate = releaseDate;
music.Type = releaseType;
music.Artist = string.IsNullOrEmpty(releaseArtist) ? Helper.UnknownArtist : releaseArtist;
music.PosterImagePath = release.CoverPath;
music.PosterImageUrl = release.ImageFullUrl;
return(music);
}
public void should_replace_matches_with_pattern()
{
var re = new PcreRegex(@"a+(b+)", PcreOptions.IgnoreCase);
var result = re.Replace("foo aabb bar aaabbab baz", "<$0><$1><$&>");
Assert.That(result, Is.EqualTo("foo <aabb><bb><aabb> bar <aaabb><bb><aaabb><ab><b><ab> baz"));
}
public void should_support_multiple_groups()
{
var re = new PcreRegex(@"a+(b+)(c+)?(d+)e+");
var match = re.Match("xxxaaabbddeeezzz");
Assert.That(match, Is.Not.Null);
Assert.That(match.Success, Is.True);
Assert.That(match.CaptureCount, Is.EqualTo(3));
Assert.That(match.Value, Is.EqualTo("aaabbddeee"));
Assert.That(match.Index, Is.EqualTo(3));
Assert.That(match.Length, Is.EqualTo(10));
Assert.That(match[1], Is.Not.Null);
Assert.That(match[1].Success, Is.True);
Assert.That(match[1].Value, Is.EqualTo("bb"));
Assert.That(match[1].Index, Is.EqualTo(6));
Assert.That(match[1].Length, Is.EqualTo(2));
Assert.That(match[2], Is.Not.Null);
Assert.That(match[2].Success, Is.False);
Assert.That(match[2].Value, Is.SameAs(string.Empty));
Assert.That(match[2].Index, Is.EqualTo(-1));
Assert.That(match[2].Length, Is.EqualTo(0));
Assert.That(match[3], Is.Not.Null);
Assert.That(match[3].Success, Is.True);
Assert.That(match[3].Value, Is.EqualTo("dd"));
Assert.That(match[3].Index, Is.EqualTo(8));
Assert.That(match[3].Length, Is.EqualTo(2));
}
public void should_replace_named_groups()
{
var re = new PcreRegex(@"a+(?<grp>b+)", PcreOptions.IgnoreCase);
var result = re.Replace("foo aabb bar aaabbab baz", "<${grp}>");
Assert.That(result, Is.EqualTo("foo <bb> bar <bb><b> baz"));
}
public void should_handle_named_groups()
{
var re = new PcreRegex(@"a+(?<bees>b+)(c+)(?<dees>d+)e+");
var match = re.Match("xxxaaabbcccddeeezzz");
Assert.That(match, Is.Not.Null);
Assert.That(match.Success, Is.True);
Assert.That(match.CaptureCount, Is.EqualTo(3));
Assert.That(match.Value, Is.EqualTo("aaabbcccddeee"));
Assert.That(match.Index, Is.EqualTo(3));
Assert.That(match.Length, Is.EqualTo(13));
Assert.That(match["bees"], Is.Not.Null);
Assert.That(match["bees"].Value, Is.EqualTo("bb"));
Assert.That(match["bees"].Index, Is.EqualTo(6));
Assert.That(match["bees"].Length, Is.EqualTo(2));
Assert.That(match.Groups["bees"], Is.SameAs(match["bees"]));
Assert.That(match[2], Is.Not.Null);
Assert.That(match[2].Value, Is.EqualTo("ccc"));
Assert.That(match[2].Index, Is.EqualTo(8));
Assert.That(match[2].Length, Is.EqualTo(3));
Assert.That(match["dees"], Is.Not.Null);
Assert.That(match["dees"].Value, Is.EqualTo("dd"));
Assert.That(match["dees"].Index, Is.EqualTo(11));
Assert.That(match["dees"].Length, Is.EqualTo(2));
}
public void should_insert_dollar()
{
var re = new PcreRegex(@"a+(b+)", PcreOptions.IgnoreCase);
var result = re.Replace("foo aabb bar aaabbab baz", "$$-$");
Assert.That(result, Is.EqualTo("foo $-$ bar $-$$-$ baz"));
}
public void should_match_with_dfa()
{
var re = new PcreRegex(@"<.*>");
var result = re.Dfa.Match("This is <something> <something else> <something further> no more");
Assert.That(result, Is.Not.Null);
Assert.That(result.Success, Is.True);
Assert.That(result.Count, Is.EqualTo(3));
Assert.That(result.Index, Is.EqualTo(8));
Assert.That(result.LongestMatch, Is.Not.Null);
Assert.That(result.LongestMatch.Value, Is.EqualTo("<something> <something else> <something further>"));
Assert.That(result.LongestMatch, Is.SameAs(result[0]));
Assert.That(result.ShortestMatch, Is.SameAs(result[2]));
Assert.That(result.ShortestMatch, Is.Not.Null);
Assert.That(result.ShortestMatch.Value, Is.EqualTo("<something>"));
Assert.That(result[1], Is.Not.Null);
Assert.That(result[1].Value, Is.EqualTo("<something> <something else>"));
Assert.That(result[3], Is.Null);
}
public void should_split_string_at_start_and_end()
{
var re = new PcreRegex(@"\s+");
var result = re.Split(" foo bar baz ").ToList();
Assert.That(result, Is.EqualTo(new[] { string.Empty, "foo", "bar", "baz", string.Empty }));
}
