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); }