protected virtual int[] MapToObjectIds(IQuery itemQuery, int[] foos)
{
Transaction trans = TransactionFromQuery(itemQuery);
int[] lookingFor = IntArrays4.Clone(foos);
int[] objectIds = new int[foos.Length];
IObjectSet set = itemQuery.Execute();
while (set.HasNext())
{
IHasFoo item = (IHasFoo)set.Next();
for (int i = 0; i < lookingFor.Length; i++)
{
if (lookingFor[i] == item.GetFoo())
{
lookingFor[i] = -1;
objectIds[i] = (int)((ObjectContainerBase)Db()).GetID(trans, item);
break;
}
}
}
int index = IndexOfNot(lookingFor, -1);
if (-1 != index)
{
throw new ArgumentException("Foo '" + lookingFor[index] + "' not found!");
}
return(objectIds);
}
private IEnumerable NewIterable(int[] values)
{
Collection4 collection = new Collection4();
collection.AddAll(IntArrays4.ToObjectArray(values));
return(collection);
}
public virtual void TestGetAll()
{
AbstractQueryResult queryResult = NewQueryResult();
queryResult.LoadFromClassIndexes(Container().ClassCollection().Iterator());
int[] ids = IntArrays4.Concat(itemIds, new int[] { idForGetAll });
AssertIDs(queryResult, ids, true);
}
public virtual void TestAddAllAndToArray()
{
object[] array = IntArrays4.ToObjectArray(new int[] { 6, 4, 1, 2, 7, 3 });
SortedCollection4 collection = NewSortedCollection();
Assert.AreEqual(0, collection.Size());
collection.AddAll(new ArrayIterator4(array));
AssertCollection(new int[] { 1, 2, 3, 4, 6, 7 }, collection);
}
public virtual void TestTraverseValues()
{
IStoredField field = StoredField();
ExpectingVisitor expectingVisitor = new ExpectingVisitor(IntArrays4.ToObjectArray
(Foos));
field.TraverseValues(expectingVisitor);
expectingVisitor.AssertExpectations();
}
public virtual void TestMultiTransactionSmallerWithCommit()
{
Transaction transaction = NewTransaction();
FillTransactionWith(transaction, 0);
int[] expectedZeros = NewBTreeNodeSizedArray(0);
AssertSmaller(transaction, expectedZeros, 3);
transaction.Commit();
FillTransactionWith(transaction, 5);
AssertSmaller(IntArrays4.Concat(expectedZeros, new int[] { 3, 4 }), 7);
}
private CompositeIterator4 NewIterator()
{
var iterators = new Collection4();
iterators.Add(IntArrays4.NewIterator(new[] { 1, 2, 3 }));
iterators.Add(IntArrays4.NewIterator(new int[] {}));
iterators.Add(IntArrays4.NewIterator(new[] { 4 }));
iterators.Add(IntArrays4.NewIterator(new[] { 5, 6 }));
var iterator = new CompositeIterator4(iterators.GetEnumerator());
return(iterator);
}
private void AssertIterateValues(int[] values)
{
ExpectingVisitor expectingVisitor = new ExpectingVisitor(IntArrays4.ToObjectArray
(values), true, false);
IEnumerator i = new TreeKeyIterator(CreateTree(values));
while (i.MoveNext())
{
expectingVisitor.Visit(i.Current);
}
expectingVisitor.AssertExpectations();
}
private void AssertIDs(IQueryResult queryResult, int[] expectedIDs, bool ignoreUnexpected
)
{
ExpectingVisitor expectingVisitor = new ExpectingVisitor(IntArrays4.ToObjectArray
(expectedIDs), false, ignoreUnexpected);
IIntIterator4 i = queryResult.IterateIDs();
while (i.MoveNext())
{
expectingVisitor.Visit(i.CurrentInt());
}
expectingVisitor.AssertExpectations();
}
private void AssertReadModePointerIteration(int[] expectedKeys, BTreePointer pointer
)
{
object[] expected = IntArrays4.ToObjectArray(expectedKeys);
for (int i = 0; i < expected.Length; i++)
{
Assert.IsNotNull(pointer, "Expected '" + expected[i] + "'");
Assert.AreNotSame(_btree.Root(), pointer.Node());
AssertInReadModeOrCached(pointer.Node());
Assert.AreEqual(expected[i], pointer.Key());
AssertInReadModeOrCached(pointer.Node());
pointer = pointer.Next();
}
}
public virtual void TestMap()
{
int[] array = { 1, 2, 3 };
var args = new Collection4();
var iterator = Iterators.Map(IntArrays4.NewIterator(array), new _IFunction4_149
(args));
Assert.IsNotNull(iterator);
Assert.AreEqual(0, args.Size());
for (var i = 0; i < array.Length; ++i)
{
Assert.IsTrue(iterator.MoveNext());
Assert.AreEqual(i + 1, args.Size());
Assert.AreEqual(array[i] * 2, iterator.Current);
}
}
private void AssertIterator(CompositeIterator4 iterator)
{
Iterator4Assert.AreEqual(IntArrays4.NewIterator(new[] { 1, 2, 3, 4, 5, 6 }),
iterator);
}
private void AssertCollection(int[] expected, SortedCollection4 collection)
{
Assert.AreEqual(expected.Length, collection.Size());
ArrayAssert.AreEqual(IntArrays4.ToObjectArray(expected), collection.ToArray(new object
[collection.Size()]));
}
private void ExpectKeysSearch(BTree btree, int[] values)
{
int lastValue = int.MinValue;
for (int i = 0; i < values.Length; i++)
{
if (values[i] != lastValue)
{
ExpectingVisitor expectingVisitor = ExpectingVisitor.CreateExpectingVisitor(values
[i], IntArrays4.Occurences(values, values[i]));
IBTreeRange range = FieldIndexKeySearch(Trans(), btree, values[i]);
BTreeAssert.TraverseKeys(range, new _IVisitor4_62(expectingVisitor));
expectingVisitor.AssertExpectations();
lastValue = values[i];
}
}
}
private void ExpectKeysSearch(Transaction trans, BTree btree, int[] keys)
{
int lastValue = int.MinValue;
for (int i = 0; i < keys.Length; i++)
{
if (keys[i] != lastValue)
{
ExpectingVisitor expectingVisitor = ExpectingVisitor.CreateExpectingVisitor(keys[
i], IntArrays4.Occurences(keys, keys[i]));
IBTreeRange range = btree.SearchRange(trans, keys[i]);
BTreeAssert.TraverseKeys(range, expectingVisitor);
expectingVisitor.AssertExpectations();
lastValue = keys[i];
}
}
}
