public void IsSuffix(CompareInfo compareInfo, string source, string value, CompareOptions options, bool expected, int expectedMatchLength) { if (options == CompareOptions.None) { Assert.Equal(expected, compareInfo.IsSuffix(source, value)); } Assert.Equal(expected, compareInfo.IsSuffix(source, value, options)); if ((compareInfo == s_invariantCompare) && ((options == CompareOptions.None) || (options == CompareOptions.IgnoreCase))) { StringComparison stringComparison = (options == CompareOptions.IgnoreCase) ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture; Assert.Equal(expected, source.EndsWith(value, stringComparison)); Assert.Equal(expected, source.AsSpan().EndsWith(value.AsSpan(), stringComparison)); } // Now test the span version - use BoundedMemory to detect buffer overruns using BoundedMemory <char> sourceBoundedMemory = BoundedMemory.AllocateFromExistingData <char>(source); sourceBoundedMemory.MakeReadonly(); using BoundedMemory <char> valueBoundedMemory = BoundedMemory.AllocateFromExistingData <char>(value); valueBoundedMemory.MakeReadonly(); Assert.Equal(expected, compareInfo.IsSuffix(sourceBoundedMemory.Span, valueBoundedMemory.Span, options)); Assert.Equal(expected, compareInfo.IsSuffix(sourceBoundedMemory.Span, valueBoundedMemory.Span, options, out int actualMatchLength)); Assert.Equal(expectedMatchLength, actualMatchLength); }
public void IsSuffix(CompareInfo compareInfo, string source, string value, CompareOptions options, bool expected) { if (options == CompareOptions.None) { Assert.Equal(expected, compareInfo.IsSuffix(source, value)); } Assert.Equal(expected, compareInfo.IsSuffix(source, value, options)); }
public static void IsSuffixBadCompareOptions() { CompareInfo ci = CultureInfo.InvariantCulture.CompareInfo; Assert.Throws <ArgumentException>(() => ci.IsSuffix("aaa", "a", CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); Assert.Throws <ArgumentException>(() => ci.IsSuffix("aaa", "a", CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); Assert.Throws <ArgumentException>(() => ci.IsSuffix("aaa", "a", CompareOptions.StringSort)); Assert.Throws <ArgumentException>(() => ci.IsSuffix("aaa", "a", (CompareOptions)(-1))); }
public void IsSuffix(CompareInfo compareInfo, string source, string value, CompareOptions options, bool expected) { if (options == CompareOptions.None) { Assert.Equal(expected, compareInfo.IsSuffix(source, value)); } Assert.Equal(expected, compareInfo.IsSuffix(source, value, options)); if ((compareInfo == s_invariantCompare) && ((options == CompareOptions.None) || (options == CompareOptions.IgnoreCase))) { StringComparison stringComparison = (options == CompareOptions.IgnoreCase) ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture; Assert.Equal(expected, source.EndsWith(value, stringComparison)); Assert.Equal(expected, source.AsSpan().EndsWith(value.AsSpan(), stringComparison)); } }
public void Test(CultureInfo culture, string str1, string str2, bool expected, CompareOptions options) { CompareInfo ci = culture.CompareInfo; bool i = ci.IsSuffix(str1, str2, options); Assert.Equal(expected, i); }
public bool Test(CultureInfo culture, string str1, string str2, bool expected, CompareOptions options, string id) { if (!id.Contains("s") || !Utilities.IsVistaOrLater) //Due Windows 7 bug 130925 { expected = GlobLocHelper.OSIsSuffix(culture, str1, str2, options); } 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 { bool i = ci.IsSuffix(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 TestOrd(CultureInfo culture, string str1, string str2, bool 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 { bool i = ci.IsSuffix(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); }
private static bool ValidResourceFileName(String inFile) { if (inFile == null) { return(false); } CompareInfo comp = CultureInfo.InvariantCulture.CompareInfo; if (comp.IsSuffix(inFile, ".resx", CompareOptions.IgnoreCase) || comp.IsSuffix(inFile, ".txt", CompareOptions.IgnoreCase) || comp.IsSuffix(inFile, ".restext", CompareOptions.IgnoreCase) || comp.IsSuffix(inFile, ".resources", CompareOptions.IgnoreCase)) { return(true); } return(false); }
public static void Main() { // Defines the strings to compare. String myStr1 = "calle"; String myStr2 = "llegar"; String myXfix = "lle"; // Uses the CompareInfo property of the InvariantCulture. CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo; // Determines whether myXfix is a prefix of "calle" and "llegar". Console.WriteLine("IsPrefix( {0}, {1} ) : {2}", myStr1, myXfix, myComp.IsPrefix(myStr1, myXfix)); Console.WriteLine("IsPrefix( {0}, {1} ) : {2}", myStr2, myXfix, myComp.IsPrefix(myStr2, myXfix)); // Determines whether myXfix is a suffix of "calle" and "llegar". Console.WriteLine("IsSuffix( {0}, {1} ) : {2}", myStr1, myXfix, myComp.IsSuffix(myStr1, myXfix)); Console.WriteLine("IsSuffix( {0}, {1} ) : {2}", myStr2, myXfix, myComp.IsSuffix(myStr2, myXfix)); }
private bool CheckPath(string path) { CompareInfo compareInfo = CultureInfo.InvariantCulture.CompareInfo; if (compareInfo.IsPrefix(path, "/", CompareOptions.Ordinal)) { return(path == this.currentXmlPath); } return(compareInfo.IsSuffix(this.currentXmlPath, path, CompareOptions.Ordinal)); }
public void TestExc <T>(CultureInfo culture, string str1, string str2, CompareOptions options) where T : Exception { CompareInfo ci = culture.CompareInfo; Assert.Throws <T>(() => { bool i = ci.IsSuffix(str1, str2, options); }); }
public override object Eval(object row, object context) { object lValue = base.Left.Eval(row, context); if (!DataStorageHelper.IsObjectNull(lValue)) { if (!(lValue is string || lValue is SqlString)) { throw InvalidExpressionException.TypeMismatchInBinop(Operator.Like, lValue.GetType(), typeof(string)); } object rValue = base.Right.Eval(row, context); if (DataStorageHelper.IsObjectNull(rValue)) { return(DBNull.Value); } if (!(rValue is string || rValue is SqlString)) { throw InvalidExpressionException.TypeMismatchInBinop(Operator.Like, typeof(string), rValue.GetType()); } string text = lValue.ToString(); string pattern = this.AnalizePattern(rValue.ToString()); char[] trimChars = new char[] { ' ', '\u3000' }; text = text.TrimEnd(trimChars); CompareInfo compareInfo = base.Culture.CompareInfo; switch (this.kind) { case match_left: return(0 == compareInfo.IndexOf(text, pattern, this.compareFlags)); case match_right: { string text4 = pattern.TrimEnd(trimChars); return(compareInfo.IsSuffix(text, text4, this.compareFlags)); } case match_middle: return(0 <= compareInfo.IndexOf(text, pattern, this.compareFlags)); case match_exact: return(0 == compareInfo.Compare(text, pattern, this.compareFlags)); case match_all: return(true); } } return(DBNull.Value); }
public void IsSuffix(string culture, string source, string suffix, CompareOptions options) { CompareInfo compareInfo = CultureInfo.GetCultureInfo(culture).CompareInfo; foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { compareInfo.IsSuffix(source, suffix, options); } } }
bool CheckPath(string path) { CompareInfo ci = CultureInfo.InvariantCulture.CompareInfo; if (ci.IsPrefix(path, "/", CompareOptions.Ordinal)) { return(path == currentXmlPath); } else { return(ci.IsSuffix(currentXmlPath, path, CompareOptions.Ordinal)); } }
public static void Main() { // Defines the strings to compare. String myStr1 = "calle"; String myStr2 = "llegar"; String myXfix = "LLE"; // Uses the CompareInfo property of the InvariantCulture. CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo; Console.WriteLine("IsSuffix \"{0}\", \"{1}\"", myStr1, myXfix); Console.WriteLine(" With no CompareOptions : {0}", myComp.IsSuffix(myStr1, myXfix)); Console.WriteLine(" With None : {0}", myComp.IsSuffix(myStr1, myXfix, CompareOptions.None)); Console.WriteLine(" With Ordinal : {0}", myComp.IsSuffix(myStr1, myXfix, CompareOptions.Ordinal)); Console.WriteLine(" With IgnoreCase : {0}", myComp.IsSuffix(myStr1, myXfix, CompareOptions.IgnoreCase)); Console.WriteLine("IsPrefix \"{0}\", \"{1}\"", myStr2, myXfix); Console.WriteLine(" With no CompareOptions : {0}", myComp.IsPrefix(myStr2, myXfix)); Console.WriteLine(" With None : {0}", myComp.IsPrefix(myStr2, myXfix, CompareOptions.None)); Console.WriteLine(" With Ordinal : {0}", myComp.IsPrefix(myStr2, myXfix, CompareOptions.Ordinal)); Console.WriteLine(" With IgnoreCase : {0}", myComp.IsPrefix(myStr2, myXfix, CompareOptions.IgnoreCase)); }
public void IsSuffix_Invalid() { // Source is null Assert.Throws <ArgumentNullException>(() => s_invariantCompare.IsSuffix(null, "")); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.IsSuffix(null, "", CompareOptions.None)); // Prefix is null Assert.Throws <ArgumentNullException>(() => s_invariantCompare.IsSuffix("", null)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.IsSuffix("", null, CompareOptions.None)); // Source and prefix are null Assert.Throws <ArgumentNullException>(() => s_invariantCompare.IsSuffix(null, null)); Assert.Throws <ArgumentNullException>(() => s_invariantCompare.IsSuffix(null, null, CompareOptions.None)); // Options are invalid Assert.Throws <ArgumentException>(() => s_invariantCompare.IsSuffix("Test's", "Tests", CompareOptions.StringSort)); Assert.Throws <ArgumentException>(() => s_invariantCompare.IsSuffix("Test's", "Tests", (CompareOptions)(-1))); Assert.Throws <ArgumentException>(() => s_invariantCompare.IsSuffix("Test's", "Tests", (CompareOptions)0x11111111)); }
public static bool EndsWithCultureIgnoreCaseHelper(ReadOnlySpan <char> span, ReadOnlySpan <char> value, CompareInfo compareInfo) { Debug.Assert(value.Length != 0); if (GlobalizationMode.Invariant) { return(EndsWithOrdinalIgnoreCaseHelper(span, value)); } if (span.Length == 0) { return(false); } return(compareInfo.IsSuffix(span, value, CompareOptions.IgnoreCase)); }
private static Sort GetSort(SortedField[] sortedFields) { if (sortedFields == null || sortedFields.Length == 0) { return(null); } return(new Sort(sortedFields.Select(x => { var sortOptions = SortOptions.String; if (x.Field == Constants.Indexing.Fields.IndexFieldScoreName) { return SortField.FIELD_SCORE; } if (InvariantCompare.IsPrefix(x.Field, Constants.Indexing.Fields.AlphaNumericFieldName, CompareOptions.None)) { var customFieldName = SortFieldHelper.ExtractName(x.Field); if (customFieldName.IsNullOrWhiteSpace()) { throw new InvalidOperationException("Alphanumeric sort: cannot figure out what field to sort on!"); } var anSort = new AlphaNumericComparatorSource(); return new SortField(customFieldName, anSort, x.Descending); } if (InvariantCompare.IsPrefix(x.Field, Constants.Indexing.Fields.RandomFieldName, CompareOptions.None)) { var customFieldName = SortFieldHelper.ExtractName(x.Field); if (customFieldName.IsNullOrWhiteSpace()) // truly random { return new RandomSortField(Guid.NewGuid().ToString()); } return new RandomSortField(customFieldName); } if (InvariantCompare.IsSuffix(x.Field, Constants.Indexing.Fields.RangeFieldSuffix, CompareOptions.None)) { sortOptions = SortOptions.NumericDouble; // TODO arek - it seems to be working fine with long values as well however needs to be verified } return new SortField(IndexField.ReplaceInvalidCharactersInFieldName(x.Field), (int)sortOptions, x.Descending); }).ToArray())); }
public override object Eval(object row, object context) { object obj1 = this.Left.Eval(row, context); if (!DataStorageHelper.IsObjectNull(obj1)) { if (!(obj1 is string) && !(obj1 is SqlString)) { Guid guid = obj1 as Guid; } object obj2 = this.Right.Eval(row, context); if (DataStorageHelper.IsObjectNull(obj2)) { return((object)DBNull.Value); } if (!(obj2 is string) && !(obj2 is SqlString) && !(obj1 is Guid)) { throw InvalidExpressionException.TypeMismatchInBinop(Operator.Like, typeof(string), obj2.GetType()); } string str = obj1.ToString(); string string2 = this.AnalizePattern(obj2.ToString()); char[] chArray = new char[2] { ' ', ' ' }; CompareInfo compareInfo = this.Culture.CompareInfo; switch (this.kind) { case 1: return((object)(0 == compareInfo.IndexOf(str, string2, this.compareFlags))); case 2: string suffix = string2.TrimEnd(chArray); return((object)compareInfo.IsSuffix(str, suffix, this.compareFlags)); case 3: return((object)(0 <= compareInfo.IndexOf(str, string2, this.compareFlags))); case 4: return((object)(0 == compareInfo.Compare(str, string2, this.compareFlags))); case 5: return((object)true); } } return((object)DBNull.Value); }
public static SortOptions?GetSortOption(this IndexDefinition self, string name, IndexQuery query) { SortOptions value; if (InvariantCompare.IsSuffix(name, _Range, CompareOptions.None)) { string nameWithoutRange = name.Substring(0, name.Length - _Range.Length); if (self.SortOptions.TryGetValue(nameWithoutRange, out value)) { return(value); } if (self.SortOptions.TryGetValue(Constants.AllFields, out value)) { return(value); } if (query != null && query.SortHints != null && query.SortHints.TryGetValue(_SortHint + nameWithoutRange, out value)) { return(value); } } if (self.SortOptions.TryGetValue(name, out value)) { return(value); } if (self.SortOptions.TryGetValue(Constants.AllFields, out value)) { return(value); } if (query == null || query.SortHints == null) { return(value); } if (!query.SortHints.TryGetValue(_SortHint + name, out value)) { return(SortOptions.None); } return(value); }
public static void IsSuffixArgumentNullException() { CompareInfo ci = CultureInfo.InvariantCulture.CompareInfo; Assert.Throws <ArgumentNullException>(() => ci.IsSuffix(null, "")); Assert.Throws <ArgumentNullException>(() => ci.IsSuffix(null, "", CompareOptions.Ordinal)); Assert.Throws <ArgumentNullException>(() => ci.IsSuffix("", null)); Assert.Throws <ArgumentNullException>(() => ci.IsSuffix("", null, CompareOptions.Ordinal)); Assert.Throws <ArgumentNullException>(() => ci.IsSuffix(null, null)); Assert.Throws <ArgumentNullException>(() => ci.IsSuffix(null, null, CompareOptions.Ordinal)); }
void CheckBaseName() { if (BaseNameField.Length <= 10) { return; } CompareInfo c = CultureInfo.InvariantCulture.CompareInfo; if (!c.IsSuffix(BaseNameField, ".resources", CompareOptions.IgnoreCase)) { return; } if (MainAssembly != null) { string resourceFileName = GetResourceFileName( CultureInfo.InvariantCulture); Stream s = GetManifestResourceStreamNoCase( MainAssembly, resourceFileName); if (s != null) { return; } } else { string resourceFile = GetResourceFilePath( CultureInfo.InvariantCulture); if (File.Exists(resourceFile)) { return; } } throw new ArgumentException("ResourceManager base" + " name should not end in .resources. It" + " should be similar to MyResources," + " which the ResourceManager can convert" + " into MyResources.<culture>.resources;" + " for example, MyResources.en-US.resources."); }
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 { bool i = ci.IsSuffix(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 void IsSuffix_Invalid() { // Source is null AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.IsSuffix(null, "")); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.IsSuffix(null, "", CompareOptions.None)); // Prefix is null AssertExtensions.Throws <ArgumentNullException>("suffix", () => s_invariantCompare.IsSuffix("", null)); AssertExtensions.Throws <ArgumentNullException>("suffix", () => s_invariantCompare.IsSuffix("", null, CompareOptions.None)); // Source and prefix are null AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.IsSuffix(null, null)); AssertExtensions.Throws <ArgumentNullException>("source", () => s_invariantCompare.IsSuffix(null, null, CompareOptions.None)); // Options are invalid AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.IsSuffix("Test's", "Tests", CompareOptions.StringSort)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.IsSuffix("Test's", "Tests", CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.IsSuffix("Test's", "Tests", CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.IsSuffix("Test's", "Tests", (CompareOptions)(-1))); AssertExtensions.Throws <ArgumentException>("options", () => s_invariantCompare.IsSuffix("Test's", "Tests", (CompareOptions)0x11111111)); }
internal static bool EndsWith(string source, string suffix) { return(InvariantCompareInfo.IsSuffix(source, suffix, (CompareOptions)1073741824)); }
public static void IsSuffix(string localeName, string source, string suffix, bool expectedResult, CompareOptions options) { CompareInfo ci = CompareInfo.GetCompareInfo(localeName); Assert.Equal(expectedResult, ci.IsSuffix(source, suffix, options)); }
public static bool EndsWithIgnoreCase(ref string source, string suffix) { return(__CompareInfo.IsSuffix(source, suffix, CompareOptions.IgnoreCase)); }
public static DynamicQueryMapping Create(string entityName, IndexQueryServerSide query) { var result = new DynamicQueryMapping { ForCollection = entityName, }; IEnumerable <DynamicQueryMappingItem> dynamicMapFields; string[] numericFields; if (query.DynamicMapReduceFields == null) { // auto map query var fields = SimpleQueryParser.GetFieldsForDynamicQuery(query); // TODO arek - not sure if we really need a Tuple<string, string> here if (query.SortedFields != null) { foreach (var sortedField in query.SortedFields) { var field = sortedField.Field; if (field == Constants.Indexing.Fields.IndexFieldScoreName) { continue; } if (field.StartsWith(Constants.Indexing.Fields.RandomFieldName) || field.StartsWith(Constants.Indexing.Fields.CustomSortFieldName)) { continue; } if (InvariantCompare.IsPrefix(field, Constants.Indexing.Fields.AlphaNumericFieldName, CompareOptions.None)) { field = SortFieldHelper.ExtractName(field); } if (InvariantCompare.IsSuffix(field, Constants.Indexing.Fields.RangeFieldSuffix, CompareOptions.None)) { field = field.Substring(0, field.Length - Constants.Indexing.Fields.RangeFieldSuffix.Length); } fields.Add(Tuple.Create(SimpleQueryParser.TranslateField(field), field)); } } dynamicMapFields = fields.Select(x => new DynamicQueryMappingItem(x.Item1.EndsWith(Constants.Indexing.Fields.RangeFieldSuffix) ? x.Item1.Substring(0, x.Item1.Length - Constants.Indexing.Fields.RangeFieldSuffix.Length) : x.Item1, FieldMapReduceOperation.None)); numericFields = fields.Where(x => x.Item1.EndsWith(Constants.Indexing.Fields.RangeFieldSuffix)).Select(x => x.Item1).Distinct().ToArray(); } else { // dynamic map-reduce query result.IsMapReduce = true; dynamicMapFields = query.DynamicMapReduceFields.Where(x => x.IsGroupBy == false).Select(x => new DynamicQueryMappingItem(x.Name, x.OperationType)); result.GroupByFields = query.DynamicMapReduceFields.Where(x => x.IsGroupBy).Select(x => x.Name).ToArray(); numericFields = null; } result.MapFields = dynamicMapFields .Where(x => x.Name != Constants.Indexing.Fields.DocumentIdFieldName) .OrderByDescending(x => x.Name.Length) .ToArray(); result.SortDescriptors = GetSortInfo(query.SortedFields, numericFields); result.HighlightedFields = query.HighlightedFields.EmptyIfNull().Select(x => x.Field).ToArray(); return(result); }
internal static bool EndsWith(string source, string suffix) { return(InvariantCompareInfo.IsSuffix(source, suffix, CompareOptions.Ordinal)); }
void AssertIsSuffix(string message, bool expected, string source, string target) { Assert.IsTrue(message, expected == invariant.IsSuffix( source, target)); }