public void LastIndexOf_Char(CompareInfo compareInfo, string source, char value, int startIndex, int count, CompareOptions options, int expected) { if (options == CompareOptions.None) { // Use LastIndexOf(string, char, int, int) or LastIndexOf(string, char) if (startIndex + 1 == source.Length && count == source.Length) { // Use LastIndexOf(string, char) Assert.Equal(expected, compareInfo.LastIndexOf(source, value)); } // Use LastIndexOf(string, char, int, int) Assert.Equal(expected, compareInfo.LastIndexOf(source, value, startIndex, count)); } if (count - startIndex - 1 == 0) { // Use LastIndexOf(string, char, int, CompareOptions) or LastIndexOf(string, char, CompareOptions) if (startIndex == source.Length) { // Use LastIndexOf(string, char, CompareOptions) Assert.Equal(expected, compareInfo.LastIndexOf(source, value, options)); } // Use LastIndexOf(string, char, int, CompareOptions) Assert.Equal(expected, compareInfo.LastIndexOf(source, value, startIndex, options)); } // Use LastIndexOf(string, char, int, int, CompareOptions) Assert.Equal(expected, compareInfo.LastIndexOf(source, value, startIndex, count, options)); }
public void LastIndexOf_String(CompareInfo compareInfo, string source, string value, int startIndex, int count, CompareOptions options, int expected) { if (value.Length == 1) { LastIndexOf_Char(compareInfo, source, value[0], startIndex, count, options, expected); } if (options == CompareOptions.None) { // Use LastIndexOf(string, string, int, int) or LastIndexOf(string, string) if (startIndex + 1 == source.Length && count == source.Length) { // Use LastIndexOf(string, string) Assert.Equal(expected, compareInfo.LastIndexOf(source, value)); } // Use LastIndexOf(string, string, int, int) Assert.Equal(expected, compareInfo.LastIndexOf(source, value, startIndex, count)); } if (count - startIndex - 1 == 0) { // Use LastIndexOf(string, string, int, CompareOptions) or LastIndexOf(string, string, CompareOptions) if (startIndex == source.Length) { // Use LastIndexOf(string, string, CompareOptions) Assert.Equal(expected, compareInfo.LastIndexOf(source, value, options)); } // Use LastIndexOf(string, string, int, CompareOptions) Assert.Equal(expected, compareInfo.LastIndexOf(source, value, startIndex, options)); } // Use LastIndexOf(string, string, int, int, CompareOptions) Assert.Equal(expected, compareInfo.LastIndexOf(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.LastIndexOf(string, StringComparison) Assert.Equal(expected, source.LastIndexOf(value, startIndex, count, stringComparison)); // Use int MemoryExtensions.LastIndexOf(this ReadOnlySpan<char>, ReadOnlySpan<char>, StringComparison) // Filter differences betweeen string-based and Span-based LastIndexOf // - Empty value handling - https://github.com/dotnet/runtime/issues/13382 // - Negative count if (value.Length == 0 || count < 0) { return; } if (startIndex == source.Length) { startIndex--; if (count > 0) { count--; } } int leftStartIndex = (startIndex - count + 1); Assert.Equal((expected == -1) ? -1 : (expected - leftStartIndex), source.AsSpan(leftStartIndex, count).LastIndexOf(value.AsSpan(), stringComparison)); } }
public static void LastIndexOfArgumentOutOfRangeIndex(string source, char value, int badStartIndex) { CompareInfo ci = CultureInfo.InvariantCulture.CompareInfo; string valueAsString = value.ToString(); Assert.Throws <ArgumentOutOfRangeException>(() => ci.LastIndexOf(source, value, badStartIndex, CompareOptions.Ordinal)); Assert.Throws <ArgumentOutOfRangeException>(() => ci.LastIndexOf(source, valueAsString, badStartIndex, CompareOptions.Ordinal)); }
public static void LastIndexOfBadCompareOptions() { CompareInfo ci = CultureInfo.InvariantCulture.CompareInfo; Assert.Throws <ArgumentException>(() => ci.LastIndexOf("abc", "a", CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); Assert.Throws <ArgumentException>(() => ci.LastIndexOf("abc", "a", CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); Assert.Throws <ArgumentException>(() => ci.LastIndexOf("abc", "a", (CompareOptions)(-1))); Assert.Throws <ArgumentException>(() => ci.LastIndexOf("abc", "a", CompareOptions.StringSort)); }
public static void Main() { CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo; string s1 = "ani\u00ADmal"; string s2 = "animal"; // Find the index of the last soft hyphen. Console.WriteLine(ci.LastIndexOf(s1, '\u00AD')); Console.WriteLine(ci.LastIndexOf(s2, '\u00AD')); }
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 == 1) { Assert.Equal(indexOfExpected, compareInfo.IndexOf(source, value[0], startIndex)); } Assert.Equal(lastIndexOfExpected, compareInfo.LastIndexOf(source, value, startIndex)); if (value.Length == 1) { Assert.Equal(lastIndexOfExpected, compareInfo.LastIndexOf(source, value[0], startIndex)); } }
public static void Main() { CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo; string s1 = "ani\u00ADmal"; string s2 = "animal"; // Find the last index of the soft hyphen using culture-sensitive comparison. Console.WriteLine(ci.LastIndexOf(s1, '\u00AD', CompareOptions.IgnoreCase)); Console.WriteLine(ci.LastIndexOf(s2, '\u00AD', CompareOptions.IgnoreCase)); // Find the last index of the soft hyphen using ordinal comparison. Console.WriteLine(ci.LastIndexOf(s1, '\u00AD', CompareOptions.Ordinal)); Console.WriteLine(ci.LastIndexOf(s2, '\u00AD', CompareOptions.Ordinal)); }
// Token: 0x060039B7 RID: 14775 RVA: 0x00105DC4 File Offset: 0x00103FC4 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 : CompareOptions.None; int num = -1; int num2 = 0; int i = textString.Length; matchLength = 0; while (i > 0) { num = (matchLast ? compareInfo.LastIndexOf(textString, findPattern, num2 + i - 1, i, options) : compareInfo.IndexOf(textString, findPattern, num2, i, options)); matchLength = findPattern.Length; if (num == -1 || !matchWholeWord || TextFindEngine.IsAtWordBoundary(textString, num, matchLength, hasPreceedingSeparatorChar, hasFollowingSeparatorChar)) { break; } if (matchLast) { num2 = 0; i = num + matchLength - 1; } else { num2 = num + 1; i = textString.Length - num2; } num = -1; } return(num); }
public void Test(CultureInfo culture, string str1, string str2, int expected, CompareOptions options) { CompareInfo ci = culture.CompareInfo; int i = ci.LastIndexOf(str1, str2, options); Assert.Equal(expected, i); }
public bool TestOrd(CultureInfo culture, string str1, string str2, int expected, CompareOptions options, string id) { CompareInfo ci = culture.CompareInfo; bool result = true; if (str1 == null || str2 == null || (str1.Length < 100 && str2.Length < 100)) { TestFramework.BeginScenario(id + ": Comparing " + ((str1 == null) ? "null" : str1) + " / " + ((str2 == null) ? "null" : str2) + "; options: " + options + "; culture: " + ci.Name); } else { TestFramework.BeginScenario(id + ": Comparing LongStr (" + str1.Length + ") / LongStr(" + str2.Length + "); options: " + options + "; culture: " + ci.Name); } try { int i = ci.LastIndexOf(str1, str2, options); if (i != expected) { result = false; TestFramework.LogError("001", "Error in " + id + ", unexpected comparison result. Actual: " + i + ", Expected: " + expected); } } catch (Exception exc) { result = false; TestFramework.LogError("003", "Unexpected exception in " + id + ", excpetion: " + exc.ToString()); } return(result); }
public bool Test(CultureInfo culture, string str1, string str2, int expected, CompareOptions options, string id) { CompareInfo ci = culture.CompareInfo; if (!id.Contains("s") || !Utilities.IsVistaOrLater) //Due Windows 7 bug 130925 { expected = GlobLocHelper.OSLastIndexOf(culture, str1, str2, options); } bool result = true; if (str1 == null || str2 == null || (str1.Length < 100 && str2.Length < 100)) { TestFramework.BeginScenario(id + ": Comparing " + ((str1 == null) ? "null" : str1) + " / " + ((str2 == null) ? "null" : str2) + "; options: " + options + "; culture: " + ci.Name); } else { TestFramework.BeginScenario(id + ": Comparing LongStr (" + str1.Length + ") / LongStr(" + str2.Length + "); options: " + options + "; culture: " + ci.Name); } try { int i = ci.LastIndexOf(str1, str2, options); if (i != expected) { result = false; TestFramework.LogError("001z", "Error in " + id + ", unexpected comparison result. Actual: " + i + ", Expected: " + expected); } } catch (Exception exc) { result = false; TestFramework.LogError("003z", "Unexpected exception in " + id + ", excpetion: " + exc.ToString()); } return(result); }
public void LastIndexOf_String(CompareInfo compareInfo, string source, string value, int startIndex, int count, CompareOptions options, int expected) { if (value.Length == 1) { LastIndexOf_Char(compareInfo, source, value[0], startIndex, count, options, expected); } if (options == CompareOptions.None) { // Use LastIndexOf(string, string, int, int) or LastIndexOf(string, string) if (startIndex + 1 == source.Length && count == source.Length) { // Use LastIndexOf(string, string) Assert.Equal(expected, compareInfo.LastIndexOf(source, value)); } // Use LastIndexOf(string, string, int, int) Assert.Equal(expected, compareInfo.LastIndexOf(source, value, startIndex, count)); } if (count - startIndex - 1 == 0) { // Use LastIndexOf(string, string, int, CompareOptions) or LastIndexOf(string, string, CompareOptions) if (startIndex == source.Length) { // Use LastIndexOf(string, string, CompareOptions) Assert.Equal(expected, compareInfo.LastIndexOf(source, value, options)); } // Use LastIndexOf(string, string, int, CompareOptions) Assert.Equal(expected, compareInfo.LastIndexOf(source, value, startIndex, options)); } // Use LastIndexOf(string, string, int, int, CompareOptions) Assert.Equal(expected, compareInfo.LastIndexOf(source, value, startIndex, count, options)); // Fixup offsets so that we can call the span-based APIs. ReadOnlySpan <char> sourceSpan; int adjustmentFactor; // number of chars to add to retured index from span-based APIs if (startIndex == source.Length - 1 && count == source.Length) { // This idiom means "read the whole span" sourceSpan = source; adjustmentFactor = 0; } else if (startIndex == source.Length) { // Account for possible off-by-one at the call site sourceSpan = source.AsSpan()[^ (Math.Max(0, count - 1))..];
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.LastIndexOf(str1, str2, options); }); }
public static void LastIndexOf(string localeName, string source, string value, int expectedResult, CompareOptions options) { CompareInfo ci = CompareInfo.GetCompareInfo(localeName); Assert.Equal(expectedResult, ci.LastIndexOf(source, value, options)); if (value.Length == 1) { Assert.Equal(expectedResult, ci.LastIndexOf(source, value[0], options)); } if (options == CompareOptions.None) { Assert.Equal(expectedResult, ci.LastIndexOf(source, value)); } if (value.Length == 1 && options == CompareOptions.None) { Assert.Equal(expectedResult, ci.LastIndexOf(source, value[0])); } }
public void LastIndexOf(string culture, string source, string value, CompareOptions options) { CompareInfo compareInfo = CultureInfo.GetCultureInfo(culture).CompareInfo; foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { compareInfo.LastIndexOf(source, value, options); } } }
public static void Main() { // Creates CompareInfo for the InvariantCulture. CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo; // iS is the starting index of the substring. int iS = 8; // iL is the length of the substring. int iL = 18; // myT1 and myT2 are the strings used for padding. String myT1 = new String('-', iS); String myT2; // Searches for the ligature Æ. String myStr = "Is AE or ae the same as Æ or æ?"; myT2 = new String('-', myStr.Length - iS - iL); Console.WriteLine(); Console.WriteLine("Original : {0}", myStr); Console.WriteLine("No options : {0}{1}{2}", myT1, myStr.Substring(iS, iL), myT2); PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", iS, iL), myComp.LastIndexOf(myStr, "AE", iS + iL - 1, iL)); PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", iS, iL), myComp.LastIndexOf(myStr, "ae", iS + iL - 1, iL)); PrintMarker(" Æ : ", myComp.IndexOf(myStr, 'Æ', iS, iL), myComp.LastIndexOf(myStr, 'Æ', iS + iL - 1, iL)); PrintMarker(" æ : ", myComp.IndexOf(myStr, 'æ', iS, iL), myComp.LastIndexOf(myStr, 'æ', iS + iL - 1, iL)); Console.WriteLine("Ordinal : {0}{1}{2}", myT1, myStr.Substring(iS, iL), myT2); PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", iS, iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "AE", iS + iL - 1, iL, CompareOptions.Ordinal)); PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", iS, iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ae", iS + iL - 1, iL, CompareOptions.Ordinal)); PrintMarker(" Æ : ", myComp.IndexOf(myStr, 'Æ', iS, iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, 'Æ', iS + iL - 1, iL, CompareOptions.Ordinal)); PrintMarker(" æ : ", myComp.IndexOf(myStr, 'æ', iS, iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, 'æ', iS + iL - 1, iL, CompareOptions.Ordinal)); Console.WriteLine("IgnoreCase : {0}{1}{2}", myT1, myStr.Substring(iS, iL), myT2); PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", iS, iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "AE", iS + iL - 1, iL, CompareOptions.IgnoreCase)); PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", iS, iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ae", iS + iL - 1, iL, CompareOptions.IgnoreCase)); PrintMarker(" Æ : ", myComp.IndexOf(myStr, 'Æ', iS, iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, 'Æ', iS + iL - 1, iL, CompareOptions.IgnoreCase)); PrintMarker(" æ : ", myComp.IndexOf(myStr, 'æ', iS, iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, 'æ', iS + iL - 1, iL, CompareOptions.IgnoreCase)); // Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis. myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?"; myT2 = new String('-', myStr.Length - iS - iL); Console.WriteLine(); Console.WriteLine("Original : {0}", myStr); Console.WriteLine("No options : {0}{1}{2}", myT1, myStr.Substring(iS, iL), myT2); PrintMarker(" U\u0308 : ", myComp.IndexOf(myStr, "U\u0308", iS, iL), myComp.LastIndexOf(myStr, "U\u0308", iS + iL - 1, iL)); PrintMarker(" u\u0308 : ", myComp.IndexOf(myStr, "u\u0308", iS, iL), myComp.LastIndexOf(myStr, "u\u0308", iS + iL - 1, iL)); PrintMarker(" Ü : ", myComp.IndexOf(myStr, 'Ü', iS, iL), myComp.LastIndexOf(myStr, 'Ü', iS + iL - 1, iL)); PrintMarker(" ü : ", myComp.IndexOf(myStr, 'ü', iS, iL), myComp.LastIndexOf(myStr, 'ü', iS + iL - 1, iL)); Console.WriteLine("Ordinal : {0}{1}{2}", myT1, myStr.Substring(iS, iL), myT2); PrintMarker(" U\u0308 : ", myComp.IndexOf(myStr, "U\u0308", iS, iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.Ordinal)); PrintMarker(" u\u0308 : ", myComp.IndexOf(myStr, "u\u0308", iS, iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.Ordinal)); PrintMarker(" Ü : ", myComp.IndexOf(myStr, 'Ü', iS, iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, 'Ü', iS + iL - 1, iL, CompareOptions.Ordinal)); PrintMarker(" ü : ", myComp.IndexOf(myStr, 'ü', iS, iL, CompareOptions.Ordinal), myComp.LastIndexOf(myStr, 'ü', iS + iL - 1, iL, CompareOptions.Ordinal)); Console.WriteLine("IgnoreCase : {0}{1}{2}", myT1, myStr.Substring(iS, iL), myT2); PrintMarker(" U\u0308 : ", myComp.IndexOf(myStr, "U\u0308", iS, iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase)); PrintMarker(" u\u0308 : ", myComp.IndexOf(myStr, "u\u0308", iS, iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase)); PrintMarker(" Ü : ", myComp.IndexOf(myStr, 'Ü', iS, iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, 'Ü', iS + iL - 1, iL, CompareOptions.IgnoreCase)); PrintMarker(" ü : ", myComp.IndexOf(myStr, 'ü', iS, iL, CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, 'ü', iS + iL - 1, iL, CompareOptions.IgnoreCase)); }
public static void Main() { CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo; string s1 = "ani\u00ADmal"; string s2 = "animal"; int position = 0; // Find the last index of the soft hyphen. position = ci.LastIndexOf(s1, 'm'); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, '\u00AD', position)); } position = ci.LastIndexOf(s2, 'm'); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, '\u00AD', position)); } }
public static void Main() { // Creates CompareInfo for the InvariantCulture. CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo; // Searches for the ligature Æ. String myStr = "Is AE or ae the same as Æ or æ?"; Console.WriteLine(); Console.WriteLine("No options : {0}", myStr); PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE"), myComp.LastIndexOf(myStr, "AE")); PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae"), myComp.LastIndexOf(myStr, "ae")); PrintMarker(" Æ : ", myComp.IndexOf(myStr, 'Æ'), myComp.LastIndexOf(myStr, 'Æ')); PrintMarker(" æ : ", myComp.IndexOf(myStr, 'æ'), myComp.LastIndexOf(myStr, 'æ')); Console.WriteLine("Ordinal : {0}", myStr); PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "AE", CompareOptions.Ordinal)); PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "ae", CompareOptions.Ordinal)); PrintMarker(" Æ : ", myComp.IndexOf(myStr, 'Æ', CompareOptions.Ordinal), myComp.LastIndexOf(myStr, 'Æ', CompareOptions.Ordinal)); PrintMarker(" æ : ", myComp.IndexOf(myStr, 'æ', CompareOptions.Ordinal), myComp.LastIndexOf(myStr, 'æ', CompareOptions.Ordinal)); Console.WriteLine("IgnoreCase : {0}", myStr); PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "AE", CompareOptions.IgnoreCase)); PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "ae", CompareOptions.IgnoreCase)); PrintMarker(" Æ : ", myComp.IndexOf(myStr, 'Æ', CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, 'Æ', CompareOptions.IgnoreCase)); PrintMarker(" æ : ", myComp.IndexOf(myStr, 'æ', CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, 'æ', CompareOptions.IgnoreCase)); // Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis. myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?"; Console.WriteLine(); Console.WriteLine("No options : {0}", myStr); PrintMarker(" U\u0308 : ", myComp.IndexOf(myStr, "U\u0308"), myComp.LastIndexOf(myStr, "U\u0308")); PrintMarker(" u\u0308 : ", myComp.IndexOf(myStr, "u\u0308"), myComp.LastIndexOf(myStr, "u\u0308")); PrintMarker(" Ü : ", myComp.IndexOf(myStr, 'Ü'), myComp.LastIndexOf(myStr, 'Ü')); PrintMarker(" ü : ", myComp.IndexOf(myStr, 'ü'), myComp.LastIndexOf(myStr, 'ü')); Console.WriteLine("Ordinal : {0}", myStr); PrintMarker(" U\u0308 : ", myComp.IndexOf(myStr, "U\u0308", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "U\u0308", CompareOptions.Ordinal)); PrintMarker(" u\u0308 : ", myComp.IndexOf(myStr, "u\u0308", CompareOptions.Ordinal), myComp.LastIndexOf(myStr, "u\u0308", CompareOptions.Ordinal)); PrintMarker(" Ü : ", myComp.IndexOf(myStr, 'Ü', CompareOptions.Ordinal), myComp.LastIndexOf(myStr, 'Ü', CompareOptions.Ordinal)); PrintMarker(" ü : ", myComp.IndexOf(myStr, 'ü', CompareOptions.Ordinal), myComp.LastIndexOf(myStr, 'ü', CompareOptions.Ordinal)); Console.WriteLine("IgnoreCase : {0}", myStr); PrintMarker(" U\u0308 : ", myComp.IndexOf(myStr, "U\u0308", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "U\u0308", CompareOptions.IgnoreCase)); PrintMarker(" u\u0308 : ", myComp.IndexOf(myStr, "u\u0308", CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, "u\u0308", CompareOptions.IgnoreCase)); PrintMarker(" Ü : ", myComp.IndexOf(myStr, 'Ü', CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, 'Ü', CompareOptions.IgnoreCase)); PrintMarker(" ü : ", myComp.IndexOf(myStr, 'ü', CompareOptions.IgnoreCase), myComp.LastIndexOf(myStr, 'ü', CompareOptions.IgnoreCase)); }
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.LastIndexOf(s1, 'm'); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, '\u00AD', position, position + 1, CompareOptions.IgnoreCase)); } position = ci.LastIndexOf(s2, 'm'); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, '\u00AD', position, position + 1, CompareOptions.IgnoreCase)); } // Find the index of the soft hyphen using ordinal comparison. position = ci.LastIndexOf(s1, 'm'); Console.WriteLine("'m' at position {0}", position, CompareOptions.Ordinal); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, '\u00AD', position, position + 1, CompareOptions.Ordinal)); } position = ci.LastIndexOf(s2, 'm'); Console.WriteLine("'m' at position {0}", position, CompareOptions.Ordinal); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, '\u00AD', position, position + 1, 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); }
public bool TestExc(CultureInfo culture, string str1, string str2, Type expected, CompareOptions options, string id) { CompareInfo ci = culture.CompareInfo; bool result = true; TestFramework.BeginScenario(id + ": Comparing " + str1 + " / " + str2 + "; options: " + options + "; culture: " + ci.Name); try { int i = ci.LastIndexOf(str1, str2, options); result = false; TestFramework.LogError("004", "Error in " + id + ", expected exception did not occur. Comparison result: " + i); } catch (Exception exc) { if (!exc.GetType().Equals(expected)) { result = false; TestFramework.LogError("005", "Unexpected exception in " + id + ", excpetion: " + exc.ToString()); } } return(result); }
public static void Main() { CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo; string searchString = "\u00ADm"; string s1 = "ani\u00ADmal"; string s2 = "animal"; int position; position = ci.LastIndexOf(s1, 'm'); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, searchString, position, CompareOptions.None)); Console.WriteLine(ci.LastIndexOf(s1, searchString, position, CompareOptions.Ordinal)); } position = ci.LastIndexOf(s2, 'm'); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, searchString, position, CompareOptions.None)); Console.WriteLine(ci.LastIndexOf(s2, searchString, position, CompareOptions.Ordinal)); } }
public static void Main() { CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo; int position = 0; string s1 = "ani\u00ADmal"; string s2 = "animal"; // All the following comparisons are culture-sensitive. Console.WriteLine("Culture-sensitive comparisons:"); // Find the index of the soft hyphen. position = ci.LastIndexOf(s1, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, "\u00AD", position, position + 1, CompareOptions.None)); } position = ci.LastIndexOf(s2, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, "\u00AD", position, position + 1, CompareOptions.None)); } // Find the index of the soft hyphen followed by "n". position = ci.LastIndexOf(s1, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, "\u00ADn", position, position + 1, CompareOptions.IgnoreCase)); } position = ci.LastIndexOf(s2, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, "\u00ADn", position, position + 1, CompareOptions.IgnoreCase)); } // Find the index of the soft hyphen followed by "m". position = ci.LastIndexOf(s1, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, "\u00ADm", position, position + 1, CompareOptions.IgnoreCase)); } position = ci.LastIndexOf(s2, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, "\u00ADm", position, position + 1, CompareOptions.IgnoreCase)); } // All the following comparisons are ordinal. Console.WriteLine("\nOrdinal comparisons:"); // Find the index of the soft hyphen. position = ci.LastIndexOf(s1, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, "\u00AD", position, position + 1, CompareOptions.Ordinal)); } position = ci.LastIndexOf(s2, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, "\u00AD", position, position + 1, CompareOptions.Ordinal)); } // Find the index of the soft hyphen followed by "n". position = ci.LastIndexOf(s1, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, "\u00ADn", position, position + 1, CompareOptions.Ordinal)); } position = ci.LastIndexOf(s2, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, "\u00ADn", position, position + 1, CompareOptions.Ordinal)); } // Find the index of the soft hyphen followed by "m". position = ci.LastIndexOf(s1, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, "\u00ADm", position, position + 1, CompareOptions.Ordinal)); } position = ci.LastIndexOf(s2, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, "\u00ADm", position, position + 1, CompareOptions.Ordinal)); } }
internal static int LastIndexOf(string source, string value) { return(InvariantCompareInfo.LastIndexOf(source, value, CompareOptions.Ordinal)); }
public void LastIndexOf_Invalid() { // Source is null Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, "a")); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, "a", CompareOptions.None)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, "a", 0, 0)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, "a", 0, CompareOptions.None)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, "a", 0, 0, CompareOptions.None)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, 'a')); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, 'a', CompareOptions.None)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, 'a', 0, 0)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, 'a', 0, CompareOptions.None)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, 'a', 0, 0, CompareOptions.None)); // Value is null Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf("", null)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf("", null, CompareOptions.None)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf("", null, 0, 0)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf("", null, 0, CompareOptions.None)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf("", null, 0, 0, CompareOptions.None)); // Source and value are null Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, null)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, null, CompareOptions.None)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, null, 0, 0)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, null, 0, CompareOptions.None)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.LastIndexOf(null, null, 0, 0, CompareOptions.None)); // Options are invalid Assert.Throws <ArgumentException>(() => s_invariantCompare.LastIndexOf("Test's", "Tests", CompareOptions.StringSort)); Assert.Throws <ArgumentException>(() => s_invariantCompare.LastIndexOf("Test's", "Tests", (CompareOptions)(-1))); Assert.Throws <ArgumentException>(() => s_invariantCompare.LastIndexOf("Test's", "Tests", (CompareOptions)0x11111111)); }
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 LastIndexOf_Invalid() { // Source is null AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, "a")); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, "a", CompareOptions.None)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, "a", 0, 0)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, "a", 0, CompareOptions.None)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, "a", 0, 0, CompareOptions.None)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, 'a')); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, 'a', CompareOptions.None)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, 'a', 0, 0)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, 'a', 0, CompareOptions.None)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, 'a', 0, 0, CompareOptions.None)); // Value is null AssertExtensions.Throws <ArgumentNullException>("value", () => s_invariantCompare.LastIndexOf("", null)); AssertExtensions.Throws <ArgumentNullException>("value", () => s_invariantCompare.LastIndexOf("", null, CompareOptions.None)); AssertExtensions.Throws <ArgumentNullException>("value", () => s_invariantCompare.LastIndexOf("", null, 0, 0)); AssertExtensions.Throws <ArgumentNullException>("value", () => s_invariantCompare.LastIndexOf("", null, 0, CompareOptions.None)); AssertExtensions.Throws <ArgumentNullException>("value", () => s_invariantCompare.LastIndexOf("", null, 0, 0, CompareOptions.None)); // Source and value are null AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, null)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, null, CompareOptions.None)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, null, 0, 0)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, null, 0, CompareOptions.None)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.LastIndexOf(null, null, 0, 0, CompareOptions.None)); // Options are invalid AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", CompareOptions.StringSort)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, CompareOptions.StringSort)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, 2, CompareOptions.StringSort)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', CompareOptions.StringSort)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, CompareOptions.StringSort)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, 2, CompareOptions.StringSort)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, 2, CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, 2, CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, 2, CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, 2, CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", (CompareOptions)(-1))); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, (CompareOptions)(-1))); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, 2, (CompareOptions)(-1))); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", (CompareOptions)(-1))); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, (CompareOptions)(-1))); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, 2, (CompareOptions)(-1))); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", (CompareOptions)0x11111111)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, (CompareOptions)0x11111111)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, 2, (CompareOptions)0x11111111)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', (CompareOptions)0x11111111)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, (CompareOptions)0x11111111)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, 2, (CompareOptions)0x11111111)); // StartIndex < 0 AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", "Test", -1, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", "Test", -1, 2)); AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", "Test", -1, 2, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", 'a', -1, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", 'a', -1, 2)); AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", 'a', -1, 2, CompareOptions.None)); // StartIndex >= source.Length AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", "Test", 5, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", "Test", 5, 0)); AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", "Test", 5, 0, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", 'a', 5, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", 'a', 5, 0)); AssertExtensions.Throws <ArgumentOutOfRangeException>("startIndex", () => s_invariantCompare.LastIndexOf("Test", 'a', 5, 0, CompareOptions.None)); // Count < 0 AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "Test", 0, -1)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "Test", 0, -1, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", 'a', 0, -1)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", 'a', 0, -1, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "Test", 4, -1)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "Test", 4, -1, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", 'a', 4, -1)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", 'a', 4, -1, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "", 4, -1)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "", 4, -1, CompareOptions.None)); // Count > source.Length AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "Test", 0, 5)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "Test", 0, 5, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", 'a', 0, 5)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", 'a', 0, 5, CompareOptions.None)); // StartIndex + count > source.Length + 1 AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "Test", 3, 5)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "Test", 3, 5, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", 'a', 3, 5)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", 'a', 3, 5, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "s", 4, 6)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", "s", 4, 7, CompareOptions.None)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", 's', 4, 6)); AssertExtensions.Throws <ArgumentOutOfRangeException>("count", () => s_invariantCompare.LastIndexOf("Test", 's', 4, 7, CompareOptions.None)); }
private object RFindWorker(string /*!*/ s, long start, long end) { ContractUtils.RequiresNotNull(s, nameof(s)); start = PythonOps.FixSliceIndex(start, _view.Capacity); end = PythonOps.FixSliceIndex(end, _view.Capacity); if (s == "") { return(start <= end?ReturnLong(start) : -1); } long findLength = end - start; if (s.Length > findLength) { return(-1); } int index = -1; int bufferLength = Math.Max(s.Length, PAGESIZE); CompareInfo c = CultureInfo.InvariantCulture.CompareInfo; if (findLength <= bufferLength * 2) { // In this case, the search area is not significantly larger than s, so we only need to // allocate a single string to search through. byte[] buffer = new byte[findLength]; findLength = _view.ReadArray(start, buffer, 0, (int)findLength); string findString = PythonOps.MakeString(buffer); index = c.LastIndexOf(findString, s, CompareOptions.Ordinal); } else { // We're matching s against a significantly larger file, so we partition the stream into // sections twice the length of s and search each segment. Because a match could exist on a // boundary, sections must overlap by s.Length. Data is saved in 2 buffers to avoid // reading the same parts of the stream twice. byte[] buffer0 = new byte[bufferLength]; byte[] buffer1 = new byte[bufferLength]; int remainder = (int)((end - start) % bufferLength); if (remainder == 0) { remainder = bufferLength; } start = end - bufferLength - remainder; findLength -= bufferLength + remainder; _view.ReadArray(start, buffer0, 0, bufferLength); int bytesRead = _view.ReadArray(start + bufferLength, buffer1, 0, remainder); while (findLength >= 0) { string findString = GetString(buffer0, buffer1, bytesRead); index = c.LastIndexOf(findString, s, CompareOptions.Ordinal); if (index != -1) { return(ReturnLong(index + start)); } byte[] temp = buffer0; buffer0 = buffer1; buffer1 = temp; start -= bufferLength; bytesRead = _view.ReadArray(start, buffer0, 0, bufferLength); findLength -= bytesRead; } } return(index == -1 ? -1 : ReturnLong(index + start)); }
public void CompareInfoIndexTest2() { // Creates CompareInfo for the InvariantCulture. CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo; // iS is the starting index of the substring. int iS = 8; // iL is the length of the substring. int iL = 18; // Searches for the combining character sequence Latin capital letter U with diaeresis or Latin small letter u with diaeresis. string myStr = "Is \u0055\u0308 or \u0075\u0308 the same as \u00DC or \u00FC?"; Assert.Equal(myComp.IndexOf(myStr, "U\u0308", iS, iL), 24); Assert.Equal(myComp.LastIndexOf(myStr, "U\u0308", iS + iL - 1, iL), 24); Assert.Equal(myComp.IndexOf(myStr, "u\u0308", iS, iL), 9); Assert.Equal(myComp.LastIndexOf(myStr, "u\u0308", iS + iL - 1, iL), 9); Assert.Equal(myComp.IndexOf(myStr, '\u00DC', iS, iL), 24); Assert.Equal(myComp.LastIndexOf(myStr, '\u00DC', iS + iL - 1, iL), 24); Assert.Equal(myComp.IndexOf(myStr, '\u00FC', iS, iL), 9); Assert.Equal(myComp.LastIndexOf(myStr, '\u00FC', iS + iL - 1, iL), 9); Assert.Equal(myComp.IndexOf(myStr, "U\u0308", iS, iL, CompareOptions.Ordinal), -1); Assert.Equal(myComp.LastIndexOf(myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.Ordinal), -1); Assert.Equal(myComp.IndexOf(myStr, "u\u0308", iS, iL, CompareOptions.Ordinal), 9); Assert.Equal(myComp.LastIndexOf(myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.Ordinal), 9); Assert.Equal(myComp.IndexOf(myStr, '\u00DC', iS, iL, CompareOptions.Ordinal), 24); Assert.Equal(myComp.LastIndexOf(myStr, '\u00DC', iS + iL - 1, iL, CompareOptions.Ordinal), 24); Assert.Equal(myComp.IndexOf(myStr, '\u00FC', iS, iL, CompareOptions.Ordinal), -1); Assert.Equal(myComp.LastIndexOf(myStr, '\u00FC', iS + iL - 1, iL, CompareOptions.Ordinal), -1); Assert.Equal(myComp.IndexOf(myStr, "U\u0308", iS, iL, CompareOptions.IgnoreCase), 9); Assert.Equal(myComp.LastIndexOf(myStr, "U\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase), 24); Assert.Equal(myComp.IndexOf(myStr, "u\u0308", iS, iL, CompareOptions.IgnoreCase), 9); Assert.Equal(myComp.LastIndexOf(myStr, "u\u0308", iS + iL - 1, iL, CompareOptions.IgnoreCase), 24); Assert.Equal(myComp.IndexOf(myStr, '\u00DC', iS, iL, CompareOptions.IgnoreCase), 9); Assert.Equal(myComp.LastIndexOf(myStr, '\u00DC', iS + iL - 1, iL, CompareOptions.IgnoreCase), 24); Assert.Equal(myComp.IndexOf(myStr, '\u00FC', iS, iL, CompareOptions.IgnoreCase), 9); Assert.Equal(myComp.LastIndexOf(myStr, '\u00FC', iS + iL - 1, iL, CompareOptions.IgnoreCase), 24); }
public void CompareInfoIndexTest1() { // Creates CompareInfo for the InvariantCulture. CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo; // iS is the starting index of the substring. int iS = 8; // iL is the length of the substring. int iL = 18; // Searches for the ligature Æ. String myStr = "Is AE or ae the same as \u00C6 or \u00E6?"; Assert.Equal(myComp.IndexOf(myStr, "AE", iS, iL), 24); Assert.Equal(myComp.LastIndexOf(myStr, "AE", iS + iL - 1, iL), 24); Assert.Equal(myComp.IndexOf(myStr, "ae", iS, iL), 9); Assert.Equal(myComp.LastIndexOf(myStr, "ae", iS + iL - 1, iL), 9); Assert.Equal(myComp.IndexOf(myStr, '\u00C6', iS, iL), 24); Assert.Equal(myComp.LastIndexOf(myStr, '\u00C6', iS + iL - 1, iL), 24); Assert.Equal(myComp.IndexOf(myStr, '\u00E6', iS, iL), 9); Assert.Equal(myComp.LastIndexOf(myStr, '\u00E6', iS + iL - 1, iL), 9); Assert.Equal(myComp.IndexOf(myStr, "AE", iS, iL, CompareOptions.Ordinal), -1); Assert.Equal(myComp.LastIndexOf(myStr, "AE", iS + iL - 1, iL, CompareOptions.Ordinal), -1); Assert.Equal(myComp.IndexOf(myStr, "ae", iS, iL, CompareOptions.Ordinal), 9); Assert.Equal(myComp.LastIndexOf(myStr, "ae", iS + iL - 1, iL, CompareOptions.Ordinal), 9); Assert.Equal(myComp.IndexOf(myStr, '\u00C6', iS, iL, CompareOptions.Ordinal), 24); Assert.Equal(myComp.LastIndexOf(myStr, '\u00C6', iS + iL - 1, iL, CompareOptions.Ordinal), 24); Assert.Equal(myComp.IndexOf(myStr, '\u00E6', iS, iL, CompareOptions.Ordinal), -1); Assert.Equal(myComp.LastIndexOf(myStr, '\u00E6', iS + iL - 1, iL, CompareOptions.Ordinal), -1); Assert.Equal(myComp.IndexOf(myStr, "AE", iS, iL, CompareOptions.IgnoreCase), 9); Assert.Equal(myComp.LastIndexOf(myStr, "AE", iS + iL - 1, iL, CompareOptions.IgnoreCase), 24); Assert.Equal(myComp.IndexOf(myStr, "ae", iS, iL, CompareOptions.IgnoreCase), 9); Assert.Equal(myComp.LastIndexOf(myStr, "ae", iS + iL - 1, iL, CompareOptions.IgnoreCase), 24); Assert.Equal(myComp.IndexOf(myStr, '\u00C6', iS, iL, CompareOptions.IgnoreCase), 9); Assert.Equal(myComp.LastIndexOf(myStr, '\u00C6', iS + iL - 1, iL, CompareOptions.IgnoreCase), 24); Assert.Equal(myComp.IndexOf(myStr, '\u00E6', iS, iL, CompareOptions.IgnoreCase), 9); Assert.Equal(myComp.LastIndexOf(myStr, '\u00E6', iS + iL - 1, iL, CompareOptions.IgnoreCase), 24); }
public static void Main() { CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo; int position = 0; string s1 = "ani\u00ADmal"; string s2 = "animal"; // Find the index of the soft hyphen. position = ci.LastIndexOf(s1, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, "\u00AD", position, position + 1)); } position = ci.LastIndexOf(s2, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, "\u00AD", position, position + 1)); } // Find the index of the soft hyphen followed by "n". position = ci.LastIndexOf(s1, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, "\u00ADn", position, position + 1)); } position = ci.LastIndexOf(s2, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, "\u00ADn", position, position + 1)); } // Find the index of the soft hyphen followed by "m". position = ci.LastIndexOf(s1, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s1, "\u00ADm", position, position + 1)); } position = ci.LastIndexOf(s2, "m"); Console.WriteLine("'m' at position {0}", position); if (position >= 0) { Console.WriteLine(ci.LastIndexOf(s2, "\u00ADm", position, position + 1)); } }