src/Test/Store/TestLockFactory.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;

 using NUnit.Framework;

 using Document = Lucene.Net.Documents.Document;
 using Field = Lucene.Net.Documents.Field;
 using IndexReader = Lucene.Net.Index.IndexReader;
 using IndexWriter = Lucene.Net.Index.IndexWriter;
 using Term = Lucene.Net.Index.Term;
 using WhitespaceAnalyzer = Lucene.Net.Analysis.WhitespaceAnalyzer;
 using Hits = Lucene.Net.Search.Hits;
 using IndexSearcher = Lucene.Net.Search.IndexSearcher;
 using Query = Lucene.Net.Search.Query;
 using TermQuery = Lucene.Net.Search.TermQuery;
 using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;

 namespace Lucene.Net.Store
 {

 	[TestFixture]
 	public class TestLockFactory : LuceneTestCase
 	{

 		// Verify: we can provide our own LockFactory implementation, the right
 		// methods are called at the right time, locks are created, etc.
 		[Test]
 		public virtual void  TestCustomLockFactory()
 		{
 			Directory dir = new RAMDirectory();
 			MockLockFactory lf = new MockLockFactory(this);
 			dir.SetLockFactory(lf);

 			// Lock prefix should have been set:
 			Assert.IsTrue(lf.lockPrefixSet, "lock prefix was not set by the RAMDirectory");

 			IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true);

 			// add 100 documents (so that commit lock is used)
 			for (int i = 0; i < 100; i++)
 			{
 				AddDoc(writer);
 			}

 			// Both write lock and commit lock should have been created:
 			Assert.AreEqual(1, lf.locksCreated.Count, "# of unique locks created (after instantiating IndexWriter)");
 			Assert.IsTrue(lf.makeLockCount >= 1, "# calls to makeLock is 0 (after instantiating IndexWriter)");

 			for (System.Collections.IEnumerator e = lf.locksCreated.Keys.GetEnumerator(); e.MoveNext(); )
 			{
 				System.String lockName = (System.String) e.Current;
 				MockLockFactory.MockLock lock_Renamed = (MockLockFactory.MockLock) lf.locksCreated[lockName];
 				Assert.IsTrue(lock_Renamed.lockAttempts > 0, "# calls to Lock.obtain is 0 (after instantiating IndexWriter)");
 			}

 			writer.Close();
 		}

 		// Verify: we can use the NoLockFactory with RAMDirectory w/ no
 		// exceptions raised:
 		// Verify: NoLockFactory allows two IndexWriters
 		[Test]
 		public virtual void  TestRAMDirectoryNoLocking()
 		{
 			Directory dir = new RAMDirectory();
 			dir.SetLockFactory(NoLockFactory.GetNoLockFactory());

 			Assert.IsTrue(typeof(NoLockFactory).IsInstanceOfType(dir.GetLockFactory()), "RAMDirectory.setLockFactory did not take");

 			IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true);

 			// Create a 2nd IndexWriter.  This is normally not allowed but it should run through since we're not
 			// using any locks:
 			IndexWriter writer2 = null;
 			try
 			{
 				writer2 = new IndexWriter(dir, new WhitespaceAnalyzer(), false);
 			}
 			catch (System.Exception e)
 			{
 				System.Console.Out.WriteLine(e.StackTrace);
 				Assert.Fail("Should not have hit an IOException with no locking");
 			}

 			writer.Close();
 			if (writer2 != null)
 			{
 				writer2.Close();
 			}
 		}

 		// Verify: SingleInstanceLockFactory is the default lock for RAMDirectory
 		// Verify: RAMDirectory does basic locking correctly (can't create two IndexWriters)
 		[Test]
 		public virtual void  TestDefaultRAMDirectory()
 		{
 			Directory dir = new RAMDirectory();

 			Assert.IsTrue(typeof(SingleInstanceLockFactory).IsInstanceOfType(dir.GetLockFactory()), "RAMDirectory did not use correct LockFactory: got " + dir.GetLockFactory());

 			IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true);

 			// Create a 2nd IndexWriter.  This should fail:
 			IndexWriter writer2 = null;
 			try
 			{
 				writer2 = new IndexWriter(dir, new WhitespaceAnalyzer(), false);
 				Assert.Fail("Should have hit an IOException with two IndexWriters on default SingleInstanceLockFactory");
 			}
 			catch (System.IO.IOException)
 			{
 			}

 			writer.Close();
 			if (writer2 != null)
 			{
 				writer2.Close();
 			}
 		}

 		// Verify: SimpleFSLockFactory is the default for FSDirectory
 		// Verify: FSDirectory does basic locking correctly
 		[Test]
 		public virtual void  TestDefaultFSDirectory()
 		{
 			System.String indexDirName = "index.TestLockFactory1";

 			IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);

 			Assert.IsTrue(typeof(SimpleFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()) || typeof(NativeFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());

 			IndexWriter writer2 = null;

 			// Create a 2nd IndexWriter.  This should fail:
 			try
 			{
 				writer2 = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), false);
 				Assert.Fail("Should have hit an IOException with two IndexWriters on default SimpleFSLockFactory");
 			}
 			catch (System.IO.IOException)
 			{
 			}

 			writer.Close();
 			if (writer2 != null)
 			{
 				writer2.Close();
 			}

 			// Cleanup
 			RmDir(indexDirName);
 		}

 		// Verify: FSDirectory's default lockFactory clears all locks correctly
 		[Test]
 		public virtual void  TestFSDirectoryTwoCreates()
 		{
 			System.String indexDirName = "index.TestLockFactory2";

 			IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);

 			Assert.IsTrue(typeof(SimpleFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()) || typeof(NativeFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());

 			// Intentionally do not close the first writer here.
 			// The goal is to "simulate" a crashed writer and
 			// ensure the second writer, with create=true, is
 			// able to remove the lock files.  This works OK
 			// with SimpleFSLockFactory as the locking
 			// implementation.  Note, however, that this test
 			// will not work on WIN32 when we switch to
 			// NativeFSLockFactory as the default locking for
 			// FSDirectory because the second IndexWriter cannot
 			// remove those lock files since they are held open
 			// by the first writer.  This is because leaving the
 			// first IndexWriter open is not really a good way
 			// to simulate a crashed writer.

 			// Create a 2nd IndexWriter.  This should not fail:
 			IndexWriter writer2 = null;
 			try
 			{
 				writer2 = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
 			}
 			catch (System.IO.IOException e)
 			{
 				System.Console.Error.WriteLine(e.StackTrace);
 				Assert.Fail("Should not have hit an IOException with two IndexWriters with create=true, on default SimpleFSLockFactory");
 			}

 			writer.Close();
 			if (writer2 != null)
 			{
 				try
 				{
 					writer2.Close();
 					// expected
 				}
 				catch (LockReleaseFailedException)
 				{
 					Assert.Fail("writer2.close() should not have hit LockReleaseFailedException");
 				}
 			}

 			// Cleanup
 			RmDir(indexDirName);
 		}


 		// Verify: setting custom lock factory class (as system property) works:
 		// Verify: all 4 builtin LockFactory implementations are
 		//         settable this way
 		// Verify: FSDirectory does basic locking correctly
 		[Test]
 		public virtual void  TestLockClassProperty()
 		{
 			System.String indexDirName = "index.TestLockFactory3";
 			System.String prpName = "Lucene.Net.Store.FSDirectoryLockFactoryClass";

 			try
 			{

 				// NoLockFactory:
 				SupportClass.AppSettings.Set(prpName, "Lucene.Net.Store.NoLockFactory");
 				IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
 				Assert.IsTrue(typeof(NoLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());
 				writer.Close();

 				// SingleInstanceLockFactory:
 				SupportClass.AppSettings.Set(prpName, "Lucene.Net.Store.SingleInstanceLockFactory");
 				writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
 				Assert.IsTrue(typeof(SingleInstanceLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());
 				writer.Close();

 				// NativeFSLockFactory:
 				SupportClass.AppSettings.Set(prpName, "Lucene.Net.Store.NativeFSLockFactory");
 				writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
 				Assert.IsTrue(typeof(NativeFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());
 				writer.Close();

 				// SimpleFSLockFactory:
 				SupportClass.AppSettings.Set(prpName, "Lucene.Net.Store.SimpleFSLockFactory");
 				writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
 				Assert.IsTrue(typeof(SimpleFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());
 				writer.Close();
 			}
 			finally
 			{
 				// Put back to the correct default for subsequent tests:
 				SupportClass.AppSettings.Set("Lucene.Net.Store.FSDirectoryLockFactoryClass", "");
 			}

 			// Cleanup
 			RmDir(indexDirName);
 		}

 		// Verify: setDisableLocks works
 		[Test]
 		public virtual void  TestDisableLocks()
 		{
 			System.String indexDirName = "index.TestLockFactory4";

 			Assert.IsTrue(!FSDirectory.GetDisableLocks(), "Locks are already disabled");
 			FSDirectory.SetDisableLocks(true);

 			IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);

 			Assert.IsTrue(typeof(NoLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct default LockFactory: got " + writer.GetDirectory().GetLockFactory());

 			// Should be no error since locking is disabled:
 			IndexWriter writer2 = null;
 			try
 			{
 				writer2 = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), false);
 			}
 			catch (System.IO.IOException e)
 			{
 				System.Console.Error.WriteLine(e.StackTrace);
 				Assert.Fail("Should not have hit an IOException with locking disabled");
 			}

 			FSDirectory.SetDisableLocks(false);
 			writer.Close();
 			if (writer2 != null)
 			{
 				writer2.Close();
 			}
 			// Cleanup
 			RmDir(indexDirName);
 		}

 		// Verify: if I try to getDirectory() with two different locking implementations, I get an IOException
 		[Test]
 		public virtual void  TestFSDirectoryDifferentLockFactory()
 		{
 			System.String indexDirName = "index.TestLockFactory5";

 			LockFactory lf = new SingleInstanceLockFactory();
 			FSDirectory fs1 = FSDirectory.GetDirectory(indexDirName, lf);

 			// Different lock factory instance should hit IOException:
 			try
 			{
 				FSDirectory fs2 = FSDirectory.GetDirectory(indexDirName, new SingleInstanceLockFactory());
 				Assert.Fail("Should have hit an IOException because LockFactory instances differ");
 			}
 			catch (System.IO.IOException)
 			{
 			}

 			FSDirectory fs3 = null;

 			// Same lock factory instance should not:
 			try
 			{
 				fs3 = FSDirectory.GetDirectory(indexDirName, lf);
 			}
 			catch (System.IO.IOException e)
 			{
 				System.Console.Error.WriteLine(e.StackTrace);
 				Assert.Fail("Should not have hit an IOException because LockFactory instances are the same");
 			}

 			fs1.Close();
 			if (fs3 != null)
 			{
 				fs3.Close();
 			}
 			// Cleanup
 			RmDir(indexDirName);
 		}

 		// Verify: do stress test, by opening IndexReaders and
 		// IndexWriters over & over in 2 threads and making sure
 		// no unexpected exceptions are raised:
 		[Test]
 		public virtual void  TestStressLocks()
 		{
 			_TestStressLocks(null, "index.TestLockFactory6");
 		}

 		// Verify: do stress test, by opening IndexReaders and
 		// IndexWriters over & over in 2 threads and making sure
 		// no unexpected exceptions are raised, but use
 		// NativeFSLockFactory:
 		public virtual void  testStressLocksNativeFSLockFactory()
 		{
 			_TestStressLocks(new NativeFSLockFactory("index.TestLockFactory7"), "index.TestLockFactory7");
 		}

 		public virtual void  _TestStressLocks(LockFactory lockFactory, System.String indexDirName)
 		{
 			FSDirectory fs1 = FSDirectory.GetDirectory(indexDirName, lockFactory);

 			// First create a 1 doc index:
 			IndexWriter w = new IndexWriter(fs1, new WhitespaceAnalyzer(), true);
 			AddDoc(w);
 			w.Close();

 			WriterThread writer = new WriterThread(this, 100, fs1);
 			SearcherThread searcher = new SearcherThread(this, 100, fs1);
 			writer.Start();
 			searcher.Start();

 			while (writer.IsAlive || searcher.IsAlive)
 			{
 				try
 				{
 					System.Threading.Thread.Sleep(new System.TimeSpan((System.Int64) 10000 * 1000));
 				}
 				catch (System.Threading.ThreadInterruptedException)
 				{
 				}
 			}

 			Assert.IsTrue(!writer.hitException, "IndexWriter hit unexpected exceptions");
 			Assert.IsTrue(!searcher.hitException, "IndexSearcher hit unexpected exceptions");

 			// Cleanup
 			RmDir(indexDirName);
 		}

 		// Verify: NativeFSLockFactory works correctly
 		[Test]
 		public virtual void  TestNativeFSLockFactory()
 		{
 			System.String altTempDir = System.IO.Path.GetTempPath();

 			NativeFSLockFactory f = new NativeFSLockFactory(SupportClass.AppSettings.Get("tempDir", altTempDir));

 			NativeFSLockFactory f2 = new NativeFSLockFactory(SupportClass.AppSettings.Get("tempDir", altTempDir));

 			f.SetLockPrefix("test");
 			Lock l = f.MakeLock("commit");
 			Lock l2 = f.MakeLock("commit");

 			Assert.IsTrue(l.Obtain(), "failed to obtain lock");
 			Assert.IsTrue(!l2.Obtain(), "succeeded in obtaining lock twice");
 			l.Release();

 			Assert.IsTrue(l2.Obtain(), "failed to obtain 2nd lock after first one was freed");
 			l2.Release();

 			// Make sure we can obtain first one again:
 			Assert.IsTrue(l.Obtain(), "failed to obtain lock");
 			l.Release();
 		}

 		// Verify: NativeFSLockFactory assigns different lock
 		// prefixes to different directories:
 		[Test]
 		public virtual void  TestNativeFSLockFactoryPrefix()
 		{

 			// Make sure we get identical instances:
 			Directory dir1 = FSDirectory.GetDirectory("TestLockFactory.8", new NativeFSLockFactory("TestLockFactory.8"));
 			Directory dir2 = FSDirectory.GetDirectory("TestLockFactory.9", new NativeFSLockFactory("TestLockFactory.9"));

 			System.String prefix1 = dir1.GetLockFactory().GetLockPrefix();
 			System.String prefix2 = dir2.GetLockFactory().GetLockPrefix();

 			Assert.IsTrue(!prefix1.Equals(prefix2), "Native Lock Factories are incorrectly shared: dir1 and dir2 have same lock prefix '" + prefix1 + "'; they should be different");
 			RmDir("TestLockFactory.8");
 			RmDir("TestLockFactory.9");
 		}

 		// Verify: default LockFactory has no prefix (ie
 		// write.lock is stored in index):
 		[Test]
 		public virtual void  TestDefaultFSLockFactoryPrefix()
 		{

 			// Make sure we get null prefix:
 			Directory dir = FSDirectory.GetDirectory("TestLockFactory.10");

 			System.String prefix = dir.GetLockFactory().GetLockPrefix();

 			Assert.IsTrue(null == prefix, "Default lock prefix should be null");

 			RmDir("TestLockFactory.10");
 		}

 		private class WriterThread : SupportClass.ThreadClass
 		{
 			private void  InitBlock(TestLockFactory enclosingInstance)
 			{
 				this.enclosingInstance = enclosingInstance;
 			}
 			private TestLockFactory enclosingInstance;
 			public TestLockFactory Enclosing_Instance
 			{
 				get
 				{
 					return enclosingInstance;
 				}

 			}
 			private Directory dir;
 			private int numIteration;
 			public bool hitException = false;
 			public WriterThread(TestLockFactory enclosingInstance, int numIteration, Directory dir)
 			{
 				InitBlock(enclosingInstance);
 				this.numIteration = numIteration;
 				this.dir = dir;
 			}
 			override public void  Run()
 			{
 				WhitespaceAnalyzer analyzer = new WhitespaceAnalyzer();
 				IndexWriter writer = null;
 				for (int i = 0; i < this.numIteration; i++)
 				{
 					try
 					{
 						writer = new IndexWriter(dir, analyzer, false);
 					}
 					catch (System.IO.IOException e)
 					{
 						if (e.ToString().IndexOf(" timed out:") == - 1)
 						{
 							hitException = true;
 						}
 						else
 						{
 							// lock obtain timed out
 							// NOTE: we should at some point
 							// consider this a failure?  The lock
 							// obtains, across IndexReader &
 							// IndexWriters should be "fair" (ie
 							// FIFO).
 						}
 					}
 					catch (System.Exception e)
 					{
 						hitException = true;
 						System.Console.Out.WriteLine("Stress Test Index Writer: creation hit unexpected exception: " + e.ToString());
 						System.Console.Error.WriteLine(e.StackTrace);
 						break;
 					}
 					if (writer != null)
 					{
 						try
 						{
 							Enclosing_Instance.AddDoc(writer);
 						}
 						catch (System.IO.IOException e)
 						{
 							hitException = true;
 							System.Console.Out.WriteLine("Stress Test Index Writer: AddDoc hit unexpected exception: " + e.ToString());
 							System.Console.Error.WriteLine(e.StackTrace);
 							break;
 						}
 						try
 						{
 							writer.Close();
 						}
 						catch (System.IO.IOException e)
 						{
 							hitException = true;
 							System.Console.Out.WriteLine("Stress Test Index Writer: close hit unexpected exception: " + e.ToString());
 							System.Console.Error.WriteLine(e.StackTrace);
 							break;
 						}
 						writer = null;
 					}
 				}
 			}
 		}

 		private class SearcherThread : SupportClass.ThreadClass
 		{
 			private void  InitBlock(TestLockFactory enclosingInstance)
 			{
 				this.enclosingInstance = enclosingInstance;
 			}
 			private TestLockFactory enclosingInstance;
 			public TestLockFactory Enclosing_Instance
 			{
 				get
 				{
 					return enclosingInstance;
 				}

 			}
 			private Directory dir;
 			private int numIteration;
 			public bool hitException = false;
 			public SearcherThread(TestLockFactory enclosingInstance, int numIteration, Directory dir)
 			{
 				InitBlock(enclosingInstance);
 				this.numIteration = numIteration;
 				this.dir = dir;
 			}
 			override public void  Run()
 			{
 				IndexSearcher searcher = null;
 				WhitespaceAnalyzer analyzer = new WhitespaceAnalyzer();
 				Query query = new TermQuery(new Term("content", "aaa"));
 				for (int i = 0; i < this.numIteration; i++)
 				{
 					try
 					{
 						searcher = new IndexSearcher(dir);
 					}
 					catch (System.Exception e)
 					{
 						hitException = true;
 						System.Console.Out.WriteLine("Stress Test Index Searcher: create hit unexpected exception: " + e.ToString());
 						System.Console.Error.WriteLine(e.StackTrace);
 						break;
 					}
 					if (searcher != null)
 					{
 						Hits hits = null;
 						try
 						{
 							hits = searcher.Search(query);
 						}
 						catch (System.IO.IOException e)
 						{
 							hitException = true;
 							System.Console.Out.WriteLine("Stress Test Index Searcher: search hit unexpected exception: " + e.ToString());
 							System.Console.Error.WriteLine(e.StackTrace);
 							break;
 						}
 						// System.out.println(hits.length() + " total results");
 						try
 						{
 							searcher.Close();
 						}
 						catch (System.IO.IOException e)
 						{
 							hitException = true;
 							System.Console.Out.WriteLine("Stress Test Index Searcher: close hit unexpected exception: " + e.ToString());
 							System.Console.Out.WriteLine(e.StackTrace);
 							break;
 						}
 						searcher = null;
 					}
 				}
 			}
 		}

 		public class MockLockFactory : LockFactory
 		{
 			public MockLockFactory(TestLockFactory enclosingInstance)
 			{
 				InitBlock(enclosingInstance);
 			}
 			private void  InitBlock(TestLockFactory enclosingInstance)
 			{
 				this.enclosingInstance = enclosingInstance;
 			}
 			private TestLockFactory enclosingInstance;
 			public TestLockFactory Enclosing_Instance
 			{
 				get
 				{
 					return enclosingInstance;
 				}

 			}

 			public bool lockPrefixSet;
 			public System.Collections.Hashtable locksCreated = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
 			public int makeLockCount = 0;

 			public override void  SetLockPrefix(System.String lockPrefix)
 			{
 				base.SetLockPrefix(lockPrefix);
 				lockPrefixSet = true;
 			}

 			public override Lock MakeLock(System.String lockName)
 			{
 				lock (this)
 				{
 					Lock lock_Renamed = new MockLock(this);
 					locksCreated[lockName] = lock_Renamed;
 					makeLockCount++;
 					return lock_Renamed;
 				}
 			}

 			public override void  ClearLock(System.String specificLockName)
 			{
 			}

 			public class MockLock : Lock
 			{
 				public MockLock(MockLockFactory enclosingInstance)
 				{
 					InitBlock(enclosingInstance);
 				}
 				private void  InitBlock(MockLockFactory enclosingInstance)
 				{
 					this.enclosingInstance = enclosingInstance;
 				}
 				private MockLockFactory enclosingInstance;
 				public MockLockFactory Enclosing_Instance
 				{
 					get
 					{
 						return enclosingInstance;
 					}

 				}
 				public int lockAttempts;

 				public override bool Obtain()
 				{
 					lockAttempts++;
 					return true;
 				}
 				public override void  Release()
 				{
 					// do nothing
 				}
 				public override bool IsLocked()
 				{
 					return false;
 				}
 			}
 		}

 		private void  AddDoc(IndexWriter writer)
 		{
 			Document doc = new Document();
 			doc.Add(new Field("content", "aaa", Field.Store.NO, Field.Index.TOKENIZED));
 			writer.AddDocument(doc);
 		}

 		private void  RmDir(System.String dirName)
 		{
 			System.IO.FileInfo dir = new System.IO.FileInfo(dirName);
 			System.String[] files = System.IO.Directory.GetFileSystemEntries(dir.FullName); // clear old files
 			for (int i = 0; i < files.Length; i++)
 			{
 				System.IO.FileInfo file = new System.IO.FileInfo(files[i]);
 				bool tmpBool;
 				if (System.IO.File.Exists(file.FullName))
 				{
 					System.IO.File.Delete(file.FullName);
 					tmpBool = true;
 				}
 				else if (System.IO.Directory.Exists(file.FullName))
 				{
 					System.IO.Directory.Delete(file.FullName);
 					tmpBool = true;
 				}
 				else
 					tmpBool = false;
 				bool generatedAux = tmpBool;
 			}
 			bool tmpBool2;
 			if (System.IO.File.Exists(dir.FullName))
 			{
 				System.IO.File.Delete(dir.FullName);
 				tmpBool2 = true;
 			}
 			else if (System.IO.Directory.Exists(dir.FullName))
 			{
 				System.IO.Directory.Delete(dir.FullName);
 				tmpBool2 = true;
 			}
 			else
 				tmpBool2 = false;
 			bool generatedAux2 = tmpBool2;
 		}
 	}
 }
	/*
	* 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;

	using NUnit.Framework;

	using Document = Lucene.Net.Documents.Document;
	using Field = Lucene.Net.Documents.Field;
	using IndexReader = Lucene.Net.Index.IndexReader;
	using IndexWriter = Lucene.Net.Index.IndexWriter;
	using Term = Lucene.Net.Index.Term;
	using WhitespaceAnalyzer = Lucene.Net.Analysis.WhitespaceAnalyzer;
	using Hits = Lucene.Net.Search.Hits;
	using IndexSearcher = Lucene.Net.Search.IndexSearcher;
	using Query = Lucene.Net.Search.Query;
	using TermQuery = Lucene.Net.Search.TermQuery;
	using LuceneTestCase = Lucene.Net.Util.LuceneTestCase;

	namespace Lucene.Net.Store
	{

	[TestFixture]
	public class TestLockFactory : LuceneTestCase
	{

	// Verify: we can provide our own LockFactory implementation, the right
	// methods are called at the right time, locks are created, etc.
	[Test]
	public virtual void TestCustomLockFactory()
	{
	Directory dir = new RAMDirectory();
	MockLockFactory lf = new MockLockFactory(this);
	dir.SetLockFactory(lf);

	// Lock prefix should have been set:
	Assert.IsTrue(lf.lockPrefixSet, "lock prefix was not set by the RAMDirectory");

	IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true);

	// add 100 documents (so that commit lock is used)
	for (int i = 0; i < 100; i++)
	{
	AddDoc(writer);
	}

	// Both write lock and commit lock should have been created:
	Assert.AreEqual(1, lf.locksCreated.Count, "# of unique locks created (after instantiating IndexWriter)");
	Assert.IsTrue(lf.makeLockCount >= 1, "# calls to makeLock is 0 (after instantiating IndexWriter)");

	for (System.Collections.IEnumerator e = lf.locksCreated.Keys.GetEnumerator(); e.MoveNext(); )
	{
	System.String lockName = (System.String) e.Current;
	MockLockFactory.MockLock lock_Renamed = (MockLockFactory.MockLock) lf.locksCreated[lockName];
	Assert.IsTrue(lock_Renamed.lockAttempts > 0, "# calls to Lock.obtain is 0 (after instantiating IndexWriter)");
	}

	writer.Close();
	}

	// Verify: we can use the NoLockFactory with RAMDirectory w/ no
	// exceptions raised:
	// Verify: NoLockFactory allows two IndexWriters
	[Test]
	public virtual void TestRAMDirectoryNoLocking()
	{
	Directory dir = new RAMDirectory();
	dir.SetLockFactory(NoLockFactory.GetNoLockFactory());

	Assert.IsTrue(typeof(NoLockFactory).IsInstanceOfType(dir.GetLockFactory()), "RAMDirectory.setLockFactory did not take");

	IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true);

	// Create a 2nd IndexWriter. This is normally not allowed but it should run through since we're not
	// using any locks:
	IndexWriter writer2 = null;
	try
	{
	writer2 = new IndexWriter(dir, new WhitespaceAnalyzer(), false);
	}
	catch (System.Exception e)
	{
	System.Console.Out.WriteLine(e.StackTrace);
	Assert.Fail("Should not have hit an IOException with no locking");
	}

	writer.Close();
	if (writer2 != null)
	{
	writer2.Close();
	}
	}

	// Verify: SingleInstanceLockFactory is the default lock for RAMDirectory
	// Verify: RAMDirectory does basic locking correctly (can't create two IndexWriters)
	[Test]
	public virtual void TestDefaultRAMDirectory()
	{
	Directory dir = new RAMDirectory();

	Assert.IsTrue(typeof(SingleInstanceLockFactory).IsInstanceOfType(dir.GetLockFactory()), "RAMDirectory did not use correct LockFactory: got " + dir.GetLockFactory());

	IndexWriter writer = new IndexWriter(dir, new WhitespaceAnalyzer(), true);

	// Create a 2nd IndexWriter. This should fail:
	IndexWriter writer2 = null;
	try
	{
	writer2 = new IndexWriter(dir, new WhitespaceAnalyzer(), false);
	Assert.Fail("Should have hit an IOException with two IndexWriters on default SingleInstanceLockFactory");
	}
	catch (System.IO.IOException)
	{
	}

	writer.Close();
	if (writer2 != null)
	{
	writer2.Close();
	}
	}

	// Verify: SimpleFSLockFactory is the default for FSDirectory
	// Verify: FSDirectory does basic locking correctly
	[Test]
	public virtual void TestDefaultFSDirectory()
	{
	System.String indexDirName = "index.TestLockFactory1";

	IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);

	Assert.IsTrue(typeof(SimpleFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()) \|\| typeof(NativeFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());

	IndexWriter writer2 = null;

	// Create a 2nd IndexWriter. This should fail:
	try
	{
	writer2 = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), false);
	Assert.Fail("Should have hit an IOException with two IndexWriters on default SimpleFSLockFactory");
	}
	catch (System.IO.IOException)
	{
	}

	writer.Close();
	if (writer2 != null)
	{
	writer2.Close();
	}

	// Cleanup
	RmDir(indexDirName);
	}

	// Verify: FSDirectory's default lockFactory clears all locks correctly
	[Test]
	public virtual void TestFSDirectoryTwoCreates()
	{
	System.String indexDirName = "index.TestLockFactory2";

	IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);

	Assert.IsTrue(typeof(SimpleFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()) \|\| typeof(NativeFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());

	// Intentionally do not close the first writer here.
	// The goal is to "simulate" a crashed writer and
	// ensure the second writer, with create=true, is
	// able to remove the lock files. This works OK
	// with SimpleFSLockFactory as the locking
	// implementation. Note, however, that this test
	// will not work on WIN32 when we switch to
	// NativeFSLockFactory as the default locking for
	// FSDirectory because the second IndexWriter cannot
	// remove those lock files since they are held open
	// by the first writer. This is because leaving the
	// first IndexWriter open is not really a good way
	// to simulate a crashed writer.

	// Create a 2nd IndexWriter. This should not fail:
	IndexWriter writer2 = null;
	try
	{
	writer2 = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
	}
	catch (System.IO.IOException e)
	{
	System.Console.Error.WriteLine(e.StackTrace);
	Assert.Fail("Should not have hit an IOException with two IndexWriters with create=true, on default SimpleFSLockFactory");
	}

	writer.Close();
	if (writer2 != null)
	{
	try
	{
	writer2.Close();
	// expected
	}
	catch (LockReleaseFailedException)
	{
	Assert.Fail("writer2.close() should not have hit LockReleaseFailedException");
	}
	}

	// Cleanup
	RmDir(indexDirName);
	}


	// Verify: setting custom lock factory class (as system property) works:
	// Verify: all 4 builtin LockFactory implementations are
	// settable this way
	// Verify: FSDirectory does basic locking correctly
	[Test]
	public virtual void TestLockClassProperty()
	{
	System.String indexDirName = "index.TestLockFactory3";
	System.String prpName = "Lucene.Net.Store.FSDirectoryLockFactoryClass";

	try
	{

	// NoLockFactory:
	SupportClass.AppSettings.Set(prpName, "Lucene.Net.Store.NoLockFactory");
	IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
	Assert.IsTrue(typeof(NoLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());
	writer.Close();

	// SingleInstanceLockFactory:
	SupportClass.AppSettings.Set(prpName, "Lucene.Net.Store.SingleInstanceLockFactory");
	writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
	Assert.IsTrue(typeof(SingleInstanceLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());
	writer.Close();

	// NativeFSLockFactory:
	SupportClass.AppSettings.Set(prpName, "Lucene.Net.Store.NativeFSLockFactory");
	writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
	Assert.IsTrue(typeof(NativeFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());
	writer.Close();

	// SimpleFSLockFactory:
	SupportClass.AppSettings.Set(prpName, "Lucene.Net.Store.SimpleFSLockFactory");
	writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);
	Assert.IsTrue(typeof(SimpleFSLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct LockFactory: got " + writer.GetDirectory().GetLockFactory());
	writer.Close();
	}
	finally
	{
	// Put back to the correct default for subsequent tests:
	SupportClass.AppSettings.Set("Lucene.Net.Store.FSDirectoryLockFactoryClass", "");
	}

	// Cleanup
	RmDir(indexDirName);
	}

	// Verify: setDisableLocks works
	[Test]
	public virtual void TestDisableLocks()
	{
	System.String indexDirName = "index.TestLockFactory4";

	Assert.IsTrue(!FSDirectory.GetDisableLocks(), "Locks are already disabled");
	FSDirectory.SetDisableLocks(true);

	IndexWriter writer = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), true);

	Assert.IsTrue(typeof(NoLockFactory).IsInstanceOfType(writer.GetDirectory().GetLockFactory()), "FSDirectory did not use correct default LockFactory: got " + writer.GetDirectory().GetLockFactory());

	// Should be no error since locking is disabled:
	IndexWriter writer2 = null;
	try
	{
	writer2 = new IndexWriter(indexDirName, new WhitespaceAnalyzer(), false);
	}
	catch (System.IO.IOException e)
	{
	System.Console.Error.WriteLine(e.StackTrace);
	Assert.Fail("Should not have hit an IOException with locking disabled");
	}

	FSDirectory.SetDisableLocks(false);
	writer.Close();
	if (writer2 != null)
	{
	writer2.Close();
	}
	// Cleanup
	RmDir(indexDirName);
	}

	// Verify: if I try to getDirectory() with two different locking implementations, I get an IOException
	[Test]
	public virtual void TestFSDirectoryDifferentLockFactory()
	{
	System.String indexDirName = "index.TestLockFactory5";

	LockFactory lf = new SingleInstanceLockFactory();
	FSDirectory fs1 = FSDirectory.GetDirectory(indexDirName, lf);

	// Different lock factory instance should hit IOException:
	try
	{
	FSDirectory fs2 = FSDirectory.GetDirectory(indexDirName, new SingleInstanceLockFactory());
	Assert.Fail("Should have hit an IOException because LockFactory instances differ");
	}
	catch (System.IO.IOException)
	{
	}

	FSDirectory fs3 = null;

	// Same lock factory instance should not:
	try
	{
	fs3 = FSDirectory.GetDirectory(indexDirName, lf);
	}
	catch (System.IO.IOException e)
	{
	System.Console.Error.WriteLine(e.StackTrace);
	Assert.Fail("Should not have hit an IOException because LockFactory instances are the same");
	}

	fs1.Close();
	if (fs3 != null)
	{
	fs3.Close();
	}
	// Cleanup
	RmDir(indexDirName);
	}

	// Verify: do stress test, by opening IndexReaders and
	// IndexWriters over & over in 2 threads and making sure
	// no unexpected exceptions are raised:
	[Test]
	public virtual void TestStressLocks()
	{
	_TestStressLocks(null, "index.TestLockFactory6");
	}

	// Verify: do stress test, by opening IndexReaders and
	// IndexWriters over & over in 2 threads and making sure
	// no unexpected exceptions are raised, but use
	// NativeFSLockFactory:
	public virtual void testStressLocksNativeFSLockFactory()
	{
	_TestStressLocks(new NativeFSLockFactory("index.TestLockFactory7"), "index.TestLockFactory7");
	}

	public virtual void _TestStressLocks(LockFactory lockFactory, System.String indexDirName)
	{
	FSDirectory fs1 = FSDirectory.GetDirectory(indexDirName, lockFactory);

	// First create a 1 doc index:
	IndexWriter w = new IndexWriter(fs1, new WhitespaceAnalyzer(), true);
	AddDoc(w);
	w.Close();

	WriterThread writer = new WriterThread(this, 100, fs1);
	SearcherThread searcher = new SearcherThread(this, 100, fs1);
	writer.Start();
	searcher.Start();

	while (writer.IsAlive \|\| searcher.IsAlive)
	{
	try
	{
	System.Threading.Thread.Sleep(new System.TimeSpan((System.Int64) 10000 * 1000));
	}
	catch (System.Threading.ThreadInterruptedException)
	{
	}
	}

	Assert.IsTrue(!writer.hitException, "IndexWriter hit unexpected exceptions");
	Assert.IsTrue(!searcher.hitException, "IndexSearcher hit unexpected exceptions");

	// Cleanup
	RmDir(indexDirName);
	}

	// Verify: NativeFSLockFactory works correctly
	[Test]
	public virtual void TestNativeFSLockFactory()
	{
	System.String altTempDir = System.IO.Path.GetTempPath();

	NativeFSLockFactory f = new NativeFSLockFactory(SupportClass.AppSettings.Get("tempDir", altTempDir));

	NativeFSLockFactory f2 = new NativeFSLockFactory(SupportClass.AppSettings.Get("tempDir", altTempDir));

	f.SetLockPrefix("test");
	Lock l = f.MakeLock("commit");
	Lock l2 = f.MakeLock("commit");

	Assert.IsTrue(l.Obtain(), "failed to obtain lock");
	Assert.IsTrue(!l2.Obtain(), "succeeded in obtaining lock twice");
	l.Release();

	Assert.IsTrue(l2.Obtain(), "failed to obtain 2nd lock after first one was freed");
	l2.Release();

	// Make sure we can obtain first one again:
	Assert.IsTrue(l.Obtain(), "failed to obtain lock");
	l.Release();
	}

	// Verify: NativeFSLockFactory assigns different lock
	// prefixes to different directories:
	[Test]
	public virtual void TestNativeFSLockFactoryPrefix()
	{

	// Make sure we get identical instances:
	Directory dir1 = FSDirectory.GetDirectory("TestLockFactory.8", new NativeFSLockFactory("TestLockFactory.8"));
	Directory dir2 = FSDirectory.GetDirectory("TestLockFactory.9", new NativeFSLockFactory("TestLockFactory.9"));

	System.String prefix1 = dir1.GetLockFactory().GetLockPrefix();
	System.String prefix2 = dir2.GetLockFactory().GetLockPrefix();

	Assert.IsTrue(!prefix1.Equals(prefix2), "Native Lock Factories are incorrectly shared: dir1 and dir2 have same lock prefix '" + prefix1 + "'; they should be different");
	RmDir("TestLockFactory.8");
	RmDir("TestLockFactory.9");
	}

	// Verify: default LockFactory has no prefix (ie
	// write.lock is stored in index):
	[Test]
	public virtual void TestDefaultFSLockFactoryPrefix()
	{

	// Make sure we get null prefix:
	Directory dir = FSDirectory.GetDirectory("TestLockFactory.10");

	System.String prefix = dir.GetLockFactory().GetLockPrefix();

	Assert.IsTrue(null == prefix, "Default lock prefix should be null");

	RmDir("TestLockFactory.10");
	}

	private class WriterThread : SupportClass.ThreadClass
	{
	private void InitBlock(TestLockFactory enclosingInstance)
	{
	this.enclosingInstance = enclosingInstance;
	}
	private TestLockFactory enclosingInstance;
	public TestLockFactory Enclosing_Instance
	{
	get
	{
	return enclosingInstance;
	}

	}
	private Directory dir;
	private int numIteration;
	public bool hitException = false;
	public WriterThread(TestLockFactory enclosingInstance, int numIteration, Directory dir)
	{
	InitBlock(enclosingInstance);
	this.numIteration = numIteration;
	this.dir = dir;
	}
	override public void Run()
	{
	WhitespaceAnalyzer analyzer = new WhitespaceAnalyzer();
	IndexWriter writer = null;
	for (int i = 0; i < this.numIteration; i++)
	{
	try
	{
	writer = new IndexWriter(dir, analyzer, false);
	}
	catch (System.IO.IOException e)
	{
	if (e.ToString().IndexOf(" timed out:") == - 1)
	{
	hitException = true;
	}
	else
	{
	// lock obtain timed out
	// NOTE: we should at some point
	// consider this a failure? The lock
	// obtains, across IndexReader &
	// IndexWriters should be "fair" (ie
	// FIFO).
	}
	}
	catch (System.Exception e)
	{
	hitException = true;
	System.Console.Out.WriteLine("Stress Test Index Writer: creation hit unexpected exception: " + e.ToString());
	System.Console.Error.WriteLine(e.StackTrace);
	break;
	}
	if (writer != null)
	{
	try
	{
	Enclosing_Instance.AddDoc(writer);
	}
	catch (System.IO.IOException e)
	{
	hitException = true;
	System.Console.Out.WriteLine("Stress Test Index Writer: AddDoc hit unexpected exception: " + e.ToString());
	System.Console.Error.WriteLine(e.StackTrace);
	break;
	}
	try
	{
	writer.Close();
	}
	catch (System.IO.IOException e)
	{
	hitException = true;
	System.Console.Out.WriteLine("Stress Test Index Writer: close hit unexpected exception: " + e.ToString());
	System.Console.Error.WriteLine(e.StackTrace);
	break;
	}
	writer = null;
	}
	}
	}
	}

	private class SearcherThread : SupportClass.ThreadClass
	{
	private void InitBlock(TestLockFactory enclosingInstance)
	{
	this.enclosingInstance = enclosingInstance;
	}
	private TestLockFactory enclosingInstance;
	public TestLockFactory Enclosing_Instance
	{
	get
	{
	return enclosingInstance;
	}

	}
	private Directory dir;
	private int numIteration;
	public bool hitException = false;
	public SearcherThread(TestLockFactory enclosingInstance, int numIteration, Directory dir)
	{
	InitBlock(enclosingInstance);
	this.numIteration = numIteration;
	this.dir = dir;
	}
	override public void Run()
	{
	IndexSearcher searcher = null;
	WhitespaceAnalyzer analyzer = new WhitespaceAnalyzer();
	Query query = new TermQuery(new Term("content", "aaa"));
	for (int i = 0; i < this.numIteration; i++)
	{
	try
	{
	searcher = new IndexSearcher(dir);
	}
	catch (System.Exception e)
	{
	hitException = true;
	System.Console.Out.WriteLine("Stress Test Index Searcher: create hit unexpected exception: " + e.ToString());
	System.Console.Error.WriteLine(e.StackTrace);
	break;
	}
	if (searcher != null)
	{
	Hits hits = null;
	try
	{
	hits = searcher.Search(query);
	}
	catch (System.IO.IOException e)
	{
	hitException = true;
	System.Console.Out.WriteLine("Stress Test Index Searcher: search hit unexpected exception: " + e.ToString());
	System.Console.Error.WriteLine(e.StackTrace);
	break;
	}
	// System.out.println(hits.length() + " total results");
	try
	{
	searcher.Close();
	}
	catch (System.IO.IOException e)
	{
	hitException = true;
	System.Console.Out.WriteLine("Stress Test Index Searcher: close hit unexpected exception: " + e.ToString());
	System.Console.Out.WriteLine(e.StackTrace);
	break;
	}
	searcher = null;
	}
	}
	}
	}

	public class MockLockFactory : LockFactory
	{
	public MockLockFactory(TestLockFactory enclosingInstance)
	{
	InitBlock(enclosingInstance);
	}
	private void InitBlock(TestLockFactory enclosingInstance)
	{
	this.enclosingInstance = enclosingInstance;
	}
	private TestLockFactory enclosingInstance;
	public TestLockFactory Enclosing_Instance
	{
	get
	{
	return enclosingInstance;
	}

	}

	public bool lockPrefixSet;
	public System.Collections.Hashtable locksCreated = System.Collections.Hashtable.Synchronized(new System.Collections.Hashtable());
	public int makeLockCount = 0;

	public override void SetLockPrefix(System.String lockPrefix)
	{
	base.SetLockPrefix(lockPrefix);
	lockPrefixSet = true;
	}

	public override Lock MakeLock(System.String lockName)
	{
	lock (this)
	{
	Lock lock_Renamed = new MockLock(this);
	locksCreated[lockName] = lock_Renamed;
	makeLockCount++;
	return lock_Renamed;
	}
	}

	public override void ClearLock(System.String specificLockName)
	{
	}

	public class MockLock : Lock
	{
	public MockLock(MockLockFactory enclosingInstance)
	{
	InitBlock(enclosingInstance);
	}
	private void InitBlock(MockLockFactory enclosingInstance)
	{
	this.enclosingInstance = enclosingInstance;
	}
	private MockLockFactory enclosingInstance;
	public MockLockFactory Enclosing_Instance
	{
	get
	{
	return enclosingInstance;
	}

	}
	public int lockAttempts;

	public override bool Obtain()
	{
	lockAttempts++;
	return true;
	}
	public override void Release()
	{
	// do nothing
	}
	public override bool IsLocked()
	{
	return false;
	}
	}
	}

	private void AddDoc(IndexWriter writer)
	{
	Document doc = new Document();
	doc.Add(new Field("content", "aaa", Field.Store.NO, Field.Index.TOKENIZED));
	writer.AddDocument(doc);
	}

	private void RmDir(System.String dirName)
	{
	System.IO.FileInfo dir = new System.IO.FileInfo(dirName);
	System.String[] files = System.IO.Directory.GetFileSystemEntries(dir.FullName); // clear old files
	for (int i = 0; i < files.Length; i++)
	{
	System.IO.FileInfo file = new System.IO.FileInfo(files[i]);
	bool tmpBool;
	if (System.IO.File.Exists(file.FullName))
	{
	System.IO.File.Delete(file.FullName);
	tmpBool = true;
	}
	else if (System.IO.Directory.Exists(file.FullName))
	{
	System.IO.Directory.Delete(file.FullName);
	tmpBool = true;
	}
	else
	tmpBool = false;
	bool generatedAux = tmpBool;
	}
	bool tmpBool2;
	if (System.IO.File.Exists(dir.FullName))
	{
	System.IO.File.Delete(dir.FullName);
	tmpBool2 = true;
	}
	else if (System.IO.Directory.Exists(dir.FullName))
	{
	System.IO.Directory.Delete(dir.FullName);
	tmpBool2 = true;
	}
	else
	tmpBool2 = false;
	bool generatedAux2 = tmpBool2;
	}
	}
	}