protected override void AssertArrays(IExtObjectContainer objectContainer, object
     obj)
 {
     var itemArrays = (ItemArrays
         ) obj;
     AssertPrimitiveArray(itemArrays._typedPrimitiveArray);
     if (Db4oHeaderVersion() == VersionServices.Header3040)
     {
     }
     else
     {
         // Bug in the oldest format: It accidentally byte[] arrays to Byte[]
         // arrays.
         if (Db4oHandlerVersion() == 1 && Db4oHeaderVersion() == 100 && itemArrays._primitiveArrayInObject
             == null)
         {
         }
         else
         {
             // do nothing
             // We started treating byte[] in untyped variables differently
             // but we forgot to update the handler version.
             // Concerns only 6.3.500: Updates are not possible.
             AssertPrimitiveArray((byte[]) itemArrays._primitiveArrayInObject);
         }
     }
 }

 private void AssertDateTimeQuery(IExtObjectContainer objectContainer, DateTime value)
 {
     IQuery query = objectContainer.Query();
     query.Constrain(typeof (Item));
     query.Descend("_dateTime").Constrain(value);
     Assert.AreEqual(1, query.Execute().Count);
 }

 private Collection4 CommitCapturingUpdatedObjects(IExtObjectContainer container)
 {
     var updated = new Collection4();
     EventRegistryFor(container).Updated += new _IEventListener4_51(updated).OnEvent;
     container.Commit();
     return updated;
 }

		protected override void AssertArrays(IExtObjectContainer objectContainer, object 
			obj)
		{
			object[] array = (object[])obj;
			Assert.AreEqual(2, array.Length);
			Assert.AreSame(array[0], array[1]);
		}

 private IObjectSet QueryContains(IExtObjectContainer oc, string str)
 {
     var q = oc.Query();
     q.Constrain(typeof (ParameterizedEvaluationTestCase));
     q.Constrain(new MyEvaluation(str));
     return q.Execute();
 }

		/// <exception cref="System.Exception"></exception>
		public virtual void Conc(IExtObjectContainer oc)
		{
			IObjectSet os = oc.Query(typeof(InvalidUUIDTestCase));
			if (os.Count == 0)
			{
				// already deleted by other threads
				return;
			}
			Assert.AreEqual(1, os.Count);
			InvalidUUIDTestCase iu = (InvalidUUIDTestCase)os.Next();
			Db4oUUID myUuid = oc.GetObjectInfo(iu).GetUUID();
			Assert.IsNotNull(myUuid);
			byte[] mySignature = myUuid.GetSignaturePart();
			long myLong = myUuid.GetLongPart();
			long unknownLong = long.MaxValue - 100;
			byte[] unknownSignature = new byte[] { 1, 2, 4, 99, 33, 22 };
			Db4oUUID unknownLongPart = new Db4oUUID(unknownLong, mySignature);
			Db4oUUID unknownSignaturePart = new Db4oUUID(myLong, unknownSignature);
			Db4oUUID unknownBoth = new Db4oUUID(unknownLong, unknownSignature);
			Assert.IsNull(oc.GetByUUID(unknownLongPart));
			Assert.IsNull(oc.GetByUUID(unknownSignaturePart));
			Assert.IsNull(oc.GetByUUID(unknownBoth));
			Assert.IsNull(oc.GetByUUID(unknownLongPart));
			Thread.Sleep(500);
			oc.Delete(iu);
			oc.Commit();
			Assert.IsNull(oc.GetByUUID(myUuid));
		}

		/// <exception cref="System.Exception"></exception>
		public virtual void Conc1(IExtObjectContainer oc)
		{
			IObjectSet os = oc.Query(typeof(DualDeleteTestCase.Item));
			Thread.Sleep(500);
			DeleteObjectSet(oc, os);
			oc.Rollback();
		}

 protected override void AssertValues(IExtObjectContainer objectContainer, object[] values)
 {
     var holder = (HashtableHolder) values[0];
     AssertHashtable(holder._dictionary);
     AssertHashtable(holder._hashtable);
     AssertHashtable(holder._untyped);
 }

 public virtual void Conc(IExtObjectContainer oc)
 {
     int[] expect = {3, 4, 5};
     var q = oc.Query();
     q.Constrain(typeof (GreaterOrEqualTestCase
         ));
     q.Descend("val").Constrain(3).Greater().Equal();
     var res = q.Execute();
     while (res.HasNext())
     {
         var r = (GreaterOrEqualTestCase
             ) res.Next();
         for (var i = 0; i < expect.Length; i++)
         {
             if (expect[i] == r.val)
             {
                 expect[i] = 0;
             }
         }
     }
     for (var i = 0; i < expect.Length; i++)
     {
         Assert.AreEqual(0, expect[i]);
     }
 }

 // do nothing
 protected override void AssertValues(IExtObjectContainer objectContainer, object[]
     values)
 {
     var item = (Item) values
         [0];
     Assert.AreEqual("one", item._name);
 }

 protected override void Update(IExtObjectContainer objectContainer)
 {
     var holder = RetrieveHolderInstance(objectContainer);
     UpdateValues(holder._values);
     UpdateArrays(holder._arrays);
     objectContainer.Store(holder, int.MaxValue);
 }

		private ConcurrentLazyQueriesTestCase.Item QueryRoot(IExtObjectContainer container
			)
		{
			IQuery q = ItemQuery(container);
			q.Descend("id").Constrain(-1);
			return (ConcurrentLazyQueriesTestCase.Item)q.Execute().Next();
		}

 protected override void AssertObjectsAreUpdated(IExtObjectContainer objectContainer
     )
 {
     var holder = RetrieveHolderInstance(objectContainer);
     AssertUpdatedValues(holder._values);
     AssertUpdatedArrays(holder._arrays);
 }

 private Item QueryRoot(IExtObjectContainer container
     )
 {
     var q = ItemQuery(container);
     q.Descend("id").Constrain(-1);
     return (Item) q.Execute().Next();
 }

		// do nothing
		protected override void AssertValues(IExtObjectContainer objectContainer, object[]
			 values)
		{
			EncryptedFileMigrationTestCase.Item item = (EncryptedFileMigrationTestCase.Item)values
				[0];
			Assert.AreEqual("one", item._name);
		}

		public virtual void Conc(IExtObjectContainer oc)
		{
			int[] expect = new int[] { 3, 4, 5 };
			IQuery q = oc.Query();
			q.Constrain(typeof(Db4objects.Db4o.Tests.Common.Concurrency.GreaterOrEqualTestCase
				));
			q.Descend("val").Constrain(3).Greater().Equal();
			IObjectSet res = q.Execute();
			while (res.HasNext())
			{
				Db4objects.Db4o.Tests.Common.Concurrency.GreaterOrEqualTestCase r = (Db4objects.Db4o.Tests.Common.Concurrency.GreaterOrEqualTestCase
					)res.Next();
				for (int i = 0; i < expect.Length; i++)
				{
					if (expect[i] == r.val)
					{
						expect[i] = 0;
					}
				}
			}
			for (int i = 0; i < expect.Length; i++)
			{
				Assert.AreEqual(0, expect[i]);
			}
		}

 public virtual void Conc(IExtObjectContainer oc)
 {
     var nr = (NestedArraysTestCase) RetrieveOnlyInstance
         (oc, typeof (NestedArraysTestCase));
     Check((object[]) nr._object, Depth);
     Check(nr._objectArray, Depth);
 }

		/// <exception cref="System.Exception"></exception>
		public virtual void ConcReadDifferentObject(IExtObjectContainer oc, int seq)
		{
			SimpleObject expected = new SimpleObject(testString + seq, seq);
			IObjectSet result = oc.Query(new ReadObjectNQTestCase.MyPredicate(expected));
			Assert.AreEqual(1, result.Count);
			Assert.AreEqual(expected, result.Next());
		}

 /// <exception cref="System.Exception"></exception>
 public virtual void ConcReadDifferentObject(IExtObjectContainer oc, int seq)
 {
     var example = new SimpleObject(testString + seq, seq);
     var result = oc.QueryByExample(example);
     Assert.AreEqual(1, result.Count);
     Assert.AreEqual(example, result.Next());
 }

		public virtual void ConcSetRollback(IExtObjectContainer oc, int seq)
		{
			if (seq % 2 == 0)
			{
				// if the thread sequence is even, store something
				for (int i = 0; i < 1000; i++)
				{
					SimpleObject c = new SimpleObject("oc " + i, i);
					oc.Store(c);
				}
			}
			else
			{
				// if the thread sequence is odd, rollback
				for (int i = 0; i < 1000; i++)
				{
					SimpleObject c = new SimpleObject("oc " + i, i);
					oc.Store(c);
					oc.Rollback();
					c = new SimpleObject("oc2.2 " + i, i);
					oc.Store(c);
				}
				oc.Rollback();
			}
		}