src/Test/Store/MockRAMDirectory.cs - lucenenet - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 using System;

 namespace Lucene.Net.Store
 {

 	/// <summary> This is a subclass of RAMDirectory that adds methods
 	/// intented to be used only by unit tests.
 	/// </summary>
 	/// <version>  $Id: RAMDirectory.java 437897 2006-08-29 01:13:10Z yonik $
 	/// </version>

 	[Serializable]
 	public class MockRAMDirectory : RAMDirectory
 	{
 		internal long maxSize;

 		// Max actual bytes used. This is set by MockRAMOutputStream:
 		internal long maxUsedSize;
 		internal double randomIOExceptionRate;
 		internal System.Random randomState;
 		internal bool noDeleteOpenFile = true;

 		// NOTE: we cannot initialize the Map here due to the
 		// order in which our constructor actually does this
 		// member initialization vs when it calls super.  It seems
 		// like super is called, then our members are initialized:
 		internal System.Collections.IDictionary openFiles;

 		public MockRAMDirectory() : base()
 		{
 			if (openFiles == null)
 			{
 				openFiles = new System.Collections.Hashtable();
 			}
 		}
 		public MockRAMDirectory(System.String dir) : base(dir)
 		{
 			if (openFiles == null)
 			{
 				openFiles = new System.Collections.Hashtable();
 			}
 		}
 		public MockRAMDirectory(Directory dir) : base(dir)
 		{
 			if (openFiles == null)
 			{
 				openFiles = new System.Collections.Hashtable();
 			}
 		}
 		public MockRAMDirectory(System.IO.FileInfo dir) : base(dir)
 		{
 			if (openFiles == null)
 			{
 				openFiles = new System.Collections.Hashtable();
 			}
 		}

 		public virtual void  SetMaxSizeInBytes(long maxSize)
 		{
 			this.maxSize = maxSize;
 		}
 		public virtual long GetMaxSizeInBytes()
 		{
 			return this.maxSize;
 		}

 		/// <summary> Returns the peek actual storage used (bytes) in this
 		/// directory.
 		/// </summary>
 		public virtual long GetMaxUsedSizeInBytes()
 		{
 			return this.maxUsedSize;
 		}
 		public virtual void  ResetMaxUsedSizeInBytes()
 		{
 			this.maxUsedSize = GetRecomputedActualSizeInBytes();
 		}

 		/// <summary> Emulate windows whereby deleting an open file is not
 		/// allowed (raise IOException).
 		/// </summary>
 		public virtual void  SetNoDeleteOpenFile(bool value_Renamed)
 		{
 			this.noDeleteOpenFile = value_Renamed;
 		}
 		public virtual bool GetNoDeleteOpenFile()
 		{
 			return noDeleteOpenFile;
 		}

 		/// <summary> If 0.0, no exceptions will be thrown.  Else this should
 		/// be a double 0.0 - 1.0.  We will randomly throw an
 		/// IOException on the first write to an OutputStream based
 		/// on this probability.
 		/// </summary>
 		public virtual void  SetRandomIOExceptionRate(double rate, long seed)
 		{
 			randomIOExceptionRate = rate;
 			// seed so we have deterministic behaviour:
 			randomState = new System.Random((System.Int32) seed);
 		}
 		public virtual double GetRandomIOExceptionRate()
 		{
 			return randomIOExceptionRate;
 		}

 		internal virtual void  MaybeThrowIOException()
 		{
 			if (randomIOExceptionRate > 0.0)
 			{
 				int number = System.Math.Abs(randomState.Next() % 1000);
 				if (number < randomIOExceptionRate * 1000)
 				{
 					throw new System.IO.IOException("a random IOException");
 				}
 			}
 		}

 		public override void  DeleteFile(System.String name)
 		{
 			lock (this)
 			{
 				lock (openFiles.SyncRoot)
 				{
 					if (noDeleteOpenFile && openFiles.Contains(name))
 					{
 						throw new System.IO.IOException("MockRAMDirectory: file \"" + name + "\" is still open: cannot delete");
 					}
 				}
 				base.DeleteFile(name);
 			}
 		}

 		public override IndexOutput CreateOutput(System.String name)
 		{
 			if (openFiles == null)
 			{
 				openFiles = new System.Collections.Hashtable();
 			}
 			lock (openFiles.SyncRoot)
 			{
 				if (noDeleteOpenFile && openFiles.Contains(name))
 					throw new System.IO.IOException("MockRAMDirectory: file \"" + name + "\" is still open: cannot overwrite");
 			}
 			RAMFile file = new RAMFile(this);
 			lock (this)
 			{
 				RAMFile existing = (RAMFile) fileMap_ForNUnitTest[name];
 				// Enforce write once:
 				if (existing != null && !name.Equals("segments.gen"))
 					throw new System.IO.IOException("file " + name + " already exists");
 				else
 				{
 					if (existing != null)
 					{
 						sizeInBytes_ForNUnitTest -= existing.sizeInBytes_ForNUnitTest;
 						existing.directory_ForNUnitTest = null;
 					}

 					fileMap_ForNUnitTest[name] = file;
 				}
 			}

 			return new MockRAMOutputStream(this, file);
 		}

 		public override IndexInput OpenInput(System.String name)
 		{
 			RAMFile file;
 			lock (this)
 			{
 				file = (RAMFile)fileMap_ForNUnitTest[name];
 			}
 			if (file == null)
 				throw new System.IO.FileNotFoundException(name);
 			else
 			{
 				lock (openFiles.SyncRoot)
 				{
 					if (openFiles.Contains(name))
 					{
 						System.Int32 v = (System.Int32) openFiles[name];
 						v = (System.Int32) (v + 1);
 						openFiles[name] = v;
 					}
 					else
 					{
 						openFiles[name] = 1;
 					}
 				}
 			}
 			return new MockRAMInputStream(this, name, file);
 		}

 		/// <summary>Provided for testing purposes.  Use sizeInBytes() instead. </summary>
 		public long GetRecomputedSizeInBytes()
 		{
 			lock (this)
 			{
 				long size = 0;
 				System.Collections.IEnumerator it = fileMap_ForNUnitTest.Values.GetEnumerator();
 				while (it.MoveNext())
 				{
 					size += ((RAMFile)it.Current).GetSizeInBytes_ForNUnitTest();
 				}
 				return size;
 			}
 		}

 		/// <summary>Like getRecomputedSizeInBytes(), but, uses actual file
 		/// lengths rather than buffer allocations (which are
 		/// quantized up to nearest
 		/// RAMOutputStream.BUFFER_SIZE (now 1024) bytes.
 		/// </summary>

 		public long GetRecomputedActualSizeInBytes()
 		{
 			lock (this)
 			{
 				long size = 0;
 				System.Collections.IEnumerator it = fileMap_ForNUnitTest.Values.GetEnumerator();
 				while (it.MoveNext())
 				{
 					size += ((RAMFile)it.Current).length_ForNUnitTest;
 				}
 				return size;
 			}
 		}

 		public override void  Close()
 		{
 			if (openFiles == null)
 			{
 				openFiles = new System.Collections.Hashtable();
 			}
 			lock (openFiles.SyncRoot)
 			{
 				if (noDeleteOpenFile && openFiles.Count > 0)
 				{
 					// RuntimeException instead of IOException because
 					// super() does not throw IOException currently:
 					throw new System.SystemException("MockRAMDirectory: cannot close: there are still open files: " + openFiles.ToString());
 				}
 			}
 		}

 		/// <summary> Objects that represent fail-able conditions. Objects of a derived
 		/// class are created and registered with the mock directory. After
 		/// register, each object will be invoked once for each first write
 		/// of a file, giving the object a chance to throw an IOException.
 		/// </summary>
 		public class Failure
 		{
 			/// <summary> eval is called on the first write of every new file.</summary>
 			public virtual void  Eval(MockRAMDirectory dir)
 			{
 			}

 			/// <summary> reset should set the state of the failure to its default
 			/// (freshly constructed) state. Reset is convenient for tests
 			/// that want to create one failure object and then reuse it in
 			/// multiple cases. This, combined with the fact that Failure
 			/// subclasses are often anonymous classes makes reset difficult to
 			/// do otherwise.
 			///
 			/// A typical example of use is
 			/// Failure failure = new Failure() { ... };
 			/// ...
 			/// mock.failOn(failure.reset())
 			/// </summary>
 			public virtual Failure Reset()
 			{
 				return this;
 			}

 			protected internal bool doFail;

 			public virtual void  SetDoFail()
 			{
 				doFail = true;
 			}

 			public virtual void  ClearDoFail()
 			{
 				doFail = false;
 			}
 		}

 		internal System.Collections.ArrayList failures;

 		/// <summary> add a Failure object to the list of objects to be evaluated
 		/// at every potential failure point
 		/// </summary>
 		public virtual void  FailOn(Failure fail)
 		{
 			lock (this)
 			{
 				if (failures == null)
 				{
 					failures = new System.Collections.ArrayList();
 				}
 				failures.Add(fail);
 			}
 		}

 		/// <summary> Iterate through the failures list, giving each object a
 		/// chance to throw an IOE
 		/// </summary>
 		internal virtual void  MaybeThrowDeterministicException()
 		{
 			lock (this)
 			{
 				if (failures != null)
 				{
 					for (int i = 0; i < failures.Count; i++)
 					{
 						((Failure) failures[i]).Eval(this);
 					}
 				}
 			}
 		}
 	}
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	using System;

	namespace Lucene.Net.Store
	{

	/// <summary> This is a subclass of RAMDirectory that adds methods
	/// intented to be used only by unit tests.
	/// </summary>
	/// <version> $Id: RAMDirectory.java 437897 2006-08-29 01:13:10Z yonik $
	/// </version>

	[Serializable]
	public class MockRAMDirectory : RAMDirectory
	{
	internal long maxSize;

	// Max actual bytes used. This is set by MockRAMOutputStream:
	internal long maxUsedSize;
	internal double randomIOExceptionRate;
	internal System.Random randomState;
	internal bool noDeleteOpenFile = true;

	// NOTE: we cannot initialize the Map here due to the
	// order in which our constructor actually does this
	// member initialization vs when it calls super. It seems
	// like super is called, then our members are initialized:
	internal System.Collections.IDictionary openFiles;

	public MockRAMDirectory() : base()
	{
	if (openFiles == null)
	{
	openFiles = new System.Collections.Hashtable();
	}
	}
	public MockRAMDirectory(System.String dir) : base(dir)
	{
	if (openFiles == null)
	{
	openFiles = new System.Collections.Hashtable();
	}
	}
	public MockRAMDirectory(Directory dir) : base(dir)
	{
	if (openFiles == null)
	{
	openFiles = new System.Collections.Hashtable();
	}
	}
	public MockRAMDirectory(System.IO.FileInfo dir) : base(dir)
	{
	if (openFiles == null)
	{
	openFiles = new System.Collections.Hashtable();
	}
	}

	public virtual void SetMaxSizeInBytes(long maxSize)
	{
	this.maxSize = maxSize;
	}
	public virtual long GetMaxSizeInBytes()
	{
	return this.maxSize;
	}

	/// <summary> Returns the peek actual storage used (bytes) in this
	/// directory.
	/// </summary>
	public virtual long GetMaxUsedSizeInBytes()
	{
	return this.maxUsedSize;
	}
	public virtual void ResetMaxUsedSizeInBytes()
	{
	this.maxUsedSize = GetRecomputedActualSizeInBytes();
	}

	/// <summary> Emulate windows whereby deleting an open file is not
	/// allowed (raise IOException).
	/// </summary>
	public virtual void SetNoDeleteOpenFile(bool value_Renamed)
	{
	this.noDeleteOpenFile = value_Renamed;
	}
	public virtual bool GetNoDeleteOpenFile()
	{
	return noDeleteOpenFile;
	}

	/// <summary> If 0.0, no exceptions will be thrown. Else this should
	/// be a double 0.0 - 1.0. We will randomly throw an
	/// IOException on the first write to an OutputStream based
	/// on this probability.
	/// </summary>
	public virtual void SetRandomIOExceptionRate(double rate, long seed)
	{
	randomIOExceptionRate = rate;
	// seed so we have deterministic behaviour:
	randomState = new System.Random((System.Int32) seed);
	}
	public virtual double GetRandomIOExceptionRate()
	{
	return randomIOExceptionRate;
	}

	internal virtual void MaybeThrowIOException()
	{
	if (randomIOExceptionRate > 0.0)
	{
	int number = System.Math.Abs(randomState.Next() % 1000);
	if (number < randomIOExceptionRate * 1000)
	{
	throw new System.IO.IOException("a random IOException");
	}
	}
	}

	public override void DeleteFile(System.String name)
	{
	lock (this)
	{
	lock (openFiles.SyncRoot)
	{
	if (noDeleteOpenFile && openFiles.Contains(name))
	{
	throw new System.IO.IOException("MockRAMDirectory: file \"" + name + "\" is still open: cannot delete");
	}
	}
	base.DeleteFile(name);
	}
	}

	public override IndexOutput CreateOutput(System.String name)
	{
	if (openFiles == null)
	{
	openFiles = new System.Collections.Hashtable();
	}
	lock (openFiles.SyncRoot)
	{
	if (noDeleteOpenFile && openFiles.Contains(name))
	throw new System.IO.IOException("MockRAMDirectory: file \"" + name + "\" is still open: cannot overwrite");
	}
	RAMFile file = new RAMFile(this);
	lock (this)
	{
	RAMFile existing = (RAMFile) fileMap_ForNUnitTest[name];
	// Enforce write once:
	if (existing != null && !name.Equals("segments.gen"))
	throw new System.IO.IOException("file " + name + " already exists");
	else
	{
	if (existing != null)
	{
	sizeInBytes_ForNUnitTest -= existing.sizeInBytes_ForNUnitTest;
	existing.directory_ForNUnitTest = null;
	}

	fileMap_ForNUnitTest[name] = file;
	}
	}

	return new MockRAMOutputStream(this, file);
	}

	public override IndexInput OpenInput(System.String name)
	{
	RAMFile file;
	lock (this)
	{
	file = (RAMFile)fileMap_ForNUnitTest[name];
	}
	if (file == null)
	throw new System.IO.FileNotFoundException(name);
	else
	{
	lock (openFiles.SyncRoot)
	{
	if (openFiles.Contains(name))
	{
	System.Int32 v = (System.Int32) openFiles[name];
	v = (System.Int32) (v + 1);
	openFiles[name] = v;
	}
	else
	{
	openFiles[name] = 1;
	}
	}
	}
	return new MockRAMInputStream(this, name, file);
	}

	/// <summary>Provided for testing purposes. Use sizeInBytes() instead. </summary>
	public long GetRecomputedSizeInBytes()
	{
	lock (this)
	{
	long size = 0;
	System.Collections.IEnumerator it = fileMap_ForNUnitTest.Values.GetEnumerator();
	while (it.MoveNext())
	{
	size += ((RAMFile)it.Current).GetSizeInBytes_ForNUnitTest();
	}
	return size;
	}
	}

	/// <summary>Like getRecomputedSizeInBytes(), but, uses actual file
	/// lengths rather than buffer allocations (which are
	/// quantized up to nearest
	/// RAMOutputStream.BUFFER_SIZE (now 1024) bytes.
	/// </summary>

	public long GetRecomputedActualSizeInBytes()
	{
	lock (this)
	{
	long size = 0;
	System.Collections.IEnumerator it = fileMap_ForNUnitTest.Values.GetEnumerator();
	while (it.MoveNext())
	{
	size += ((RAMFile)it.Current).length_ForNUnitTest;
	}
	return size;
	}
	}

	public override void Close()
	{
	if (openFiles == null)
	{
	openFiles = new System.Collections.Hashtable();
	}
	lock (openFiles.SyncRoot)
	{
	if (noDeleteOpenFile && openFiles.Count > 0)
	{
	// RuntimeException instead of IOException because
	// super() does not throw IOException currently:
	throw new System.SystemException("MockRAMDirectory: cannot close: there are still open files: " + openFiles.ToString());
	}
	}
	}

	/// <summary> Objects that represent fail-able conditions. Objects of a derived
	/// class are created and registered with the mock directory. After
	/// register, each object will be invoked once for each first write
	/// of a file, giving the object a chance to throw an IOException.
	/// </summary>
	public class Failure
	{
	/// <summary> eval is called on the first write of every new file.</summary>
	public virtual void Eval(MockRAMDirectory dir)
	{
	}

	/// <summary> reset should set the state of the failure to its default
	/// (freshly constructed) state. Reset is convenient for tests
	/// that want to create one failure object and then reuse it in
	/// multiple cases. This, combined with the fact that Failure
	/// subclasses are often anonymous classes makes reset difficult to
	/// do otherwise.
	///
	/// A typical example of use is
	/// Failure failure = new Failure() { ... };
	/// ...
	/// mock.failOn(failure.reset())
	/// </summary>
	public virtual Failure Reset()
	{
	return this;
	}

	protected internal bool doFail;

	public virtual void SetDoFail()
	{
	doFail = true;
	}

	public virtual void ClearDoFail()
	{
	doFail = false;
	}
	}

	internal System.Collections.ArrayList failures;

	/// <summary> add a Failure object to the list of objects to be evaluated
	/// at every potential failure point
	/// </summary>
	public virtual void FailOn(Failure fail)
	{
	lock (this)
	{
	if (failures == null)
	{
	failures = new System.Collections.ArrayList();
	}
	failures.Add(fail);
	}
	}

	/// <summary> Iterate through the failures list, giving each object a
	/// chance to throw an IOE
	/// </summary>
	internal virtual void MaybeThrowDeterministicException()
	{
	lock (this)
	{
	if (failures != null)
	{
	for (int i = 0; i < failures.Count; i++)
	{
	((Failure) failures[i]).Eval(this);
	}
	}
	}
	}
	}
	}