public void Cloner_Collection_HashSet()
{
//Arrange
IEnumerable <Test2> test2List = new HashSet <Test2>
{
new Test2 {
Name = "Name11"
},
new Test2 {
Name = "Name12"
}
};
//Act
var cloner = ClonerBase.Create(test2List.GetType());
var clone = (HashSet <Test2>)cloner.Clone(test2List);
//Assert
Assert.IsTrue(clone != null &&
clone != test2List &&
clone.GetType() == test2List.GetType() &&
clone.Count == 2 &&
clone.Any(x => x.Name == "Name11") &&
clone.Any(x => x.Name == "Name12"));
}
/// <inheritdoc/>
public void WriteField <TBufferWriter>(ref Writer <TBufferWriter> writer, uint fieldIdDelta, Type expectedType, HashSet <T> value) where TBufferWriter : IBufferWriter <byte>
{
if (ReferenceCodec.TryWriteReferenceField(ref writer, fieldIdDelta, expectedType, value))
{
return;
}
writer.WriteFieldHeader(fieldIdDelta, expectedType, value.GetType(), WireType.TagDelimited);
if (value.Comparer != EqualityComparer <T> .Default)
{
_comparerCodec.WriteField(ref writer, 0, typeof(IEqualityComparer <T>), value.Comparer);
}
Int32Codec.WriteField(ref writer, 1, typeof(int), value.Count);
uint innerFieldIdDelta = 1;
foreach (var element in value)
{
_fieldCodec.WriteField(ref writer, innerFieldIdDelta, CodecElementType, element);
innerFieldIdDelta = 0;
}
writer.WriteEndObject();
}
{ // hashsets are used for unique data!!!
static void Main(string[] args)
{
HashSet <int> MyHashSet = new HashSet <int>();
HashSet <int> NewHashSet = new HashSet <int>();
MyHashSet.Add(1);
MyHashSet.Add(2);
MyHashSet.Add(3);
MyHashSet.Add(4);
MyHashSet.Add(5);
MyHashSet.Add(5);
NewHashSet.Add(4);
Console.WriteLine(MyHashSet.Count);
// printed 5 instead of six because i added 5 twice!
Console.WriteLine("=====================");
foreach (int i in MyHashSet)
{
Console.WriteLine(i);
}
// five was only printed once even though I included it twice
Console.WriteLine("Did i put 5 in here? {0}", MyHashSet.Contains(5));
int[] HashArry = MyHashSet.ToArray();
Console.WriteLine(string.Join(", ", MyHashSet));
Console.WriteLine(MyHashSet.GetType());
Console.WriteLine(MyHashSet.Overlaps(NewHashSet));
Console.WriteLine(MyHashSet.Average());
// string[] CastTest = MyHashSet.Cast<string>();
}
public static HashSet <T> SetCapacity <T>(this HashSet <T> hs, int capacity)
{
var initialize = hs.GetType().GetMethod("Initialize", Flags);
initialize.Invoke(hs, new object[] { capacity });
return(hs);
}
static long CountMemory(HashSet <T> set, int sizeOfT)
{
int bytes = IntPtr.Size * 6 + 4 * 4; // size of HashSet<T> itself
if (HashSet_buckets == null)
{
HashSet_buckets = set.GetType().GetField("m_buckets", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.IgnoreCase);
}
int arrayLength = 0;
if (HashSet_buckets != null)
{
int[] buckets = (int[])HashSet_buckets.GetValue(set);
if (buckets != null)
{
arrayLength = buckets.Length;
}
}
else
{
arrayLength = MathEx.NextPowerOf2(set.Count) - 1; // guess array length
}
if (arrayLength != 0)
{
bytes += IntPtr.Size * 6; // overhead of the two arrays in HashSet
bytes += arrayLength * (sizeOfT + 12); // size of the buckets, cached hashcodes, "next" indexes and T data
}
return(bytes);
}
public void Methods_Ignored()
{
var set = new HashSet <int>();
set.GetHashCode();
set.Equals(items);
set.GetType();
set.Contains(5);
}
public void CanAggregateIntoHashSet()
{
HashSet <int> set = from i in INT_SOURCE
orderby Distinct
group i by ToHashSet into s
select s;
set.GetType().Should().Be <HashSet <int> >();
}
public void CanSelectDistinct()
{
HashSet <int> distinctItems = from i in INT_SOURCE
orderby Distinct
group i by ToHashSet into set
select set;
distinctItems.GetType().Should().Be <HashSet <int> >();
distinctItems.Should().ContainInOrder(1, 9, 4, 5, 0, 8, 7);
}
/// <summary>
/// Our replacement loop
/// </summary>
/// <param name="list">The Asteroid collection</param>
/// <param name="writer">The stream used by the Asteroid.SerializeBytes() method.</param>
public static void Serialize_Asteroids(ref HashSet <Asteroid> list, ref BinaryWriter writer)
{
if (PatchWriteWorld.Debug)
{
Log($"In Serialize_Asteroids:\nHashSet:{list.GetType().FullDescription()}\n\tCount:{list.Count}");
Log($"BinaryWriter:{writer.GetType().FullDescription()}");
}
foreach (Asteroid a in list)
{
a.SerializeBytes(ref writer);
}
}
public void ShouldAssignArrayToNativeSet()
{
var intSet = new HashSet <int>();
SinTDArray array = new SinTDArray();
array.elementType = SinTDInstance.GetSinTDType("i32");
ISet <int> test = (HashSet <int>)array.AssignValuesToNativeType(new int[1] {
1
}, intSet.GetType());
Assert.AreEqual(1, test.Count);
Assert.AreEqual(1, test.ElementAt(0));
}
public void OnGUI()
{
PropertyEditor.Get(_resources.GetType(), null)
.FirstEditor
.EditWithGUILayout(new GUIContent("Resources"), _resources, _metadata.Enter("Resources", null));
if (GUILayout.Button("Write To Disk"))
{
const string outputPath = "Assets/FullInspector2/Modules/EditorImagesManager/Editor/fiEditorImages.cs";
File.WriteAllText(outputPath, BuildFile(_resources));
AssetDatabase.Refresh();
}
}
public static void Serialize(HashSet <BaseTalent> t, IGenericWriter writer)
{
if (t == null)
{
writer.WriteEncodedInt(0);
}
else
{
writer.WriteEncodedInt(t.Count);
foreach (BaseTalent talent in t)
{
Write(t.GetType(), BaseTalent.TalentTypes, writer);
writer.WriteEncodedInt(talent.Level);
}
}
}
public async Task TestHomogeneousTypeSafeSet()
{
var expected = new HashSet <string> {
"test", "123"
};
var writer = CreateGraphBinaryWriter();
var reader = CreateGraphBinaryReader();
var serializationStream = new MemoryStream();
await writer.WriteValueAsync(expected, serializationStream, false);
serializationStream.Position = 0;
var actual = await reader.ReadValueAsync <HashSet <string> >(serializationStream, false);
Assert.Equal(expected, actual);
Assert.Equal(expected.GetType(), actual.GetType());
}
public virtual void TestHashSetOfString()
{
Object obj = "";
ISet <String> coll = new HashSet <String>();
MethodInfo addMethod = coll.GetType().GetMethod("Add", new Type[] { typeof(String) });
fixture = new CollectionSetterCommand();
fixture.ObjectFuture = null;
fixture.Parent = coll;
fixture.AddMethod = addMethod;
fixture.Obj = obj;
fixture.AfterPropertiesSet();
fixture.Execute(null);
Assert.AreEqual(1, coll.Count);
Assert.AreEqual(obj, coll.ElementAt(0));
}
private static void SaveSet <T>(XmlWriter writer, HashSet <T> items, string key)
{
writer.WriteStartElement(PROPERTY_ID);
writer.WriteAttributeString(KEY_ID, key);
writer.WriteAttributeString(TYPE_ID, items.GetType().Name);
T[] sorted = new T[items.Count];
items.CopyTo(sorted, 0);
Array.Sort(sorted);
foreach (T item in sorted)
{
writer.WriteStartElement(ITEM_ID);
writer.WriteString(item.ToString());
writer.WriteEndElement(); // Item
}
writer.WriteEndElement(); // Property
}
public void Serialize_HashSetWithComparer()
{
var source1 = new HashSet <string>(new CaseInsensitiveStringEquality());
source1.Add("one");
source1.Add("two");
source1.Add("three");
var deserialized = OrleansSerializationLoop(environment.Serializer, environment.DeepCopier, source1);
Assert.IsAssignableFrom(source1.GetType(), deserialized); //Type is wrong after round-trip of string hash set with comparer
var result = deserialized as HashSet <string>;
Assert.Equal(source1.Count, result.Count); //Count is wrong after round-trip of string hash set with comparer
#pragma warning disable xUnit2017 // Do not use Contains() to check if a value exists in a collection
foreach (var key in source1)
{
Assert.True(result.Contains(key)); //key is missing after round-trip of string hash set with comparer
}
Assert.True(result.Contains("One")); //Comparer is wrong after round-trip of string hash set with comparer
#pragma warning restore xUnit2017 // Do not use Contains() to check if a value exists in a collection
}
/// <inheritdoc/>
public HashSet <T> DeepCopy(HashSet <T> input, CopyContext context)
{
if (context.TryGetCopy <HashSet <T> >(input, out var result))
{
return(result);
}
if (input.GetType() != typeof(HashSet <T>))
{
return(context.DeepCopy(input));
}
result = new HashSet <T>(input.Comparer);
context.RecordCopy(input, result);
foreach (var item in input)
{
result.Add(_copier.DeepCopy(item, context));
}
return(result);
}
protected override Expression VisitTypeBinary(TypeBinaryExpression node)
{
var expression = Visit(node.Expression);
if (expression.Type != node.Expression.Type)
{
HashSet <int> typeDbIds = null;
Expression <Func <int> > x = () => typeDbIds.Count;
ModelType.TryGetNotAbstractIncludingDerivedTypeDbIds(new string[] { node.TypeOperand.FullName }, out typeDbIds);
Expression typePropAccess = Expression.MakeMemberAccess(
expression,
typeof(TDbEntity).GetProperty(nameof(IDbEntity.Type), BindingFlags.Instance | BindingFlags.Public));
return(Expression.Call(
Expression.Constant(typeDbIds),
typeDbIds.GetType().GetMethod(nameof(HashSet <int> .Contains)),
typePropAccess));
}
return(base.VisitTypeBinary(node));
}
public void QueryFilterCustomPareter()
{
using (var container = new RhetosTestContainer())
{
var repository = container.Resolve <Common.DomRepository>();
var items = new[]
{
new TestFilter.SimpleItem {
Name = "si0"
},
new TestFilter.SimpleItem {
Name = "si1"
},
new TestFilter.SimpleItem {
Name = "si2"
},
new TestFilter.SimpleItem {
Name = "si3"
},
};
repository.TestFilter.SimpleItem.Insert(items);
var filter = new HashSet <string>(new[] { "si0", "si1" });
var ids = items.Select(item => item.ID).ToList();
var query = repository.TestFilter.SimpleItem.Query();
var directFilterImplementation = repository.TestFilter.SimpleItem.Filter(query, filter).Where(item => ids.Contains(item.ID));
Assert.AreEqual("si0, si1", TestUtility.DumpSorted(directFilterImplementation, item => item.Name));
var genericWithExplicitFilterType = repository.TestFilter.SimpleItem.Load(filter, filter.GetType()).Where(item => ids.Contains(item.ID));
Assert.AreEqual("si0, si1", TestUtility.DumpSorted(genericWithExplicitFilterType, item => item.Name));
var genericWithImplicitFilterType = repository.TestFilter.SimpleItem.Load(filter).Where(item => ids.Contains(item.ID));
Assert.AreEqual("si0, si1", TestUtility.DumpSorted(genericWithImplicitFilterType, item => item.Name));
var legacyFilterMethod = repository.TestFilter.SimpleItem.Filter(filter).Where(item => ids.Contains(item.ID));
Assert.AreEqual("si0, si1", TestUtility.DumpSorted(legacyFilterMethod, item => item.Name));
}
}
public void RecursiveJavaScriptSerializerArray()
{
var list = SampleModel.CreateListSampleWithCircularReference().ToList();
var jss = new JavaScriptSerializer();
jss.RegisterConverters(new[] { new ControlledSerializationJsonConverter(new[] { list.GetType() }, 50, true, false) });
var json = jss.Serialize(list);
if (json != @"[{""Number"":1,""Name"":""a"",""Child"":{""Number"":2,""Name"":""b"",""Child"":{""Number"":3,""Name"":""c""}}}]")
{
throw new ApplicationException("List serialization doesn't work. Case 1");
}
var array = SampleModel.CreateListSampleWithCircularReference().ToArray();
var jss2 = new JavaScriptSerializer();
jss2.RegisterConverters(new[] { new ControlledSerializationJsonConverter(new[] { array.GetType() }, 50, true, false) });
var json2 = jss.Serialize(array);
if (json2 != @"[{""Number"":1,""Name"":""a"",""Child"":{""Number"":2,""Name"":""b"",""Child"":{""Number"":3,""Name"":""c""}}}]")
{
throw new ApplicationException("List serialization doesn't work. Case 2");
}
var hashSet = new HashSet <SampleModel>(SampleModel.CreateListSampleWithCircularReference().ToArray());
var jss3 = new JavaScriptSerializer();
jss3.RegisterConverters(new[] { new ControlledSerializationJsonConverter(new[] { hashSet.GetType() }, 50, true, false) });
var json3 = jss.Serialize(hashSet);
if (json3 != @"[{""Number"":1,""Name"":""a"",""Child"":{""Number"":2,""Name"":""b"",""Child"":{""Number"":3,""Name"":""c""}}}]")
{
throw new ApplicationException("List serialization doesn't work. Case 3");
}
var arrayList = new ArrayList(SampleModel.CreateListSampleWithCircularReference().ToArray());
var jss4 = new JavaScriptSerializer();
jss4.RegisterConverters(new[] { new ControlledSerializationJsonConverter(new[] { arrayList.GetType() }, 50, true, false) });
var json4 = jss.Serialize(arrayList);
if (json4 != @"[{""Number"":1,""Name"":""a"",""Child"":{""Number"":2,""Name"":""b"",""Child"":{""Number"":3,""Name"":""c""}}}]")
{
throw new ApplicationException("List serialization doesn't work. Case 3");
}
}
public void ShouldAssignArrayToNativeSet()
{
var intSet = new HashSet<int>();
SinTDArray array = new SinTDArray();
array.elementType = SinTDInstance.GetSinTDType("i32");
ISet<int> test = (HashSet<int>)array.AssignValuesToNativeType(new int[1] { 1 }, intSet.GetType());
Assert.AreEqual(1, test.Count);
Assert.AreEqual(1, test.ElementAt(0));
}
static void Imprimir(HashSet<String> t)
{
Console.WriteLine("tipo: {0}", t.GetType().Name);
Console.WriteLine("quantidade de elementos: {0}", t.Count);
}
public void ShouldAssignArrayOfSetsToNative()
{
var intArray = new int[1][];
intArray[0] = new int[1] {
2
};
ISet <int>[] setArray = new HashSet <int>[1] {
new HashSet <int> {
1
}
};
SinTDArray innerArray = new SinTDArray();
innerArray.elementType = SinTDInstance.GetSinTDType("i32");
SinTDArray outerArray = new SinTDArray();
outerArray.elementType = innerArray;
HashSet <int>[] test = (HashSet <int>[])outerArray.AssignValuesToNativeType(intArray, setArray.GetType());
Assert.IsAssignableFrom <HashSet <int> >(test[0]);
Assert.AreEqual(2, test[0].ElementAt(0));
}
public void ShouldAssignLSetOfArraysToNative()
{
var intArray = new int[1][];
intArray[0] = new int[1] { 2 };
ISet<int[]> arraySet = new HashSet<int[]> { new int[1] { 1 } };
SinTDArray innerArray = new SinTDArray();
innerArray.elementType = SinTDInstance.GetSinTDType("i32");
SinTDArray outerArray = new SinTDArray();
outerArray.elementType = innerArray;
ISet<int[]> test = (HashSet<int[]>)outerArray.AssignValuesToNativeType(intArray, arraySet.GetType());
Assert.IsAssignableFrom<int[]>(test.ElementAt(0));
Assert.AreEqual(2, test.ElementAt(0)[0]);
}
public void ShouldAssignLSetOfArraysToNative()
{
var intArray = new int[1][];
intArray[0] = new int[1] {
2
};
ISet <int[]> arraySet = new HashSet <int[]> {
new int[1] {
1
}
};
SinTDArray innerArray = new SinTDArray();
innerArray.elementType = SinTDInstance.GetSinTDType("i32");
SinTDArray outerArray = new SinTDArray();
outerArray.elementType = innerArray;
ISet <int[]> test = (HashSet <int[]>)outerArray.AssignValuesToNativeType(intArray, arraySet.GetType());
Assert.IsAssignableFrom <int[]>(test.ElementAt(0));
Assert.AreEqual(2, test.ElementAt(0)[0]);
}
public void ShouldAssignArrayOfSetsToNative()
{
var intArray = new int[1][];
intArray[0] = new int[1] { 2 };
ISet<int>[] setArray = new HashSet<int>[1] { new HashSet<int> { 1 } };
SinTDArray innerArray = new SinTDArray();
innerArray.elementType = SinTDInstance.GetSinTDType("i32");
SinTDArray outerArray = new SinTDArray();
outerArray.elementType = innerArray;
HashSet<int>[] test = (HashSet<int>[])outerArray.AssignValuesToNativeType(intArray, setArray.GetType());
Assert.IsAssignableFrom<HashSet<int>>(test[0]);
Assert.AreEqual(2, test[0].ElementAt(0));
}
public static void testvector()
{
Dictionary <string, string> testdict = new Dictionary <string, string>()
{
{ "1", "1" },
{ "2", "1" },
{ "3", "2" },
{ "4", "3" },
{ "5", "5" },
{ "6", "8" },
};
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(testdict.GetType(), testdict));
HashSet <string> testhashset = new HashSet <string>()
{
"12", "123", "ad", "fd", "qwe", "23",
};
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(testhashset.GetType(), testhashset));
List <int> testlist = new List <int>()
{
1, 2, 10, 2, 5, 9, 22, 14, 16,
};
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(testlist.GetType(), testlist));
LinkedList <int> testlinkedlist = new LinkedList <int>(testlist);
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(testlinkedlist.GetType(), testlinkedlist));
Queue <string> testq = new Queue <string>(testhashset);
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(testq.GetType(), testq));
Stack <int> tests = new Stack <int>(testlist);
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(tests.GetType(), tests));
SortedDictionary <string, string> testsd = new SortedDictionary <string, string>(testdict);
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(testsd.GetType(), testsd));
SortedList <int, int> testsl = new SortedList <int, int>()
{
{ 1, 10 },
{ 10, 1 },
{ 55, 5 },
{ 5, 55 },
{ 1000, 101 },
{ 101, 1001 },
};
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(testsl.GetType(), testsl));
Console.WriteLine(ObjectPropertyPrinter.PrintProperty <int>(1));
Dictionary <string, Dictionary <string, string> > test2dict = new Dictionary <string, Dictionary <string, string> > ();
test2dict.Add("test2", testdict);
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(test2dict.GetType(), test2dict));
Dictionary <string, Dictionary <string, Dictionary <string, string> > > test3dict = new Dictionary <string, Dictionary <string, Dictionary <string, string> > > ();
test3dict.Add("test3", test2dict);
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(test3dict.GetType(), test3dict));
List <Dictionary <string, string> > testldict = new List <Dictionary <string, string> > ();
testldict.Add(testdict);
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(testldict.GetType(), testldict));
object o = new object();
Console.WriteLine(ObjectPropertyPrinter.PrintProperty(o.GetType(), o));
}
