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);
}
