public void generic_iEqualityComparer_equals_with_null_and_instance()
{
var instance = new ReferenceEqualityComparer<GenericParameterHelper>();
var y = new GenericParameterHelper();
bool actual = instance.Equals( null, y );
actual.Should().Be.False();
}
public void advisedAction_ctor()
{
GenericParameterHelper target = new GenericParameterHelper();
AdvisedAction actual = new AdvisedAction( target, ProposedActions.Delete );
actual.Action.Should().Be.EqualTo( ProposedActions.Delete );
actual.Target.Should().Be.EqualTo( target );
}
public void itemChangedDescriptor_ctor_normal_should_set_expected_values()
{
var item = new GenericParameterHelper();
var index = 10;
var target = new ItemChangedDescriptor<GenericParameterHelper>( item, index );
target.Index.Should().Be.EqualTo( index );
target.Item.Should().Be.EqualTo( item );
}
public void addingNewEventArgs_ctor_normal_should_set_expected_values()
{
var expected = new GenericParameterHelper();
var target = new AddingNewEventArgs<GenericParameterHelper>();
target.NewItem = expected;
var actual = target.NewItem;
actual.Should().Be.EqualTo( expected );
target.Cancel.Should().Be.False();
}
public void generic_iEqualityComparer_getHashCode()
{
IEqualityComparer<GenericParameterHelper> instance = new ReferenceEqualityComparer<GenericParameterHelper>();
var obj = new GenericParameterHelper();
Int32 expected = obj.GetHashCode();
Int32 actual = instance.GetHashCode( obj );
actual.Should().Be.EqualTo( expected );
}
public void generic_iEqualityComparer_equals_with_equal_instances()
{
var instance = new ReferenceEqualityComparer<GenericParameterHelper>();
var x = new GenericParameterHelper();
var y = x;
bool actual = instance.Equals( x, y );
actual.Should().Be.True();
}
public void itemMovedDescriptor_ctor_normal_should_set_expected_values()
{
var item = new GenericParameterHelper();
var newIndex = 50;
var oldIndex = 2;
var target = new ItemMovedDescriptor<GenericParameterHelper>( item, newIndex, oldIndex );
target.Index.Should().Be.EqualTo( newIndex );
target.Item.Should().Be.EqualTo( item );
target.NewIndex.Should().Be.EqualTo( newIndex );
target.OldIndex.Should().Be.EqualTo( oldIndex );
}
public void itemReplacedDescriptor_ctor_normal_should_set_expected_values()
{
var newItem = new GenericParameterHelper();
var replacedItem = new GenericParameterHelper();
var index = 102;
var target = new ItemReplacedDescriptor<GenericParameterHelper>( newItem, replacedItem, index );
target.Index.Should().Be.EqualTo( index );
target.Item.Should().Be.EqualTo( newItem );
target.ReplacedItem.Should().Be.EqualTo( replacedItem );
target.NewItem.Should().Be.EqualTo( newItem );
}
public void entityItemViewFilterBase_interface_shouldInclude_using_valid_entity_should_call_abstract_implementation()
{
var expected = new GenericParameterHelper();
MockRepository mocks = new MockRepository();
var filter = mocks.PartialMock<EntityItemViewFilterBase<GenericParameterHelper>>();
filter.Expect( obj => obj.ShouldInclude( expected ) )
.Return( true )
.Repeat.Once();
filter.Replay();
var target = ( IEntityItemViewFilter )filter;
target.ShouldInclude( expected );
filter.VerifyAllExpectations();
}
/// <summary>
/// Do the value comparison for two GenericParameterHelper object
/// </summary>
/// <param name="obj">object to do comparison with</param>
/// <returns>true if obj has the same value as 'this' GenericParameterHelper object.
/// false otherwise.</returns>
public override bool Equals(object obj)
{
GenericParameterHelper other = obj as GenericParameterHelper;
return(this.Data == other?.Data);
}
/// <summary>
/// Returns a GenericParameterHelper object that is equal to
/// 'this' one.
/// </summary>
/// <returns></returns>
public object Clone()
{
GenericParameterHelper clone = new GenericParameterHelper();
clone.m_data = this.m_data;
return clone;
}
public void TestEqual()
{
GenericParameterHelper value = new GenericParameterHelper();
TextValuePair<GenericParameterHelper> pair1 =
new TextValuePair<GenericParameterHelper>();
TextValuePair<GenericParameterHelper> pair2 =
new TextValuePair<GenericParameterHelper>();
Assert.IsTrue(pair1.Equals(pair2));
Assert.IsTrue(pair1 == pair2);
Assert.IsFalse(pair1 != pair2);
pair1.Text = "1";
Assert.IsFalse(pair1.Equals(pair2));
Assert.IsFalse(pair1 == pair2);
Assert.IsTrue(pair1 != pair2);
pair2.Text = "12".Substring(0, 1);
Assert.IsTrue(pair1.Equals(pair2));
Assert.IsTrue(pair1 == pair2);
Assert.IsFalse(pair1 != pair2);
pair1.Value = value;
Assert.IsFalse(pair1.Equals(pair2));
Assert.IsFalse(pair1 == pair2);
Assert.IsTrue(pair1 != pair2);
pair2.Value = value;
Assert.IsTrue(pair1.Equals(pair2));
Assert.IsTrue(pair1 == pair2);
Assert.IsFalse(pair1 != pair2);
}
public void TestEditableObjectValue()
{
GenericParameterHelper para1 = new GenericParameterHelper(1);
GenericParameterHelper para2 = new GenericParameterHelper(2);
TextValuePair<GenericParameterHelper> target =
new TextValuePair<GenericParameterHelper>("", para1);
IEditableObject obj = (IEditableObject)target;
bool changing = false;
bool changed = false;
bool error = false;
target.PropertyChanging += (sender, e) =>
{
if (e.PropertyName == "Value")
{
changing = true;
if (target.Value != para1)
{
error = true;
}
}
};
target.PropertyChanged += (sender, e) =>
{
if (changing && e.PropertyName == "Value")
{
changed = true;
if (target.Value != para2)
{
error = true;
}
}
};
// Test Value
obj.BeginEdit();
target.Value = para2;
Assert.IsFalse(error);
Assert.IsFalse(changing);
Assert.IsFalse(changed);
obj.CancelEdit();
Assert.AreEqual(target.Value, para1);
Assert.IsFalse(error);
Assert.IsFalse(changing);
Assert.IsFalse(changed);
obj.EndEdit();
Assert.AreEqual(target.Value, para1);
Assert.IsFalse(error);
Assert.IsFalse(changing);
Assert.IsFalse(changed);
obj.CancelEdit();
Assert.AreEqual(target.Value, para1);
Assert.IsFalse(error);
Assert.IsFalse(changing);
Assert.IsFalse(changed);
obj.BeginEdit();
target.Value = para2;
obj.EndEdit();
Assert.AreEqual(target.Value, para2);
Assert.IsFalse(error);
Assert.IsTrue(changing);
Assert.IsTrue(changed);
changing = false;
changed = false;
obj.CancelEdit();
Assert.AreEqual(target.Value, para2);
Assert.IsFalse(error);
Assert.IsFalse(changing);
Assert.IsFalse(changed);
// Test Value without change
changing = changed = error = false;
obj.BeginEdit();
target.Value = para2;
obj.EndEdit();
Assert.IsFalse(error);
Assert.IsFalse(changing);
Assert.IsFalse(changed);
}
public void iEqualityComparer_equals_with_instance_and_null()
{
IEqualityComparer instance = new ReferenceEqualityComparer<GenericParameterHelper>();
var x = new GenericParameterHelper();
bool actual = instance.Equals( x, null );
actual.Should().Be.False();
}
public void entityItemViewPropertyDescriptor_setValue_using_default_ctor_should_set_expected_value()
{
var expected = 100;
var entityItem = new GenericParameterHelper( 0 );
var component = MockRepository.GenerateMock<IEntityItemView<GenericParameterHelper>>();
component.Expect( mock => mock.EntityItem )
.Return( entityItem )
.Repeat.Once();
var target = new EntityItemViewPropertyDescriptor<GenericParameterHelper>( "Data" );
target.SetValue( component, expected );
entityItem.Data.Should().Be.EqualTo( expected );
component.VerifyAllExpectations();
}
public void TestValueEvent()
{
GenericParameterHelper para = new GenericParameterHelper();
TextValuePair<GenericParameterHelper> target =
new TextValuePair<GenericParameterHelper>("AA", null);
bool changing = false;
bool changed = false;
bool error = false;
target.PropertyChanging += (sender, e) =>
{
if (e.PropertyName == "Value")
{
changing = true;
if (target.Value != null)
{
error = true;
}
}
};
target.PropertyChanged += (sender, e) =>
{
if (changing && e.PropertyName == "Value")
{
changed = true;
if (target.Value != para)
{
error = true;
}
}
};
target.Value = para;
Assert.IsFalse(error);
Assert.IsTrue(changing);
Assert.IsTrue(changed);
}
public void ObservableDictionaryItemTest()
{
ObservableDictionary<GenericParameterHelper, GenericParameterHelper> target = new ObservableDictionary<GenericParameterHelper, GenericParameterHelper>();
GenericParameterHelper itemKey = new GenericParameterHelper(1);
GenericParameterHelper itemValue = new GenericParameterHelper(1);
Assert.AreEqual(0, target.Count);
target[itemKey] = itemValue;
Assert.AreEqual(1, target.Count);
GenericParameterHelper expected, actual;
expected = itemValue;
actual = target[itemKey];
Assert.AreEqual(expected, actual);
}
