private bool searchEntryForWord(string sourceText, string searchWord) { // Remove any tags from sourceText. sourceText = stripTags.Replace(sourceText, String.Empty); CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo; return(myComp.IndexOf(sourceText, searchWord, CompareOptions.IgnoreCase) >= 0); }
private static string CreateCountSQL(string sql) { const string countSatement = "SELECT COUNT(*) "; CompareInfo Compare = CultureInfo.InvariantCulture.CompareInfo; var Index = Compare.IndexOf(sql, "FROM", CompareOptions.IgnoreCase); var countSql = countSatement + sql.AsSpan().Slice(Index).ToString(); return(countSql); }
public void IndexOf_String(CompareInfo compareInfo, string source, string value, int startIndex, int count, CompareOptions options, int expected, int expectedMatchLength) { if (value.Length == 1) { IndexOf_Char(compareInfo, source, value[0], startIndex, count, options, expected); } if (options == CompareOptions.None) { // Use IndexOf(string, string, int, int) or IndexOf(string, string) if (startIndex == 0 && count == source.Length) { // Use IndexOf(string, string) Assert.Equal(expected, compareInfo.IndexOf(source, value)); } // Use IndexOf(string, string, int, int) Assert.Equal(expected, compareInfo.IndexOf(source, value, startIndex, count)); } if (startIndex + count == source.Length) { // Use IndexOf(string, string, int, CompareOptions) or IndexOf(string, string, CompareOptions) if (startIndex == 0) { // Use IndexOf(string, string, CompareOptions) Assert.Equal(expected, compareInfo.IndexOf(source, value, options)); } // Use IndexOf(string, string, int, CompareOptions) Assert.Equal(expected, compareInfo.IndexOf(source, value, startIndex, options)); } // Use IndexOf(string, string, int, int, CompareOptions) Assert.Equal(expected, compareInfo.IndexOf(source, value, startIndex, count, options)); if ((compareInfo == s_invariantCompare) && ((options == CompareOptions.None) || (options == CompareOptions.IgnoreCase))) { StringComparison stringComparison = (options == CompareOptions.IgnoreCase) ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture; // Use int string.IndexOf(string, StringComparison) Assert.Equal(expected, source.IndexOf(value, startIndex, count, stringComparison)); // Use int MemoryExtensions.IndexOf(this ReadOnlySpan<char>, ReadOnlySpan<char>, StringComparison) Assert.Equal((expected == -1) ? -1 : (expected - startIndex), source.AsSpan(startIndex, count).IndexOf(value.AsSpan(), stringComparison)); } // Now test the span-based versions - use BoundedMemory to detect buffer overruns RunSpanIndexOfTest(compareInfo, source.AsSpan(startIndex, count), value, options, (expected < 0) ? expected : expected - startIndex, expectedMatchLength);
public void TestExc <T>(CultureInfo culture, string str1, string str2, CompareOptions options) where T : Exception { CompareInfo ci = culture.CompareInfo; Assert.Throws <T>(() => { int i = ci.IndexOf(str1, str2, options); }); }
public static object _Internal_ContainsIgnoreCase(object corpus, object pattern) { var ctx = corpus as string; var ptx = pattern as string; if (ctx == null || ptx == null) { return(Undefined.Value); } return(CompareInfo.IndexOf(ctx, ptx, CompareOptions.OrdinalIgnoreCase) >= 0); }
/// <summary> /// 塞选方法 - 返回满足条件的句柄集合 /// </summary> /// <param name="textName">窗口标题 - 为空不匹配标题( 模糊匹配,不区分大小写)</param> /// <param name="textClass">窗口类名 - 为空不匹配类名( 模糊匹配,不区分大小写)</param> /// <returns></returns> public List <int> EnumWindow(string textName, string textClass) { CompareInfo Compare = CultureInfo.InvariantCulture.CompareInfo; List <int> gethwnd = new List <int>(); //先取得所有句柄 List <WindowInfo> Listwindows = GetAllDesktopWindows(); // foreach (WindowInfo wdf in Listwindows) { if (textName != "" && textClass != "") { if (Compare.IndexOf(wdf.szClassName.ToUpper(), textClass.ToUpper()) > -1 && Compare.IndexOf(wdf.szWindowName.ToUpper(), textName.ToUpper()) > -1) { gethwnd.Add((int)wdf.hWnd); } } else if (textName == "" && textClass == "") { gethwnd.Add((int)wdf.hWnd); //都返回 } else if (textName == "") { //只匹配类名 if (Compare.IndexOf(wdf.szClassName.ToUpper(), textClass.ToUpper()) > -1) { gethwnd.Add((int)wdf.hWnd); } } else if (textClass == "") { //只匹配标题 if (Compare.IndexOf(wdf.szWindowName.ToUpper(), textName.ToUpper()) > -1) { gethwnd.Add((int)wdf.hWnd); } } } return(gethwnd); }
public DataSet GetDataByQuery(string search) { CompareInfo Compare = CultureInfo.InvariantCulture.CompareInfo; SQLiteDBHelper db = new SQLiteDBHelper(path); string outS = "("; bool flag = false; search = search.Replace(" ", ""); using (SQLiteDataReader reader = db.ExecuteReader("select ID,CodeName,Comments from CodeMass order by id", null)) { while (reader.Read()) { if ((Compare.IndexOf(reader.GetString(1).Replace(" ", ""), search, CompareOptions.IgnoreCase) != -1) || (Compare.IndexOf(reader.GetString(2).Replace(" ", ""), search, CompareOptions.IgnoreCase) != -1)) { outS = outS + reader.GetInt64(0).ToString() + ","; flag = true; } } if (flag) { outS = outS.Substring(0, outS.Length - 1) + ")"; } else { outS = "(-1,-2)"; } } String connectionString = "Data Source=" + path; //String selectCommand = "Select ID, CodeName,Language,AddTime,UpdateTime,Source_Code,Comments from CodeMass"; //String selectCommand = "select * from CodeMass where CodeName like '%"+ChangeStrToLikeStr(search) + "%'"; String selectCommand = "select * from CodeMass where ID in " + outS; SQLiteDataAdapter dataAdapter = new SQLiteDataAdapter(selectCommand, connectionString); DataSet ds = new DataSet(); dataAdapter.Fill(ds, "T_CLASS"); return(ds); }
public void IndexOf(string culture, string source, string value, CompareOptions options) { CompareInfo compareInfo = CultureInfo.GetCultureInfo(culture).CompareInfo; foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { compareInfo.IndexOf(source, value, options); } } }
public static int IndexOfCultureIgnoreCaseHelper(ReadOnlySpan <char> span, ReadOnlySpan <char> value, CompareInfo compareInfo) { Debug.Assert(span.Length != 0); Debug.Assert(value.Length != 0); if (GlobalizationMode.Invariant) { return(CompareInfo.InvariantIndexOf(span, value, ignoreCase: true)); } return(compareInfo.IndexOf(span, value, CompareOptions.IgnoreCase)); }
public static IEnumerable <ComboItem> GetItemsMatching(string itemName, IReadOnlyList <ComboItem> strings) { foreach (var item in strings) { var result = Comparer.IndexOf(item.Text, itemName, opt); if (result < 0) { continue; } yield return(item); } }
public static void IndexOf(string localeName, string source, string value, int expectedResult, CompareOptions options) { CompareInfo ci = CompareInfo.GetCompareInfo(localeName); Assert.Equal(expectedResult, ci.IndexOf(source, value, options)); if (value.Length == 1) { Assert.Equal(expectedResult, ci.IndexOf(source, value[0], options)); } if (options == CompareOptions.None) { Assert.Equal(expectedResult, ci.IndexOf(source, value)); } if (value.Length == 1 && options == CompareOptions.None) { Assert.Equal(expectedResult, ci.IndexOf(source, value[0])); } }
/// <summary> /// Return true if the specified URL is from a LinkMe domain. /// </summary> private static bool IsInternalUrl(string host, string absoluteUri) { CompareInfo compare = CultureInfo.CurrentCulture.CompareInfo; // Compare against the current request. HttpContext context = HttpContext.Current; if (context != null) { if (compare.Compare(host, context.Request.Url.Host, CompareOptions.IgnoreCase) == 0) { return(true); } } return((compare.IndexOf(absoluteUri, InsecureRootUrl, CompareOptions.IgnoreCase) == 0) || (compare.IndexOf(absoluteUri, SecureRootUrl, CompareOptions.IgnoreCase) == 0) || (compare.Compare(host, "localhost", CompareOptions.IgnoreCase) == 0) || (compare.Compare(host, Dns.GetHostName(), CompareOptions.IgnoreCase) == 0)); }
/// <summary> /// 指定した文字列内の指定した文字列を別の文字列に置換する。 /// </summary> /// <param name="input">置換する文字列のある文字列。</param> /// <param name="oldValue">検索文字列。</param> /// <param name="newValue">置換文字列。</param> /// <param name="count">置換する回数。負の数が指定されたときは、すべて置換する。</param> /// <param name="compInfo">文字列の検索に使用するCompareInfo。</param> /// <param name="compOptions">文字列の検索に使用するCompareOptions。</param> /// <returns>置換された結果の文字列。</returns> public static string ReplaceByForwardCount(string input, string oldValue, string newValue, int count, CompareInfo compInfo, CompareOptions compOptions) { if (input == null || input.Length == 0 || oldValue == null || oldValue.Length == 0 || count == 0) { return(input); } if (compInfo == null) { compInfo = CultureInfo.InvariantCulture.CompareInfo; compOptions = CompareOptions.Ordinal; } int inputLen = input.Length; int oldValueLen = oldValue.Length; StringBuilder buf = new StringBuilder(inputLen); int currentPoint = 0; int foundPoint = -1; int currentCount = 0; do { //文字列を検索する foundPoint = compInfo.IndexOf(input, oldValue, currentPoint, compOptions); if (foundPoint < 0) { buf.Append(input.Substring(currentPoint)); break; } //見つかった文字列を新しい文字列に換える buf.Append(input.Substring(currentPoint, foundPoint - currentPoint)); buf.Append(newValue); //次の検索開始位置を取得 currentPoint = foundPoint + oldValueLen; //指定回数置換したか調べる currentCount++; if (currentCount == count) { buf.Append(input.Substring(currentPoint)); break; } }while (currentPoint < inputLen); return(buf.ToString()); }
private byte[] BytesFromBase64String(string base64string) { CompareInfo compareInfo = CultureInfo.InvariantCulture.CompareInfo; int index = compareInfo.IndexOf(base64string, ";base64,", CompareOptions.Ordinal); if (index < 0) { return(null); } var base64clean = base64string.Substring(index + ";base64,".Length); return(Convert.FromBase64String(base64clean)); }
/// <summary> /// 获取符合条件的所有最小数据 /// </summary> /// <param name="strInfo">需要进行查找的字符串</param> /// <param name="stMark">开始标识</param> /// <param name="edMark">结束标识</param> /// <param name="isSelf">是否包含开始结束标识</param> /// <returns>开始与结束标识之间的内容</returns> public static List <string> GetStringList(string strInfo, string stMark, string edMark, bool isSelf) { CompareInfo Compare = CultureInfo.InvariantCulture.CompareInfo; List <string> strList = new List <string>(); int index = 0; int endIndex = 0; while (index > -1 && strInfo.Length > 0) { index = Compare.IndexOf(strInfo, stMark, CompareOptions.IgnoreCase);//忽略大小写 if (index > -1) { if (isSelf) { strInfo = strInfo.Substring(index); endIndex = Compare.IndexOf(strInfo, edMark, stMark.Length, CompareOptions.IgnoreCase);//忽略大小写 } else { strInfo = strInfo.Substring(index + stMark.Length); endIndex = Compare.IndexOf(strInfo, edMark, CompareOptions.IgnoreCase);//忽略大小写 } if (endIndex > -1) { if (isSelf) { strList.Add(strInfo.Substring(0, endIndex + edMark.Length)); } else { strList.Add(strInfo.Substring(0, endIndex)); } strInfo = strInfo.Substring(endIndex + edMark.Length); } index = endIndex; } } return(strList); }
/// <summary> /// Output the field string adding delimiters and any required quotes /// </summary> /// <param name="sb">buffer to add field to</param> /// <param name="fieldValue">value object to add</param> /// <param name="isLast">Indicates if we are processing last field</param> internal override void CreateFieldString(StringBuilder sb, object fieldValue, bool isLast) { string field = base.CreateFieldString(fieldValue); bool hasNewLine = mCompare.IndexOf(field, StringHelper.NewLine, CompareOptions.Ordinal) >= 0; // If have a new line and this is not allowed. We throw an exception if (hasNewLine && (QuoteMultiline == MultilineMode.AllowForRead || QuoteMultiline == MultilineMode.NotAllow)) { throw new BadUsageException("One value for the field " + this.FieldInfo.Name + " has a new line inside. To allow write this value you must add a FieldQuoted attribute with the multiline option in true."); } // Add Quotes If: // - optional == false // - is optional and contains the separator // - is optional and contains a new line if ((QuoteChar != '\0') && (QuoteMode == QuoteMode.AlwaysQuoted || QuoteMode == QuoteMode.OptionalForRead || ((QuoteMode == QuoteMode.OptionalForWrite || QuoteMode == QuoteMode.OptionalForBoth) && mCompare.IndexOf(field, mSeparator, CompareOptions.Ordinal) >= 0) || hasNewLine)) { StringHelper.CreateQuotedString(sb, field, QuoteChar); } else { sb.Append(field); } if (isLast == false) { sb.Append(mSeparator); } }
public static bool Contains(string str1, string str2) { if (string.IsNullOrWhiteSpace(str2)) { return(true); } if (string.IsNullOrWhiteSpace(str1)) { return(false); } CompareInfo compareInfo = CultureInfo.InvariantCulture.CompareInfo; return(compareInfo.IndexOf(str1, str2, CompareOptions.IgnoreCase | CompareOptions.IgnoreSymbols | CompareOptions.IgnoreNonSpace) > -1); }
public static Controller.Find FindString(TextEditor Editor, string SearchQuery, int lastIndex, bool IgnoreCase) { Controller.Find find = new Controller.Find(); CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo; string Text = Editor.Text; if (SearchQuery.Length > 0 && Text.Length > 0) { find.Index = myComp.IndexOf(Text, SearchQuery, lastIndex, (IgnoreCase == true) ? CompareOptions.IgnoreCase : CompareOptions.None); find.Line = (find.Index == -1) ? -1 : Editor.TextArea.Document.GetLineByOffset(find.Index).LineNumber; return(find); } return(null); }
public static string SubstringBefore(this string source, string value) { if (string.IsNullOrEmpty(value)) { return(value); } CompareInfo compareInfo = CultureInfo.InvariantCulture.CompareInfo; int index = compareInfo.IndexOf(source, value, CompareOptions.OrdinalIgnoreCase); if (index < 0) { return(string.Empty); } return(source.Substring(0, index)); }
public static void Main() { CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo; string s1 = "ani\u00ADmal"; string s2 = "animal"; int position = 0; // Find the index of the soft hyphen. position = ci.IndexOf(s1, 'n'); Console.WriteLine("'n' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.IndexOf(s1, '\u00AD', position, s1.Length - position)); } position = ci.IndexOf(s2, 'n'); Console.WriteLine("'n' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.IndexOf(s2, '\u00AD', position, s2.Length - position)); } }
/// <summary> /// Modified from Oleg Tkachenko's SubstringBefore and SubstringAfter extension functions /// @ http://www.tkachenko.com/blog/archives/000684.html /// This will be moved into an appropriate class once I have the time. /// </summary> /// <param name="source"></param> /// <param name="value"></param> /// <returns></returns> public static string SubstringAfter(this string source, string value) { if (string.IsNullOrEmpty(value)) { return(source); } CompareInfo compareInfo = CultureInfo.InvariantCulture.CompareInfo; int index = compareInfo.IndexOf(source, value, CompareOptions.Ordinal); if (index < 0) { //No such substring return(string.Empty); } return(source.Substring(index + value.Length)); }
private DataTable Ara(string aranan, DataTable dt, string arananStun) { arananDt = dt.Copy(); arananDt.Clear(); CompareInfo karsilastirma = CultureInfo.InvariantCulture.CompareInfo; foreach (DataRow row in dt.Rows) { if (karsilastirma.IndexOf(row[arananStun].ToString(), aranan, CompareOptions.IgnoreCase) == 0) { arananDt.ImportRow(row); } } return arananDt; }
public static string SubstringBefore(this string aText, string aSearchedSubstring) { if (string.IsNullOrEmpty(aSearchedSubstring)) { return(aSearchedSubstring); } CompareInfo compareInfo = CultureInfo.InvariantCulture.CompareInfo; int index = compareInfo.IndexOf(aText, aSearchedSubstring, CompareOptions.Ordinal); if (index < 0) { return(string.Empty); //No such substring } return(aText.Substring(0, index)); }
// Token: 0x06002E72 RID: 11890 RVA: 0x000D26DC File Offset: 0x000D08DC private static bool _FoundOnPage(string pageString, string findPattern, CultureInfo cultureInfo, CompareOptions compareOptions) { CompareInfo compareInfo = cultureInfo.CompareInfo; string[] array = findPattern.Split(null); if (array != null) { foreach (string value in array) { if (!string.IsNullOrEmpty(value) && compareInfo.IndexOf(pageString, value, compareOptions) == -1) { return(false); } } } return(true); }
public static void Main() { CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo; string s1 = "ani\u00ADmal"; string s2 = "animal"; int position = 0; // Find the index of the soft hyphen using culture-sensitive comparison. position = ci.IndexOf(s1, 'n'); Console.WriteLine("'n' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.IndexOf(s1, '\u00AD', position, s1.Length - position, CompareOptions.IgnoreCase)); } position = ci.IndexOf(s2, 'n'); Console.WriteLine("'n' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.IndexOf(s2, '\u00AD', position, s2.Length - position, CompareOptions.IgnoreCase)); } // Find the index of the soft hyphen using ordinal comparison. position = ci.IndexOf(s1, 'n'); Console.WriteLine("'n' at position {0}", position, CompareOptions.Ordinal); if (position >= 0) { Console.WriteLine(ci.IndexOf(s1, '\u00AD', position, s1.Length - position, CompareOptions.Ordinal)); } position = ci.IndexOf(s2, 'n'); Console.WriteLine("'n' at position {0}", position, CompareOptions.Ordinal); if (position >= 0) { Console.WriteLine(ci.IndexOf(s2, '\u00AD', position, s2.Length - position, CompareOptions.Ordinal)); } }
// Returns the index and length of the first or last occurance of one string // within another string. private static int StandardMatchIndexCalculation(string textString, string findPattern, bool matchWholeWord, bool matchLast, bool ignoreCase, CompareInfo compareInfo, bool hasPreceedingSeparatorChar, bool hasFollowingSeparatorChar, out int matchLength) { CompareOptions options = ignoreCase ? CompareOptions.IgnoreCase : 0; int matchIndex = -1; int searchStart = 0; int searchLength = textString.Length; matchLength = 0; while (searchLength > 0) { matchIndex = matchLast ? compareInfo.LastIndexOf(textString, findPattern, searchStart + searchLength - 1, searchLength, options) : compareInfo.IndexOf(textString, findPattern, searchStart, searchLength, options); matchLength = findPattern.Length; if (matchIndex == -1) { break; } if (!matchWholeWord || IsAtWordBoundary(textString, matchIndex, matchLength, hasPreceedingSeparatorChar, hasFollowingSeparatorChar)) { break; } if (matchLast) { searchStart = 0; searchLength = matchIndex + matchLength - 1; } else { searchStart = matchIndex + 1; searchLength = textString.Length - searchStart; } matchIndex = -1; } return(matchIndex); }
void context_BeginRequest(object sender, EventArgs e) { HttpApplication application = (HttpApplication)sender; HttpContext context = application.Context; HttpResponse response = context.Response; string path = context.Request.FilePath; //重写后的URL地址 if (path.IndexOf("member") > -1 || path.IndexOf("menu") > -1 || path.IndexOf("orders") > -1 || path.IndexOf("syspage") > -1 || path.IndexOf("sysparam") > -1 || path.IndexOf("sysuser") > -1 || path.IndexOf("control") > -1) { CompareInfo Compare = CultureInfo.InvariantCulture.CompareInfo; if (Compare.IndexOf(path, "images", CompareOptions.IgnoreCase) == -1) { //... } } }
public static string StringReplace( [DekiScriptParam("string value")] string text, [DekiScriptParam("old value")] string before, [DekiScriptParam("new value")] string after, [DekiScriptParam("ignore case (default: false)", true)] bool?ignorecase ) { // check for the degenarate case if (before.Length == 0) { // nothing to do return(text); } // check if we're doing a case-insensitve replace if (ignorecase ?? false) { StringBuilder result = new StringBuilder(); // use culture specific comparer CompareInfo compare = GetCulture().CompareInfo; int start = 0; while (true) { int index = compare.IndexOf(text, before, start, CompareOptions.IgnoreCase); if (index < 0) { // append the end of the string and we're done result.Append(text, start, text.Length - start); break; } // append the part we skipped over, then the replacement result.Append(text, start, index - start); result.Append(after); start = index + before.Length; } return(result.ToString()); } return(text.Replace(before, after)); }
private static string SubstringAfter(this string str, string separator) { if (string.IsNullOrEmpty(str)) { return(str); } if (separator == null) { return(string.Empty); } CompareInfo compareInfo = CultureInfo.InvariantCulture.CompareInfo; int index = compareInfo.IndexOf(str, separator, CompareOptions.Ordinal); if (index < 0) { //No such substring return(string.Empty); } return(str.Substring(index + separator.Length)); }
private void FillList() { // first finish edit opeation FinishEdit(); lvwMessages.Items.Clear(); Array values = Enum.GetValues(typeof(NativeMethods.Msgs)); Array.Sort(values); string filter = txtFilter.Text; if (filter.Equals(Properties.Resources.Filter_Key)) { filter = string.Empty; } filter = filter.ToUpper(CultureInfo.InvariantCulture); bool onlyWatched = chkOnlyWactheds.Checked; CompareInfo info = CompareInfo.GetCompareInfo(1033); for (int i = 0; i < values.Length; i++) { NativeMethods.Msgs msg = (NativeMethods.Msgs)values.GetValue(i); if ((onlyWatched && !_Watchs.ContainsKey(msg)) || info.IndexOf(msg.ToString().ToUpper(CultureInfo.InvariantCulture), filter) == -1) { continue; } lvwMessages.Items.Add(msg); } foreach (KeyValuePair <NativeMethods.Msgs, FormMain.MessageBreakpoint> watch in _Watchs) { if (Array.IndexOf(values, watch.Key) == -1) { lvwMessages.Items.Add(watch.Key); } } }
public void IndexOfTest(CompareInfo compareInfo, string source, string value, int startIndex, int indexOfExpected, int lastIndexOfExpected) { Assert.Equal(indexOfExpected, compareInfo.IndexOf(source, value, startIndex)); if (value.Length > 0) { Assert.Equal(indexOfExpected, compareInfo.IndexOf(source, value[0], startIndex)); } Assert.Equal(lastIndexOfExpected, compareInfo.LastIndexOf(source, value, startIndex)); if (value.Length > 0) { Assert.Equal(lastIndexOfExpected, compareInfo.LastIndexOf(source, value[0], startIndex)); } }
public void IndexOf_Char(CompareInfo compareInfo, string source, char value, int startIndex, int count, CompareOptions options, int expected) { if (options == CompareOptions.None) { // Use IndexOf(string, char, int, int) or IndexOf(string, char) if (startIndex == 0 && count == source.Length) { // Use IndexOf(string, char) Assert.Equal(expected, compareInfo.IndexOf(source, value)); } // Use IndexOf(string, char, int, int) Assert.Equal(expected, compareInfo.IndexOf(source, value, startIndex, count)); } if (startIndex + count == source.Length) { // Use IndexOf(string, char, int, CompareOptions) or IndexOf(string, char, CompareOptions) if (startIndex == 0) { // Use IndexOf(string, char, CompareOptions) Assert.Equal(expected, compareInfo.IndexOf(source, value, options)); } // Use IndexOf(string, char, int, CompareOptions) Assert.Equal(expected, compareInfo.IndexOf(source, value, startIndex, options)); } // Use IndexOf(string, char, int, int, CompareOptions) Assert.Equal(expected, compareInfo.IndexOf(source, value, startIndex, count, options)); }