public virtual void Update(PersistenceContext context, PersistentEntry entry)
{
var existing = SelectByUid(context, entry.className, entry.uid);
existing.fieldValues = entry.fieldValues;
DataContainer(context).Store(existing);
}
private PersistentEntry[] Copy(PersistentEntry[] entries)
{
var clone = new PersistentEntry[entries.Length];
Array.Copy(entries, 0, clone, 0, clone.Length);
return(clone);
}
public virtual void Insert(PersistenceContext context, PersistentEntry entry)
{
LogMethodCall("insert", context, entry);
// clone the entry because clients are allowed to reuse
// entry objects
DataContainer(context).Store(Clone(entry));
}
private void AssertSingleEntry(PersistentEntry expected, IEnumerator found)
{
Assert.IsTrue(found.MoveNext(), "Expecting entry '" + expected + "'");
PersistentEntry actual = (PersistentEntry)found.Current;
AssertEqualEntries(expected, actual);
Assert.IsFalse(found.MoveNext(), "Expecting only '" + expected + "'");
}
private void ExerciseSelectByField(PersistentEntry expected, string[] fieldNames)
{
for (int i = 0; i < fieldNames.Length; ++i)
{
IEnumerator found = SelectByField(expected.className, fieldNames[i], expected.fieldValues
[i]);
AssertSingleEntry(expected, found);
}
}
public virtual void TestUpdate()
{
PersistentEntry entry = new PersistentEntry(CatClass, CatEntries[0].uid, new object
[] { "Birinho", 10 });
Update(entry);
RestartProvider();
//exerciseSelectByField(entry, CAT_FIELD_NAMES);
PersistentEntry[] expected = Copy(CatEntries);
expected[0] = entry;
AssertEntries(expected, SelectAll(CatClass));
}
private PersistentEntry EntryByUid(IEnumerator iterator, object uid)
{
while (iterator.MoveNext())
{
PersistentEntry e = (PersistentEntry)iterator.Current;
if (uid.Equals(e.uid))
{
return(e);
}
}
return(null);
}
public virtual void TestUpdate()
{
PersistentEntry entry = new PersistentEntry(CatClass, CatEntries[0].uid, new object
[] { "Birinho", 10 });
Update(entry);
RestartProvider();
//exerciseSelectByField(entry, CAT_FIELD_NAMES);
PersistentEntry[] expected = Copy(CatEntries);
expected[0] = entry;
AssertEntries(expected, SelectAll(CatClass));
}
private void InsertEntries(PersistentEntry[] entries)
{
PersistentEntry entry = new PersistentEntry(null, null, null);
for (int i = 0; i < entries.Length; ++i)
{
entry.className = entries[i].className;
entry.uid = entries[i].uid;
entry.fieldValues = entries[i].fieldValues;
// reuse entries so the provider can't assume
// anything about identity
Insert(entry);
}
}
private IReflectClass RepositoryForObject(object obj)
{
if (_classRepository == null)
{
return(null);
}
if (!(obj is PersistentEntry))
{
return(null);
}
PersistentEntry entry = (PersistentEntry)obj;
return(_classRepository.ForName(entry.className));
}
public virtual void TestSelectByFields()
{
PersistentEntry existing = CatEntries[0];
PersistentEntry newEntry = new PersistentEntry(CatClass, 3, new object[] { existing
.fieldValues[0], 10 });
Insert(newEntry);
IEnumerator found = SelectByField(existing.className, CatFieldNames[0], existing.
fieldValues[0]);
AssertEntries(new PersistentEntry[] { existing, newEntry }, found);
AssertSingleEntry(existing, Select(existing.className, CatFieldNames, existing.fieldValues
));
AssertSingleEntry(newEntry, Select(newEntry.className, CatFieldNames, newEntry.fieldValues
));
}
private void AssertEntries(PersistentEntry[] expected, IEnumerator actual)
{
Collection4 checklist = new Collection4(actual);
Assert.AreEqual(expected.Length, checklist.Size());
for (int i = 0; i < expected.Length; ++i)
{
PersistentEntry e = expected[i];
PersistentEntry a = EntryByUid(checklist.GetEnumerator(), e.uid);
if (a != null)
{
AssertEqualEntries(e, a);
checklist.Remove(a);
}
}
Assert.IsTrue(checklist.IsEmpty(), checklist.ToString());
}
private void Insert(PersistentEntry entry)
{
_provider.Insert(_context, entry);
}
private void AssertEqualEntries(PersistentEntry expected, PersistentEntry actual)
{
Assert.AreEqual(expected.className, actual.className);
Assert.AreEqual(expected.uid, actual.uid);
ArrayAssert.AreEqual(expected.fieldValues, actual.fieldValues);
}
private void ExerciseSelectByField(PersistentEntry[] entries, string[] fieldNames
)
{
for (int i = 0; i < entries.Length; ++i)
{
ExerciseSelectByField(entries[i], fieldNames);
}
}
private void ExerciseSelectByField(PersistentEntry expected, string[] fieldNames)
{
for (int i = 0; i < fieldNames.Length; ++i)
{
IEnumerator found = SelectByField(expected.className, fieldNames[i], expected.fieldValues
[i]);
AssertSingleEntry(expected, found);
}
}
private void AssertSingleEntry(PersistentEntry expected, IEnumerator found)
{
Assert.IsTrue(found.MoveNext(), "Expecting entry '" + expected + "'");
PersistentEntry actual = (PersistentEntry)found.Current;
AssertEqualEntries(expected, actual);
Assert.IsFalse(found.MoveNext(), "Expecting only '" + expected + "'");
}
private void InsertEntries(PersistentEntry[] entries)
{
PersistentEntry entry = new PersistentEntry(null, null, null);
for (int i = 0; i < entries.Length; ++i)
{
entry.className = entries[i].className;
entry.uid = entries[i].uid;
entry.fieldValues = entries[i].fieldValues;
// reuse entries so the provider can't assume
// anything about identity
Insert(entry);
}
}
public virtual void Update(PersistenceContext context, PersistentEntry entry)
{
var existing = SelectByUid(context, entry.className, entry.uid);
existing.fieldValues = entry.fieldValues;
DataContainer(context).Store(existing);
}
private void Update(PersistentEntry entry)
{
_provider.Update(_context, entry);
}
private void AssertEqualEntries(PersistentEntry expected, PersistentEntry actual)
{
Assert.AreEqual(expected.className, actual.className);
Assert.AreEqual(expected.uid, actual.uid);
ArrayAssert.AreEqual(expected.fieldValues, actual.fieldValues);
}
private void Insert(PersistentEntry entry)
{
_provider.Insert(_context, entry);
}
private PersistentEntry Clone(PersistentEntry entry)
{
return(new PersistentEntry(entry.className, entry.uid, entry.fieldValues));
}
private PersistentEntry[] Copy(PersistentEntry[] entries)
{
PersistentEntry[] clone = new PersistentEntry[entries.Length];
System.Array.Copy(entries, 0, clone, 0, clone.Length);
return clone;
}
private void Update(PersistentEntry entry)
{
_provider.Update(_context, entry);
}
private PersistentEntry Clone(PersistentEntry entry)
{
return new PersistentEntry(entry.className, entry.uid, entry.fieldValues);
}
private void AssertEntries(PersistentEntry[] expected, IEnumerator actual)
{
Collection4 checklist = new Collection4(actual);
Assert.AreEqual(expected.Length, checklist.Size());
for (int i = 0; i < expected.Length; ++i)
{
PersistentEntry e = expected[i];
PersistentEntry a = EntryByUid(checklist.GetEnumerator(), e.uid);
if (a != null)
{
AssertEqualEntries(e, a);
checklist.Remove(a);
}
}
Assert.IsTrue(checklist.IsEmpty(), checklist.ToString());
}
public virtual void Insert(PersistenceContext context, PersistentEntry entry)
{
LogMethodCall("insert", context, entry);
// clone the entry because clients are allowed to reuse
// entry objects
DataContainer(context).Store(Clone(entry));
}
public virtual void TestSelectByFields()
{
PersistentEntry existing = CatEntries[0];
PersistentEntry newEntry = new PersistentEntry(CatClass, 3, new object[] { existing
.fieldValues[0], 10 });
Insert(newEntry);
IEnumerator found = SelectByField(existing.className, CatFieldNames[0], existing.
fieldValues[0]);
AssertEntries(new PersistentEntry[] { existing, newEntry }, found);
AssertSingleEntry(existing, Select(existing.className, CatFieldNames, existing.fieldValues
));
AssertSingleEntry(newEntry, Select(newEntry.className, CatFieldNames, newEntry.fieldValues
));
}
