| public CopyTo ( Array array, int arrayIndex ) : void | ||
| array | Array | |
| arrayIndex | int | |
| return | void | |
protected override void Reload ()
{
System.Collections.Hashtable ht = new System.Collections.Hashtable ();
Photo [] photos = query.Store.Query ((Tag [])null, null, null, null);
foreach (Photo p in photos) {
if (ht.Contains (p.DirectoryPath)) {
DirectoryAdaptor.Group group = (DirectoryAdaptor.Group) ht [p.DirectoryPath];
group.Count += 1;
} else
ht [p.DirectoryPath] = new DirectoryAdaptor.Group ();
}
Console.WriteLine ("Count = {0}", ht.Count);
dirs = new System.Collections.DictionaryEntry [ht.Count];
ht.CopyTo (dirs, 0);
Array.Sort (dirs, new DirectoryAdaptor.Group ());
Array.Sort (query.Photos, new Photo.CompareDirectory ());
if (!order_ascending) {
Array.Reverse (dirs);
Array.Reverse (query.Photos);
}
if (Changed != null)
Changed (this);
}
public override void CopyTo(Array array, int arrayIndex)
{
lock (_table.SyncRoot)
{
_table.CopyTo(array, arrayIndex);
}
}
// Implement the ICollection interface.
public override void CopyTo(Array array, int index)
{
lock (SyncRoot)
{
table.CopyTo(array, index);
}
}
static int CopyTo(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 3);
System.Collections.Hashtable obj = (System.Collections.Hashtable)ToLua.CheckObject(L, 1, typeof(System.Collections.Hashtable));
System.Array arg0 = (System.Array)ToLua.CheckObject(L, 2, typeof(System.Array));
int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
obj.CopyTo(arg0, arg1);
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static public int CopyTo(IntPtr l)
{
try {
System.Collections.Hashtable self = (System.Collections.Hashtable)checkSelf(l);
System.Array a1;
checkType(l, 2, out a1);
System.Int32 a2;
checkType(l, 3, out a2);
self.CopyTo(a1, a2);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
public static Hashtable applyKeepWords(Hashtable centroidValues, int keepWords)
{
DictionaryEntry[] centValuesArr = new DictionaryEntry[centroidValues.Count];
centroidValues.CopyTo(centValuesArr, 0);
Array.Sort(centValuesArr, new DictionaryEntryValueComparer());
Array.Reverse(centValuesArr);
Hashtable finalCentroidValues = new Hashtable();
for (int i = 0; i < keepWords && i < centValuesArr.Length; i++)
{
DictionaryEntry entry = centValuesArr[i];
finalCentroidValues.Add(entry.Key, entry.Value);
}
return (finalCentroidValues);
}
protected override void Reload()
{
System.Collections.Hashtable ht = new System.Collections.Hashtable();
Photo [] photos = query.Store.Query((Tag [])null, null, null, null);
foreach (Photo p in photos)
{
if (ht.Contains(p.DirectoryPath))
{
DirectoryAdaptor.Group group = (DirectoryAdaptor.Group)ht [p.DirectoryPath];
group.Count += 1;
}
else
{
ht [p.DirectoryPath] = new DirectoryAdaptor.Group();
}
}
Console.WriteLine("Count = {0}", ht.Count);
dirs = new System.Collections.DictionaryEntry [ht.Count];
ht.CopyTo(dirs, 0);
Array.Sort(dirs, new DirectoryAdaptor.Group());
Array.Sort(query.Photos, new Photo.CompareDirectory());
if (!order_ascending)
{
Array.Reverse(dirs);
Array.Reverse(query.Photos);
}
if (Changed != null)
{
Changed(this);
}
}
public void TestCopyTo() {
{
bool errorThrown = false;
try {
Hashtable h = new Hashtable();
h.CopyTo(null, 0);
} catch (ArgumentNullException e) {
errorThrown = true;
Assert.AreEqual ("array", e.ParamName, "ParamName is not \"array\"");
}
Assert.IsTrue (errorThrown, "null hashtable error not thrown");
}
{
bool errorThrown = false;
try {
Hashtable h = new Hashtable();
Object[] o = new Object[1];
h.CopyTo(o, -1);
} catch (ArgumentOutOfRangeException e) {
errorThrown = true;
Assert.AreEqual ("arrayIndex", e.ParamName, "ParamName is not \"arrayIndex\"");
}
Assert.IsTrue (errorThrown, "out of range error not thrown");
}
{
bool errorThrown = false;
try {
Hashtable h = new Hashtable();
Object[,] o = new Object[1,1];
h.CopyTo(o, 1);
} catch (ArgumentException) {
errorThrown = true;
}
Assert.IsTrue (errorThrown, "multi-dim array error not thrown");
}
{
bool errorThrown = false;
try {
Hashtable h = new Hashtable();
h['a'] = 1; // no error if table is empty
Object[] o = new Object[5];
h.CopyTo(o, 5);
} catch (ArgumentException) {
errorThrown = true;
}
Assert.IsTrue (errorThrown, "no room in array error not thrown");
}
{
bool errorThrown = false;
try {
Hashtable h = new Hashtable();
h['a'] = 1;
h['b'] = 2;
h['c'] = 2;
Object[] o = new Object[2];
h.CopyTo(o, 0);
} catch (ArgumentException) {
errorThrown = true;
}
Assert.IsTrue (errorThrown, "table too big error not thrown");
}
{
bool errorThrown = false;
try {
Hashtable h = new Hashtable();
h["blue"] = 1;
h["green"] = 2;
h["red"] = 3;
Char[] o = new Char[3];
h.CopyTo(o, 0);
} catch (InvalidCastException) {
errorThrown = true;
}
Assert.IsTrue (errorThrown, "invalid cast error not thrown");
}
{
Hashtable h = new Hashtable();
h['a'] = 1;
h['b'] = 2;
DictionaryEntry[] o = new DictionaryEntry[2];
h.CopyTo(o,0);
Assert.AreEqual ('a', o[0].Key, "first copy fine.");
Assert.AreEqual (1, o[0].Value, "first copy fine.");
Assert.AreEqual ('b', o[1].Key, "second copy fine.");
Assert.AreEqual (2, o[1].Value, "second copy fine.");
}
}
public void CopyTo(Array array, int idx)
{
objectTable.CopyTo(array, idx);
}
void ICollection.CopyTo(Array array, int index)
{
_innerhash.CopyTo(array, index);
}
public void TestCtorIntSingle()
{
// variables used for tests
Hashtable hash = null;
// [] should get ArgumentException if trying to have large num of entries
Assert.Throws<ArgumentException>(() =>
{
hash = new Hashtable(int.MaxValue, .1f);
}
);
// []should not get any exceptions for valid values - we also check that the HT works here
hash = new Hashtable(100, .1f);
int iNumberOfElements = 100;
for (int i = 0; i < iNumberOfElements; i++)
{
hash.Add("Key_" + i, "Value_" + i);
}
//Count
Assert.Equal(hash.Count, iNumberOfElements);
DictionaryEntry[] strValueArr = new DictionaryEntry[hash.Count];
hash.CopyTo(strValueArr, 0);
Hashtable hsh3 = new Hashtable();
for (int i = 0; i < iNumberOfElements; i++)
{
Assert.True(hash.Contains("Key_" + i), "Error, Expected value not returned, " + hash.Contains("Key_" + i));
Assert.True(hash.ContainsKey("Key_" + i), "Error, Expected value not returned, " + hash.ContainsKey("Key_" + i));
Assert.True(hash.ContainsValue("Value_" + i), "Error, Expected value not returned, " + hash.ContainsValue("Value_" + i));
//we still need a way to make sure that there are all these unique values here -see below code for that
Assert.True(hash.ContainsValue(((DictionaryEntry)strValueArr[i]).Value), "Error, Expected value not returned, " + ((DictionaryEntry)strValueArr[i]).Value);
hsh3.Add(((DictionaryEntry)strValueArr[i]).Value, null);
}
}
public void TestSynchronizedBasic()
{
Hashtable hsh1;
string strValue;
Task[] workers;
Action ts1;
int iNumberOfWorkers = 3;
DictionaryEntry[] strValueArr;
string[] strKeyArr;
Hashtable hsh3;
Hashtable hsh4;
IDictionaryEnumerator idic;
object oValue;
//[]Vanila - Syncronized returns a wrapped HT. We must make sure that all the methods
//are accounted for here for the wrapper
hsh1 = new Hashtable();
for (int i = 0; i < _iNumberOfElements; i++)
{
hsh1.Add("Key_" + i, "Value_" + i);
}
_hsh2 = Hashtable.Synchronized(hsh1);
//Count
Assert.Equal(_hsh2.Count, hsh1.Count);
//get/set item
for (int i = 0; i < _iNumberOfElements; i++)
{
Assert.True(((string)_hsh2["Key_" + i]).Equals("Value_" + i));
}
Assert.Throws<ArgumentNullException>(() =>
{
oValue = _hsh2[null];
});
_hsh2.Clear();
for (int i = 0; i < _iNumberOfElements; i++)
{
_hsh2["Key_" + i] = "Value_" + i;
}
strValueArr = new DictionaryEntry[_hsh2.Count];
_hsh2.CopyTo(strValueArr, 0);
//ContainsXXX
hsh3 = new Hashtable();
for (int i = 0; i < _iNumberOfElements; i++)
{
Assert.True(_hsh2.Contains("Key_" + i));
Assert.True(_hsh2.ContainsKey("Key_" + i));
Assert.True(_hsh2.ContainsValue("Value_" + i));
//we still need a way to make sure that there are all these unique values here -see below code for that
Assert.True(hsh1.ContainsValue(((DictionaryEntry)strValueArr[i]).Value));
hsh3.Add(strValueArr[i], null);
}
hsh4 = (Hashtable)_hsh2.Clone();
Assert.Equal(hsh4.Count, hsh1.Count);
strValueArr = new DictionaryEntry[hsh4.Count];
hsh4.CopyTo(strValueArr, 0);
//ContainsXXX
hsh3 = new Hashtable();
for (int i = 0; i < _iNumberOfElements; i++)
{
Assert.True(hsh4.Contains("Key_" + i));
Assert.True(hsh4.ContainsKey("Key_" + i));
Assert.True(hsh4.ContainsValue("Value_" + i));
//we still need a way to make sure that there are all these unique values here -see below code for that
Assert.True(hsh1.ContainsValue(((DictionaryEntry)strValueArr[i]).Value));
hsh3.Add(((DictionaryEntry)strValueArr[i]).Value, null);
}
Assert.False(hsh4.IsReadOnly);
Assert.True(hsh4.IsSynchronized);
//Phew, back to other methods
idic = _hsh2.GetEnumerator();
hsh3 = new Hashtable();
hsh4 = new Hashtable();
while (idic.MoveNext())
{
Assert.True(_hsh2.ContainsKey(idic.Key));
Assert.True(_hsh2.ContainsValue(idic.Value));
hsh3.Add(idic.Key, null);
hsh4.Add(idic.Value, null);
}
hsh4 = (Hashtable)_hsh2.Clone();
strValueArr = new DictionaryEntry[hsh4.Count];
hsh4.CopyTo(strValueArr, 0);
hsh3 = new Hashtable();
for (int i = 0; i < _iNumberOfElements; i++)
{
Assert.True(hsh4.Contains("Key_" + i));
Assert.True(hsh4.ContainsKey("Key_" + i));
Assert.True(hsh4.ContainsValue("Value_" + i));
//we still need a way to make sure that there are all these unique values here -see below code for that
Assert.True(hsh1.ContainsValue(((DictionaryEntry)strValueArr[i]).Value));
hsh3.Add(((DictionaryEntry)strValueArr[i]).Value, null);
}
Assert.False(hsh4.IsReadOnly);
Assert.True(hsh4.IsSynchronized);
//Properties
Assert.False(_hsh2.IsReadOnly);
Assert.True(_hsh2.IsSynchronized);
Assert.Equal(_hsh2.SyncRoot, hsh1.SyncRoot);
//we will test the Keys & Values
string[] strValueArr11 = new string[hsh1.Count];
strKeyArr = new string[hsh1.Count];
_hsh2.Keys.CopyTo(strKeyArr, 0);
_hsh2.Values.CopyTo(strValueArr11, 0);
hsh3 = new Hashtable();
hsh4 = new Hashtable();
for (int i = 0; i < _iNumberOfElements; i++)
{
Assert.True(_hsh2.ContainsKey(strKeyArr[i]));
Assert.True(_hsh2.ContainsValue(strValueArr11[i]));
hsh3.Add(strKeyArr[i], null);
hsh4.Add(strValueArr11[i], null);
}
//now we test the modifying methods
_hsh2.Remove("Key_1");
Assert.False(_hsh2.ContainsKey("Key_1"));
Assert.False(_hsh2.ContainsValue("Value_1"));
_hsh2.Add("Key_1", "Value_1");
Assert.True(_hsh2.ContainsKey("Key_1"));
Assert.True(_hsh2.ContainsValue("Value_1"));
_hsh2["Key_1"] = "Value_Modified_1";
Assert.True(_hsh2.ContainsKey("Key_1"));
Assert.False(_hsh2.ContainsValue("Value_1"));
///////////////////////////
Assert.True(_hsh2.ContainsValue("Value_Modified_1"));
hsh3 = Hashtable.Synchronized(_hsh2);
//we are not going through all of the above again:) we will just make sure that this syncrnized and that
//values are there
Assert.Equal(hsh3.Count, hsh1.Count);
Assert.True(hsh3.IsSynchronized);
_hsh2.Clear();
Assert.Equal(_hsh2.Count, 0);
//[] Synchronized returns a HT that is thread safe
// We will try to test this by getting a number of threads to write some items
// to a synchronized IList
hsh1 = new Hashtable();
_hsh2 = Hashtable.Synchronized(hsh1);
workers = new Task[iNumberOfWorkers];
for (int i = 0; i < workers.Length; i++)
{
var name = "Thread worker " + i;
ts1 = new Action(() => AddElements(name));
workers[i] = Task.Run(ts1);
}
Task.WaitAll(workers);
//checking time
Assert.Equal(_hsh2.Count, _iNumberOfElements * iNumberOfWorkers);
for (int i = 0; i < iNumberOfWorkers; i++)
{
for (int j = 0; j < _iNumberOfElements; j++)
{
strValue = "Thread worker " + i + "_" + j;
Assert.True(_hsh2.Contains(strValue));
}
}
//I dont think that we can make an assumption on the order of these items though
//now we are going to remove all of these
workers = new Task[iNumberOfWorkers];
for (int i = 0; i < workers.Length; i++)
{
var name = "Thread worker " + i;
ts1 = new Action(() => RemoveElements(name));
workers[i] = Task.Run(ts1);
}
Task.WaitAll(workers);
Assert.Equal(_hsh2.Count, 0);
Assert.False(hsh1.IsSynchronized);
Assert.True(_hsh2.IsSynchronized);
//[] Tyr calling Synchronized with null
Assert.Throws<ArgumentNullException>(() =>
{
Hashtable.Synchronized(null);
}
);
}
// Implement the ICollection interface.
public void CopyTo(Array array, int index)
{
table.CopyTo(array, index);
}
public void CopyTo_Empty ()
{
Hashtable ht = new Hashtable ();
Assert.AreEqual (0, ht.Count, "Count");
object[] array = new object [ht.Count];
ht.CopyTo (array, 0);
}
public void CopyTo_Empty ()
{
Hashtable ht = new Hashtable ();
AssertEquals ("Count", 0, ht.Count);
object[] array = new object [ht.Count];
ht.CopyTo (array, 0);
}
public void TestCopyToBasic()
{
Hashtable hash = null; // the hashtable object which will be used in the tests
object[] objArr = null; // the object array corresponding to arr
object[] objArr2 = null; // helper object array
object[,] objArrRMDim = null; // multi dimensional object array
// these are the keys and values which will be added to the hashtable in the tests
object[] keys = new object[] {
new object(),
"Hello" ,
"my array" ,
new DateTime(),
new SortedList(),
typeof( System.Environment ),
5
};
object[] values = new object[] {
"Somestring" ,
new object(),
new int [] { 1, 2, 3, 4, 5 },
new Hashtable(),
new Exception(),
new CopyToTests(),
null
};
//[]test normal conditions, array is large enough to hold all elements
// make new hashtable
hash = new Hashtable();
// put in values and keys
for (int i = 0; i < values.Length; i++)
{
hash.Add(keys[i], values[i]);
}
// now try getting out the values using CopyTo method
objArr = new object[values.Length + 2];
// put a sentinal in first position, and make sure it is not overriden
objArr[0] = "startstring";
// put a sentinal in last position, and make sure it is not overriden
objArr[values.Length + 1] = "endstring";
hash.Values.CopyTo((Array)objArr, 1);
// make sure sentinal character is still there
Assert.Equal("startstring", objArr[0]);
Assert.Equal("endstring", objArr[values.Length + 1]);
// check to make sure arr is filled up with the correct elements
objArr2 = new object[values.Length];
Array.Copy(objArr, 1, objArr2, 0, values.Length);
objArr = objArr2;
Assert.True(CompareArrays(objArr, values));
//[] This is the same test as before but now we are going to used Hashtable.CopyTo instead of Hasthabe.Values.CopyTo
// now try getting out the values using CopyTo method
objArr = new object[values.Length + 2];
// put a sentinal in first position, and make sure it is not overriden
objArr[0] = "startstring";
// put a sentinal in last position, and make sure it is not overriden
objArr[values.Length + 1] = "endstring";
hash.CopyTo((Array)objArr, 1);
// make sure sentinal character is still there
Assert.Equal("startstring", objArr[0]);
Assert.Equal("endstring", objArr[values.Length + 1]);
// check to make sure arr is filled up with the correct elements
BitArray bitArray = new BitArray(values.Length);
for (int i = 0; i < values.Length; i++)
{
DictionaryEntry entry = (DictionaryEntry)objArr[i + 1];
int valueIndex = Array.IndexOf(values, entry.Value);
int keyIndex = Array.IndexOf(keys, entry.Key);
Assert.NotEqual(-1, valueIndex);
Assert.NotEqual(-1, keyIndex);
Assert.Equal(valueIndex, keyIndex);
bitArray[i] = true;
}
for (int i = 0; i < ((ICollection)bitArray).Count; i++)
{
Assert.True(bitArray[i]);
}
//[] Parameter validation
//[] Null array
Assert.Throws<ArgumentNullException>(() =>
{
hash = new Hashtable();
objArr = new object[0];
hash.CopyTo(null, 0);
}
);
//[] Multidimentional array
Assert.Throws<ArgumentException>(() =>
{
hash = new Hashtable();
objArrRMDim = new object[16, 16];
hash.CopyTo(objArrRMDim, 0);
}
);
//[] Array not large enough
Assert.Throws<ArgumentException>(() =>
{
hash = new Hashtable();
for (int i = 0; i < 256; i++)
{
hash.Add(i.ToString(), i);
}
objArr = new object[hash.Count + 8];
hash.CopyTo(objArr, 9);
}
);
Assert.Throws<ArgumentException>(() =>
{
hash = new Hashtable();
objArr = new object[0];
hash.CopyTo(objArr, Int32.MaxValue);
}
);
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
hash = new Hashtable();
objArr = new object[0];
hash.CopyTo(objArr, Int32.MinValue);
}
);
//[]copy should throw because of outofrange
Random random = new Random(-55);
for (int iii = 0; iii < 20; iii++)
{
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
hash = new Hashtable();
objArr = new object[0];
hash.CopyTo(objArr, random.Next(-1000, 0));
}
);
}
//[]test when array is to small to hold all values hashtable has more values then array can hold
hash = new Hashtable();
// put in values and keys
for (int i = 0; i < values.Length; i++)
{
hash.Add(keys[i], values[i]);
}
// now try getting out the values using CopyTo method into a small array
objArr = new object[values.Length - 1];
Assert.Throws<ArgumentException>(() =>
{
hash.Values.CopyTo((Array)objArr, 0);
}
);
//[]test when array is size 0
// now try getting out the values using CopyTo method into a 0 sized array
objArr = new object[0];
Assert.Throws<ArgumentException>(() =>
{
hash.Values.CopyTo((Array)objArr, 0);
}
);
//[]test when array is null
Assert.Throws<ArgumentNullException>(() =>
{
hash.Values.CopyTo(null, 0);
}
);
}
public void NonGenericDictionarySource()
{
var source = new Hashtable();
// guid
var guidValue = new Guid("21EC2020-3AEA-1069-A2DD-08002B30309D");
source["GuidPty"] = guidValue;
Assert.AreEqual(guidValue, source.CopyTo<TargetType>().GuidPty);
source["GuidPty"] = guidValue.ToString();
Assert.AreEqual(guidValue, source.CopyTo<TargetType>().GuidPty);
source["GuidPty"] = guidValue.ToByteArray();
Assert.AreEqual(guidValue, source.CopyTo<TargetType>().GuidPty);
// int
source["IntPty"] = 345;
Assert.AreEqual(345, source.CopyTo<TargetType>().IntPty);
source["IntPty"] = 345.ToString(CultureInfo.InvariantCulture);
Assert.AreEqual(345, source.CopyTo<TargetType>().IntPty);
source["IntPty"] = (long)345;
Assert.AreEqual(345, source.CopyTo<TargetType>().IntPty);
source["IntPty"] = int.MaxValue;
Assert.AreEqual(int.MaxValue, source.CopyTo<TargetType>().IntPty);
// enum pty
source["EnumPty"] = TargetType.TestEnum.Three;
Assert.AreEqual(TargetType.TestEnum.Three, source.CopyTo<TargetType>().EnumPty);
source["EnumPty"] = TargetType.TestEnum.Three.ToString();
Assert.AreEqual(TargetType.TestEnum.Three, source.CopyTo<TargetType>().EnumPty);
source["EnumPty"] = (int)TargetType.TestEnum.Three;
Assert.AreEqual(TargetType.TestEnum.Three, source.CopyTo<TargetType>().EnumPty);
source["EnumPty"] = (byte)TargetType.TestEnum.Three;
Assert.AreEqual(TargetType.TestEnum.Three, source.CopyTo<TargetType>().EnumPty);
source["EnumPty"] = (long)TargetType.TestEnum.Three;
Assert.AreEqual(TargetType.TestEnum.Three, source.CopyTo<TargetType>().EnumPty);
// obj pty
var obj = new object();
source["ObjPty"] = obj;
Assert.AreEqual(obj, source.CopyTo<TargetType>().ObjPty);
}
// ICollection
public override void CopyTo(Array array, int arrayIndex)
{
host.CopyTo(array, arrayIndex);
}
public void ElementAtShouldReturnExpectedValueFromDictionary()
{
var target = new Hashtable();
target.Add( 0, new object() );
target.Add( 1, new object() );
target.Add( 2, new object() );
var index = 2;
var array = Array.CreateInstance( typeof( DictionaryEntry ), 3 );
target.CopyTo( array, 0 );
var expected = array.GetValue( index );
var actual = target.ElementAt( index );
Assert.Equal( expected, actual );
}
