public Comparer(CultureInfo culture)
{
if (culture == null)
throw new ArgumentNullException("culture");
m_compareInfo = culture.CompareInfo;
}
public void Equals(CompareInfo compare1, object value, bool expected)
{
Assert.Equal(expected, compare1.Equals(value));
if (value is CompareInfo)
{
Assert.Equal(expected, compare1.GetHashCode().Equals(value.GetHashCode()));
}
}
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));
}
/// <summary>
/// Perform deep comparison of two model instances
/// </summary>
/// <param name="obj">First object to compare</param>
/// <param name="value">Second object to compare</param>
/// <param name="path">Location of the non-equal element found first</param>
/// <returns>If both objects are equal</returns>
public static bool Compare(this IBabelModel obj, IBabelModel value, out string path)
{
if (obj == null)
{
if (value == null)
{
path = null;
return true;
}
else
{
path = "";
return false;
}
}
var ci = new CompareInfo { Model = value, Path = null, AreEqual = true};
obj.RunOnChildren<CompareInfo>(CompareInternal, ci);
path = ci.Path;
return ci.AreEqual;
}
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_Aesc_Ligature(CompareInfo compareInfo, string source, string value, int startIndex, int count, CompareOptions options, int expected)
{
LastIndexOf_String(compareInfo, source, value, startIndex, count, options, expected);
}
private StringComparer(CultureInfo culture)
{
Debug.Assert(culture != null);
_compareInfo = culture.CompareInfo;
}
public static void Ctor(CompareInfo aThis, CultureInfo aCulture)
{
}
public void Compare(CompareInfo compareInfo, string string1, int offset1, int length1, string string2, int offset2, int length2, CompareOptions options, int expected)
{
if (offset1 + length1 == (string1?.Length ?? 0) && offset2 + length2 == (string2?.Length ?? 0))
{
if (offset1 == 0 && offset2 == 0)
{
if (options == CompareOptions.None)
{
// Use Compare(string, string)
Assert.Equal(expected, Math.Sign(compareInfo.Compare(string1, string2)));
Assert.Equal(-expected, Math.Sign(compareInfo.Compare(string2, string1)));
}
// Use Compare(string, string, CompareOptions)
Assert.Equal(expected, Math.Sign(compareInfo.Compare(string1, string2, options)));
Assert.Equal(-expected, Math.Sign(compareInfo.Compare(string2, string1, options)));
}
if (options == CompareOptions.None)
{
// Use Compare(string, int, string, int)
Assert.Equal(expected, Math.Sign(compareInfo.Compare(string1, offset1, string2, offset2)));
Assert.Equal(-expected, Math.Sign(compareInfo.Compare(string2, offset2, string1, offset1)));
}
// Use Compare(string, int, string, int, CompareOptions)
Assert.Equal(expected, Math.Sign(compareInfo.Compare(string1, offset1, string2, offset2, options)));
Assert.Equal(-expected, Math.Sign(compareInfo.Compare(string2, offset2, string1, offset1, options)));
}
if (options == CompareOptions.None)
{
// Use Compare(string, int, int, string, int, int)
Assert.Equal(expected, Math.Sign(compareInfo.Compare(string1, offset1, length1, string2, offset2, length2)));
Assert.Equal(-expected, Math.Sign(compareInfo.Compare(string2, offset2, length2, string1, offset1, length1)));
}
// Use Compare(string, int, int, string, int, int, CompareOptions)
Assert.Equal(expected, Math.Sign(compareInfo.Compare(string1, offset1, length1, string2, offset2, length2, options)));
Assert.Equal(-expected, Math.Sign(compareInfo.Compare(string2, offset2, length2, string1, offset1, length1, options)));
}
public override string GetSavedLicenseKey(Type type, Assembly resourceAssembly)
{
if (_savedLicenseKeys == null || _savedLicenseKeys[type.AssemblyQualifiedName] == null)
{
Debug.WriteLineIf(s_runtimeLicenseContextSwitch.TraceVerbose, "savedLicenseKey is null or doesn't contain our type");
if (_savedLicenseKeys == null)
{
_savedLicenseKeys = new Hashtable();
}
if (resourceAssembly == null)
{
resourceAssembly = Assembly.GetEntryAssembly();
}
if (resourceAssembly == null)
{
Debug.WriteLineIf(s_runtimeLicenseContextSwitch.TraceVerbose, "resourceAssembly is null");
// If Assembly.EntryAssembly returns null, then we will
// try everything.
foreach (Assembly asm in AppDomain.CurrentDomain.GetAssemblies())
{
// Though, I could not repro this, we seem to be hitting an AssemblyBuilder
// when walking through all the assemblies in the current app domain. This throws an
// exception on Assembly.CodeBase and we bail out. Catching exceptions here is not a
// bad thing.
if (asm.IsDynamic)
{
continue;
}
// file://fullpath/foo.exe
string fileName = GetLocalPath(asm.EscapedCodeBase);
fileName = new FileInfo(fileName).Name;
Stream s = asm.GetManifestResourceStream(fileName + ".licenses");
if (s == null)
{
// Since the casing may be different depending on how the assembly was loaded,
// we'll do a case insensitive lookup for this manifest resource stream...
s = CaseInsensitiveManifestResourceStreamLookup(asm, fileName + ".licenses");
}
if (s != null)
{
DesigntimeLicenseContextSerializer.Deserialize(s, fileName.ToUpper(CultureInfo.InvariantCulture), this);
break;
}
}
}
else if (!resourceAssembly.IsDynamic)
{
// EscapedCodeBase won't be supported by emitted assemblies anyway
Debug.WriteLineIf(s_runtimeLicenseContextSwitch.TraceVerbose, "resourceAssembly is not null");
string fileName;
fileName = GetLocalPath(resourceAssembly.EscapedCodeBase);
fileName = Path.GetFileName(fileName);
string licResourceName = fileName + ".licenses";
// First try the filename
Stream s = resourceAssembly.GetManifestResourceStream(licResourceName);
if (s == null)
{
string resolvedName = null;
CompareInfo comparer = CultureInfo.InvariantCulture.CompareInfo;
string shortAssemblyName = resourceAssembly.GetName().Name;
// If the assembly has been renamed, we try our best to find a good match in the available resources
// by looking at the assembly name (which doesn't change even after a file rename) + ".exe.licenses" or + ".dll.licenses"
foreach (string existingName in resourceAssembly.GetManifestResourceNames())
{
if (comparer.Compare(existingName, licResourceName, CompareOptions.IgnoreCase) == 0 ||
comparer.Compare(existingName, shortAssemblyName + ".exe.licenses", CompareOptions.IgnoreCase) == 0 ||
comparer.Compare(existingName, shortAssemblyName + ".dll.licenses", CompareOptions.IgnoreCase) == 0)
{
resolvedName = existingName;
break;
}
}
if (resolvedName != null)
{
s = resourceAssembly.GetManifestResourceStream(resolvedName);
}
}
if (s != null)
{
DesigntimeLicenseContextSerializer.Deserialize(s, fileName.ToUpper(CultureInfo.InvariantCulture), this);
}
}
}
Debug.WriteLineIf(s_runtimeLicenseContextSwitch.TraceVerbose, $"returning : {(string)_savedLicenseKeys[type.AssemblyQualifiedName]}");
return((string)_savedLicenseKeys[type.AssemblyQualifiedName]);
}
static void TestIndexOf()
{
// based on examples in documentation page for
// System.Globalization.CompareInfo.IndexOf methods
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
int iS = 20;
String myT1;
String myStr = "Is AE or ae the same as Æ or æ?";
myT1 = new String('-', iS);
//Console.WriteLine( "IndexOf( String, *, {0}, * )", iS );
//Console.WriteLine( "Original : {0}", myStr );
//Console.WriteLine( "No options : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", iS), -1);
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", iS), -1);
PrintMarker(" Æ : ", myComp.IndexOf(myStr, 'Æ', iS), -1);
PrintMarker(" æ : ", myComp.IndexOf(myStr, 'æ', iS), -1);
Console.WriteLine(/* "Ordinal : {0}{1}", myT1, myStr.Substring( iS ) */);
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", iS, CompareOptions.Ordinal), -1);
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", iS, CompareOptions.Ordinal), -1);
PrintMarker(" Æ : ", myComp.IndexOf(myStr, 'Æ', iS, CompareOptions.Ordinal), -1);
PrintMarker(" æ : ", myComp.IndexOf(myStr, 'æ', iS, CompareOptions.Ordinal), -1);
Console.WriteLine(/* "IgnoreCase : {0}{1}", myT1, myStr.Substring( iS ) */);
PrintMarker(" AE : ", myComp.IndexOf(myStr, "AE", iS, CompareOptions.IgnoreCase), -1);
PrintMarker(" ae : ", myComp.IndexOf(myStr, "ae", iS, CompareOptions.IgnoreCase), -1);
PrintMarker(" Æ : ", myComp.IndexOf(myStr, 'Æ', iS, CompareOptions.IgnoreCase), -1);
PrintMarker(" æ : ", myComp.IndexOf(myStr, 'æ', iS, CompareOptions.IgnoreCase), -1);
Console.WriteLine();
myT1 = new String('-', myStr.Length - iS - 1);
//Console.WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
//Console.WriteLine( "Original : {0}", myStr );
//Console.WriteLine( "No options : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker(" AE : ", -1, myComp.LastIndexOf(myStr, "AE", iS));
PrintMarker(" ae : ", -1, myComp.LastIndexOf(myStr, "ae", iS));
PrintMarker(" Æ : ", -1, myComp.LastIndexOf(myStr, 'Æ', iS));
PrintMarker(" æ : ", -1, myComp.LastIndexOf(myStr, 'æ', iS));
Console.WriteLine(/* "Ordinal : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 */);
PrintMarker(" AE : ", -1, myComp.LastIndexOf(myStr, "AE", iS, CompareOptions.Ordinal));
PrintMarker(" ae : ", -1, myComp.LastIndexOf(myStr, "ae", iS, CompareOptions.Ordinal));
PrintMarker(" Æ : ", -1, myComp.LastIndexOf(myStr, 'Æ', iS, CompareOptions.Ordinal));
PrintMarker(" æ : ", -1, myComp.LastIndexOf(myStr, 'æ', iS, CompareOptions.Ordinal));
Console.WriteLine(/* "IgnoreCase : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 */);
PrintMarker(" AE : ", -1, myComp.LastIndexOf(myStr, "AE", iS, CompareOptions.IgnoreCase));
PrintMarker(" ae : ", -1, myComp.LastIndexOf(myStr, "ae", iS, CompareOptions.IgnoreCase));
PrintMarker(" Æ : ", -1, myComp.LastIndexOf(myStr, 'Æ', iS, CompareOptions.IgnoreCase));
PrintMarker(" æ : ", -1, myComp.LastIndexOf(myStr, 'æ', iS, CompareOptions.IgnoreCase));
Console.WriteLine();
// 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?";
myT1 = new String('-', iS);
//Console.WriteLine( "IndexOf( String, *, {0}, * )", iS );
//Console.WriteLine( "Original : {0}", myStr );
//Console.WriteLine( "No options : {0}{1}", myT1, myStr.Substring( iS ) );
PrintMarker(" U\u0308 : ", myComp.IndexOf(myStr, "U\u0308", iS), -1);
PrintMarker(" u\u0308 : ", myComp.IndexOf(myStr, "u\u0308", iS), -1);
PrintMarker(" Ü : ", myComp.IndexOf(myStr, 'Ü', iS), -1);
PrintMarker(" ü : ", myComp.IndexOf(myStr, 'ü', iS), -1);
Console.WriteLine(/* "Ordinal : {0}{1}", myT1, myStr.Substring( iS ) */);
PrintMarker(" U\u0308 : ", myComp.IndexOf(myStr, "U\u0308", iS, CompareOptions.Ordinal), -1);
PrintMarker(" u\u0308 : ", myComp.IndexOf(myStr, "u\u0308", iS, CompareOptions.Ordinal), -1);
PrintMarker(" Ü : ", myComp.IndexOf(myStr, 'Ü', iS, CompareOptions.Ordinal), -1);
PrintMarker(" ü : ", myComp.IndexOf(myStr, 'ü', iS, CompareOptions.Ordinal), -1);
Console.WriteLine(/* "IgnoreCase : {0}{1}", myT1, myStr.Substring( iS ) */);
PrintMarker(" U\u0308 : ", myComp.IndexOf(myStr, "U\u0308", iS, CompareOptions.IgnoreCase), -1);
PrintMarker(" u\u0308 : ", myComp.IndexOf(myStr, "u\u0308", iS, CompareOptions.IgnoreCase), -1);
PrintMarker(" Ü : ", myComp.IndexOf(myStr, 'Ü', iS, CompareOptions.IgnoreCase), -1);
PrintMarker(" ü : ", myComp.IndexOf(myStr, 'ü', iS, CompareOptions.IgnoreCase), -1);
Console.WriteLine();
myT1 = new String('-', myStr.Length - iS - 1);
//Console.WriteLine( "LastIndexOf( String, *, {0}, * )", iS );
//Console.WriteLine( "Original : {0}", myStr );
//Console.WriteLine( "No options : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 );
PrintMarker(" U\u0308 : ", -1, myComp.LastIndexOf(myStr, "U\u0308", iS));
PrintMarker(" u\u0308 : ", -1, myComp.LastIndexOf(myStr, "u\u0308", iS));
PrintMarker(" Ü : ", -1, myComp.LastIndexOf(myStr, 'Ü', iS));
PrintMarker(" ü : ", -1, myComp.LastIndexOf(myStr, 'ü', iS));
Console.WriteLine(/* "Ordinal : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 */);
PrintMarker(" U\u0308 : ", -1, myComp.LastIndexOf(myStr, "U\u0308", iS, CompareOptions.Ordinal));
PrintMarker(" u\u0308 : ", -1, myComp.LastIndexOf(myStr, "u\u0308", iS, CompareOptions.Ordinal));
PrintMarker(" Ü : ", -1, myComp.LastIndexOf(myStr, 'Ü', iS, CompareOptions.Ordinal));
PrintMarker(" ü : ", -1, myComp.LastIndexOf(myStr, 'ü', iS, CompareOptions.Ordinal));
Console.WriteLine(/* "IgnoreCase : {0}{1}", myStr.Substring( 0, iS + 1 ), myT1 */);
PrintMarker(" U\u0308 : ", -1, myComp.LastIndexOf(myStr, "U\u0308", iS, CompareOptions.IgnoreCase));
PrintMarker(" u\u0308 : ", -1, myComp.LastIndexOf(myStr, "u\u0308", iS, CompareOptions.IgnoreCase));
PrintMarker(" Ü : ", -1, myComp.LastIndexOf(myStr, 'Ü', iS, CompareOptions.IgnoreCase));
PrintMarker(" ü : ", -1, myComp.LastIndexOf(myStr, 'ü', iS, CompareOptions.IgnoreCase));
Console.WriteLine();
/// <summary>
/// Create a collation based on a given <c>CompareInfo</c> and <c>CompareOptions</c>
/// </summary>
/// <param name="uri">The collation URI to be used within the XPath expression to refer to this collation</param>
/// <param name="compareInfo">The <c>CompareInfo</c>, which determines the language-specific
/// collation rules to be used</param>
/// <param name="options">Options to be used in performing comparisons, for example
/// whether they are to be case-blind and/or accent-blind</param>
/// <param name="isDefault">If true, this collation will be used as the default collation</param>
public void DeclareCollation(Uri uri, CompareInfo compareInfo, CompareOptions options, Boolean isDefault)
{
DotNetComparator comparator = new DotNetComparator(compareInfo, options);
env.declareCollation(uri.ToString(), comparator, isDefault);
}
public static IComparer <string> ToComparer <T>(this CompareInfo compareInfo)
{
Contract.Requires(compareInfo != null);
return(new FuncComparer <string>(compareInfo.Compare));
}
internal Max(CompareInfo compareInfo, CompareOptions compareOptions)
{
m_currentMax = null;
m_compareInfo = compareInfo;
m_compareOptions = compareOptions;
}
public CultureAwareComparer(CultureInfo ci, bool ignore_case)
{
_compareInfo = ci.CompareInfo;
_ignoreCase = ignore_case;
}
/// <summary>
/// Serves as a hash function for the current System.Globalization.SortKey object
/// that is suitable for hashing algorithms and data structures such as a hash table.
/// </summary>
/// <returns>A hash code for the current System.Globalization.SortKey object.</returns>
public override int GetHashCode()
{
return(CompareInfo.GetCompareInfo(localeName).GetHashCode(m_String, options));
}
internal __DTString(String str, DateTimeFormatInfo dtfi)
{
Index = -1;
Value = str;
len = Value.Length;
m_current = '\0';
if (dtfi != null)
{
m_info = dtfi.CompareInfo;
m_checkDigitToken = ((dtfi.FormatFlags & DateTimeFormatFlags.UseDigitPrefixInTokens) != 0);
} else
{
m_info = Thread.CurrentThread.CurrentCulture.CompareInfo;
m_checkDigitToken = false;
}
}
public static void Main()
{
CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;
int position = 0;
string s1 = "ani\u00ADmal";
string s2 = "animal";
// Use culture-sensitive comparison for the following searches:
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, CompareOptions.None));
}
position = ci.LastIndexOf(s2, "m");
Console.WriteLine("'m' at position {0}", position);
if (position >= 0)
{
Console.WriteLine(ci.LastIndexOf(s2, "\u00AD", position, 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, CompareOptions.IgnoreCase));
}
position = ci.LastIndexOf(s2, "m");
Console.WriteLine("'m' at position {0}", position);
if (position >= 0)
{
Console.WriteLine(ci.LastIndexOf(s2, "\u00ADn", position, 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, CompareOptions.IgnoreCase));
}
position = ci.LastIndexOf(s2, "m");
Console.WriteLine("'m' at position {0}", position);
if (position >= 0)
{
Console.WriteLine(ci.LastIndexOf(s2, "\u00ADm", position, CompareOptions.IgnoreCase));
}
Console.WriteLine();
// Use ordinal comparison for the following searches:
Console.WriteLine("Ordinal 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, CompareOptions.Ordinal));
}
position = ci.LastIndexOf(s2, "m");
Console.WriteLine("'m' at position {0}", position);
if (position >= 0)
{
Console.WriteLine(ci.LastIndexOf(s2, "\u00AD", position, 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, CompareOptions.Ordinal));
}
position = ci.LastIndexOf(s2, "m");
Console.WriteLine("'m' at position {0}", position);
if (position >= 0)
{
Console.WriteLine(ci.LastIndexOf(s2, "\u00ADn", position, 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, CompareOptions.Ordinal));
}
position = ci.LastIndexOf(s2, "m");
Console.WriteLine("'m' at position {0}", position);
if (position >= 0)
{
Console.WriteLine(ci.LastIndexOf(s2, "\u00ADm", position, CompareOptions.Ordinal));
}
}
public void LastIndexOf_Aesc_Ligature(CompareInfo compareInfo, string source, string value, int startIndex, int count, CompareOptions options, int expected)
{
// TODO: Remove this function, and combine into LastIndexOf_String once 5463 is fixed
LastIndexOf_String(compareInfo, source, value, startIndex, count, options, expected);
}
private Comparer()
{
this.m_compareInfo = (CompareInfo)null;
}
public void GetCompareInfo_Null_ThrowsArgumentNullException()
{
AssertExtensions.Throws <ArgumentNullException>("name", () => CompareInfo.GetCompareInfo(null));
}
public void SortKeyKanaTest(CompareInfo compareInfo, string string1, string string2, CompareOptions options, int expected)
{
SortKeyTest(compareInfo, string1, string2, options, expected);
}
public void Compare(CompareInfo compareInfo, string string1, string string2, CompareOptions options, int expected)
{
if (options == CompareOptions.None)
{
// Use Compare(string, string)
Assert.Equal(expected, NormalizeCompare(compareInfo.Compare(string1, string2)));
Assert.Equal(-expected, NormalizeCompare(compareInfo.Compare(string2, string1)));
}
// Use Compare(string, string, CompareOptions)
Assert.Equal(expected, NormalizeCompare(compareInfo.Compare(string1, string2, options)));
Assert.Equal(-expected, NormalizeCompare(compareInfo.Compare(string2, string1, options)));
}
public void GetHashCode(string source1, CompareOptions options1, string source2, CompareOptions options2, bool expected)
{
CompareInfo invariantCompare = CultureInfo.InvariantCulture.CompareInfo;
Assert.Equal(expected, invariantCompare.GetHashCode(source1, options1).Equals(invariantCompare.GetHashCode(source2, options2)));
}
static bool CompareInternal(string name, object data1, object data2, out string path)
{
if (data1 == null)
{
if (data2 == null)
{
path = null;
return true;
}
else
{
path = name;
return false;
}
}
if (data2 == null) //data1 != null
{
path = name;
return false;
}
var dict1 = data1 as IDictionary;
if(dict1 != null)
{
var dict2 = data2 as IDictionary;
if (dict2 == null)
{
path = name;
return false;
//"Both or none supposed to be dictionaries: " + name);
}
if(dict1.Count != dict2.Count)
{
path = name;
return false;
}
foreach(DictionaryEntry kv in dict1)
{
if (!CompareInternal(string.Format("{0}[{1}]", name, kv.Key), kv.Value, dict2[kv.Key], out path))
{
return false;
}
}
path = null;
return true;
}
else
{
var ba1 = data1 as byte[];
if(ba1 != null)
{
var ba2 = data2 as byte[];
if (ba2 == null || ba1.Length != ba2.Length)
{
path = name;
return false;
}
for(int i = 0; i < ba1.Length; i++)
{
if (ba1[i] != ba2[i])
{
path = string.Format("{0}[{1}]", name, i);
return false;
}
}
path = null;
return true;
}
else
{
var list1 = data1 as IList;
if(list1 != null)
{
var list2 = data2 as IList;
if(list2 == null || list1.Count != list2.Count)
{
path = name;
return false;
}
for(int i = 0; i < list1.Count; i++)
{
if(!CompareInternal(string.Format("{0}[{1}]", name, i), list1[i], list2[i], out path))
{
return false;
}
}
path = null;
return true;
}
else
{
if(data1 is DateTime)
{
if (!(data2 is DateTime))
{
path = name;
return false;
}
if(Math.Abs((((DateTime)data1) - ((DateTime)data2)).TotalMilliseconds) > 5)
{
path = name;
return false;
}
else
{
path = null;
return true;
}
}
else
{
var m1 = data1 as IBabelModel;
if(m1 != null)
{
var m2 = data2 as IBabelModel;
if (m2 == null)
{
path = name;
return false;
}
var cd = new CompareInfo { Model = m2, AreEqual = true };
m1.RunOnChildren<CompareInfo>(CompareInternal, cd);
path = cd.AreEqual ? null : name + "/" + cd.Path;
return cd.AreEqual;
}
else
{
if (data1.Equals(data2))
{
path = null;
return true;
}
else
{
path = name;
return false;
}
}
}
}
}
}
}
private Comparer()
{
m_compareInfo = null;
}
static object CompareInternal(string name, System.Type itemType, object itemData, CompareInfo auxData)
{
if (!auxData.AreEqual)
{
return itemData; //No reason to proceed
}
var data = new DataWrapper();
auxData.Model.RunOnChild<DataWrapper>(name, GetProperty, data); //Get named element from the second model
auxData.AreEqual = CompareInternal(name, itemData, data.Data, out auxData.Path);
return itemData;
}
public bool Equals([NotNull] string x, [NotNull] string y) => CompareInfo.Compare(x, y, CompareOptions.IgnoreWidth | CompareOptions.IgnoreCase) == 0;
public void SortKeyTest(CompareInfo compareInfo, string string1, string string2, CompareOptions options, int expected)
{
SortKey sk1 = compareInfo.GetSortKey(string1, options);
SortKey sk2 = compareInfo.GetSortKey(string2, options);
Assert.Equal(expected, SortKey.Compare(sk1, sk2));
Assert.Equal(string1, sk1.OriginalString);
Assert.Equal(string2, sk2.OriginalString);
}
private int CompareNatural(string strA, string strB, CultureInfo culture, CompareOptions options)
{
CompareInfo cmp = culture.CompareInfo;
int iA = 0;
int iB = 0;
int softResult = 0;
int softResultWeight = 0;
while (iA < strA.Length && iB < strB.Length)
{
bool isDigitA = char.IsDigit(strA[iA]);
bool isDigitB = char.IsDigit(strB[iB]);
if (isDigitA != isDigitB)
{
return(cmp.Compare(strA, iA, strB, iB, options));
}
if (!isDigitA)
{
int jA = iA + 1;
int jB = iB + 1;
while (jA < strA.Length && !char.IsDigit(strA[jA]))
{
jA++;
}
while (jB < strB.Length && !char.IsDigit(strB[jB]))
{
jB++;
}
int cmpResult = cmp.Compare(strA, iA, jA - iA, strB, iB, jB - iB, options);
if (cmpResult != 0)
{
// Certain strings may be considered different due to "soft" differences that are
// ignored if more significant differences follow, e.g. a hyphen only affects the
// comparison if no other differences follow
string sectionA = strA.Substring(iA, jA - iA);
string sectionB = strB.Substring(iB, jB - iB);
if (cmp.Compare(sectionA + "1", sectionB + "2", options) ==
cmp.Compare(sectionA + "2", sectionB + "1", options))
{
return(cmp.Compare(strA, iA, strB, iB, options));
}
if (softResultWeight < 1)
{
softResult = cmpResult;
softResultWeight = 1;
}
}
iA = jA;
iB = jB;
}
else
{
char zeroA = (char)(strA[iA] - (int)Char.GetNumericValue(strA[iA]));
char zeroB = (char)(strB[iB] - (int)Char.GetNumericValue(strB[iB]));
int jA = iA;
int jB = iB;
while (jA < strA.Length && strA[jA] == zeroA)
{
jA++;
}
while (jB < strB.Length && strB[jB] == zeroB)
{
jB++;
}
int resultIfSameLength = 0;
do
{
isDigitA = jA < strA.Length && Char.IsDigit(strA[jA]);
isDigitB = jB < strB.Length && Char.IsDigit(strB[jB]);
int numA = isDigitA ? (int)Char.GetNumericValue(strA[jA]) : 0;
int numB = isDigitB ? (int)Char.GetNumericValue(strB[jB]) : 0;
if (isDigitA && (char)(strA[jA] - numA) != zeroA)
{
isDigitA = false;
}
if (isDigitB && (char)(strB[jB] - numB) != zeroB)
{
isDigitB = false;
}
if (isDigitA && isDigitB)
{
if (numA != numB && resultIfSameLength == 0)
{
resultIfSameLength = numA < numB ? -1 : 1;
}
jA++;
jB++;
}
} while (isDigitA && isDigitB);
if (isDigitA != isDigitB)
{
// One number has more digits than the other (ignoring leading zeros) - the longer
// number must be larger
return(isDigitA ? 1 : -1);
}
if (resultIfSameLength != 0)
{
// Both numbers are the same length (ignoring leading zeros) and at least one of
// the digits differed - the first difference determines the result
return(resultIfSameLength);
}
int lA = jA - iA;
int lB = jB - iB;
if (lA != lB)
{
// Both numbers are equivalent but one has more leading zeros
return(lA > lB ? -1 : 1);
}
if (zeroA != zeroB && softResultWeight < 2)
{
softResult = cmp.Compare(strA, iA, 1, strB, iB, 1, options);
softResultWeight = 2;
}
iA = jA;
iB = jB;
}
}
if (iA < strA.Length || iB < strB.Length)
{
return(iA < strA.Length ? 1 : -1);
}
if (softResult != 0)
{
return(softResult);
}
return(0);
}
public CaseInsensitiveHashCodeProvider()
{
_compareInfo = CultureInfo.CurrentCulture.CompareInfo;
}
/// <summary>
/// Searches a directory recursively for files and directories matching
/// the search criteria.
/// </summary>
/// <param name="path">Directory in which to search (absolute canonical path)</param>
/// <param name="recursive">Whether to scan recursively or not</param>
private void ScanDirectory(string path, bool recursive)
{
// scan each directory only once
if (_scannedDirectories.Contains(path))
{
return;
}
// add directory to list of scanned directories
_scannedDirectories.Add(path);
// if the path doesn't exist, return.
if (!Directory.Exists(path))
{
return;
}
// check whether directory is on case-sensitive volume
bool caseSensitive = IsCaseSensitiveFileSystem(path);
string pathCompare = path;
if (!caseSensitive)
{
pathCompare = pathCompare.ToLower();
}
CompareOptions compareOptions = CompareOptions.None;
CompareInfo compare = CultureInfo.InvariantCulture.CompareInfo;
if (!caseSensitive)
{
compareOptions |= CompareOptions.IgnoreCase;
}
ArrayList includedPatterns = new ArrayList();
ArrayList excludedPatterns = new ArrayList();
// Only include the valid patterns for this path
foreach (RegexEntry entry in _includePatterns)
{
string baseDirectory = (caseSensitive ? entry.BaseDirectory : entry.BaseDirectory.ToLower());
// check if the directory being searched is equal to the
// basedirectory of the RegexEntry
if (compare.Compare(path, baseDirectory, compareOptions) == 0)
{
includedPatterns.Add(entry);
}
else
{
// check if the directory being searched is subdirectory of
// basedirectory of RegexEntry
if (!entry.IsRecursive)
{
continue;
}
// make sure basedirectory ends with directory separator
if (!StringUtils.EndsWith(baseDirectory, Path.DirectorySeparatorChar))
{
baseDirectory += Path.DirectorySeparatorChar;
}
if (pathCompare.StartsWith(baseDirectory))
{
includedPatterns.Add(entry);
}
}
}
foreach (RegexEntry entry in _excludePatterns)
{
string baseDirectory = (caseSensitive ? entry.BaseDirectory : entry.BaseDirectory.ToLower());
if (entry.BaseDirectory.Length == 0 || compare.Compare(path, baseDirectory, compareOptions) == 0)
{
excludedPatterns.Add(entry);
}
else
{
// check if the directory being searched is subdirectory of
// basedirectory of RegexEntry
if (!entry.IsRecursive)
{
continue;
}
// make sure basedirectory ends with directory separator
if (!StringUtils.EndsWith(baseDirectory, Path.DirectorySeparatorChar))
{
baseDirectory += Path.DirectorySeparatorChar;
}
if (pathCompare.StartsWith(baseDirectory))
{
excludedPatterns.Add(entry);
}
}
}
foreach (string directoryPath in Directory.GetDirectories(path))
{
if (recursive)
{
// scan subfolders if we are running recursively
ScanDirectory(directoryPath, true);
}
else
{
// otherwise just test to see if the subdirectories are included
if (IsPathIncluded(directoryPath, caseSensitive, includedPatterns, excludedPatterns))
{
_directoryNames.Add(directoryPath);
}
}
}
// scan files
foreach (string filePath in Directory.GetFiles(path))
{
string filename = filePath;
if (!caseSensitive)
{
filename = filename.ToLower();
}
if (IsPathIncluded(filename, caseSensitive, includedPatterns, excludedPatterns))
{
_fileNames.Add(filePath);
}
}
// check current path last so that delete task will correctly
// delete empty directories. This may *seem* like a special case
// but it is more like formalizing something in a way that makes
// writing the delete task easier :)
if (IsPathIncluded(path, caseSensitive, includedPatterns, excludedPatterns))
{
_directoryNames.Add(path);
}
}
public void IndexOf_String(CompareInfo compareInfo, string source, string value, int startIndex, int count, CompareOptions options, int expected)
{
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));
}
private bool IsPathIncluded(string path, bool caseSensitive, ArrayList includedPatterns, ArrayList excludedPatterns)
{
bool included = false;
CompareOptions compareOptions = CompareOptions.None;
CompareInfo compare = CultureInfo.InvariantCulture.CompareInfo;
if (!caseSensitive)
{
compareOptions |= CompareOptions.IgnoreCase;
}
#if DEBUG_REGEXES
Console.WriteLine("Test: {0}", path);
#endif
// check path against include names
foreach (string name in _includeNames)
{
#if DEBUG_REGEXES
Console.WriteLine("Test include name: '{0}'", name);
#endif
if (compare.Compare(name, path, compareOptions) == 0)
{
included = true;
#if DEBUG_REGEXES
Console.WriteLine("Included by name: {0}", name);
#endif
break;
}
}
// check path against include regexes
if (!included)
{
foreach (RegexEntry entry in includedPatterns)
{
#if DEBUG_REGEXES
Console.Write("Test include pattern: ");
#endif
if (TestRegex(path, entry, caseSensitive))
{
included = true;
#if DEBUG_REGEXES
Console.WriteLine("Included by pattern: {0}", entry.Pattern);
#endif
break;
}
}
}
// check path against exclude names
if (included)
{
foreach (string name in _excludeNames)
{
#if DEBUG_REGEXES
Console.WriteLine("Test exclude name: '{0}'", name);
#endif
if (compare.Compare(name, path, compareOptions) == 0)
{
included = false;
#if DEBUG_REGEXES
Console.WriteLine("Excluded by name: {0}", name);
#endif
break;
}
}
}
// check path against exclude regexes
if (included)
{
foreach (RegexEntry entry in excludedPatterns)
{
#if DEBUG_REGEXES
Console.Write("Test exclude pattern: ");
#endif
if (TestRegex(path, entry, caseSensitive))
{
included = false;
#if DEBUG_REGEXES
Console.WriteLine("Excluded by pattern: {0}", entry.Pattern);
#endif
break;
}
}
}
#if DEBUG_REGEXES
Console.WriteLine("Result: {0}", included);
#endif
return(included);
}
public void Compare(CompareInfo compareInfo, string string1, string string2, CompareOptions options, int expected)
{
Compare(compareInfo, string1, 0, string1?.Length ?? 0, string2, 0, string2?.Length ?? 0, options, expected);
}
[MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var have to be marked non-inlineable
private Stream CaseInsensitiveManifestResourceStreamLookup(RuntimeAssembly satellite, String name)
{
Contract.Requires(satellite != null, "satellite shouldn't be null; check caller");
Contract.Requires(name != null, "name shouldn't be null; check caller");
StringBuilder sb = new StringBuilder();
if (_mediator.LocationInfo != null)
{
String nameSpace = _mediator.LocationInfo.Namespace;
if (nameSpace != null)
{
sb.Append(nameSpace);
if (name != null)
{
sb.Append(Type.Delimiter);
}
}
}
sb.Append(name);
String givenName = sb.ToString();
CompareInfo comparer = CultureInfo.InvariantCulture.CompareInfo;
String canonicalName = null;
foreach (String existingName in satellite.GetManifestResourceNames())
{
if (comparer.Compare(existingName, givenName, CompareOptions.IgnoreCase) == 0)
{
if (canonicalName == null)
{
canonicalName = existingName;
}
else
{
throw new MissingManifestResourceException(Environment.GetResourceString("MissingManifestResource_MultipleBlobs", givenName, satellite.ToString()));
}
}
}
#if !FEATURE_CORECLR
if (FrameworkEventSource.IsInitialized)
{
if (canonicalName != null)
{
FrameworkEventSource.Log.ResourceManagerCaseInsensitiveResourceStreamLookupSucceeded(_mediator.BaseName, _mediator.MainAssembly, satellite.GetSimpleName(), givenName);
}
else
{
FrameworkEventSource.Log.ResourceManagerCaseInsensitiveResourceStreamLookupFailed(_mediator.BaseName, _mediator.MainAssembly, satellite.GetSimpleName(), givenName);
}
}
#endif
if (canonicalName == null)
{
return(null);
}
// If we're looking in the main assembly AND if the main
// assembly was the person who created the ResourceManager,
// skip a security check for private manifest resources.
bool canSkipSecurityCheck = _mediator.MainAssembly == satellite && _mediator.CallingAssembly == _mediator.MainAssembly;
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
Stream s = satellite.GetManifestResourceStream(canonicalName, ref stackMark, canSkipSecurityCheck);
// GetManifestResourceStream will return null if we don't have
// permission to read this stream from the assembly. For example,
// if the stream is private and we're trying to access it from another
// assembly (ie, ResMgr in mscorlib accessing anything else), we
// require Reflection TypeInformation permission to be able to read
// this.
#if !FEATURE_CORECLR
if (s != null)
{
if (FrameworkEventSource.IsInitialized)
{
FrameworkEventSource.Log.ResourceManagerManifestResourceAccessDenied(_mediator.BaseName, _mediator.MainAssembly, satellite.GetSimpleName(), canonicalName);
}
}
#endif
return(s);
}
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 GetCompareInfo(string name)
{
CompareInfo compare = CompareInfo.GetCompareInfo(name);
Assert.Equal(name, compare.Name);
}
public void FrameCompare(CompareInfo cCompareInfo, byte[] aFrameBytes)
{
_cInfo = cCompareInfo;
//_aLayers = aLayers;
//_aqQueue.Enqueue(this);
//_cMREDone.WaitOne();
}
internal InvariantComparer()
{
m_compareInfo = CultureInfo.InvariantCulture.CompareInfo;
}