[Nhibernate-commit] NHibernateContrib/src/NHibernate.Caches.Prevalence AssemblyInfo.cs,NONE,1.1 CacheEntry.cs,NONE,1.1 CacheSystem.cs,NONE,1.1 NHibernate.Caches.Prevalence-1.1.csproj,NONE,1.1 NHibernate.Caches.Prevalence.Tests-1.1.csproj,NONE,1.1 NHibernate.Caches.Prevalence.xml,NONE,1.1 prevalencecache.build,NONE,1.1 prevalencecache.config,NONE,1.1 PrevalenceCache.cs,NONE,1.1 prevalencecache.nunit,NONE,1.1 PrevalenceCacheFixture.cs,NONE,1.1 PrevalenceCacheProvider.cs,NONE,1.1 PrevalenceCacheProviderFixture.cs,NONE,1.1

[Kevin W. <kev...@us...>]

Update of /cvsroot/nhibernate/NHibernateContrib/src/NHibernate.Caches.Prevalence
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv28723

Added Files:
	AssemblyInfo.cs CacheEntry.cs CacheSystem.cs 
	NHibernate.Caches.Prevalence-1.1.csproj 
	NHibernate.Caches.Prevalence.Tests-1.1.csproj 
	NHibernate.Caches.Prevalence.xml prevalencecache.build 
	prevalencecache.config PrevalenceCache.cs 
	prevalencecache.nunit PrevalenceCacheFixture.cs 
	PrevalenceCacheProvider.cs PrevalenceCacheProviderFixture.cs 
Log Message:
adding pervalence cache provider

--- NEW FILE: CacheSystem.cs ---
using System;
using System.Collections.Specialized;
using Bamboo.Prevalence;

namespace NHibernate.Caches.Prevalence
{
	/// <summary>
	/// Summary description for CacheSystem.
	/// </summary>
	[Serializable]
	internal class CacheSystem : MarshalByRefObject
	{
		private HybridDictionary _items;

		/// <summary>
		/// default constructor
		/// </summary>
		public CacheSystem()
		{
			_items = new HybridDictionary();
		}

		/// <summary>
		/// retrieve the value for the given key
		/// </summary>
		/// <param name="key"></param>
		/// <returns></returns>
		public object Get( object key )
		{
			CacheEntry entry = _items[key] as CacheEntry;
			if( entry == null )
			{
				return null;
			}
			return entry.Value;
		}

		/// <summary>
		/// add or update an object in the cache
		/// </summary>
		/// <param name="key"></param>
		/// <param name="value"></param>
		public void Add( object key, object value )
		{
			CacheEntry entry = _items[key] as CacheEntry;
			if( entry == null )
			{
				entry = new CacheEntry();
				entry.Key = key;
				entry.Value = value;
				entry.DateCreated = PrevalenceEngine.Now;
				_items.Add( key, entry );
			}
			else
			{
				entry.Value = value;
				_items[key] = entry;
			}
		}

		/// <summary>
		/// remove an item from the cache
		/// </summary>
		/// <param name="key"></param>
		public void Remove( object key )
		{
			_items.Remove( key );
		}

		/// <summary>
		/// clear the cache
		/// </summary>
		public void Clear()
		{
			_items.Clear();
		}
	}
}
--- NEW FILE: CacheEntry.cs ---
using System;

namespace NHibernate.Caches.Prevalence
{
	/// <summary>
	/// An item in the cache
	/// </summary>
	[Serializable]
	public class CacheEntry
	{
		private object _key;
		private object _value;
		private DateTime _dateCreated;

		/// <summary>
		/// the unique identifier
		/// </summary>
		public object Key
		{
			get { return _key; }
			set { _key = value; }
		}

		/// <summary>
		/// the value
		/// </summary>
		public object Value
		{
			get { return _value; }
			set { _value = value; }
		}

		/// <summary>
		/// the unique timestamp
		/// </summary>
		public DateTime DateCreated
		{
			get { return _dateCreated; }
			set { _dateCreated = value; }
		}
	}
}
--- NEW FILE: PrevalenceCacheProvider.cs ---
using System;
using System.Collections;
using System.Text;
using log4net;
using NHibernate.Cache;

namespace NHibernate.Caches.Prevalence
{
	/// <summary>
	/// Cache provider using <a href="http://bbooprevalence.sourceforge.net/">Bamboo Prevalence</a>,
	/// a Prevayler implementation in .NET.
	/// </summary>
	public class PrevalenceCacheProvider : ICacheProvider
	{
		private static readonly ILog log = LogManager.GetLogger( typeof( PrevalenceCacheProvider ) );

		/// <summary>
		/// build and return a new cache implementation
		/// </summary>
		/// <param name="regionName"></param>
		/// <param name="properties"></param>
		/// <returns></returns>
		[CLSCompliant(false)]
		public ICache BuildCache( string regionName, IDictionary properties )
		{
			if( regionName == null )
			{
				regionName = "";
			}
			if( properties == null )
			{
				properties = new Hashtable();
			}
			if( log.IsDebugEnabled )
			{
				StringBuilder sb = new StringBuilder();
				foreach( DictionaryEntry de in properties )
				{
					sb.Append( "name=" );
					sb.Append( de.Key.ToString() );
					sb.Append( "&value=" );
					sb.Append( de.Value.ToString() );
					sb.Append( ";" );
				}
				log.Debug( "building cache with region: " + regionName + ", properties: " + sb.ToString() );
			}
			return new PrevalenceCache( regionName, properties );
		}

		/// <summary></summary>
		/// <returns></returns>
		public long NextTimestamp()
		{
			return Timestamper.Next();
		}
	}
}
--- NEW FILE: NHibernate.Caches.Prevalence.Tests-1.1.csproj ---
<VisualStudioProject>
    <CSHARP
        ProjectType = "Local"
        ProductVersion = "7.10.3077"
        SchemaVersion = "2.0"
        ProjectGuid = "{C04709C0-2FF9-424A-82FF-235312877853}"
    >
        <Build>
            <Settings
                ApplicationIcon = ""
                AssemblyKeyContainerName = ""
                AssemblyName = "NHibernate.Caches.Prevalence.Tests"
                AssemblyOriginatorKeyFile = ""
                DefaultClientScript = "JScript"
                DefaultHTMLPageLayout = "Grid"
                DefaultTargetSchema = "IE50"
                DelaySign = "false"
                OutputType = "Library"
                PreBuildEvent = ""
                PostBuildEvent = ""
                RootNamespace = "NHibernate.Caches.Prevalence.Tests"
                RunPostBuildEvent = "OnBuildSuccess"
                StartupObject = ""
            >
                <Config
                    Name = "Debug"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "DEBUG;TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "true"
                    FileAlignment = "4096"
                    IncrementalBuild = "false"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "false"
                    OutputPath = "bin\Debug\"
                    RegisterForComInterop = "false"
                    RemoveIntegerChecks = "false"
                    TreatWarningsAsErrors = "false"
                    WarningLevel = "4"
                />
                <Config
                    Name = "Release"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "false"
                    FileAlignment = "4096"
                    IncrementalBuild = "false"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "true"
                    OutputPath = "bin\Release\"
                    RegisterForComInterop = "false"
                    RemoveIntegerChecks = "false"
                    TreatWarningsAsErrors = "false"
                    WarningLevel = "4"
                />
            </Settings>
            <References>
                <Reference
                    Name = "System"
                    AssemblyName = "System"
                    HintPath = "..\..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.dll"
                />
                <Reference
                    Name = "System.Data"
                    AssemblyName = "System.Data"
                    HintPath = "..\..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
                />
                <Reference
                    Name = "System.XML"
                    AssemblyName = "System.Xml"
                    HintPath = "..\..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
                />
                <Reference
                    Name = "nunit.framework"
                    AssemblyName = "nunit.framework"
                    HintPath = "..\..\lib\net\1.1\nunit.framework.dll"
                />
                <Reference
                    Name = "NHibernate.Caches.Prevalence-1.1"
                    Project = "{51179C23-5555-45A4-9BBB-8F6E24D05C2B}"
                    Package = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}"
                />
                <Reference
                    Name = "NHibernate"
                    AssemblyName = "NHibernate"
                    HintPath = "..\..\lib\net\1.1\NHibernate.dll"
                />
                <Reference
                    Name = "log4net"
                    AssemblyName = "log4net"
                    HintPath = "..\..\lib\net\1.1\log4net.dll"
                />
            </References>
        </Build>
        <Files>
            <Include>
                <File
                    RelPath = "AssemblyInfo.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "PrevalenceCacheFixture.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "PrevalenceCacheProviderFixture.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
            </Include>
        </Files>
    </CSHARP>
</VisualStudioProject>


--- NEW FILE: NHibernate.Caches.Prevalence-1.1.csproj ---
<VisualStudioProject>
    <CSHARP
        ProjectType = "Local"
        ProductVersion = "7.10.3077"
        SchemaVersion = "2.0"
        ProjectGuid = "{51179C23-5555-45A4-9BBB-8F6E24D05C2B}"
    >
        <Build>
            <Settings
                ApplicationIcon = ""
                AssemblyKeyContainerName = ""
                AssemblyName = "NHibernate.Caches.Prevalence"
                AssemblyOriginatorKeyFile = ""
                DefaultClientScript = "JScript"
                DefaultHTMLPageLayout = "Grid"
                DefaultTargetSchema = "IE50"
                DelaySign = "false"
                OutputType = "Library"
                PreBuildEvent = ""
                PostBuildEvent = ""
                RootNamespace = "NHibernate.Caches.Prevalence"
                RunPostBuildEvent = "OnBuildSuccess"
                StartupObject = ""
            >
                <Config
                    Name = "Debug"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "DEBUG;TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "true"
                    FileAlignment = "4096"
                    IncrementalBuild = "false"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "false"
                    OutputPath = "bin\Debug\"
                    RegisterForComInterop = "false"
                    RemoveIntegerChecks = "false"
                    TreatWarningsAsErrors = "false"
                    WarningLevel = "4"
                />
                <Config
                    Name = "Release"
                    AllowUnsafeBlocks = "false"
                    BaseAddress = "285212672"
                    CheckForOverflowUnderflow = "false"
                    ConfigurationOverrideFile = ""
                    DefineConstants = "TRACE"
                    DocumentationFile = ""
                    DebugSymbols = "false"
                    FileAlignment = "4096"
                    IncrementalBuild = "false"
                    NoStdLib = "false"
                    NoWarn = ""
                    Optimize = "true"
                    OutputPath = "bin\Release\"
                    RegisterForComInterop = "false"
                    RemoveIntegerChecks = "false"
                    TreatWarningsAsErrors = "false"
                    WarningLevel = "4"
                />
            </Settings>
            <References>
                <Reference
                    Name = "System"
                    AssemblyName = "System"
                    HintPath = "..\..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.dll"
                />
                <Reference
                    Name = "System.Data"
                    AssemblyName = "System.Data"
                    HintPath = "..\..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
                />
                <Reference
                    Name = "System.XML"
                    AssemblyName = "System.Xml"
                    HintPath = "..\..\..\..\..\..\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
                />
                <Reference
                    Name = "Bamboo.Prevalence"
                    AssemblyName = "Bamboo.Prevalence"
                    HintPath = "..\..\lib\Bamboo.Prevalence.dll"
                />
                <Reference
                    Name = "log4net"
                    AssemblyName = "log4net"
                    HintPath = "..\..\lib\net\1.1\log4net.dll"
                />
                <Reference
                    Name = "NHibernate"
                    AssemblyName = "NHibernate"
                    HintPath = "..\..\lib\net\1.1\NHibernate.dll"
                />
            </References>
        </Build>
        <Files>
            <Include>
                <File
                    RelPath = "AssemblyInfo.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "CacheEntry.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "CacheSystem.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "PrevalenceCache.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
                <File
                    RelPath = "PrevalenceCacheProvider.cs"
                    SubType = "Code"
                    BuildAction = "Compile"
                />
            </Include>
        </Files>
    </CSHARP>
</VisualStudioProject>


--- NEW FILE: NHibernate.Caches.Prevalence.xml ---
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>NHibernate.Caches.Prevalence</name>
    </assembly>
    <members>
        <member name="T:NHibernate.Caches.Prevalence.CacheEntry">
            <summary>
            An item in the cache
            </summary>
        </member>
        <member name="P:NHibernate.Caches.Prevalence.CacheEntry.Key">
            <summary>
            the unique identifier
            </summary>
        </member>
        <member name="P:NHibernate.Caches.Prevalence.CacheEntry.Value">
            <summary>
            the value
            </summary>
        </member>
        <member name="P:NHibernate.Caches.Prevalence.CacheEntry.DateCreated">
            <summary>
            the unique timestamp
            </summary>
        </member>
        <member name="T:NHibernate.Caches.Prevalence.CacheSystem">
            <summary>
            Summary description for CacheSystem.
            </summary>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.CacheSystem.#ctor">
            <summary>
            default constructor
            </summary>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.CacheSystem.Get(System.Object)">
            <summary>
            retrieve the value for the given key
            </summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.CacheSystem.Add(System.Object,System.Object)">
            <summary>
            add or update an object in the cache
            </summary>
            <param name="key"></param>
            <param name="value"></param>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.CacheSystem.Remove(System.Object)">
            <summary>
            remove an item from the cache
            </summary>
            <param name="key"></param>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.CacheSystem.Clear">
            <summary>
            clear the cache
            </summary>
        </member>
        <member name="T:NHibernate.Caches.Prevalence.PrevalenceCache">
            <summary>
            Summary description for PrevalenceCache.
            </summary>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.PrevalenceCache.#ctor">
            <summary>
            default constructor
            </summary>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.PrevalenceCache.#ctor(System.String)">
            <summary>
            constructor with no properties
            </summary>
            <param name="region"></param>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.PrevalenceCache.#ctor(System.String,System.Collections.IDictionary)">
            <summary>
            full constructor
            </summary>
            <param name="region"></param>
            <param name="properties">cache configuration properties</param>
            <remarks>There is only one configurable parameter: prevalenceBase. This is
            the directory on the file system where the Prevalence engine will save data.
            It can be relative to the current directory or a full path. If the directory
            doesn't exist, it will be created.</remarks>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.PrevalenceCache.Get(System.Object)">
            <summary></summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.PrevalenceCache.Put(System.Object,System.Object)">
            <summary></summary>
            <param name="key"></param>
            <param name="value"></param>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.PrevalenceCache.Remove(System.Object)">
            <summary></summary>
            <param name="key"></param>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.PrevalenceCache.Clear">
            <summary></summary>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.PrevalenceCache.Destroy">
            <summary></summary>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.PrevalenceCache.Dispose">
            <summary>
            take snapshot before shutting down
            </summary>
        </member>
        <member name="P:NHibernate.Caches.Prevalence.PrevalenceCache.Region">
            <summary></summary>
        </member>
        <member name="T:NHibernate.Caches.Prevalence.PrevalenceCacheProvider">
            <summary>
            Cache provider using <a href="http://bbooprevalence.sourceforge.net/">Bamboo Prevalence</a>,
            a Prevayler implementation in .NET.
            </summary>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.PrevalenceCacheProvider.BuildCache(System.String,System.Collections.IDictionary)">
            <summary>
            build and return a new cache implementation
            </summary>
            <param name="regionName"></param>
            <param name="properties"></param>
            <returns></returns>
        </member>
        <member name="M:NHibernate.Caches.Prevalence.PrevalenceCacheProvider.NextTimestamp">
            <summary></summary>
            <returns></returns>
        </member>
    </members>
</doc>

--- NEW FILE: prevalencecache.build ---
<?xml version="1.0"?>
<project
		name="NHibernate.Caches.Prevalence"
		default="build"
		description="NHibernate pluggable cache provider using Bamboo.Prevalence engine"
		xmlns="http://nant.sourceforge.net/schemas/nant-0.84.win32.net-1.0.xsd">
		
	<!--
		Required properties:
			* build.dir				- (path) root level to build to, assemblies will go in ${build.dir}/bin
			* build.debug			- (true|false) debug build?
			* current.build.defines - framework-specific build defines
			* project.version		- full project version
			* project.version.major	- the major number of the build
			* project.version.minor - the minor number of the build
			* project.version.build - the build number
			* sign					- (true|false)indicates if the Assembly should be signed.
			* clover.enabled		- (true|false) indicates if Clover.NET should handle the build
			* clover.src			- location of the clovered source to be stored at from the root of NHibernateContrib
			* clover.db				- location of the coverage db from the root of NHibernateContrib
	-->
	
	<if propertytrue="clover.enabled">	
		<loadtasks assembly="${clover.home}/CloverNAnt-0.84.dll" />
	</if>
	
	<property name="keyFile" value="..\NHibernate.snk" />
	
	<target name="build">
		<if propertytrue="clover.enabled">	
			<clover-setup 
				initstring="..\..\${clover.db}"
				builddir="..\..\${clover.src}\${nant.project.name}"
				enabled="${clover.enabled}"
				flushinterval="1000"
			/>
		</if>
		
		<attrib file="AssemblyInfo.cs" readonly="false" />
		<asminfo output="AssemblyInfo.cs" language="CSharp">
			<imports>
				<import name="System" />
				<import name="System.Reflection" />
				<import name="System.Runtime.CompilerServices" />
				<import name="System.Runtime.InteropServices" />
				<import name="System.Security.Permissions" />
			</imports>
			<attributes>
				<attribute type="AssemblyTitleAttribute" value="${nant.project.name} for ${current.runtime.description}" />
				<attribute type="AssemblyDescriptionAttribute" value="Cache provider for NHibernate using Bamboo.Prevalence engine." />
				<attribute type="AssemblyCompanyAttribute" value="nhibernate.sourceforge.net" />
				<attribute type="AssemblyProductAttribute" value="${nant.project.name}" />
				<attribute type="AssemblyCopyrightAttribute" value="Licensed under LGPL." />
				<attribute type="AssemblyVersionAttribute" value="${project.version}" />
				<attribute type="AssemblyInformationalVersionAttribute" value="${project.version.major}.${project.version.minor}" />
				<attribute type="AssemblyKeyFileAttribute" value="${keyFile}" if="${sign}" />
			</attributes>
		</asminfo>
		<csc
			output="${build.dir}/bin/${nant.project.name}.dll"
			doc="${build.dir}/bin/${nant.project.name}.xml"
			target="library"
			debug="${build.debug}"
			define="${current.build.defines}"
			optimize="true"
		>
			<sources>
				<excludes name="**/*Fixture.cs" />
				<includes name="**/*.cs" />
			</sources>
			<references>
				<includes name="System.dll" />
				<includes name="System.Data.dll" />
				<includes name="System.Web.dll" />
				<includes name="System.XML.dll" />
				<includes name="${build.dir}/bin/NHibernate.dll" />
				<includes name="${build.dir}/bin/log4net.dll" />
				<includes name="${build.dir}/bin/Bamboo.Prevalence.dll" />
			</references>
		</csc>
		<csc
			output="${build.dir}/bin/${nant.project.name}.Tests.dll"
			target="library"
			debug="${build.debug}"
			define="${current.build.defines}"
			optimize="true"
		>
			<sources>
				<includes name="**/AssemblyInfo.cs" />
				<includes name="**/*Fixture.cs" />
			</sources>
			<references>
				<includes name="System.dll" />
				<includes name="System.Data.dll" />
				<includes name="System.XML.dll" />
				<includes name="${build.dir}/bin/${nant.project.name}.dll" />
				<includes name="${build.dir}/bin/NHibernate.dll" />
				<includes name="${build.dir}/bin/nunit.framework.dll" />
				<includes name="${build.dir}/bin/log4net.dll" />
				<includes name="${build.dir}/bin/Bamboo.Prevalence.dll" />
			</references>
		</csc>
	</target>
	
	<target name="test" depends="build" description="run unit tests">
		<copy file="prevalencecache.config" tofile="${build.dir}/bin/${nant.project.name}.Tests.dll.config" />
		<nunit2 failonerror="false">
			<formatter type="Xml" usefile="true" extension=".xml" outputdir="${build.dir}/bin" />
			<test assemblyname="${build.dir}/bin/${nant.project.name}.Tests.dll" appconfig="${build.dir}/${nant.project.name}.Tests.dll.config" />
		</nunit2>
		<if propertytrue="nunit2report.installed">
			<mkdir dir="${build.dir}/testresults" />
			<nunit2report out="${build.dir}/testresults/prevalencecache.html" todir="${build.dir}/testresults">
				<fileset>
					<includes name="${build.dir}\bin\${nant.project.name}.Tests.dll-results.xml" />
				</fileset>
			</nunit2report>
		</if>
	</target>
	
</project>

--- NEW FILE: PrevalenceCacheFixture.cs ---
using System;
using System.Collections;
using NHibernate.Cache;
using NUnit.Framework;

namespace NHibernate.Caches.Prevalence.Tests
{
	[TestFixture]
	public class PrevalenceCacheFixture
	{
		private PrevalenceCacheProvider provider;
		private Hashtable props;

		[TestFixtureSetUp]
		public void FixtureSetup()
		{
			log4net.Config.DOMConfigurator.Configure();
			props = new Hashtable();
			provider = new PrevalenceCacheProvider();
		}

		[Test]
		public void TestPut()
		{
			string key = "key1";
			string value = "value";

			ICache cache = provider.BuildCache( "nunit", props );
			Assert.IsNotNull( cache, "no cache returned" );

			Assert.IsNull( cache.Get( key ), "cache returned an item we didn't add !?!" );

			cache.Put( key, value );
			object item = cache.Get( key );
			Assert.IsNotNull( item );
			Assert.AreEqual( value, item, "didn't return the item we added" );
		}

		[Test]
		public void TestRemove()
		{
			string key = "key1";
			string value = "value";

			ICache cache = provider.BuildCache( "nunit", props );
			Assert.IsNotNull( cache, "no cache returned" );

			// add the item
			cache.Put( key, value );

			// make sure it's there
			object item = cache.Get( key );
			Assert.IsNotNull( item, "item just added is not there" );

			// remove it
			cache.Remove( key );

			// make sure it's not there
			item = cache.Get( key );
			Assert.IsNull( item, "item still exists in cache" );
		}

		[Test]
		public void TestClear()
		{
			string key = "key1";
			string value = "value";

			ICache cache = provider.BuildCache( "nunit", props );
			Assert.IsNotNull( cache, "no cache returned" );

			// add the item
			cache.Put( key, value );

			// make sure it's there
			object item = cache.Get( key );
			Assert.IsNotNull( item, "couldn't find item in cache" );

			// clear the cache
			cache.Clear();

			// make sure we don't get an item
			item = cache.Get( key );
			Assert.IsNull( item, "item still exists in cache" );
		}

		[Test]
		public void TestDefaultConstructor()
		{
			ICache cache = new PrevalenceCache();
			Assert.IsNotNull( cache );
		}

		[Test]
		public void TestNoPropertiesConstructor()
		{
			ICache cache = new PrevalenceCache( "nunit" );
			Assert.IsNotNull( cache );
		}

		[Test]
		public void TestEmptyProperties()
		{
			ICache cache = new PrevalenceCache( "nunit", new Hashtable() );
			Assert.IsNotNull( cache );
		}

		[Test]
		[ExpectedException( typeof( ArgumentNullException ) )]
		public void TestNullKeyPut()
		{
			ICache cache = new PrevalenceCache();
			cache.Put( null, null );
		}

		[Test]
		[ExpectedException( typeof( ArgumentNullException ) )]
		public void TestNullValuePut()
		{
			ICache cache = new PrevalenceCache();
			cache.Put( "nunit", null );
		}

		[Test]
		public void TestNullKeyGet()
		{
			ICache cache = new PrevalenceCache();
			cache.Put( "nunit", "value" );
			object item = cache.Get( null );
			Assert.IsNull( item );
		}

		[Test]
		[ExpectedException( typeof( ArgumentNullException ) )]
		public void TestNullKeyRemove()
		{
			ICache cache = new PrevalenceCache();
			cache.Remove( null );
		}
	}
}
--- NEW FILE: prevalencecache.nunit ---
<NUnitProject>
	<Settings activeconfig="Debug"/>
	<Config name="Debug">
		<assembly path="bin\Debug\NHibernate.Caches.Prevalence.Tests.dll"/>
	</Config>
	<Config name="Release">
		<assembly path="bin\Release\NHibernate.Caches.Prevalence.Tests.dll"/>
	</Config>
</NUnitProject>

--- NEW FILE: prevalencecache.config ---
<?xml version="1.0" encoding="utf-8" ?>
<configuration>

	<configSections>
	    <section name="nhibernate" type="System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0,Culture=neutral, PublicKeyToken=b77a5c561934e089" />
	    <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net" />
	</configSections>
	
	<nhibernate>
		<!--
		<add key="hibernate.connection.pool_size" value="2" />
		<add key="hibernate.use_outer_join" value="false" />
		-->

		<!-- 
			The valid strings for Isolation can be found in the documentation for the System.Data.IsolationLevel
			Enumeration documentation.  Use the member names - not the values.
		-->
		<!--add key="hibernate.connection.isolation" value="ReadCommitted" /-->
		
		<add key="hibernate.connection.provider" value="NHibernate.Connection.DriverConnectionProvider" />
		<add key="hibernate.dialect" value="NHibernate.Dialect.MsSql2000Dialect" />
		<add key="hibernate.connection.driver_class" value="NHibernate.Driver.SqlClientDriver" />
		<add key="hibernate.connection.connection_string" value="Server=localhost;initial catalog=nhibernate;Integrated Security=SSPI" />
		<add key="hibernate.cache.provider_class" value="NHibernate.Caches.Prevalence.PrevalenceCacheProvider,NHibernate.Caches.Prevalence" />
		<add key="hibernate.cache.use_query_cache" value="true" />
	</nhibernate>

	<log4net>
		<appender name="myFile" type="log4net.Appender.FileAppender,log4net" >
			<param name="File" value="log.txt" />
			<param name="AppendToFile" value="false" />
			<layout type="log4net.Layout.PatternLayout,log4net">
				<param name="ConversionPattern" value="%d [%t] %-5p %c [%x] &lt;%X{auth}&gt; - %m%n" />
			</layout>
		</appender>
		<root>
			<priority value="DEBUG" />
			<appender-ref ref="myFile" />
		</root>
		<logger name="NHibernate">
			<level value="WARN" />
		</logger>
	</log4net>

</configuration>

--- NEW FILE: PrevalenceCacheProviderFixture.cs ---
using System;
using System.Collections;
using System.IO;
using NHibernate.Cache;
using NUnit.Framework;

namespace NHibernate.Caches.Prevalence.Tests
{
	[TestFixture]
	public class PrevalenceCacheProviderFixture
	{
		private PrevalenceCacheProvider provider;
		private Hashtable props;
		private string testDir;

		[TestFixtureSetUp]
		public void FixtureSetup()
		{
			log4net.Config.DOMConfigurator.Configure();
			props = new Hashtable();
			testDir = @"C:\temp\prevalence";
			props.Add( "prevalenceBase", testDir );
		}

		[SetUp]
		public void Setup()
		{
			provider = new PrevalenceCacheProvider();
		}

		[TearDown]
		public void Teardown()
		{
			if( Directory.Exists( testDir ) )
			{
				Directory.Delete( testDir );
			}
		}

		[Test]
		public void TestBuildCacheNullNull()
		{
			ICache cache = provider.BuildCache( null, null );
			Assert.IsNotNull( cache, "no cache returned" );
		}

		[Test]
		public void TestBuildCacheStringNull()
		{
			ICache cache = provider.BuildCache( "a_region", null );
			Assert.IsNotNull( cache, "no cache returned" );
		}

		[Test]
		public void TestBuildCacheStringICollection()
		{
			Assert.IsFalse( Directory.Exists( testDir ) );
			ICache cache = provider.BuildCache( "another_region", props );
			Assert.IsTrue( Directory.Exists( testDir ) );
			Assert.IsNotNull( cache, "no cache returned" );
		}

		[Test]
		public void TestNextTimestamp()
		{
			long ts = provider.NextTimestamp();
			Assert.IsNotNull( ts, "no timestamp returned" );
		}
	}
}
--- NEW FILE: AssemblyInfo.cs ---
using System;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.Permissions;

//------------------------------------------------------------------------------
// <autogenerated>
//     This code was generated by a tool.
//     Runtime Version: 1.1.4322.2032
//
//     Changes to this file may cause incorrect behavior and will be lost if 
//     the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------

[assembly: AssemblyTitleAttribute("NHibernate.Caches.Prevalence for Microsoft .NET Framework 1.1")]
[assembly: AssemblyDescriptionAttribute("Cache provider for NHibernate using Bamboo.Prevalence engine.")]
[assembly: AssemblyCompanyAttribute("nhibernate.sourceforge.net")]
[assembly: AssemblyProductAttribute("NHibernate.Caches.Prevalence")]
[assembly: AssemblyCopyrightAttribute("Licensed under LGPL.")]
[assembly: AssemblyVersionAttribute("0.6.0.0")]
[assembly: AssemblyInformationalVersionAttribute("0.6")]


--- NEW FILE: PrevalenceCache.cs ---
using System;
using System.Collections;
using System.IO;
using Bamboo.Prevalence;
using log4net;
using NHibernate.Cache;

namespace NHibernate.Caches.Prevalence
{
	/// <summary>
	/// Summary description for PrevalenceCache.
	/// </summary>
	public class PrevalenceCache : ICache, IDisposable
	{
		private static readonly ILog log = LogManager.GetLogger( typeof( PrevalenceCache ) );
		private string _region;
		private PrevalenceEngine _engine;
		private CacheSystem _system;

		/// <summary>
		/// default constructor
		/// </summary>
		public PrevalenceCache() : this( null, null )
		{
		}

		/// <summary>
		/// constructor with no properties
		/// </summary>
		/// <param name="region"></param>
		public PrevalenceCache( string region ) : this( region, null )
		{
		}

		/// <summary>
		/// full constructor
		/// </summary>
		/// <param name="region"></param>
		/// <param name="properties">cache configuration properties</param>
		/// <remarks>There is only one configurable parameter: prevalenceBase. This is
		/// the directory on the file system where the Prevalence engine will save data.
		/// It can be relative to the current directory or a full path. If the directory
		/// doesn't exist, it will be created.</remarks>
		public PrevalenceCache( string region, IDictionary properties )
		{
			_region = region;
			Configure( properties );
		}

		private void Configure( IDictionary properties )
		{
			string dataDir = Path.Combine( Environment.CurrentDirectory, "data" );

			if( properties != null )
			{
				if( properties["prevalenceBase"] != null )
				{
					string prevalenceBase = properties["prevalenceBase"].ToString();
					if( Path.IsPathRooted( prevalenceBase ) )
					{
						dataDir = prevalenceBase;
					}
					else
					{
						dataDir = Path.Combine( Environment.CurrentDirectory, prevalenceBase );
					}
				}
			}
			if( Directory.Exists( dataDir ) == false )
			{
				if( log.IsDebugEnabled )
				{
					log.Debug( String.Format( "Data directory {0} doesn't exist: creating it.", dataDir ) );
				}
				Directory.CreateDirectory( dataDir );
			}
			if( log.IsDebugEnabled )
			{
				log.Debug( String.Format( "configuring cache in {0}.", dataDir ) );
			}
			_engine = PrevalenceActivator.CreateTransparentEngine( typeof( CacheSystem ), dataDir );
			_system = _engine.PrevalentSystem as CacheSystem;
		}

		/// <summary></summary>
		/// <param name="key"></param>
		/// <returns></returns>
		public object Get( object key )
		{
			if( key == null )
			{
				return null;
			}
			if( log.IsDebugEnabled )
			{
				log.Debug( "getting object with key: " + key.ToString() );
			}
			return _system.Get( key );
		}

		/// <summary></summary>
		/// <param name="key"></param>
		/// <param name="value"></param>
		public void Put( object key, object value )
		{
			if( key == null )
			{
				if( log.IsErrorEnabled )
				{
					log.Error( "null key passed to 'Put'" );
				}
				throw new ArgumentNullException( "key", "null key not allowed" );
			}
			if( value == null )
			{
				if( log.IsErrorEnabled )
				{
					log.Error( "null value passed to 'Put'" );
				}
				throw new ArgumentNullException( "value", "null value not allowed" );
			}
			if( log.IsDebugEnabled )
			{
				log.Debug( String.Format( "setting value {1} for key {0}", key.ToString(), value.ToString() ) );
			}
			_system.Add( key, value );
		}

		/// <summary></summary>
		/// <param name="key"></param>
		public void Remove( object key )
		{
			if( key == null )
			{
				if( log.IsErrorEnabled )
				{
					log.Error( "null key passed to 'Remove'" );
				}
				throw new ArgumentNullException( "key" );
			}
			if( log.IsDebugEnabled )
			{
				log.Debug( "removing item with key: " + key.ToString() );
			}
			_system.Remove( key );
		}

		/// <summary></summary>
		public void Clear()
		{
			if( log.IsInfoEnabled )
			{
				log.Info( "clearing all objects from system" );
			}
			_system.Clear();
		}

		/// <summary></summary>
		public void Destroy()
		{
			if( log.IsInfoEnabled )
			{
				log.Info( "'Destroy' was called" );
			}
			Clear();
		}

		/// <summary></summary>
		public string Region
		{
			set { _region = value; }
		}
		#region IDisposable Members

		/// <summary>
		/// take snapshot before shutting down
		/// </summary>
		public void Dispose()
		{
			_engine.TakeSnapshot();
		}

		#endregion
	}
}