/// <summary>
/// ...
/// </summary>
public ListViewItemComparer()
{
m_UseTagObject = false;
m_SortColumn = 0;
m_SortOrder = SortOrder.None;
m_Comparer = new CaseInsensitiveComparer();
}
public static void TestCtor_CultureInfo_Compare(object a, object b, int expected)
{
var cultureNames = new string[]
{
"cs-CZ","da-DK","de-DE","el-GR","en-US",
"es-ES","fi-FI","fr-FR","hu-HU","it-IT",
"ja-JP","ko-KR","nb-NO","nl-NL","pl-PL",
"pt-BR","pt-PT","ru-RU","sv-SE","tr-TR",
"zh-CN","zh-HK","zh-TW"
};
foreach (string cultureName in cultureNames)
{
CultureInfo culture;
try
{
culture = new CultureInfo(cultureName);
}
catch (CultureNotFoundException)
{
continue;
}
var comparer = new CaseInsensitiveComparer(culture);
Assert.Equal(expected, Helpers.NormalizeCompare(comparer.Compare(a, b)));
}
}
public ListViewColumnSorter()
{
ColumnToSort = 0;
OrderOfSort = SortOrder.None;
ObjectCompare = new CaseInsensitiveComparer();
}
public bool runTest()
{
Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
String strLoc = "Loc_000oo";
String strValue = String.Empty;
int iCountErrors = 0;
int iCountTestcases = 0;
CaseInsensitiveComparer comparer;
try
{
strLoc = "Loc_384sdg";
iCountTestcases++;
comparer = new CaseInsensitiveComparer();
if(comparer.Compare("hello", "HELLO")!=0)
{
iCountErrors++;
Console.WriteLine( "Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "HELLO"));
}
if(comparer.Compare("hello", "hello")!=0)
{
iCountErrors++;
Console.WriteLine( "Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "hello"));
}
if(comparer.Compare("hello", "mello")==0)
{
iCountErrors++;
Console.WriteLine( "Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "mello"));
}
iCountTestcases++;
if(comparer.Compare(5, 5)!=0)
{
iCountErrors++;
Console.WriteLine( "Err_347tsfg! wrong value returned");
}
if(comparer.Compare(5, 10)==0)
{
iCountErrors++;
Console.WriteLine( "Err_973425sdg! wrong value returned");
}
}
catch (Exception exc_general )
{
++iCountErrors;
Console.WriteLine (s_strTFAbbrev + " : Error Err_8888yyy! strLoc=="+ strLoc +", exc_general=="+exc_general.ToString());
}
if ( iCountErrors == 0 )
{
Console.WriteLine( "paSs. "+s_strTFName+" ,iCountTestcases=="+iCountTestcases.ToString());
return true;
}
else
{
Console.WriteLine("FAiL! "+s_strTFName+" ,inCountErrors=="+iCountErrors.ToString()+" , BugNums?: "+s_strActiveBugNums );
return false;
}
}
/// <summary>
/// Class constructor. Initializes various elements
/// </summary>
public ListViewColumnSorter() {
// Initialize the column to '0'
ColumnToSort = 0;
// Initialize the sort order to 'none'
OrderOfSort = SortOrder.None;
// Initialize the CaseInsensitiveComparer object
ObjectCompare = new CaseInsensitiveComparer();
}
public IEnumerable<string> GetForAutocomplete(string prefixText, int count)
{
var comparer = new CaseInsensitiveComparer();
var remaining = count;
var locations = _context.Locations.Where(p => p.Description.Contains(prefixText))
.OrderBy(p => p.Description.ToLower().IndexOf(prefixText.ToLower()))
.Take(remaining).Select(p => p.Description).ToList().Distinct(comparer);
var list = locations.OrderBy(p => p.ToLower().IndexOf(prefixText.ToLower())).Distinct(comparer).ToList();
if (locations.Count() == remaining) return list;
remaining -= locations.Count();
var regions = _context.Regions.Where(p => p.Description.Contains(prefixText))
.OrderBy(p => p.Description.ToLower().IndexOf(prefixText.ToLower()))
.Take(remaining).Select(p => p.Description).ToList().Distinct(comparer);
list = list.Concat(regions).OrderBy(p => p.ToLower().IndexOf(prefixText.ToLower())).Distinct(comparer).ToList();
return list;
}
public myCultureComparer(CultureInfo myCulture)
{
myComparer = new CaseInsensitiveComparer(myCulture);
}
public ListViewColumnSorter()
{
_intColumnToSort = 0;
_objOrderOfSort = SortOrder.None;
_objObjectCompare = new CaseInsensitiveComparer();
}
public bool runTest()
{
//////////// Global Variables used for all tests
int iCountErrors = 0;
int iCountTestcases = 0;
CaseInsensitiveComparer comparer;
try
{
///////////////////////// START TESTS ////////////////////////////
///////////////////////////////////////////////////////////////////
//[]vanilla - the ctor simply sets the CompareInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo
//There is no easy way to test this other than make sure that string comparison is case insensitive
iCountTestcases++;
iCountTestcases++;
iCountTestcases++;
var somePopularCultureNames = new string[] {
"cs-CZ", "da-DK", "de-DE", "el-GR", "en-US",
"es-ES", "fi-FI", "fr-FR", "hu-HU", "it-IT",
"ja-JP", "ko-KR", "nb-NO", "nl-NL", "pl-PL",
"pt-BR", "pt-PT", "ru-RU", "sv-SE", "tr-TR",
"zh-CN", "zh-HK", "zh-TW"
};
foreach (string cultureName in somePopularCultureNames)
{
CultureInfo culture = new CultureInfo(cultureName);
if (culture == null)
{
continue;
}
comparer = new CaseInsensitiveComparer(culture);
if (comparer.Compare("hello", "HELLO") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("hello", "HELLO"), culture.Name);
}
//same strings should work ok
if (comparer.Compare("hello", "hello") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("hello", "hello"), culture.Name);
}
//different strings should return false
if (comparer.Compare("hello", "mello") == 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", "non-zero", comparer.Compare("hello", "mello"), culture.Name);
}
// "tr-TR" = "Turkish (Turkey)"
// Turkish has lower-case and upper-case version of the dotted "i", so the upper case of "i" (U+0069) isn't "I" (U+0049), but rather "İ" (U+0130).
if (culture.Name != "tr-TR")
{
if (comparer.Compare("file", "FILE") != 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("file", "FILE"), culture.Name);
}
}
else
{
if (comparer.Compare("file", "FILE") == 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", "non-zero", comparer.Compare("file", "FILE"), culture.Name);
}
}
//[]Other data types should work as is
iCountTestcases++;
if (comparer.Compare(5, 5) != 0)
{
iCountErrors++;
Console.WriteLine("Err_347tsfg! wrong value returned");
}
if (comparer.Compare(5, 10) == 0)
{
iCountErrors++;
Console.WriteLine("Err_973425sdg! wrong value returned");
}
}
//[]parm test
iCountTestcases++;
try
{
comparer = new CaseInsensitiveComparer(null);
iCountErrors++;
Console.WriteLine("Err_9745sdg! Exception not thrown");
}
catch (ArgumentNullException)
{
}
catch (Exception ex)
{
iCountErrors++;
Console.WriteLine("Err_9745sdg! Unexpected exception thrown, " + ex.GetType().Name);
}
///////////////////////////////////////////////////////////////////
/////////////////////////// END TESTS /////////////////////////////
}
catch (Exception exc_general)
{
++iCountErrors;
Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString());
}
//// Finish Diagnostics
if (iCountErrors == 0)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Class constructor. Initializes various elements
/// </summary>
public ListViewColumnSorter()
{
SortColumn = 0;
Order = SortOrder.None;
_objectCompare = new CaseInsensitiveComparer();
}
public ListViewColumnSorter()
{
ColumnToSort = 0;
OrderOfSort = SortOrder.None;
ciCompare = new CaseInsensitiveComparer();
}
/// <summary>
/// Constructor
/// </summary>
public ListViewColumnSorter()
{
ColumnToSort = 0;
OrderOfSort = SortOrder.Ascending;
ObjectCompare = new CaseInsensitiveComparer();
}
public static void Ctor_Empty_Compare(object a, object b, int expected)
{
CaseInsensitiveComparer comparer = new CaseInsensitiveComparer();
Assert.Equal(expected, Math.Sign(comparer.Compare(a, b)));
}
public static void TestCtor_CultureInfo_Compare_TurkishI()
{
var cultureNames = new string[]
{
"cs-CZ","da-DK","de-DE","el-GR","en-US",
"es-ES","fi-FI","fr-FR","hu-HU","it-IT",
"ja-JP","ko-KR","nb-NO","nl-NL","pl-PL",
"pt-BR","pt-PT","ru-RU","sv-SE","tr-TR",
"zh-CN","zh-HK","zh-TW"
};
foreach (string cultureName in cultureNames)
{
CultureInfo culture;
try
{
culture = new CultureInfo(cultureName);
}
catch (CultureNotFoundException)
{
continue;
}
var comparer = new CaseInsensitiveComparer(culture);
// Turkish has lower-case and upper-case version of the dotted "i", so the upper case of "i" (U+0069) isn't "I" (U+0049)
// but rather "İ" (U+0130)
if (culture.Name == "tr-TR")
{
Assert.Equal(1, comparer.Compare("file", "FILE"));
}
else
{
Assert.Equal(0, comparer.Compare("file", "FILE"));
}
}
}
public MachineRecordComparer()
{
ColumnToSort = 0;
OrderOfSort = SortOrder.None;
ObjectCompare = new CaseInsensitiveComparer();
}
public static void TestCtor_Empty_Compare(object a, object b, int expected)
{
CaseInsensitiveComparer comparer = new CaseInsensitiveComparer();
Assert.Equal(expected, Helpers.NormalizeCompare(comparer.Compare(a, b)));
}
public int Compare(string x, string y)
{
CaseInsensitiveComparer comparer = new CaseInsensitiveComparer();
return(comparer.Compare(x, y));
}
public bool runTest()
{
Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
String strLoc = "Loc_000oo";
String strValue = String.Empty;
int iCountErrors = 0;
int iCountTestcases = 0;
CaseInsensitiveComparer comparer;
CultureInfo[] cultures;
try
{
strLoc = "Loc_384sdg";
iCountTestcases++;
iCountTestcases++;
iCountTestcases++;
cultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
for(int i=0; i<cultures.Length; i++)
{
comparer = new CaseInsensitiveComparer(cultures[i]);
if(comparer.Compare("hello", "HELLO")!=0)
{
iCountErrors++;
Console.WriteLine( "Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "HELLO"));
}
if(comparer.Compare("hello", "hello")!=0)
{
iCountErrors++;
Console.WriteLine( "Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "hello"));
}
if(comparer.Compare("hello", "mello")==0)
{
iCountErrors++;
Console.WriteLine( "Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "mello"));
}
iCountTestcases++;
if(comparer.Compare(5, 5)!=0)
{
iCountErrors++;
Console.WriteLine( "Err_347tsfg! wrong value returned");
}
if(comparer.Compare(5, 10)==0)
{
iCountErrors++;
Console.WriteLine( "Err_973425sdg! wrong value returned");
}
}
strLoc = "Loc_dfyusg";
iCountTestcases++;
try
{
comparer = new CaseInsensitiveComparer(null);
iCountErrors++;
Console.WriteLine( "Err_9745sdg! Exception not thrown");
}
catch(ArgumentNullException)
{
}
catch(Exception ex)
{
iCountErrors++;
Console.WriteLine( "Err_9745sdg! Unexpected exception thrown, " + ex.GetType().Name);
}
}
catch (Exception exc_general )
{
++iCountErrors;
Console.WriteLine (s_strTFAbbrev + " : Error Err_8888yyy! strLoc=="+ strLoc +", exc_general=="+exc_general.ToString());
}
if ( iCountErrors == 0 )
{
Console.WriteLine( "paSs. "+s_strTFName+" ,iCountTestcases=="+iCountTestcases.ToString());
return true;
}
else
{
Console.WriteLine("FAiL! "+s_strTFName+" ,inCountErrors=="+iCountErrors.ToString()+" , BugNums?: "+s_strActiveBugNums );
return false;
}
}
public ListViewColumnSorter()
{
this.ColumnToSort = 0;
this.ObjectCompare = new CaseInsensitiveComparer();
}
public ListViewItemComparer()
{
ColumnaAOrdenar = 0;
Orden = SortOrder.None;
ObjectCompare = new CaseInsensitiveComparer();
}
public void SortByColumn(int column, SortOrder sortOrder, bool isNumeric)
{
// Do nothing if column is outside bounds
if (column < 0 || column >= Columns.Count)
{
return;
}
if (!colComparer.ContainsKey(column))
{
if (isNumeric)
{
colComparer.Add(column, new ListViewColumnSorterNumeric());
}
else
{
colComparer.Add(column, new CaseInsensitiveComparer());
}
}
else
{
if (isNumeric && colComparer[column] is CaseInsensitiveComparer)
{
colComparer[column] = new ListViewColumnSorterNumeric();
}
else if (!isNumeric && colComparer[column] is ListViewColumnSorterNumeric)
{
colComparer[column] = new CaseInsensitiveComparer();
}
}
colSorter.Comparer = colComparer[column];
// Determine if clicked column is already the column that is being sorted.
if (column == colSorter.SortColumn)
{
// If not selected sort order then order like if clicked on the column
if (sortOrder == SortOrder.None)
{
// Reverse the current sort direction for this column.
if (colSorter.Order == SortOrder.Ascending)
{
colSorter.Order = SortOrder.Descending;
}
else
{
colSorter.Order = SortOrder.Ascending;
}
}
else
{
colSorter.Order = sortOrder;
}
}
else
{
// Set the column number that is to be sorted; default to ascending.
colSorter.SortColumn = column;
colSorter.Order = sortOrder == SortOrder.None ? SortOrder.Ascending : sortOrder;
}
// Perform the sort with these new sort options.
this.Sort();
}
public ListViewItemComparer(int column)
{
col = column;
OrderOfSort = SortOrder.None;
ObjectCompare = new CaseInsensitiveComparer();
}
int IComparer <ListItem> .Compare(ListItem x, ListItem y)
{
CaseInsensitiveComparer c = new CaseInsensitiveComparer();
return(c.Compare(x.Text, y.Text));
}
public bool runTest()
{
Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
String strLoc = "Loc_000oo";
String strValue = String.Empty;
int iCountErrors = 0;
int iCountTestcases = 0;
CaseInsensitiveComparer comparer;
CaseInsensitiveComparer defaultComparer;
CultureInfo[] cultures;
try
{
strLoc = "Loc_384sdg";
iCountTestcases++;
iCountTestcases++;
cultures = CultureInfo.GetCultures(CultureTypes.AllCultures);
for (int i = 0; i < cultures.Length; i++)
{
comparer = new CaseInsensitiveComparer(cultures[i]);
defaultComparer = CaseInsensitiveComparer.Default;
if (defaultComparer.Compare("hello", "HELLO") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "HELLO"));
}
if (defaultComparer.Compare("hello", "hello") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "hello"));
}
if (defaultComparer.Compare("hello", "mello") == 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "mello"));
}
iCountTestcases++;
if (defaultComparer.Compare(5, 5) != 0)
{
iCountErrors++;
Console.WriteLine("Err_347tsfg! wrong value returned");
}
if (defaultComparer.Compare(5, 10) == 0)
{
iCountErrors++;
Console.WriteLine("Err_973425sdg! wrong value returned");
}
}
}
catch (Exception exc_general)
{
++iCountErrors;
Console.WriteLine(s_strTFAbbrev + " : Error Err_8888yyy! strLoc==" + strLoc + ", exc_general==" + exc_general.ToString());
}
if (iCountErrors == 0)
{
Console.WriteLine("paSs. " + s_strTFName + " ,iCountTestcases==" + iCountTestcases.ToString());
return(true);
}
else
{
Console.WriteLine("FAiL! " + s_strTFName + " ,inCountErrors==" + iCountErrors.ToString() + " , BugNums?: " + s_strActiveBugNums);
return(false);
}
}
public bool runTest()
{
//////////// Global Variables used for all tests
int iCountErrors = 0;
int iCountTestcases = 0;
CaseInsensitiveComparer comparer;
try
{
///////////////////////// START TESTS ////////////////////////////
//[]vanila - the ctor simply sets the ComapreInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo
//There is no easy way to test this other than make sure that string comparison is case insenstive
iCountTestcases++;
comparer = new CaseInsensitiveComparer();
if (comparer.Compare("hello", "HELLO") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "HELLO"));
}
//same strings should work ok
if (comparer.Compare("hello", "hello") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "hello"));
}
//different strings should return false
if (comparer.Compare("hello", "mello") == 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "mello"));
}
//[]Other data types should work as is
iCountTestcases++;
if (comparer.Compare(5, 5) != 0)
{
iCountErrors++;
Console.WriteLine("Err_347tsfg! wrong value returned");
}
if (comparer.Compare(5, 10) == 0)
{
iCountErrors++;
Console.WriteLine("Err_973425sdg! wrong value returned");
}
///////////////////////////////////////////////////////////////////
/////////////////////////// END TESTS /////////////////////////////
}
catch (Exception exc_general)
{
++iCountErrors;
Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString());
}
//// Finish Diagnostics
if (iCountErrors == 0)
{
return(true);
}
else
{
return(false);
}
}
private static void InitHash()
{
#if NET_2_0
StringComparer comparer = StringComparer.InvariantCultureIgnoreCase;
directivesHash = new Hashtable(comparer);
#else
CaseInsensitiveHashCodeProvider provider = new CaseInsensitiveHashCodeProvider(CultureInfo.InvariantCulture);
CaseInsensitiveComparer comparer = new CaseInsensitiveComparer(CultureInfo.InvariantCulture);
directivesHash = new Hashtable(provider, comparer);
#endif
// Use Hashtable 'cause is O(1) in Contains (ArrayList is O(n))
#if NET_2_0
Hashtable valid_attributes = new Hashtable(comparer);
#else
Hashtable valid_attributes = new Hashtable(provider, comparer);
#endif
foreach (string att in page_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("PAGE", valid_attributes);
#if NET_2_0
valid_attributes = new Hashtable(comparer);
#else
valid_attributes = new Hashtable(provider, comparer);
#endif
foreach (string att in control_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("CONTROL", valid_attributes);
#if NET_2_0
valid_attributes = new Hashtable(comparer);
#else
valid_attributes = new Hashtable(provider, comparer);
#endif
foreach (string att in import_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("IMPORT", valid_attributes);
#if NET_2_0
valid_attributes = new Hashtable(comparer);
#else
valid_attributes = new Hashtable(provider, comparer);
#endif
foreach (string att in implements_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("IMPLEMENTS", valid_attributes);
#if NET_2_0
valid_attributes = new Hashtable(comparer);
#else
valid_attributes = new Hashtable(provider, comparer);
#endif
foreach (string att in register_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("REGISTER", valid_attributes);
#if NET_2_0
valid_attributes = new Hashtable(comparer);
#else
valid_attributes = new Hashtable(provider, comparer);
#endif
foreach (string att in assembly_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("ASSEMBLY", valid_attributes);
#if NET_2_0
valid_attributes = new Hashtable(comparer);
#else
valid_attributes = new Hashtable(provider, comparer);
#endif
foreach (string att in outputcache_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("OUTPUTCACHE", valid_attributes);
#if NET_2_0
valid_attributes = new Hashtable(comparer);
#else
valid_attributes = new Hashtable(provider, comparer);
#endif
foreach (string att in reference_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("REFERENCE", valid_attributes);
#if NET_2_0
valid_attributes = new Hashtable(comparer);
#else
valid_attributes = new Hashtable(provider, comparer);
#endif
foreach (string att in webservice_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("WEBSERVICE", valid_attributes);
#if NET_2_0
valid_attributes = new Hashtable(comparer);
#else
valid_attributes = new Hashtable(provider, comparer);
#endif
// same attributes as webservice
foreach (string att in webservice_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("WEBHANDLER", valid_attributes);
#if NET_2_0
valid_attributes = new Hashtable(comparer);
#else
valid_attributes = new Hashtable(provider, comparer);
#endif
foreach (string att in application_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("APPLICATION", valid_attributes);
valid_attributes = new Hashtable(provider, comparer);
foreach (string att in session_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("SESSION", valid_attributes);
#if NET_2_0
valid_attributes = new Hashtable(comparer);
foreach (string att in mastertype_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("MASTERTYPE", valid_attributes);
valid_attributes = new Hashtable(comparer);
foreach (string att in control_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("MASTER", valid_attributes);
valid_attributes = new Hashtable(comparer);
foreach (string att in previouspagetype_atts)
{
valid_attributes.Add(att, null);
}
directivesHash.Add("PREVIOUSPAGETYPE", valid_attributes);
#endif
}
public ListViewItemComparer()
{
m_columnToSort = 0;
m_orderOfSort = SortOrder.None;
m_objectCompare = new CaseInsensitiveComparer();
}
/// <summary>
/// Initializes a new instance of the <see cref="ListBoxItem"/> class.
/// </summary>
public ListBoxItem()
{
// Initialize the CaseInsensitiveComparer object
objectCompare = new CaseInsensitiveComparer(Thread.CurrentThread.CurrentCulture);
}
/// <summary>
/// Arranges a variable's contents in alphabetical, numerical, or random order optionally removing duplicates.
/// </summary>
/// <param name="input">The variable whose contents to use as the input.</param>
/// <param name="options">See the remarks.</param>
/// <remarks>
/// <list type="table">
/// <listheader>
/// <term>Name</term>
/// <description>Description</description>
/// </listheader>
/// <item>
/// <term>C</term>
/// <description>Case sensitive.</description>
/// </item>
/// <item>
/// <term>CL</term>
/// <description>Case sensitive based on current user's locale.</description>
/// </item>
/// <item>
/// <term>D<c>x</c></term>
/// <description>Specifies <c>x</c> as the delimiter character which is <c>`n</c> by default.</description>
/// </item>
/// <item>
/// <term>F <c>name</c></term>
/// <description>Use the return value of the specified function for comparing two items.</description>
/// </item>
/// <item>
/// <term>N</term>
/// <description>Numeric sorting.</description>
/// </item>
/// <item>
/// <term>P<c>n</c></term>
/// <description>Sorts items based on character position <c>n</c>.</description>
/// </item>
/// <item>
/// <term>R</term>
/// <description>Sort in reverse order.</description>
/// </item>
/// <item>
/// <term>Random</term>
/// <description>Sort in random order.</description>
/// </item>
/// <item>
/// <term>U</term>
/// <description>Remove any duplicate items.</description>
/// </item>
/// <item>
/// <term>Z</term>
/// <description>Considers a trailing delimiter as a boundary which otherwise would be ignored.</description>
/// </item>
/// <item>
/// <term>\</term>
/// <description>File path sorting.</description>
/// </item>
/// </list>
/// </remarks>
public static void Sort(ref string input, params string[] options)
{
var opts = KeyValues(string.Join(",", options), true, new[] { 'f' });
MethodInfo function = null;
if (opts.ContainsKey('f'))
{
function = FindLocalRoutine(opts['f']);
if (function == null)
{
return;
}
}
char split = '\n';
if (opts.ContainsKey('d'))
{
string s = opts['d'];
if (s.Length == 1)
{
split = s[0];
}
opts.Remove('d');
}
string[] list = input.Split(new[] { split }, StringSplitOptions.RemoveEmptyEntries);
if (split == '\n')
{
for (int i = 0; i < list.Length; i++)
{
int x = list[i].Length - 1;
if (list[i][x] == '\r')
{
list[i] = list[i].Substring(0, x);
}
}
}
if (opts.ContainsKey('z') && input[input.Length - 1] == split)
{
Array.Resize(ref list, list.Length + 1);
list[list.Length - 1] = string.Empty;
opts.Remove('z');
}
bool withcase = false;
if (opts.ContainsKey('c'))
{
string mode = opts['c'];
if (mode == "l" || mode == "L")
{
withcase = false;
}
else
{
withcase = true;
}
opts.Remove('c');
}
bool numeric = false;
if (opts.ContainsKey('n'))
{
numeric = true;
opts.Remove('n');
}
int sortAt = 1;
if (opts.ContainsKey('p'))
{
if (!int.TryParse(opts['p'], out sortAt))
{
sortAt = 1;
}
opts.Remove('p');
}
bool reverse = false, random = false;
if (opts.ContainsKey(Keyword_Random[0]))
{
if (opts[Keyword_Random[0]].Equals(Keyword_Random.Substring(1), StringComparison.OrdinalIgnoreCase)) // Random
{
random = true;
}
else
{
reverse = true;
}
opts.Remove(Keyword_Random[0]);
}
bool unique = false;
if (opts.ContainsKey('u'))
{
unique = true;
opts.Remove('u');
}
bool slash = false;
if (opts.ContainsKey('\\'))
{
slash = true;
opts.Remove('\\');
}
var comp = new CaseInsensitiveComparer();
var rand = new Random();
Array.Sort(list, delegate(string x, string y)
{
if (function != null)
{
object value = null;
try { value = function.Invoke(null, new object[] { new object[] { x, y } }); }
catch (Exception) { }
int result;
if (value is string && int.TryParse((string)value, out result))
{
return(result);
}
return(0);
}
else if (x == y)
{
return(0);
}
else if (random)
{
return(rand.Next(-1, 2));
}
else if (numeric)
{
int a, b;
return(int.TryParse(x, out a) && int.TryParse(y, out b) ?
a.CompareTo(b) : x.CompareTo(y));
}
else
{
if (slash)
{
int z = x.LastIndexOf('\\');
if (z != -1)
{
x = x.Substring(z + 1);
}
z = y.LastIndexOf('\\');
if (z != -1)
{
y = y.Substring(z + 1);
}
if (x == y)
{
return(0);
}
}
return(withcase ? x.CompareTo(y) : comp.Compare(x, y));
}
});
if (unique)
{
int error = 0;
var ulist = new List <string>(list.Length);
foreach (var item in list)
{
if (!ulist.Contains(item))
{
ulist.Add(item);
}
else
{
error++;
}
}
ErrorLevel = error;
list = ulist.ToArray();
}
if (reverse)
{
Array.Reverse(list);
}
input = string.Join(split.ToString(), list);
}
/// <summary>
/// コンストラクタ
/// </summary>
public Class_ListViewColumnSorter()
{
_orderOfSort = SortOrder.None;
_objectCompare = new CaseInsensitiveComparer(CultureInfo.CurrentUICulture);
}
public void Ctor_Empty_Compare(object a, object b, int expected)
{
CaseInsensitiveComparer comparer = new CaseInsensitiveComparer();
Assert.Equal(expected, Math.Sign(comparer.Compare(a, b)));
}
public ListViewColumnSorter()
{
_objObjectCompare = new CaseInsensitiveComparer();
}
public bool runTest()
{
//////////// Global Variables used for all tests
int iCountErrors = 0;
int iCountTestcases = 0;
CaseInsensitiveComparer comparer;
String str1;
String str2;
try
{
///////////////////////// START TESTS ////////////////////////////
///////////////////////////////////////////////////////////////////
//[]vanilla - the ctor simply sets the CompareInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo
//There is no easy way to test this other than make sure that string comparison is case insensitive
iCountTestcases++;
comparer = new CaseInsensitiveComparer();
if (comparer.Compare("hello", "HELLO") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "HELLO"));
}
//same strings should work ok
if (comparer.Compare("hello", "hello") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "hello"));
}
//different strings should return false
if (comparer.Compare("hello", "mello") == 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, comparer.Compare("hello", "mello"));
}
//[]Other data types should work as is
iCountTestcases++;
if (comparer.Compare(5, 5) != 0)
{
iCountErrors++;
Console.WriteLine("Err_347tsfg! wrong value returned");
}
if (comparer.Compare(5, 10) == 0)
{
iCountErrors++;
Console.WriteLine("Err_973425sdg! wrong value returned");
}
//[]we will consider nulls
iCountTestcases++;
if (comparer.Compare(5, null) <= 0)
{
iCountErrors++;
Console.WriteLine("Err_83sdg! wrong value returned, " + comparer.Compare(5, null));
}
if (comparer.Compare(null, 5) >= 0)
{
iCountErrors++;
Console.WriteLine("Err_94375sdg! wrong value returned, " + comparer.Compare(null, 5));
}
if (comparer.Compare(null, null) != 0)
{
iCountErrors++;
Console.WriteLine("Err_94375sdg! wrong value returned, " + comparer.Compare(null, null));
}
//[]we will consider nulls with Strings
iCountTestcases++;
str1 = "Hello";
str2 = null;
if (comparer.Compare(str1, str2) <= 0)
{
iCountErrors++;
Console.WriteLine("Err_948732dsg! wrong value returned, " + comparer.Compare(str1, str2));
}
str1 = null;
str2 = "Hello";
if (comparer.Compare(str1, str2) >= 0)
{
iCountErrors++;
Console.WriteLine("Err_948732dsg! wrong value returned, " + comparer.Compare(str1, str2));
}
str1 = null;
str2 = null;
if (comparer.Compare(str1, str2) != 0)
{
iCountErrors++;
Console.WriteLine("Err_948732dsg! wrong value returned, " + comparer.Compare(str1, str2));
}
///////////////////////////////////////////////////////////////////
/////////////////////////// END TESTS /////////////////////////////
}
catch (Exception exc_general)
{
++iCountErrors;
Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString());
}
//// Finish Diagnostics
if (iCountErrors == 0)
{
return true;
}
else
{
return false;
}
}
public myCultureComparer()
{
myComparer = CaseInsensitiveComparer.DefaultInvariant;
}
public ListViewSorter()
{
this.ColumnToSort = 0;
this.Comparer = new CaseInsensitiveComparer();
this.OrderOfSort = SortOrder.None;
}
private readonly CaseInsensitiveComparer objectCompare; // Case insensitive comparer object
/// <summary>
/// sort the listview by column
/// http://support.microsoft.com/kb/319401
/// </summary>
public ListviewSort() // Class constructor. Initializes various elements
{
columnToSort = 0;
orderOfSort = SortOrder.None;
objectCompare = new CaseInsensitiveComparer();
}
private CaseInsensitiveComparer ObjectCompare; // 声明CaseInsensitiveComparer类对象，
public ListViewColumnSorter() // 构造函数
{
ColumnToSort = 0; // 默认按第一列排序
OrderOfSort = SortOrder.None; // 排序方式为不排序
ObjectCompare = new CaseInsensitiveComparer(); // 初始化CaseInsensitiveComparer类对象
}
public bool runTest()
{
//////////// Global Variables used for all tests
int iCountErrors = 0;
int iCountTestcases = 0;
CaseInsensitiveComparer comparer;
CaseInsensitiveComparer defaultInvComparer;
try
{
///////////////////////// START TESTS ////////////////////////////
///////////////////////////////////////////////////////////////////
//[]vanilla - Default sets the CompareInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo
//There is no easy way to test this other than make sure that string comparison is case insensitive
iCountTestcases++;
iCountTestcases++;
var somePopularCultureNames = new string[] {
"cs-CZ","da-DK","de-DE","el-GR","en-US",
"es-ES","fi-FI","fr-FR","hu-HU","it-IT",
"ja-JP","ko-KR","nb-NO","nl-NL","pl-PL",
"pt-BR","pt-PT","ru-RU","sv-SE","tr-TR",
"zh-CN","zh-HK","zh-TW" };
foreach (string cultureName in somePopularCultureNames)
{
CultureInfo culture = new CultureInfo(cultureName);
if (culture == null)
{
continue;
}
comparer = new CaseInsensitiveComparer(culture);
defaultInvComparer = CaseInsensitiveComparer.DefaultInvariant;
if (defaultInvComparer.Compare("hello", "HELLO") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultInvComparer.Compare("hello", "HELLO"));
}
//same strings should work ok
if (defaultInvComparer.Compare("hello", "hello") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultInvComparer.Compare("hello", "hello"));
}
//different strings should return false
if (defaultInvComparer.Compare("hello", "mello") == 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultInvComparer.Compare("hello", "mello"));
}
//What would turkey do? - Since we are comparing with the invariant culture, this will pass
if (defaultInvComparer.Compare("file", "FILE") != 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultInvComparer.Compare("file", "FILE"));
}
//[]Other data types should work as is
iCountTestcases++;
if (defaultInvComparer.Compare(5, 5) != 0)
{
iCountErrors++;
Console.WriteLine("Err_347tsfg! wrong value returned");
}
if (defaultInvComparer.Compare(5, 10) == 0)
{
iCountErrors++;
Console.WriteLine("Err_973425sdg! wrong value returned");
}
}
///////////////////////////////////////////////////////////////////
/////////////////////////// END TESTS /////////////////////////////
}
catch (Exception exc_general)
{
++iCountErrors;
Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString());
}
//// Finish Diagnostics
if (iCountErrors == 0)
{
return true;
}
else
{
return false;
}
}
public ColumnSorterAsc()
{
ColumnToSort = 0;
sensComparer = new CaseInsensitiveComparer();
}
public ListViewColumnSorter()
{
_columnToSort = 0;
_sortOrder = SortOrder.None;
_comparer = new CaseInsensitiveComparer();
}
public bool runTest()
{
//////////// Global Variables used for all tests
int iCountErrors = 0;
int iCountTestcases = 0;
CaseInsensitiveComparer comparer;
CaseInsensitiveComparer defaultComparer;
try
{
///////////////////////// START TESTS ////////////////////////////
///////////////////////////////////////////////////////////////////
//[]vanila - Default sets the ComapreInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo
//There is no easy way to test this other than make sure that string comparison is case insenstive
iCountTestcases++;
iCountTestcases++;
var somePopularCultureNames = new string[] {
"cs-CZ", "da-DK", "de-DE", "el-GR", "en-US",
"es-ES", "fi-FI", "fr-FR", "hu-HU", "it-IT",
"ja-JP", "ko-KR", "nb-NO", "nl-NL", "pl-PL",
"pt-BR", "pt-PT", "ru-RU", "sv-SE", "tr-TR",
"zh-CN", "zh-HK", "zh-TW"
};
foreach (string cultureName in somePopularCultureNames)
{
CultureInfo culture = new CultureInfo(cultureName);
if (culture == null)
{
continue;
}
comparer = new CaseInsensitiveComparer(culture);
defaultComparer = CaseInsensitiveComparer.Default;
if (defaultComparer.Compare("hello", "HELLO") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "HELLO"));
}
//same strings should work ok
if (defaultComparer.Compare("hello", "hello") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "hello"));
}
//different strings should return false
if (defaultComparer.Compare("hello", "mello") == 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("hello", "mello"));
}
//What would turkey do? - Since we are comparing with the default culture, unless this is run on a turkish machine, this will pass
if (CultureInfo.CurrentCulture.Name != "tr-TR")
{
if (defaultComparer.Compare("file", "FILE") != 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("file", "FILE"));
}
}
else
{
if (defaultComparer.Compare("file", "FILE") == 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>", 0, defaultComparer.Compare("file", "FILE"));
}
}
//[]Other data types should work as is
iCountTestcases++;
if (defaultComparer.Compare(5, 5) != 0)
{
iCountErrors++;
Console.WriteLine("Err_347tsfg! wrong value returned");
}
if (defaultComparer.Compare(5, 10) == 0)
{
iCountErrors++;
Console.WriteLine("Err_973425sdg! wrong value returned");
}
}
///////////////////////////////////////////////////////////////////
/////////////////////////// END TESTS /////////////////////////////
}
catch (Exception exc_general)
{
++iCountErrors;
Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString());
}
//// Finish Diagnostics
if (iCountErrors == 0)
{
return(true);
}
else
{
return(false);
}
}
public bool runTest()
{
//////////// Global Variables used for all tests
int iCountErrors = 0;
int iCountTestcases = 0;
CaseInsensitiveComparer comparer;
try
{
///////////////////////// START TESTS ////////////////////////////
///////////////////////////////////////////////////////////////////
//[]vanilla - the ctor simply sets the CompareInfo to the current culture - CultureInfo.CurrentCulture.CompareInfo
//There is no easy way to test this other than make sure that string comparison is case insensitive
iCountTestcases++;
iCountTestcases++;
iCountTestcases++;
var somePopularCultureNames = new string[] {
"cs-CZ","da-DK","de-DE","el-GR","en-US",
"es-ES","fi-FI","fr-FR","hu-HU","it-IT",
"ja-JP","ko-KR","nb-NO","nl-NL","pl-PL",
"pt-BR","pt-PT","ru-RU","sv-SE","tr-TR",
"zh-CN","zh-HK","zh-TW" };
foreach (string cultureName in somePopularCultureNames)
{
CultureInfo culture = new CultureInfo(cultureName);
if (culture == null)
{
continue;
}
comparer = new CaseInsensitiveComparer(culture);
if (comparer.Compare("hello", "HELLO") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("hello", "HELLO"), culture.Name);
}
//same strings should work ok
if (comparer.Compare("hello", "hello") != 0)
{
iCountErrors++;
Console.WriteLine("Err_93745sdg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("hello", "hello"), culture.Name);
}
//different strings should return false
if (comparer.Compare("hello", "mello") == 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", "non-zero", comparer.Compare("hello", "mello"), culture.Name);
}
// "tr-TR" = "Turkish (Turkey)"
// Turkish has lower-case and upper-case version of the dotted "i", so the upper case of "i" (U+0069) isn't "I" (U+0049), but rather "İ" (U+0130).
if (culture.Name != "tr-TR")
{
if (comparer.Compare("file", "FILE") != 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", 0, comparer.Compare("file", "FILE"), culture.Name);
}
}
else
{
if (comparer.Compare("file", "FILE") == 0)
{
iCountErrors++;
Console.WriteLine("Err_3846tdfsg! wrong value returned. Expected - <{0}>, Returned - <{1}>, Culture: {2}", "non-zero", comparer.Compare("file", "FILE"), culture.Name);
}
}
//[]Other data types should work as is
iCountTestcases++;
if (comparer.Compare(5, 5) != 0)
{
iCountErrors++;
Console.WriteLine("Err_347tsfg! wrong value returned");
}
if (comparer.Compare(5, 10) == 0)
{
iCountErrors++;
Console.WriteLine("Err_973425sdg! wrong value returned");
}
}
//[]parm test
iCountTestcases++;
try
{
comparer = new CaseInsensitiveComparer(null);
iCountErrors++;
Console.WriteLine("Err_9745sdg! Exception not thrown");
}
catch (ArgumentNullException)
{
}
catch (Exception ex)
{
iCountErrors++;
Console.WriteLine("Err_9745sdg! Unexpected exception thrown, " + ex.GetType().Name);
}
///////////////////////////////////////////////////////////////////
/////////////////////////// END TESTS /////////////////////////////
}
catch (Exception exc_general)
{
++iCountErrors;
Console.WriteLine(" : Error Err_8888yyy! exc_general==" + exc_general.ToString());
}
//// Finish Diagnostics
if (iCountErrors == 0)
{
return true;
}
else
{
return false;
}
}
/// <summary>
/// Class constructor. Initializes various elements
/// </summary>
public ListViewColumnSorter()
{
SortColumn = 0; // Initialize the column to '0'
Order = SortOrder.None; // Initialize the sort order to 'none'
ObjectCompare = new CaseInsensitiveComparer(); // Initialize the CaseInsensitiveComparer object
}
