public override void Validate(ObjectType Object)
{
GenericEqualityComparer <DataType> Comparer = new GenericEqualityComparer <DataType>();
foreach (DataType Item in ItemToValidate(Object))
{
if (Comparer.Equals(Item, Value))
{
return;
}
}
throw new NotValid(ErrorMessage);
}
public void ShouldReturnFalseIfObjectsDifferentImplementIEquatableAndComparingOnObject()
{
// Arrange
var first = new TestEqualityObject {
Name = "Hello, World", Count = 10
};
var second = new TestEqualityObject {
Name = "World, Hello", Count = 5
};
var comparer = new GenericEqualityComparer <TestEqualityObject>(o => o);
// Act
bool areEqual = comparer.Equals(first, second);
// Assert
areEqual.ShouldBeFalse();
}
public void ShouldReturnFalseIfObjectsDifferentAndComparingOnPropertyWithDifferentValue()
{
// Arrange
var first = new TestObject {
Name = "Hello, World", Count = 10
};
var second = new TestObject {
Name = "World, Hello", Count = 5
};
var comparer = new GenericEqualityComparer <TestObject>(o => o.Name);
// Act
bool areEqual = comparer.Equals(first, second);
// Assert
areEqual.ShouldBeFalse();
}
/// <summary>
/// Determines if the buffer contains the item
/// </summary>
/// <param name="item">Item to check</param>
/// <returns>True if the item is present, false otherwise</returns>
public virtual bool Contains(T item)
{
int y = ReadPosition;
GenericEqualityComparer <T> Comparer = new GenericEqualityComparer <T>();
for (int x = 0; x < Count; ++x)
{
if (Comparer.Equals(Buffer[y], item))
{
return(true);
}
++y;
if (y >= MaxCapacity)
{
y = 0;
}
}
return(false);
}
public void ShouldReturnTrueIfObjectsSameReferenceAndComparingOnObject()
{
// Arrange
string objectName = "Hello, World!";
int objectCount = 10;
var first = new TestObject {
Name = objectName, Count = objectCount
};
TestObject second = first;
var comparer = new GenericEqualityComparer <TestObject>(o => o);
// Act
bool areEqual = comparer.Equals(first, second);
// Assert
areEqual.ShouldBeTrue();
}
/// <summary>
/// Removes an item from the buffer
/// </summary>
/// <param name="item">Item to remove</param>
/// <returns>True if it is removed, false otherwise</returns>
public virtual bool Remove(T item)
{
int y = ReadPosition;
var Comparer = new GenericEqualityComparer <T>();
for (int x = 0; x < Count; ++x)
{
if (Comparer.Equals(Buffer[y], item))
{
Buffer[y] = default(T);
return(true);
}
++y;
if (y >= MaxCapacity)
{
y = 0;
}
}
return(false);
}
public void ShouldReturnTrueIfObjectsSimilarAndComparingOnPropertyWithSameValue()
{
// Arrange
string objectName = "Hello, World!";
int objectCount = 10;
var first = new TestObject {
Name = objectName, Count = objectCount
};
var second = new TestObject {
Name = objectName, Count = objectCount
};
var comparer = new GenericEqualityComparer <TestObject>(o => o.Name);
// Act
bool areEqual = comparer.Equals(first, second);
// Assert
areEqual.ShouldBeTrue();
}
/// <summary>
/// Determines if the property is valid
/// </summary>
/// <param name="value">Value to check</param>
/// <param name="validationContext">Validation context</param>
/// <returns>The validation result</returns>
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (value == null)
{
return(ValidationResult.Success);
}
var Comparer = new GenericEqualityComparer <IComparable>();
var ValueList = value as IEnumerable;
IComparable ValueTemp = 0;
foreach (IComparable Item in ValueList)
{
ValueTemp = (IComparable)Value.To <object>(Item.GetType());
break;
}
foreach (IComparable Item in ValueList)
{
if (Comparer.Equals(Item, ValueTemp))
{
return(new ValidationResult(FormatErrorMessage(validationContext.DisplayName)));
}
}
return(ValidationResult.Success);
}
/// <summary>
/// Saves the object to the source
/// </summary>
/// <typeparam name="PrimaryKeyType">Primary key type</typeparam>
/// <param name="Object">Object to save</param>
public IBatch Save <PrimaryKeyType>(T Object)
{
var TempBatch = QueryProvider.Batch(Source);
IProperty <T> IDProperty = ((IProperty <T>)Mapping.IDProperties.FirstOrDefault());
var IDValue = IDProperty.GetValue(Object).To(default(PrimaryKeyType));
var Comparer = new GenericEqualityComparer <PrimaryKeyType>();
IParameter Param1 = null;
if (Comparer.Equals(IDValue, default(PrimaryKeyType)))
{
return(TempBatch.AddCommand(Insert(Object)));
}
if (IDProperty.AutoIncrement)
{
return(TempBatch.AddCommand(Update(Object)));
}
Param1 = typeof(PrimaryKeyType).Is(typeof(string)) ? (IParameter) new StringEqualParameter(IDValue.ToString(), IDProperty.FieldName, IDValue.ToString().Length, IDProperty.FieldName, Source.ParameterPrefix) : (IParameter) new EqualParameter <PrimaryKeyType>(IDValue, IDProperty.FieldName, IDProperty.FieldName, Source.ParameterPrefix);
if (Any(Param1).Execute()[0].Count == 0)
{
return(TempBatch.AddCommand(Insert(Object)));
}
return(TempBatch.AddCommand(Update(Object)));
}
/// <summary>
/// Saves (inserts/updates) an object based on the following criteria:
/// 1) If autoincrement is set to true and the primary key is the default value, it inserts
/// 2) If autoincrement is set to true and the primary key is not the default value, it updates
/// 3) If autoincrement is set to false and the primary key is the default value, it inserts
/// 4) If autoincrement is set to false and the primary key is not the default value,
/// it does an Any call to see if the item is already in the database. If it is, it does an
/// update. Otherwise it does an insert.
/// On an insert, the primary key property is updated with the resulting value of the insert.
/// </summary>
/// <param name="Object">Object to save</param>
/// <param name="Parameters">Extra parameters to be added to the insert/update function</param>
public virtual void Save <PrimaryKeyType>(ClassType Object, params IParameter[] Parameters)
{
PrimaryKeyType PrimaryKeyVal = GetPrimaryKey(Object).TryTo(default(PrimaryKeyType));
GenericEqualityComparer <PrimaryKeyType> Comparer = new GenericEqualityComparer <PrimaryKeyType>();
if (Comparer.Equals(PrimaryKeyVal, default(PrimaryKeyType)))
{
PrimaryKeyVal = Insert <PrimaryKeyType>(Object, Parameters);
PrimaryKeyMapping.CopyRightToLeft(PrimaryKeyVal, Object);
return;
}
if (AutoIncrement)
{
Update(Object, Parameters);
return;
}
IParameter Param1 = null;
if (typeof(PrimaryKeyType).IsOfType(typeof(string)))
{
Param1 = new StringEqualParameter(PrimaryKeyVal.ToString(), PrimaryKey, -1, ParameterStarter);
}
else
{
Param1 = new EqualParameter <PrimaryKeyType>(PrimaryKeyVal, PrimaryKey, ParameterStarter);
}
ClassType TempVal = Any(PrimaryKey, null, null, Param1);
if (TempVal == null)
{
PrimaryKeyVal = Insert <PrimaryKeyType>(Object, Parameters);
PrimaryKeyMapping.CopyRightToLeft(PrimaryKeyVal, Object);
return;
}
Update(Object, Parameters);
}
public void EqualsWithSubModelsReturnsExpectedResult(SubModel x, SubModel y, bool expected)
{
var sut = new GenericEqualityComparer<SubModel>();
Assert.Equal(expected, sut.Equals(x, y));
}
public void EqualsWithStringsReturnsExpectedResult(string x, string y, bool expected)
{
var sut = new GenericEqualityComparer<string>();
Assert.Equal(expected, sut.Equals(x, y));
}
public void EqualsWithListsReturnsExpectedResult(List<int> x, List<int> y, bool expected)
{
var sut = new GenericEqualityComparer<List<int>>();
Assert.Equal(expected, sut.Equals(x, y));
}
public void EqualsWithIntsReturnsExpectedResult(int x, int y, bool expected)
{
var sut = new GenericEqualityComparer<int>();
Assert.Equal(expected, sut.Equals(x, y));
}
public void EqualsWithEnumsReturnsExpectedResult(Enum x, Enum y, bool expected)
{
var sut = new GenericEqualityComparer<Enum>();
Assert.Equal(expected, sut.Equals(x, y));
}
public void Equals_SameProperties_ExpectTrue()
{
var t1 = new TestObject()
{
Id = 1, Name = "Test", InnerObject = new InnerObject {
Amount = 2, Customer = "Customer"
}, Array = new [] { 1, 2, 2 }
};
var t2 = new TestObject()
{
Id = 1, Name = "Test", InnerObject = new InnerObject {
Amount = 2, Customer = "Customer"
}, Array = new[] { 1, 2, 2 }
};
var result = _equalityComparer.Equals(t1, t2);
Assert.IsTrue(result);
}
/// <summary>
/// Determines if the objects are equal
/// </summary>
/// <param name="obj">Object to compare to</param>
/// <returns>Determines if the commands are equal</returns>
public override bool Equals(object obj)
{
Command OtherCommand = obj as Command;
if (OtherCommand == null)
return false;
if (OtherCommand.SQLCommand != SQLCommand
|| OtherCommand.CommandType != CommandType
|| Parameters.Count != OtherCommand.Parameters.Count)
return false;
GenericEqualityComparer<object> Comparer = new GenericEqualityComparer<object>();
for (int x = 0; x < Parameters.Count; ++x)
{
if (!Comparer.Equals(Parameters[x], OtherCommand.Parameters[x]))
return false;
}
return true;
}
/// <summary>
/// Determines if the property is valid
/// </summary>
/// <param name="value">Value to check</param>
/// <param name="validationContext">Validation context</param>
/// <returns>The validation result</returns>
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (value==null)
return ValidationResult.Success;
GenericEqualityComparer<IComparable> Comparer = new GenericEqualityComparer<IComparable>();
IEnumerable ValueList = value as IEnumerable;
IComparable ValueTemp = 0;
foreach (IComparable Item in ValueList)
{
ValueTemp = (IComparable)Value.To<object>(Item.GetType());
break;
}
foreach (IComparable Item in ValueList)
{
if (Comparer.Equals(Item, ValueTemp))
return new ValidationResult(FormatErrorMessage(validationContext.DisplayName));
}
return ValidationResult.Success;
}
public void EqualsWithEnumerableSubModelsReturnsExpectedResult(
IEnumerable<SubModel> x, IEnumerable<SubModel> y, bool expected)
{
var sut = new GenericEqualityComparer<IEnumerable<SubModel>>();
Assert.Equal(expected, sut.Equals(x, y));
}
