public override void Commit()
		{
			IntByRef removedReferenceCount = new IntByRef();
			TraverseNewReferences(new _IVisitor4_26(this, removedReferenceCount));
			CreateNewReferences();
			ReferenceCountChanged(-removedReferenceCount.value);
		}

 public virtual void TestCancelledTraversalWithStartingPointInTheTree()
 {
     var visits = new IntByRef();
     var tree = CreateTree();
     Tree.Traverse(tree, new TreeInt(6), new _ICancellableVisitor4_41(visits));
     Assert.AreEqual(1, visits.value);
 }

 public override void Rollback()
 {
     var newReferencesCount = new IntByRef();
     TraverseNewReferences(new _IVisitor4_63(newReferencesCount));
     CreateNewReferences();
     ReferenceCountChanged(-newReferencesCount.value);
 }

		//private void AssertSingleNullTypeHandlerAspect(Type storedClass)
		//{
		//    AssertSingleTypeHandlerAspect(storedClass, typeof(IgnoreFieldsTypeHandler));
		//}

        private void AssertSingleTypeHandlerAspect(Type storedClass, Type typeHandlerClass
            )
        {
            IntByRef aspectCount = new IntByRef(0);
            ClassMetadata classMetadata = ClassMetadata(storedClass);
            classMetadata.TraverseDeclaredAspects(new _IProcedure4_51(aspectCount, typeHandlerClass
                ));
        }

 public int MarshalledLength()
 {
     if (VariableLength())
     {
         var length = new IntByRef(Const4.IntLength);
         Traverse(new _IVisitor4_152(length));
         return length.value;
     }
     return MarshalledLength(Size());
 }

		private void AssertTestRuns(int[] failingIndices)
		{
			IntByRef counter = new IntByRef();
			TestResult result = new _TestResult_29();
			new TestRunner(Iterators.Iterable(new OpaqueTestSuiteTestCase.SimpleTestSuite[] { 
				new OpaqueTestSuiteTestCase.SimpleTestSuite(counter, NumTests, failingIndices) }
				)).Run(result);
			Assert.AreEqual(NumTests, result.TestCount);
			Assert.AreEqual(failingIndices.Length, result.Failures.Count);
			Assert.AreEqual(NumTests + 2, counter.value);
		}

 public virtual void TestItemCountChanged()
 {
     var changedCount = new IntByRef();
     IBTreeStructureListener listener = new _IBTreeStructureListener_63(changedCount);
     _btree.StructureListener(listener);
     changedCount.value = 0;
     Add(42);
     Assert.AreEqual(1, changedCount.value);
     Remove(42);
     Assert.AreEqual(-1, changedCount.value);
     changedCount.value = 0;
     Remove(42);
     Assert.AreEqual(0, changedCount.value);
 }

		public virtual void TestDelete()
		{
			IntByRef deletedCount = new IntByRef();
			IBTreeStructureListener listener = new _IBTreeStructureListener_39(deletedCount);
			_btree.StructureListener(listener);
			for (int i = 0; i < BtreeNodeSize + 1; i++)
			{
				Add(i);
			}
			for (int i = 0; i < BtreeNodeSize + 1; i++)
			{
				Remove(i);
			}
			Assert.AreEqual(2, deletedCount.value);
		}

			public SimpleTestSuite(IntByRef counter, int numTests, int[] failingIndices) : this
				(counter, numTests, new _IClosure4_47(counter, numTests, failingIndices))
			{
			}

			public _IProcedure4_136(ClassMarshaller _enclosing, IntByRef processedAspectCount
				, int aspectCount, ClassMetadata classMetadata, LatinStringIO sio, DefragmentContextImpl
				 context)
			{
				this._enclosing = _enclosing;
				this.processedAspectCount = processedAspectCount;
				this.aspectCount = aspectCount;
				this.classMetadata = classMetadata;
				this.sio = sio;
				this.context = context;
			}

			public _IProcedure4_108(ClassMarshaller _enclosing, IntByRef len, ObjectContainerBase
				 stream)
			{
				this._enclosing = _enclosing;
				this.len = len;
				this.stream = stream;
			}

			public _IVisitor4_63(IntByRef newReferencesCount)
			{
				this.newReferencesCount = newReferencesCount;
			}

 private bool Descend1(QQuery query, string fieldName, IntByRef run)
 {
     if (run.value == 2 || i_constraints.Size() == 0)
     {
         // On the second run we are really creating a second independant
         // query network that is not joined to other higher level
         // constraints.
         // Let's see how this works out. We may need to join networks.
         run.value = 0;
         // prevent a double run of this code
         Stream().ClassCollection().AttachQueryNode(fieldName, new _IVisitor4_275(this));
     }
     CheckConstraintsEvaluationMode();
     var foundClass = new BooleanByRef(false);
     var i = IterateConstraints();
     while (i.MoveNext())
     {
         if (((QCon) i.Current).Attach(query, fieldName))
         {
             foundClass.value = true;
         }
     }
     return foundClass.value;
 }

 public virtual IQuery Descend(string a_field)
 {
     lock (StreamLock())
     {
         var query = new QQuery(_trans, _this, a_field);
         var run = new IntByRef(1);
         if (!Descend1(query, a_field, run))
         {
             // try to add unparented nodes on the second run,
             // if not added in the first run and a descendant
             // was not found
             if (run.value == 1)
             {
                 run.value = 2;
                 if (!Descend1(query, a_field, run))
                 {
                     new QConUnconditional(_trans, false).Attach(query, a_field);
                 }
             }
         }
         return query;
     }
 }

			public _IVisitor4_131(IntByRef lastEnd, IntByRef lastStart)
			{
				this.lastEnd = lastEnd;
				this.lastStart = lastStart;
			}

		public virtual void DebugCheckIntegrity()
		{
			IntByRef lastStart = new IntByRef();
			IntByRef lastEnd = new IntByRef();
			Traverse(new _IVisitor4_131(lastEnd, lastStart));
		}

			public _IVisitor4_99(IntByRef mint)
			{
				this.mint = mint;
			}

				public _IClosure4_47(IntByRef counter, int numTests, int[] failingIndices)
				{
					this.counter = counter;
					this.numTests = numTests;
					this.failingIndices = failingIndices;
				}

			public _IVisitor4_26(MonitoringReferenceSystem _enclosing, IntByRef removedReferenceCount
				)
			{
				this._enclosing = _enclosing;
				this.removedReferenceCount = removedReferenceCount;
			}

		private void AssertStoredField(Type objectClass, string fieldName, object expectedFieldValue
			, Type expectedFieldType, bool hasIndex, bool isArray)
		{
			IStoredClass storedClass = StoredClass(objectClass);
			IStoredField[] storedFields = storedClass.GetStoredFields();
			Assert.AreEqual(1, storedFields.Length);
			IStoredField storedField = storedFields[0];
			Assert.AreEqual(fieldName, storedField.GetName());
			IStoredField storedFieldByName = storedClass.StoredField(fieldName, expectedFieldType
				);
			Assert.AreEqual(storedField, storedFieldByName);
			object item = RetrieveOnlyInstance(objectClass);
			Assert.AreEqual(expectedFieldValue, storedField.Get(item));
			IReflectClass fieldType = storedField.GetStoredType();
			Assert.AreEqual(Reflector().ForClass(expectedFieldType), fieldType);
			Assert.AreEqual(isArray, storedField.IsArray());
			if (IsMultiSession())
			{
				return;
			}
			Assert.AreEqual(hasIndex, storedField.HasIndex());
			// FIXME: test rename
			if (!hasIndex)
			{
				Assert.Expect(typeof(Exception), new _ICodeBlock_113(storedField));
			}
			else
			{
				IntByRef count = new IntByRef();
				storedField.TraverseValues(new _IVisitor4_123(count, expectedFieldValue));
				Assert.AreEqual(1, count.value);
			}
		}