C# ValueItem类代码示例

 public static void Test2_Negative()
 {
     HashSet<ValueItem> hashSet = new HashSet<ValueItem>();
     ValueItem[] items = new ValueItem[0];
     HashSetTestSupport<ValueItem> driver = new HashSetTestSupport<ValueItem>(hashSet, ValueItem.GenerateNext, items);
     driver.VerifyHashSet_NegativeTests();
 }

 void OnMassItemValueChanged(ValueItem massItem)
 {
     if (_massItem == massItem) {
         _rb.mass = _massItem.Value * Config.Instance.density;
         transform.localScale = Vector3.one * Mathf.Pow (_massItem.Value * 3 / 4, 1.0f / 3);
     }
 }

            //Test 4 - Set/Item Comparer Test 4
            public static void SetupTest4(out HashSet<ValueItem> set, out IEnumerable<ValueItem> other)
            {
                List<ValueItem> list = new List<ValueItem>();
                ValueItem item1 = new ValueItem(134, -15);
                ValueItem item2 = new ValueItem(14, 14);
                ValueItem item3 = new ValueItem(19999, -12);
                ValueItem innerItem;

                SetItemComparerTests.SetupTest4(out set, out innerItem);

                list.Add(item1);
                list.Add(item2);
                list.Add(item3);
                list.Add(innerItem);

                other = list;
            }

            //Test 1: other collection is multi-item with duplicates, set is empty
            public static void SetupTest1(out HashSet<ValueItem> set, out IEnumerable<ValueItem> other)
            {
                List<ValueItem> list = new List<ValueItem>();

                ValueItem item1 = new ValueItem(34, -5);
                ValueItem item2 = new ValueItem(4, 4);
                ValueItem item3 = new ValueItem(9999, -2);
                ValueItem item4 = new ValueItem(99, -2);

                list.Add(item1);
                list.Add(item2);
                list.Add(item2);
                list.Add(item3);
                list.Add(item4);
                list.Add(item4);

                set = new HashSet<ValueItem>();
                other = list;
            }

        public static void Overlaps_Test61()
        {
            HashSet<ValueItem> hashSet;
            IEnumerable<ValueItem> other;
            bool ret;
            ValueItem item2 = new ValueItem(4, 4);

            SetCollectionDuplicateItemTests.SetupTest4(out hashSet, out other);
            ret = hashSet.Overlaps(other);
            Assert.True(ret); //"Error: Overlaps returned wrong value."

            HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { item2 }, hashSet.Comparer);
        }

        public static void IsExceptWith_Test56()
        {
            HashSet<ValueItem> hashSet;
            IEnumerable<ValueItem> other;
            ValueItem item1 = new ValueItem(340, -5);
            ValueItem item2 = new ValueItem(4, 4);

            SetCollectionComparerTests.SetupTest14(out hashSet, out other);
            hashSet.ExceptWith(other);

            HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { item1, item2 }, hashSet.Comparer);
        }

        public static void IsProperSupersetOf_Test65()
        {
            HashSet<ValueItem> hashSet;
            IEnumerable<ValueItem> other;
            bool ret;
            ValueItem itemo1 = new ValueItem(34, -5);
            ValueItem itemo2 = new ValueItem(4, 4);
            ValueItem itemo3 = new ValueItem(9999, -2);
            ValueItem itemo4 = new ValueItem(99, -2);
            ValueItem items1 = new ValueItem(-34, 5);
            ValueItem items2 = new ValueItem(-4, -4);
            ValueItem items3 = new ValueItem(-9999, 2);
            ValueItem items4 = new ValueItem(-99, 2);

            SetCollectionDuplicateItemTests.SetupTest8(out hashSet, out other);
            ret = hashSet.IsProperSupersetOf(other);
            Assert.True(ret); //"Error: IsProperSupersetOf returned wrong value."

            HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { items1, items2, items3, items4, itemo1, itemo2, itemo3, itemo4 }, hashSet.Comparer);
        }

            //Test 3
            // item same as element in set by sets comparer, different by default comparer - set contains item that is equal by default comparer
            public static void SetupTest3(out HashSet<ValueItem> set, out ValueItem item)
            {
                set = new HashSet<ValueItem>(new ValueItemYEqualityComparer());
                set.Add(new ValueItem(34, -5));
                set.Add(new ValueItem(4, 4));
                set.Add(new ValueItem(9999, -2));

                item = new ValueItem(34, -2);
            }

 public static void HashSetConstructor_IEn_IEq_Comparer_Default()
 {
     IEqualityComparer<ValueItem> defaultComparer = EqualityComparer<ValueItem>.Default;
     ValueItem[] items = new ValueItem[] { new ValueItem(1, -1), new ValueItem(2, -2), new ValueItem(3, -3), new ValueItem(4, -4) };
     HashSet<ValueItem> hashSet = new HashSet<ValueItem>(items, defaultComparer);
     HashSetTestSupport<ValueItem> driver = new HashSetTestSupport<ValueItem>(hashSet, ValueItem.GenerateNext, items, defaultComparer);
     driver.VerifyHashSetTests();
 }

        public static void IsIntersectWith_Test56()
        {
            HashSet<ValueItem> hashSet;
            IEnumerable<ValueItem> other;
            ValueItem item3 = new ValueItem(9999, -2);

            SetCollectionComparerTests.SetupTest14(out hashSet, out other);
            hashSet.IntersectWith(other);

            HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { item3 }, hashSet.Comparer);
        }

        public static void IsIntersectWith_Test69()
        {
            HashSet<ValueItem> hashSet;
            IEnumerable<ValueItem> other;
            ValueItem items2 = new ValueItem(-4, -4);

            SetCollectionDuplicateItemTests.SetupTest12(out hashSet, out other);
            hashSet.IntersectWith(other);

            HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { items2 }, hashSet.Comparer);
        }

            public static void UnionWith_Test52()
            {
                ValueItem itemn4 = new ValueItem(-4, -4);
                ValueItem itemn3 = new ValueItem(-3, -3);
                ValueItem itemn2 = new ValueItem(-2, -2);
                ValueItem itemn1 = new ValueItem(-1, -1);
                ValueItem item1 = new ValueItem(1, 1);
                ValueItem item2 = new ValueItem(2, 2);
                ValueItem item3 = new ValueItem(3, 3);
                ValueItem item4 = new ValueItem(4, 4);

                HashSet<IEnumerable> itemhs1 = new HashSet<IEnumerable>(new ValueItem[] { item1, item2, item3, item4 });
                HashSet<IEnumerable> itemhs2 = new HashSet<IEnumerable>(new ValueItem[] { itemn1, itemn2, itemn3, itemn4 });
                HashSet<IEnumerable> inneritem = new HashSet<IEnumerable>();

                HashSet<HashSet<IEnumerable>> hashSet;
                IEnumerable<HashSet<IEnumerable>> other;

                SetCollectionComparerTests.SetupTest10(out hashSet, out other);
                inneritem.Add(hashSet);
                hashSet.UnionWith(other);

                HashSet<IEnumerable>[] expected = new HashSet<IEnumerable>[] { itemhs1, itemhs2, inneritem };
                HashSet<IEnumerable>[] actual = new HashSet<IEnumerable>[3];
                hashSet.CopyTo(actual, 0, 3);

                Assert.Equal(3, hashSet.Count); //"Should be equal"
                HashSetTestSupport.HashSetContains(actual, expected);
            }

            public static void UnionWith_Test61()
            {
                HashSet<ValueItem> hashSet;
                IEnumerable<ValueItem> other;
                ValueItem item1 = new ValueItem(34, -5);
                ValueItem item2 = new ValueItem(4, 4);
                ValueItem item3 = new ValueItem(9999, -2);
                ValueItem item4 = new ValueItem(99, -2);

                SetCollectionDuplicateItemTests.SetupTest4(out hashSet, out other);
                hashSet.UnionWith(other);

                HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { item1, item2, item3, item4 }, hashSet.Comparer);
            }

        public static void Contains_Test20()
        {
            HashSet<HashSet<IEnumerable>> hashSet;
            HashSet<IEnumerable> item;
            ValueItem itemn4 = new ValueItem(-4, -4);
            ValueItem itemn3 = new ValueItem(-3, -3);
            ValueItem itemn2 = new ValueItem(-2, -2);
            ValueItem itemn1 = new ValueItem(-1, -1);
            ValueItem item1 = new ValueItem(1, 1);
            ValueItem item2 = new ValueItem(2, 2);
            ValueItem item3 = new ValueItem(3, 3);
            ValueItem item4 = new ValueItem(4, 4);
            HashSet<IEnumerable> itemhs1 = new HashSet<IEnumerable>(new ValueItem[] { item1, item2, item3, item4 });
            HashSet<IEnumerable> itemhs2 = new HashSet<IEnumerable>(new ValueItem[] { itemn1, itemn2, itemn3, itemn4 });

            SetItemComparerTests.SetupTest5(out hashSet, out item);
            bool contains = hashSet.Contains(item);
            Assert.True(contains); //"Error: Contains returned wrong value"

            HashSet<IEnumerable>[] expected = new HashSet<IEnumerable>[] { itemhs1, itemhs2, item };
            HashSet<IEnumerable>[] actual = new HashSet<IEnumerable>[3];
            hashSet.CopyTo(actual, 0, 3);

            Assert.Equal(3, hashSet.Count); //"Should be equal."
            HashSetTestSupport.HashSetContains(actual, expected);
        }

            public static void UnionWith_Test46()
            {
                HashSet<ValueItem> hashSet;
                IEnumerable<ValueItem> other;
                ValueItem item1 = new ValueItem(340, -5);
                ValueItem item2 = new ValueItem(4, 4);
                ValueItem item3 = new ValueItem(9999, -2);
                ValueItem itemo1 = new ValueItem(134, -15);
                ValueItem itemo2 = new ValueItem(14, 14);
                ValueItem itemo3 = new ValueItem(19999, -12);

                SetCollectionComparerTests.SetupTest4(out hashSet, out other);
                hashSet.UnionWith(other);

                HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { item1, item2, item3, itemo1, itemo2, itemo3 }, hashSet.Comparer);
            }