private void okBtn_Click(object sender, EventArgs e)
{
StringMode pattern = GetRadioChecked();
string expression = textBox.Text;
if (pattern == StringMode.Javascript)
{
expression = textBox.Text;
}
else if (pattern == StringMode.Regex)
{
expression = regexTextbox.Text;
}
if (pattern == StringMode.Replace)
{
for (int i = 0; i < replaceList.Count; i++)
{
if (i == 0)
{
expression = "";
}
else
{
expression += ",";
}
expression += replaceList.GetKey(i) + "," + replaceList.Get(i);
}
}
Pattern = new StringPattern()
{
Expression = expression,
Pattern = pattern
};
}
public void testIsInitialCapitalLetter()
{
Assert.True(StringPattern.Recognize("Test").InitialCapitalLetter);
Assert.False(StringPattern.Recognize("tEST").InitialCapitalLetter);
Assert.True(StringPattern.Recognize("TesT").InitialCapitalLetter);
Assert.True(StringPattern.Recognize("Üäöæß").InitialCapitalLetter);
}
public StringRegexForm(StringPattern stringPattern, string testData) : this()
{
// TODO: Complete member initialization
this.stringPattern = stringPattern;
this.testData = testData;
UpdateTabPage(stringPattern.Pattern);
if (stringPattern.Pattern == StringMode.Javascript)
{
scriptRadio.Checked = true;
textBox.Text = stringPattern.Expression;
}
else if (stringPattern.Pattern == StringMode.Regex)
{
regexRadio.Checked = true;
regexTextbox.Text = stringPattern.Expression;
}
else if (stringPattern.Pattern == StringMode.Replace)
{
replaceRadioButton.Checked = true;
string[] arr = stringPattern.Expression.Split(",".ToCharArray());
replaceList.Clear();
for (int i = 0; i < arr.Length; i++)
{
replaceList.Add(arr[i], arr[i + 1]);
i++;
}
UpdateListBox();
}
}
public void MatcherModelMapper_Map_WildcardMatcher_With_PatternAsFile()
{
// Arrange
var file = "c:\\test.txt";
var fileContent = "c";
var stringPattern = new StringPattern
{
Pattern = fileContent,
PatternAsFile = file
};
var fileSystemHandleMock = new Mock <IFileSystemHandler>();
fileSystemHandleMock.Setup(f => f.ReadFileAsString(file)).Returns(fileContent);
var model = new MatcherModel
{
Name = "WildcardMatcher",
PatternAsFile = file
};
var settings = new WireMockServerSettings
{
FileSystemHandler = fileSystemHandleMock.Object
};
var sut = new MatcherMapper(settings);
// Act
var matcher = (WildcardMatcher)sut.Map(model);
// Assert
matcher.GetPatterns().Should().HaveCount(1).And.Contain(new AnyOf <string, StringPattern>(stringPattern));
matcher.IsMatch("c").Should().Be(1.0d);
}
///////////////////////////////////////////////////////////////////////////////////////////
public static NameRule Read(Context context, XmlElement element)
{
return(new NameRule
{
Name = StringPattern.Create(MCAD.XmlCommon.XmlTools.GetElement(element, "name"))
});
}
public void testIsAllCapitalLetter()
{
Assert.True(StringPattern.Recognize("TEST").AllCapitalLetter);
Assert.True(StringPattern.Recognize("ÄÄÄÜÜÜÖÖÖÖ").AllCapitalLetter);
Assert.False(StringPattern.Recognize("ÄÄÄÜÜÜÖÖä").AllCapitalLetter);
Assert.False(StringPattern.Recognize("ÄÄÄÜÜdÜÖÖ").AllCapitalLetter);
}
public void testIsAllLetters()
{
Assert.True(StringPattern.Recognize("test").AllLetter);
Assert.True(StringPattern.Recognize("TEST").AllLetter);
Assert.True(StringPattern.Recognize("TesT").AllLetter);
Assert.True(StringPattern.Recognize("grün").AllLetter);
Assert.True(StringPattern.Recognize("üäöæß").AllLetter);
}
public static void PopulatePOSDictionary(IObjectStream <POSSample> samples, IMutableTagDictionary dictionary, bool caseSensitive, int cutoff)
{
var newEntries = new Dictionary <string, Dictionary <string, int> >();
POSSample sample;
while ((sample = samples.Read()) != null)
{
for (int i = 0; i < sample.Sentence.Length; i++)
{
if (!StringPattern.Recognize(sample.Sentence[i]).ContainsDigit)
{
string word = caseSensitive ? sample.Sentence[i] : sample.Sentence[i].ToLowerInvariant();
if (!newEntries.ContainsKey(word))
{
newEntries.Add(word, new Dictionary <string, int>());
}
var dicTags = dictionary.GetTags(word);
if (dicTags != null)
{
foreach (var tag in dicTags)
{
if (!newEntries[word].ContainsKey(tag))
{
newEntries[word].Add(tag, cutoff);
}
}
}
if (!newEntries[word].ContainsKey(sample.Tags[i]))
{
newEntries[word].Add(sample.Tags[i], 1);
}
else
{
newEntries[word][sample.Tags[i]]++;
}
}
}
}
foreach (var wordEntry in newEntries)
{
var tagsForWord = new List <string>();
foreach (var entry in wordEntry.Value)
{
if (entry.Value >= cutoff)
{
tagsForWord.Add(entry.Key);
}
}
if (tagsForWord.Count > 0)
{
dictionary.Put(wordEntry.Key, tagsForWord.ToArray());
}
}
}
public int FindCategoryBM(TwitterStatus tweet, List <StringPattern> Final)
{
int kategori = 0;
String TField = tweet.Text.ToLower();
List <StringPattern> Find = new List <StringPattern>();
foreach (var item in Final)
{
if (item.Next == null)
{
BoyerMoore bm = new BoyerMoore(item.Data.ToLower());
if (bm.Search(TField) != -1)
{
Find.Add(item);
}
}
else
{
StringPattern P = new StringPattern();
P = item;
bool valid = true;
while (P != null)
{
BoyerMoore bm = new BoyerMoore(P.Data.ToLower());
if (bm.Search(TField) == -1)
{
valid = false;
break;
}
P = P.Next;
}
if (valid == true)
{
Find.Add(item);
}
}
}
int min = 999;
foreach (var item in Find)
{
BoyerMoore bm = new BoyerMoore(item.Data.ToLower());
if (bm.Search(TField) < min)
{
min = bm.Search(TField);
}
}
foreach (var item in Find)
{
BoyerMoore bm = new BoyerMoore(item.Data.ToLower());
if (bm.Search(TField) == min)
{
kategori = item.Kategori;
}
}
return(kategori);
}
public void testIsAllLowerCaseLetter()
{
Assert.True(StringPattern.Recognize("test").AllLowerCaseLetter);
Assert.True(StringPattern.Recognize("öäü").AllLowerCaseLetter);
Assert.True(StringPattern.Recognize("öäüßßß").AllLowerCaseLetter);
Assert.False(StringPattern.Recognize("Test").AllLowerCaseLetter);
Assert.False(StringPattern.Recognize("TEST").AllLowerCaseLetter);
Assert.False(StringPattern.Recognize("testT").AllLowerCaseLetter);
Assert.False(StringPattern.Recognize("tesÖt").AllLowerCaseLetter);
}
public StringPattern Parse(string pattern)
{
var result = new StringPattern();
var currentMatch = Pattern.Match(pattern);
do
{
var part = HandlePart(currentMatch);
result.Add(part);
currentMatch = currentMatch.NextMatch();
} while (currentMatch.Success);
return(result);
}
public void WildcardMatcher_IsMatch_With_StringMatcher_And_StringPattern()
{
// Arrange
var pattern = new StringPattern
{
Pattern = "*",
PatternAsFile = "pf"
};
// Act
var matcher = new WildcardMatcher(pattern);
// Assert
matcher.IsMatch("a").Should().Be(1.0d);
}
/// <summary>
/// Ensures that constraints for this field are satisfied.
/// </summary>
/// <returns>
/// Null if the value is OK, otherwise an error message.
/// </returns>
public string ValidateFieldValue(object value)
{
var sValue = ( string )value;
if (_field.IsRequired == true && string.IsNullOrEmpty(sValue))
{
return(string.Format(GlobalStrings.MandatoryMessageTextFormat, _field.Name));
}
if (sValue != null)
{
if (sValue.Length > RealMaximumStringFieldLength)
{
return(string.Format(GlobalStrings.MaximumLengthMessageTextFormat, _field.Name, RealMaximumStringFieldLength));
}
if (_field.MaxLength > 0 && sValue.Length > _field.MaxLength)
{
return(string.Format(GlobalStrings.MaximumLengthMessageTextFormat, _field.Name, _field.MaxLength));
}
if (sValue.Length < _field.MinLength)
{
return(string.Format(GlobalStrings.MinimumLengthMessageTextFormat, _field.Name, _field.MinLength));
}
if (!string.IsNullOrEmpty(sValue))
{
StringPattern pattern = _field.Pattern ?? Entity.Get <StringPattern>("core:defaultPattern");
// Note: Regex will only get applied if a value is set.
// Use IsRequired to ensure that a value is set.
string regex = pattern.Regex;
if (string.IsNullOrEmpty(regex))
{
throw new Exception(GlobalStrings.RegexNullExceptionMessage);
}
if (!Regex.IsMatch(sValue, regex))
{
return(string.Format(GlobalStrings.PatternMatchMessageTextFormat, pattern.Name));
}
}
}
return(null);
}
public void Request_WithPathRegexMatcher_WithPatternAsFile_HasMatch()
{
// Arrange
var pattern = new StringPattern
{
Pattern = "^/foo",
PatternAsFile = "c:\\x.txt"
};
var spec = Request.Create().WithPath(new RegexMatcher(pattern));
// when
var request = new RequestMessage(new UrlDetails("http://localhost/foo/bar"), "blabla", ClientIp);
// then
var requestMatchResult = new RequestMatchResult();
Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
}
public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_StringPattern_With_PatternAsFile()
{
// Assign
var pattern = new StringPattern {
Pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }", PatternAsFile = "pf"
};
var model = new MatcherModel
{
Name = "JsonPartialMatcher",
Pattern = pattern
};
// Act
var matcher = (JsonPartialMatcher)_sut.Map(model);
// Assert
matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
matcher.Value.Should().BeEquivalentTo(pattern);
}
/// <summary>
/// Extracts the features from the given words.
/// </summary>
/// <param name="text">The words array.</param>
/// <param name="extraInformation">The extra information.</param>
/// <returns>The list of features.</returns>
public List <string> ExtractFeatures(string[] text, Dictionary <string, object> extraInformation)
{
var bag = new List <string>(text.Length);
foreach (var word in text)
{
if (useOnlyAllLetterTokens)
{
if (StringPattern.Recognize(word).AllLetter)
{
bag.Add("bow=" + word);
}
}
else
{
bag.Add("bow=" + word);
}
}
return(bag);
}
public void MatcherMapper_Map_IStringMatcher_With_PatternAsFile()
{
// Arrange
var pattern = new StringPattern {
Pattern = "p", PatternAsFile = "pf"
};
var matcherMock = new Mock <IStringMatcher>();
matcherMock.Setup(m => m.Name).Returns("test");
matcherMock.Setup(m => m.GetPatterns()).Returns(new AnyOf <string, StringPattern>[] { pattern });
// Act
var model = _sut.Map(matcherMock.Object);
// Assert
model.IgnoreCase.Should().BeNull();
model.Name.Should().Be("test");
model.Pattern.Should().Be("p");
model.Patterns.Should().BeNull();
model.PatternAsFile.Should().Be("pf");
}
/// <summary>
/// Generate a random string using special patterns
/// </summary>
/// <param name="length">Length of the string</param>
/// <param name="patterns"></param>
/// <returns></returns>
public static string NextString(int length, StringPattern patterns)
=> NextString(length, false, patterns);
public void IsMatch_InvalidMatchingStrategy()
{
StringPattern pattern = new StringPattern("name", (PatternMatchingStrategy)1000);
Assert.Throws<ArgumentOutOfRangeException>(() => pattern.IsMatch("name"));
}
public void IsMatch_InvalidMatchingStrategy()
{
StringPattern pattern = new StringPattern("name", (PatternMatchingStrategy)1000);
Assert.Throws <ArgumentOutOfRangeException>(() => pattern.IsMatch("name"));
}
public StringPattern()
{
Data = "#";
Kategori = 0;
Next = null;
}
public void AddEl(StringPattern SP)
{
Next = SP;
}
public void testContainsSlash()
{
Assert.True(StringPattern.Recognize("test/").ContainsSlash);
Assert.True(StringPattern.Recognize("23/5").ContainsSlash);
Assert.False(StringPattern.Recognize("test.1-,").ContainsSlash);
}
public String ReadString(Encoding encoding = null, StringPattern stringPattern = StringPattern.VariableByteCount, int length = 0, int offset = 0)
{
Memory.Span.Slice(Position).ReadString(out var value, out var usedBytes, offset, length, encoding, stringPattern);
Position += offset + usedBytes;
return(value);
}
public void testContainsHyphen()
{
Assert.True(StringPattern.Recognize("test--").ContainsHyphen);
Assert.True(StringPattern.Recognize("23-5").ContainsHyphen);
Assert.False(StringPattern.Recognize("test.1/,").ContainsHyphen);
}
public void testIsAllDigit()
{
Assert.True(StringPattern.Recognize("123456").AllDigit);
Assert.False(StringPattern.Recognize("123,56").AllDigit);
Assert.False(StringPattern.Recognize("12356f").AllDigit);
}
public void testContainsLetters()
{
Assert.True(StringPattern.Recognize("test--").ContainsLetters);
Assert.True(StringPattern.Recognize("23h5ßm").ContainsLetters);
Assert.False(StringPattern.Recognize("---.1/,").ContainsLetters);
}
public void ParseString(String S, List <StringPattern> Final, int kategori)
{
if (S != null)
{
List <String> TS = new List <String>();//Ganti List
String temp = "";
//MISAHIN COMA atau TITIK COMA
for (int i = 0; i < S.Length; i++)
{
if (S[i] == ',' || S[i] == ';')
{
TS.Add(temp);
temp = "";
}
else
{
temp = temp + S[i];
}
}
TS.Add(temp);
//MISAHIN SPASI
//GantiList
for (int i = 0; i < TS.Count; i++)
{
List <String> tempTs = new List <String>();
if (TS.ElementAt(i) != null)
{
String temp1 = "";
for (int l = 0; l < TS.ElementAt(i).Length; l++)
{
if (TS.ElementAt(i)[l] != ' ')
{
temp1 = temp1 + TS.ElementAt(i)[l];
}
else
{
if (temp1 != "")
{
tempTs.Add(temp1);
temp1 = "";
}
}
}
tempTs.Add(temp1);
for (int l = 0; l < tempTs.Count; l++)
{
//Console.WriteLine(tempTs.ElementAt(l));
}
StringPattern TP = new StringPattern();
TP.Data = tempTs[0];
TP.Kategori = kategori;
for (int l = 1; l < tempTs.Count; l++)
{
if (tempTs.ElementAt(l) != null && tempTs.ElementAt(l) != "")
{
StringPattern temp2 = new StringPattern();
temp2.Data = tempTs.ElementAt(l);
temp2.Kategori = kategori;
TP.AddEl(temp2);
}
}
Final.Add(TP);
}
}
}
}
/// <summary>
/// Cryptographically secure generate a random string using special patterns
/// </summary>
/// <param name="length">Length of the string</param>
/// <param name="secure">Cryptographically secure random, each pattern must exists at least once</param>
/// <param name="patterns"></param>
/// <returns></returns>
public static string NextString(int length, bool secure, StringPattern patterns)
{
switch (patterns)
{
case StringPattern.SpecialCharacters:
return NextString(length, secure, SpecialChars);
case StringPattern.NumericCharacters:
return NextString(length, secure, NumericChars);
case StringPattern.LowercaseAlphabetCharacters:
return NextString(length, secure, LowerCaseAlphabetChars);
case StringPattern.UppercaseAlphabetCharacters:
return NextString(length, secure, UpperCaseAlphabetChars);
case StringPattern.HexaDecimalCharacters:
return NextString(length, secure, HexaDecimalChars);
case StringPattern.Base64Characters:
return NextString(length, secure, Base64Chars);
//case StringPattern.AlphaNumericCharacters:
default:
return NextString(length, secure, UpperCaseAlphabetChars, LowerCaseAlphabetChars, NumericChars);
}
}
public void testContainsDigit()
{
Assert.True(StringPattern.Recognize("test1").ContainsDigit);
Assert.True(StringPattern.Recognize("23,5").ContainsDigit);
Assert.False(StringPattern.Recognize("test./-,").ContainsDigit);
}
public void testContainsComma()
{
Assert.True(StringPattern.Recognize("test,").ContainsComma);
Assert.True(StringPattern.Recognize("23,5").ContainsComma);
Assert.False(StringPattern.Recognize("test./-1").ContainsComma);
}
public void testDigits()
{
Assert.AreEqual(6, StringPattern.Recognize("123456").Digits);
Assert.AreEqual(3, StringPattern.Recognize("123fff").Digits);
Assert.AreEqual(0, StringPattern.Recognize("test").Digits);
}
public void testContainsPeriod()
{
Assert.True(StringPattern.Recognize("test.").ContainsPeriod);
Assert.True(StringPattern.Recognize("23.5").ContainsPeriod);
Assert.False(StringPattern.Recognize("test,/-1").ContainsPeriod);
}
