public void TestQueryOnUntypedField()
{
IList <ValueTypeHolder> holders = new List <ValueTypeHolder>(Flatten(ObjectsToStore()));
ValueTypeHolder greatest = holders[0];
ValueTypeHolder secondGreatest = holders[0];
foreach (ValueTypeHolder holder in holders)
{
IComparable actual = (IComparable)holder.Value;
if (actual.CompareTo(greatest.Value) > 0)
{
secondGreatest = greatest;
greatest = holder;
}
else if (actual.CompareTo(secondGreatest.Value) > 0)
{
secondGreatest = holder;
}
}
Assert.AreNotEqual(greatest, secondGreatest);
IQuery query = NewQuery(typeof(ValueTypeHolder));
query.Descend("UntypedValue").Constrain(secondGreatest.Value).Greater();
IObjectSet result = query.Execute();
Assert.AreEqual(1, result.Count);
Assert.AreEqual(greatest, result[0]);
}
protected ValueTypeHolder RetrieveHolderWithValue(T value)
{
IObjectSet result = RetrieveHoldersWith(value);
Assert.AreEqual(1, result.Count);
ValueTypeHolder actual = (ValueTypeHolder)result[0];
Assert.AreEqual(value, actual.Value);
return(actual);
}
public void TestIndexedQuery()
{
DiagnosticCollector <LoadedFromClassIndex> collector = DiagnosticCollectorFor <LoadedFromClassIndex>();
ValueTypeHolder expected = ObjectsToOperateOn()[0];
ValueTypeHolder actual = RetrieveHolderWithValue(expected.Value);
Assert.IsNotNull(actual);
Assert.AreEqual(expected, actual);
Assert.AreEqual(0, collector.Diagnostics.Count, WithTypeName("Query should go through {0} indexes"));
}
public void TestQueryByExample()
{
foreach (ValueTypeHolder tbf in ObjectsToOperateOn())
{
ValueTypeHolder holder = FindHolderWithValue(tbf.Value);
IObjectSet result = Db().QueryByExample(holder);
Assert.AreEqual(1, result.Count);
ValueTypeHolder found = (ValueTypeHolder)result[0];
AssertHolder(holder, found);
}
}
public static void Main()
{
ConstructorInvoker ctor = Reflect.Constructor(typeof(long));
MemberGetter getValue = Reflect.Getter(typeof(long), "m_value");
MemberSetter setValue = Reflect.Setter(typeof(long), "m_value");
long integer = (long)ctor();
ValueTypeHolder holder = new ValueTypeHolder(integer); // IMPORTANT!
setValue(holder, 8L);
Console.WriteLine(getValue(holder));
Console.ReadLine();
}
private void AssertHolder(T expectedValue)
{
IList <ValueTypeHolder> items = Db().Query <ValueTypeHolder>(delegate(ValueTypeHolder candidate) { return(candidate.Value.Equals(expectedValue)); });
Assert.AreEqual(1, items.Count);
Assert.IsNotNull(items[0]);
ValueTypeHolder expected = Find(ObjectsToStore(), delegate(ValueTypeHolder candidate) { return(candidate.Value.Equals(expectedValue)); });
Assert.IsNotNull(expected);
Assert.AreEqual(expected, items[0]);
}
public void TestUpdate()
{
ValueTypeHolder updated = RetrieveHolderWithValue(ObjectsToOperateOn()[0].Value);
T newValue = UpdateValueFor(updated);
Store(updated);
Reopen();
ValueTypeHolder actual = RetrieveHolderWithValue(newValue);
Assert.AreEqual(updated, actual);
}
public void TestDelete()
{
DiagnosticCollector <DeletionFailed> diagnosticCollector = DiagnosticCollectorFor <DeletionFailed>();
IQuery query = NewQuery(typeof(ValueTypeHolder));
IObjectSet result = query.Execute();
while (result.HasNext())
{
ValueTypeHolder item = (ValueTypeHolder)result.Next();
Db().Delete(item);
}
Assert.IsTrue(diagnosticCollector.Empty, diagnosticCollector.ToString());
}
public override bool Equals(object obj)
{
ValueTypeHolder rhs = obj as ValueTypeHolder;
if (rhs == null)
{
return(false);
}
if (rhs.GetType() != GetType())
{
return(false);
}
return((rhs.Value.CompareTo(Value) == 0) && CompareParent(rhs));
}
public void TestPersonStruct2()
{
PersonStruct person = new PersonStruct();
person.Age = 0;
person.Name = "";
person.MetersTravelled = 0;
ValueTypeHolder h = person;
Type type = person.GetType();
MultiSetter setter = Reflect.MultiSetter(type, "totalPeopleCreated", "Age", "name", "MetersTravelled");
FieldInfo field = type.GetField("totalPeopleCreated", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.GetField);
setter(h, 12, 6, "John Doe", 2.1d);
person = (PersonStruct)h;
Assert.IsTrue(person.Name == "John Doe" && person.Age == 6 && person.MetersTravelled == 2.1 && ((int)field.GetValue(null) == 12));
}
public static void Main()
{
ConstructorInvoker ctor = Reflect.Constructor(typeof(Animal), typeof(string), typeof(int));
MemberGetter getName = Reflect.Getter(typeof(Animal), "Name");
MemberGetter getAge = Reflect.FieldGetter(typeof(Animal), "Age");
MemberSetter setAge = Reflect.Setter(typeof(Animal), "Age");
MultiSetter setBoth = Reflect.MultiSetter(typeof(Animal), "Age", "Name");
Animal animal = (Animal)ctor("Charlie", 5);
ValueTypeHolder holder = new ValueTypeHolder(animal); // IMPORTANT!
setAge(holder, 8);
Console.WriteLine(getName(holder));
Console.WriteLine(getAge(holder));
setBoth(holder, 10, "Buster");
Console.WriteLine(getName(holder));
Console.WriteLine(getAge(holder));
Console.ReadLine();
}
private bool CompareParent(ValueTypeHolder rhs)
{
return(Parent == null
? rhs.Parent == null
: Parent.Equals(rhs.Parent));
}
public ValueTypeHolder(T value, ValueTypeHolder parent) : this(value)
{
Parent = parent;
}
protected virtual T UpdateValueFor(ValueTypeHolder holder)
{
return(holder.Value);
}
private void AssertHolder(ValueTypeHolder actual, ValueTypeHolder template)
{
var expected = FindHolderWithValue(template.Value);
Assert.AreEqual(expected, actual);
}
protected override Guid UpdateValueFor(ValueTypeHolder holder)
{
holder.Value = new Guid(1, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB);
return(holder.Value);
}
protected override DateTimeOffset UpdateValueFor(ValueTypeHolder holder)
{
holder.Value = holder.Value.AddYears(2009);
return(holder.Value);
}
