public void GetValuesWithKey(string key, int value) { var response = new HttpResponseMessage(HttpStatusCode.NotImplemented); "Given an item is in the database" .x(async() => { var item = new ValueItem(key, value); await factory.RespawnDbContext(); await factory.ExecuteDbContextAsync(async context => { await context.ValueItems.AddAsync(item); await context.SaveChangesAsync(); }); }); "When we ask for that item through the API" .x(async() => { response = await client.GetAsync($"api/v1.0/values/{key}"); }); "Then the item is returned with the right information" .x(async() => { response.EnsureSuccessStatusCode(); var json = await response.Content.ReadAsStringAsync(); var result = JsonConvert.DeserializeObject <ValueItem>(json); result.Key.Should().Be(key); result.Value.Should().Be(value); }); }
public void ValueShouldReturnSameReference() { object obj = new object(); Scalar <object> scalar = new ValueItem <object>(obj); scalar.Value().Should().Be(obj); }
private Style GetRoadStyle() { ValueStyle valueStyle = new ValueStyle(); valueStyle.ColumnName = "CFCC"; LineStyle highwayStyle = new LineStyle(new GeoPen(GeoColor.FromHtml("#b8ac9c"), 7), new GeoPen(GeoColor.FromHtml("#f9de4d"), 5)); ValueItem highwayItem1 = new ValueItem("A11", highwayStyle); ValueItem highwayItem2 = new ValueItem("A21", highwayStyle); ValueItem highwayItem3 = new ValueItem("A25", highwayStyle); ValueItem highwayItem4 = new ValueItem("A31", highwayStyle); ValueItem highwayItem5 = new ValueItem("A35", highwayStyle); LineStyle localroadStyle = new LineStyle(new GeoPen(GeoColor.FromHtml("#b8ac9c"), 5), new GeoPen(GeoColor.StandardColors.White, 3)); ValueItem localroadItem1 = new ValueItem("A41", localroadStyle); ValueItem localroadItem2 = new ValueItem("A51", localroadStyle); ValueItem localroadItem3 = new ValueItem("A63", localroadStyle); ValueItem localroadItem4 = new ValueItem("A64", localroadStyle); ValueItem localroadItem5 = new ValueItem("A74", localroadStyle); ValueItem unknownItem = new ValueItem("P41", localroadStyle); valueStyle.ValueItems.Add(highwayItem1); valueStyle.ValueItems.Add(highwayItem2); valueStyle.ValueItems.Add(highwayItem3); valueStyle.ValueItems.Add(highwayItem4); valueStyle.ValueItems.Add(highwayItem5); valueStyle.ValueItems.Add(localroadItem1); valueStyle.ValueItems.Add(localroadItem2); valueStyle.ValueItems.Add(localroadItem3); valueStyle.ValueItems.Add(localroadItem4); valueStyle.ValueItems.Add(localroadItem5); valueStyle.ValueItems.Add(unknownItem); return(valueStyle); }
protected void ValueItemLabel(string keyField) { ValueItem item = GetValueItem(keyField); string input = item != default ? item.Value : string.Empty; EditorGUILayout.LabelField(input); }
public async Task <IActionResult> Post(ValueItem item) { var request = new CreateValueItemRequest(item.Key, item.Value); var valueItem = await mediator.Send(request); return(Ok(valueItem)); }
private void ParseValueItem(ValuesBunch valueItems, string type, IXLCell currentValueCell, ref int lastRowNum) { while (currentValueCell.IsEmpty() == false) { if (DateTime.TryParse(currentValueCell.CachedValue.ToString(), out var d)) { return; } if (decimal.TryParse(currentValueCell.CachedValue?.ToString(), out var num)) { try { var value = new ValueItem(num, new StatEnumItem(type)); valueItems.Add(value); } catch { continue; } } lastRowNum = Math.Max(lastRowNum, currentValueCell.Address.RowNumber); currentValueCell = currentValueCell.CellBelow(); } }
public void SaveValueItem(ValueItem it) { string msg = ""; try { if (string.IsNullOrEmpty(it.Text)) { it.Text = it.Value; } if (string.IsNullOrEmpty(it.Value)) { it.Value = it.Text; } List <string> rst = ValidateItem(it); if (rst != null) { msg = string.Join(",", rst); throw new Exception("修改值集项目失败" + msg + "!"); } db.Save(it); } catch (Exception e) { throw e; } }
//Test 16: set contains duplicate items by default comparer, those items not in other public static void SetupTest16(out HashSet <ValueItem> set, out IEnumerable <ValueItem> other) { List <ValueItem> list = new List <ValueItem>(); ValueItem itemo1 = new ValueItem(34, -5); ValueItem itemo2 = new ValueItem(4, 4); ValueItem itemo3 = new ValueItem(9999, -12); ValueItem itemo4 = new ValueItem(99, 12); ValueItem items1 = new ValueItem(-34, 5); ValueItem items2 = new ValueItem(-99, -4); ValueItem items3 = new ValueItem(-34, 2); ValueItem items4 = new ValueItem(-99, -2); list.Add(itemo1); list.Add(itemo2); list.Add(itemo3); list.Add(itemo4); set = new HashSet <ValueItem>(new ValueItemYEqualityComparer()); set.Add(items1); set.Add(items2); set.Add(items3); set.Add(items4); other = list; }
private async Task <int> AnalyzeFile(ValueItem file, int changesetId) { int resultNumber = 0; if (!file.ChangeType.Contains("delete")) { // 2.3 - Sortir les différences FileComparerResult diffResult = await _vcc.CompareChangesetFile(file.Item.Path, "P" + changesetId, changesetId.ToString()).ConfigureAwait(false); if (diffResult.Blocks.Count == 1) { //c'est le premier ajout sur le silo resultNumber += diffResult.Blocks[0].ModifiedLinesCount; } else { // 2.4 - Pour chaque différence foreach (Block block in diffResult.Blocks) { resultNumber += BlockRule.GetBlockModifiedLinesCount(block); } } } return(resultNumber); }
/// <summary> /// Sets the nodes in the control. /// </summary> public void Initialize( Session session, WriteValueCollection values, List <ServiceResult> results) { if (session == null) { throw new ArgumentNullException("session"); } Clear(); m_session = session; if (values != null) { for (int ii = 0; ii < values.Count; ii++) { ValueItem item = new ValueItem(); item.Node = m_session.NodeCache.Find(values[ii].NodeId) as Node; item.AttributeId = values[ii].AttributeId; item.Value = values[ii].Value; if (results != null && ii < results.Count) { item.Result = results[ii]; } AddItem(item, "DataType", -1); } } AdjustColumns(); }
public PropertyItem(AMemberItem parent, XElement element) : base(parent, element) { XElement valueElement = element.GetValue(); Value = valueElement != null ? new ValueItem(this, valueElement) : null; }
public void Start(Animator animator, params ValueItem[] paramConfs) { HasCompleted = false; AnimatorTarget = animator; if (AnimatorTarget == default) { return; } Frame = 0; mParamsNew = paramConfs; int max = mParamsNew.Length; for (int i = 0; i < max; i++) { ValueItem item = mParamsNew[i]; if (item.DampTime > 0f) { mParamDamp.Add(item); } else { mParamSet.Add(item); } } RefreshParams(ref mParamSet); Length = StateInfo.normalizedTime; }
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(); }
private ValueItem GetValueItem(string columnValue) { ValueItem result = null; string value = columnValue; if (columnValue.Contains("||")) { int index = columnValue.IndexOf("||"); value = columnValue.Substring(0, index); } foreach (ValueItem valueItem in ValueItems) { if (string.Compare(value, valueItem.Value, StringComparison.OrdinalIgnoreCase) == 0) { result = valueItem; break; } } if (result == null) { result = new ValueItem(); } return(result); }
public ValueItem GetValue() { ValueItem result; switch (valueType) { case ValueItem.STRING: result = GetString(); break; case ValueItem.INT: result = GetInt(); break; case ValueItem.DOUBLE: result = GetDouble(); break; case ValueItem.BOOL: result = GetBool(); break; case ValueItem.FLOAT: result = GetFloat(); break; default: result = ValueItem.New(keyField, string.Empty); break; } return(result); }
public static void ICollectionAdd_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); ((ICollection <HashSet <IEnumerable> >)hashSet).Add(item); 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); //"Expect them to be equal." HashSetTestSupport.HashSetContains(actual, expected); }
public void ValueItem_GetValue() { var item = new ValueItem(); item.SetValue("value"); Assert.AreEqual(item.GetValue(), "value"); }
public static void HashSet_Remove_T_Comparer_SetHasItem() { 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> set = new HashSet <IEnumerable>(); HashSet <HashSet <IEnumerable> > outerSet = new HashSet <HashSet <IEnumerable> >(new SetEqualityComparer <IEnumerable>()); set.Add(outerSet); outerSet.Add(itemhs1); outerSet.Add(itemhs2); outerSet.Add(set); bool removed = outerSet.Remove(set); Assert.True(removed); //"Error: Remove returned wrong value" HashSet <IEnumerable>[] expected = new HashSet <IEnumerable>[] { itemhs1, itemhs2 }; HashSet <IEnumerable>[] actual = new HashSet <IEnumerable> [2]; outerSet.CopyTo(actual, 0, 2); Assert.Equal(2, outerSet.Count); //"Expect it to be the same." HashSetTestSupport.HashSetContains(actual, expected); }
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); }
private void AddProperties(Type t, HashSet <string> existingProperties, ISerializeContext ctx) { foreach (var prop in t.GetProperties(BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.Public)) { if (existingProperties.Contains(prop.Name)) { continue; } if (prop.GetIndexParameters().Length > 0) { // ignore index properties continue; } if (!prop.CanRead || !prop.CanWrite) { continue; } if (prop.PropertyType.Equals(type)) { // ignore same nested types because of recursive endless loop continue; } IValueItem item = ValueItem.CreateValueItem(prop, ctx); items.Add(item); existingProperties.Add(prop.Name); } }
public void Reset(bool revertCombo) { if (revertCombo) { CurrentCombo = 0; } Animator animator = AniUpdater.AnimatorTarget; int max = MotionTriggerParam.Length; for (int i = 0; i < max; i++) { mValueItem = MotionTriggerParam[i]; if (!string.IsNullOrEmpty(mValueItem.KeyField)) { animator?.SetBool(mValueItem.KeyField, !mValueItem.Bool); } } string keyField = mValueItemForRevert.KeyField; if (mValueItemForRevert.IsInt) { animator?.SetInteger(keyField, mValueItemForRevert.Int); } else if (mValueItemForRevert.IsFloat) { animator?.SetFloat(keyField, mValueItemForRevert.Float); } Stop(); }
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); } }
public void StartComboMotion(ref Animator animator) { if (CurrentCombo == 0) { int max = MotionTriggerParam.Length; for (int i = 0; i < max; i++) { mValueItem = MotionTriggerParam[i]; if (!string.IsNullOrEmpty(mValueItem.KeyField)) { animator.SetBool(mValueItem.KeyField, mValueItem.Bool); } } if (MotionTransParam.Length > 0) { var item = MotionTransParam[0]; string keyField = item.KeyField; mValueItemForRevert.KeyField = keyField; if (item.IsInt) { mValueItemForRevert.Int = animator.GetInteger(keyField); } else if (item.IsFloat) { mValueItemForRevert.Float = animator.GetFloat(keyField); } } } CreateCombo(ref animator, true); }
void SerializeItem(ValueItem item) { _serializer.StartSerialize("Item"); SerializeOptionalProperty("Index", item.Index); SerializeOptionalProperty("ValueExpr", item.ValueExpr); _serializer.EndSerialize(); }
public static void HashSet_Add_T_Comparer_SetHasItem() { 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> set = new HashSet <IEnumerable>(); HashSet <HashSet <IEnumerable> > outerSet = new HashSet <HashSet <IEnumerable> >(new SetEqualityComparer <IEnumerable>()); set.Add(outerSet); outerSet.Add(itemhs1); outerSet.Add(itemhs2); outerSet.Add(set); HashSet <IEnumerable> item = set; bool added = outerSet.Add(item); Assert.False(added); //"Error: Add returned wrong value" HashSet <IEnumerable>[] expected = new HashSet <IEnumerable>[] { itemhs1, itemhs2, item }; HashSet <IEnumerable>[] actual = new HashSet <IEnumerable> [3]; outerSet.CopyTo(actual, 0, 3); Assert.Equal(3, outerSet.Count); //"Should be the same." HashSetTestSupport.HashSetContains(actual, expected); }
static void InitDefault(Database db) { if (db == null) { throw new ArgumentNullException("Database"); } var catId = db.Create(Category.Create("Favorites")); if (catId >= 0) { var catItemId = db.Create(CategoryItem.Create(catId, "Github")); if (catItemId > 0) { db.Create(ValueItem.Create(catItemId, 0, SecValueType.Url, "https://github.com")); db.Create(ValueItem.Create(catItemId, 1, SecValueType.Username, "My Username")); db.Create(ValueItem.Create(catItemId, 2, SecValueType.Password, "My Password")); } catItemId = db.Create(CategoryItem.Create(catId, "Emailaccount")); if (catItemId > 0) { db.Create(ValueItem.Create(catItemId, 0, SecValueType.Url, "https://somewhere.com")); db.Create(ValueItem.Create(catItemId, 1, SecValueType.Username, "My Username")); db.Create(ValueItem.Create(catItemId, 2, SecValueType.Password, "My Password")); } } }
private static ArrayItemExpression ToArrayItemValueExpression(ValueItem e) { return(new ArrayItemValueExpression( key: Parse(e.Index), value: Parse(e.ValueExpr) )); }
public void Test_TLValue_Definition_OK() { TLValue expected = new TLValue(); expected.Name = "ola testing ah"; expected.Value = "11223355"; expected.Length = expected.Value.Length / 2; expected.Tag = "0A"; XElement XE = new XElement("TLValue"); XE.Add(new XAttribute("Length", expected.Length.ToString())); XE.Add(new XAttribute("Default", expected.Value)); XE.Add(new XAttribute("Name", expected.Name)); XE.Add(new XAttribute("Tag", expected.Tag)); ValueItem result = xmlParser.getItem(XE); Assert.IsInstanceOfType(result, typeof(TLValue)); TLValue res = (TLValue)result; Assert.AreEqual(expected.Value, res.Value); Assert.AreEqual(expected.Length, res.Length); Assert.AreEqual(expected.Name, res.Name); Assert.AreEqual(expected.Tag, res.Tag); }
public static void IsExceptWith_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 <HashSet <IEnumerable> > hashSet; IEnumerable <HashSet <IEnumerable> > other; SetCollectionComparerTests.SetupTest10(out hashSet, out other); hashSet.ExceptWith(other); HashSet <IEnumerable>[] expected = new HashSet <IEnumerable>[] { itemhs1, itemhs2 }; HashSet <IEnumerable>[] actual = new HashSet <IEnumerable> [2]; hashSet.CopyTo(actual, 0, 2); Assert.Equal(2, hashSet.Count); //"Should be equal" HashSetTestSupport.HashSetContains(actual, expected); }
/// <summary> /// Set cache item. If value already exist, remove it and add the new one /// </summary> /// <param name="key">key</param> /// <param name="value">value</param> /// <returns>this</returns> public LruDictionary2 <TKey, TValue> Set(TKey key, TValue value) { lock (_lock) { _dict[key] = new ValueItem(value); return(this); } }
private ListBoxItem GetListBoxItem([NotNull] ItemTreeViewItem item) { Debug.ArgumentNotNull(item, nameof(item)); var valueItem = new ValueItem(item.Text, item.ItemUri.ItemId.ToString()); return(GetListBoxItem(valueItem)); }
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; }
//Test 4 // item same as element in set by sets comparer, different by default comparer - set does not contain item that is equal by default comparer public static void SetupTest4(out HashSet<ValueItem> set, out ValueItem item) { ValueItem item1 = new ValueItem(340, -5); ValueItem item2 = new ValueItem(4, 4); ValueItem item3 = new ValueItem(9999, -2); set = new HashSet<ValueItem>(new ValueItemYEqualityComparer()); set.Add(item1); set.Add(item2); set.Add(item3); item = new ValueItem(34, -2); }
/// <summary> /// Sets the nodes in the control. /// </summary> public void Initialize( Session session, ReadValueIdCollection valueIds, DataValueCollection values, List<ServiceResult> results) { if (session == null) throw new ArgumentNullException("session"); Clear(); m_session = session; if (valueIds != null) { for (int ii = 0; ii < valueIds.Count; ii++) { ValueItem item = new ValueItem(); item.Node = m_session.NodeCache.Find(valueIds[ii].NodeId) as Node; item.AttributeId = valueIds[ii].AttributeId; if (values != null && ii < values.Count) { item.Value = values[ii]; } if (results != null && ii < results.Count) { item.Result = results[ii]; } AddItem(item, "DataType", -1); } } AdjustColumns(); }
//Test 5 // item contains set and item in set with GetSetComparer<T> as comparer public static void SetupTest5(out HashSet<HashSet<IEnumerable>> outerSet, out 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 }); HashSet<IEnumerable> set = new HashSet<IEnumerable>(); outerSet = new HashSet<HashSet<IEnumerable>>(new SetEqualityComparer<IEnumerable>()); set.Add(outerSet); outerSet.Add(itemhs1); outerSet.Add(itemhs2); outerSet.Add(set); item = set; }
public static void IsSupersetOf_Test57() { 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; bool ret; SetCollectionComparerTests.SetupTest15(out hashSet, out other); inneritem.Add(hashSet); ret = hashSet.IsSupersetOf(other); Assert.True(ret); //"Error: IsSupersetOf returned wrong value." 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); }
/* <line name="Condition" type="comboBox"> <item name="value1"> <caption lang="zh-CN">值1</caption> </item> <item name="value2"> <caption lang="zh-CN">值2</caption> </item> </line> * * */ List<ValueItem> GetValueItems(XmlElement parent) { List<ValueItem> results = new List<ValueItem>(); XmlNodeList items = parent.SelectNodes("item"); foreach (XmlNode item in items) { var element = item as XmlElement; ValueItem value = new ValueItem(); value.Name = element.GetAttribute("name"); value.Caption = DomUtil.GetCaption(this.Lang, element); results.Add(value); } return results; }
public static void IsExceptWith_Test59() { HashSet<ValueItem> hashSet; IEnumerable<ValueItem> other; ValueItem item5 = new ValueItem(101, 101); SetCollectionDuplicateItemTests.SetupTest2(out hashSet, out other); hashSet.ExceptWith(other); HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { item5 }, hashSet.Comparer); }
public static void IsSupersetOf_Test73() { HashSet<ValueItem> hashSet; IEnumerable<ValueItem> other; bool ret; ValueItem items1 = new ValueItem(-34, 5); ValueItem items2 = new ValueItem(-99, -4); ValueItem items3 = new ValueItem(-34, 2); ValueItem items4 = new ValueItem(-99, -2); SetCollectionDuplicateItemTests.SetupTest16(out hashSet, out other); ret = hashSet.IsSupersetOf(other); Assert.False(ret); //"Error: IsSupersetOf returned wrong value." HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { items1, items2, items3, items4 }, hashSet.Comparer); }
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 Overlaps_Test69() { HashSet<ValueItem> hashSet; IEnumerable<ValueItem> other; bool ret; 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.SetupTest12(out hashSet, out other); ret = hashSet.Overlaps(other); Assert.True(ret); //"Error: Overlaps returned wrong value." HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { items1, items2, items3, items4 }, 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); }
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); }
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 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(); }
//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 Overlaps_Test54() { HashSet<ValueItem> hashSet; IEnumerable<ValueItem> other; bool ret; ValueItem item1 = new ValueItem(34, -5); ValueItem item2 = new ValueItem(4, 4); ValueItem item3 = new ValueItem(9999, -20); SetCollectionComparerTests.SetupTest12(out hashSet, out other); ret = hashSet.Overlaps(other); Assert.False(ret); //"Error: Overlaps returned wrong value." HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { item1, item2, item3 }, hashSet.Comparer); }
public static void IsExceptWith_Test71() { HashSet<ValueItem> hashSet; IEnumerable<ValueItem> other; ValueItem items1 = new ValueItem(-34, 5); ValueItem items2 = new ValueItem(-99, -4); ValueItem items3 = new ValueItem(-34, 2); ValueItem items4 = new ValueItem(-99, -2); SetCollectionDuplicateItemTests.SetupTest14(out hashSet, out other); hashSet.ExceptWith(other); HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { items1, items2, items3, items4 }, hashSet.Comparer); }
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 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 IsIntersectWith_Test68() { HashSet<ValueItem> hashSet; IEnumerable<ValueItem> other; 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.SetupTest11(out hashSet, out other); hashSet.IntersectWith(other); HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { items1, items2, items3, items4, itemo1, itemo2, itemo3, itemo4 }, hashSet.Comparer); }
public static void IsSupersetOf_Test56() { HashSet<ValueItem> hashSet; IEnumerable<ValueItem> other; bool ret; ValueItem item1 = new ValueItem(340, -5); ValueItem item2 = new ValueItem(4, 4); ValueItem item3 = new ValueItem(9999, -2); SetCollectionComparerTests.SetupTest14(out hashSet, out other); ret = hashSet.IsSupersetOf(other); Assert.True(ret); //"Error: IsSupersetOf returned wrong value." HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { item1, item2, 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 IsSupersetOf_Test59() { HashSet<ValueItem> hashSet; IEnumerable<ValueItem> other; bool ret; ValueItem item5 = new ValueItem(101, 101); SetCollectionDuplicateItemTests.SetupTest2(out hashSet, out other); ret = hashSet.IsSupersetOf(other); Assert.False(ret); //"Error: IsSupersetOf returned wrong value." HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { item5 }, 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 IsSubsetOf_Test60() { HashSet<ValueItem> hashSet; IEnumerable<ValueItem> other; bool ret; ValueItem item3 = new ValueItem(9999, -2); SetCollectionDuplicateItemTests.SetupTest3(out hashSet, out other); ret = hashSet.IsSubsetOf(other); Assert.True(ret); //"Error: IsSubsetOf returned wrong value." HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { item3 }, hashSet.Comparer); }
public static void SetEquals_Test64() { HashSet<ValueItem> hashSet; IEnumerable<ValueItem> other; bool ret; ValueItem itemo3 = new ValueItem(9999, -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.SetupTest7(out hashSet, out other); ret = hashSet.SetEquals(other); Assert.False(ret); //"Error: SetEquals returned wrong value." HashSetTestSupport<ValueItem>.VerifyHashSet(hashSet, new ValueItem[] { items1, items2, items3, items4, itemo3 }, hashSet.Comparer); }