[SetUp] public void Init()
		{
			// Dump the contents of the embedded resources to a file so we can read them 
			// in during the tests. 
			meerkatRssPath = Path.GetFullPath("meerkat.rss.xml"); 
			testRssXmlPath = Path.GetFullPath("rsstest.xml"); 
			testRssXslPath = Path.GetFullPath("rsstest.xsl"); 
			Assembly a = Assembly.GetExecutingAssembly(); 
			WriteResourceToFile(a, "FlexWiki.UnitTests.TestContent.meerkat.rss.xml", meerkatRssPath); 
			WriteResourceToFile(a, "FlexWiki.UnitTests.TestContent.rsstest.xml", testRssXmlPath); 
			WriteResourceToFile(a, "FlexWiki.UnitTests.TestContent.rsstest.xsl", testRssXslPath); 

			_lm = new LinkMaker(_base);
			TheFederation = new Federation(OutputFormat.HTML, _lm);
			TheFederation.WikiTalkVersion = 1;

			_cb = CreateStore("FlexWiki");
			_cb.Title  = "Friendly Title";

			WriteTestTopicAndNewVersion(_cb, "HomePage", "Home is where the heart is", user);
			WriteTestTopicAndNewVersion(_cb, "BigPolicy", "This is ", user);
			WriteTestTopicAndNewVersion(_cb, "BigDog", "This is ", user);
			WriteTestTopicAndNewVersion(_cb, "BigAddress", "This is ", user);
			WriteTestTopicAndNewVersion(_cb, "BigBox", "This is ", user);
			WriteTestTopicAndNewVersion(_cb, "IncludeOne", "inc1", user);
			WriteTestTopicAndNewVersion(_cb, "IncludeTwo", "!inc2", user);
			WriteTestTopicAndNewVersion(_cb, "IncludeThree", "!!inc3", user);
			WriteTestTopicAndNewVersion(_cb, "IncludeFour", "!inc4", user);
			WriteTestTopicAndNewVersion(_cb, "IncludeNest", @"		{{IncludeNest1}}
			{{IncludeNest2}}", user);
			WriteTestTopicAndNewVersion(_cb, "TopicWithColor", "Color: Yellow", user);
			WriteTestTopicAndNewVersion(_cb, "IncludeNest1", "!hey there", user);
			WriteTestTopicAndNewVersion(_cb, "IncludeNest2", "!black dog", user);
			WriteTestTopicAndNewVersion(_cb, "IncludeNestURI", @"wiki://IncludeNest1 wiki://IncludeNest2 ", user);
			WriteTestTopicAndNewVersion(_cb, "ResourceReference", @"URI: http://www.google.com/$$$", user);
			WriteTestTopicAndNewVersion(_cb, "FlexWiki", "flex ", user);
			WriteTestTopicAndNewVersion(_cb, "InlineTestTopic", @"aaa @@""foo""@@ zzz", user);
			WriteTestTopicAndNewVersion(_cb, "OneMinuteWiki", "one ", user);
			WriteTestTopicAndNewVersion(_cb, "TestIncludesBehaviors", "@@[email protected]@ somthing @@[email protected]@ then @@[email protected]@", user);
			WriteTestTopicAndNewVersion(_cb, "_Underscore", "Underscore", user);
			WriteTestTopicAndNewVersion(_cb, "TopicWithBehaviorProperties", @"
Face: {""hello"".Length}
one 
FaceWithArg: {arg | arg.Length }
FaceSpanningLines:{ arg |

arg.Length 

}

", user);
			WriteTestTopicAndNewVersion(_cb, "TestTopicWithBehaviorProperties", @"
[email protected]@[email protected]@
[email protected]@topics.TopicWithBehaviorProperties.FaceWithArg(""superb"")@@
[email protected]@topics.TopicWithBehaviorProperties.FaceSpanningLines(""parsing is wonderful"")@@
", user);


			_externals = new Hashtable();
		}

        static void Main(string[] args)
        {
            if (args.Length < 1)
            {
                Usage();
                return;
            }
            string fsPath = args[0];
            string topic = null;
            if (args.Length > 1)
                topic = args[1];
            LinkMaker lm = new LinkMaker("http://dummy");

            PrintTopicApplication application = new PrintTopicApplication(fsPath, lm);
            Federation fed = new Federation(application);
            if (topic != null)
                Print(fed, new TopicName(topic));
            else
            {
                int max = 10;
                foreach (TopicName top in fed.DefaultNamespaceManager.AllTopics(ImportPolicy.DoNotIncludeImports))
                {
                    Print(fed, top);
                    if (max-- <= 0)
                        break;
                }
            }
        }

 public void SetUp()
 {
     _lm = new LinkMaker(_bh);
     MockWikiApplication application = new MockWikiApplication(null, _lm, OutputFormat.HTML, 
         new MockTimeProvider(TimeSpan.FromSeconds(1))); 
     Federation = new Federation(application);
 }

		static void Main(string[] args)
		{
			if (args.Length < 1)
			{
				Usage();
				return;
			}
			string fsPath = args[0];
			string topic = null;
			if (args.Length > 1)
				topic = args[1];
			LinkMaker lm = new LinkMaker("http://dummy");

			Federation fed = new Federation(fsPath, OutputFormat.HTML, lm);
			fed.EnableCaching();
			if (topic != null)
				Print(fed, new AbsoluteTopicName(topic));
			else
			{
				int max = 10;
				foreach (AbsoluteTopicName top in fed.DefaultContentBase.AllTopics(false))
				{
					Print(fed, top);
					if (max-- <= 0)
						break;
				}
			}
		}

        /// <summary>
        /// Called when a provider is first created.  Must register all associated namespaces with the federation.
        /// Can also be used to create initial content in the namespaces.
        /// </summary>
        /// <param name="aFed"></param>
        public IList CreateNamespaces(Federation aFed)
        {
            ArrayList answer = new ArrayList();

            if (SqlNamespaceProvider.Exists(Namespace, ConnectionString))
            {
                throw new Exception("Namespace with the specified name already exists.");
            }

            this.CreateNamespace(Namespace, ConnectionString);

            SqlStore store = new SqlStore();

            throw new NotImplementedException();
            /*
            NamespaceManager manager = aFed.RegisterNamespace(store);
            manager.WriteTopic(manager.DefinitionTopicName.LocalName, "");
            manager.SetTopicPropertyValue(manager.DefinitionTopicName.LocalName, "Contact", Contact, false);
            manager.SetTopicPropertyValue(manager.DefinitionTopicName.LocalName, "Title", Title, false);
            string defaultImportedNamespaces = System.Configuration.ConfigurationSettings.AppSettings["DefaultImportedNamespaces"];
            if (defaultImportedNamespaces != null)
            {
                manager.SetTopicPropertyValue(manager.DefinitionTopicName.LocalName, "Import", defaultImportedNamespaces, false);
            }

            // whoever is last should write a new version
            manager.SetTopicPropertyValue(manager.DefinitionTopicName.LocalName, "Description", NamespaceDescription, true);
            answer.Add(Namespace);
            return ArrayList.ReadOnly(answer);

            */
        }

		public FileSystemStore(Federation aFed, string ns, string root)
		{
			// For FileSystemStores, the only thing in the connection string is the root
			SetFederation(aFed);

			Namespace = ns;

			// Calculate the root -- taking into account the relative location of the directory if needed
			if (root.StartsWith(".\\"))
			{
				FileInfo fi = new FileInfo(aFed.FederationNamespaceMapFilename);
				root = fi.DirectoryName + "\\" + root.Substring(2);
			}
			_Root = root;
			_State = State.New;
			if (Directory.Exists(root))
			{
				Read();
			}
			else
			{
				try
				{
					Directory.CreateDirectory(root);
				} 
				catch (DirectoryNotFoundException e)
				{
					e.ToString();
				}
			}
		}

		public void UpdateNamespaces(Federation aFed)
		{
			// just kill the old ones and reload new ones
			foreach (string each in NamespaceNames)
				aFed.UnregisterNamespace(aFed.ContentBaseForNamespace(each));
			LoadNamespaces(aFed);
		}

 public NewsletterManager(Federation aFed, LinkMaker lm, IDeliveryBoy boy, string newslettersFrom, string headInsert)
 {
     _LinkMaker = lm;
     _NewslettersFrom = newslettersFrom;
     _Federation = aFed;
     _DeliveryBoy = boy;
     _HeadInsert = headInsert;
 }

 /// <summary>
 /// Called when a provider should instantiate and register all of its namespaces in a federation.  
 /// Note that when a provider is first created (e.g., via the admin UI) that this function is not 
 /// called.
 /// </summary>
 /// <param name="aFed"></param>
 public void LoadNamespaces(Federation aFed)
 {
     throw new NotImplementedException();
     /*
     SqlStore store = new SqlStore();
     aFed.RegisterNamespace(store);
      */
 }

		public NewsletterDaemon(Federation fed, string rootURL, string newslettersFrom, 
			string headInsert, bool sendAsAttachments)
		{
			_TheFederation = fed;
			RootURL = rootURL;
			_NewslettersFrom = newslettersFrom;
			_HeadInsert = headInsert;
			_sendAsAttachments = sendAsAttachments; 
		}

        public BehaviorInterpreter(string contextString, string input, Federation aFed, int wikiTalkVersion, IWikiToPresentation presenter)
        {
            _Federation = aFed;
            _ContextString = contextString == null ? "(unknown location)" : contextString;
            WikiTalkVersion = wikiTalkVersion;
            Presenter = presenter;

            Input = input;
            State = InterpreterState.ReadyToParse;
        }

        static void Print(Federation federation, TopicName topic)
        {
            string formattedBody = federation.GetTopicFormattedContent(new QualifiedTopicRevision(topic), null);

            // Now calculate the borders
            string leftBorder = federation.GetTopicFormattedBorder(topic, Border.Left);
            string rightBorder =federation.GetTopicFormattedBorder(topic, Border.Right);
            string topBorder = federation.GetTopicFormattedBorder(topic, Border.Top);
            string bottomBorder = federation.GetTopicFormattedBorder(topic, Border.Bottom);

            //			Console.Out.WriteLine(formattedBody);
        }

		/// <summary>
		/// Answer the formatted text for a given topic, formatted using a given OutputFormat and possibly showing diffs with the previous revision
		/// </summary>
		/// <param name="topic">The topic</param>
		/// <param name="format">What format</param>
		/// <param name="showDiffs">true to show diffs</param>
		/// <param name="accumulator">composite cache rule in which to accumulate cache rules</param>
		/// <returns></returns>
		public static string FormattedTopic(AbsoluteTopicName topic, OutputFormat format, bool showDiffs, Federation aFederation, LinkMaker lm, CompositeCacheRule accumulator)
		{ 
		
			// Show the current topic (including diffs if there is a previous version)
			AbsoluteTopicName previousVersion = null;
			ContentBase relativeToBase = aFederation.ContentBaseForNamespace(topic.Namespace);

			if (showDiffs)
				previousVersion = relativeToBase.VersionPreviousTo(topic.LocalName);

			return FormattedTopicWithSpecificDiffs(topic, format, previousVersion, aFederation, lm, accumulator);
		}

		static void Print(Federation federation, AbsoluteTopicName topic)
		{
			bool diffs = false;

			string formattedBody = federation.GetTopicFormattedContent(topic, diffs);

			// Now calculate the borders
			string leftBorder = federation.GetTopicFormattedBorder(topic, Border.Left);
			string rightBorder =federation.GetTopicFormattedBorder(topic, Border.Right);
			string topBorder = federation.GetTopicFormattedBorder(topic, Border.Top);
			string bottomBorder = federation.GetTopicFormattedBorder(topic, Border.Bottom);

//			Console.Out.WriteLine(formattedBody);
		}

        // Constructors

        internal NamespaceManager(Federation federation, ContentProviderBase contentProvider,
            string ns, NamespaceProviderParameterCollection parameters)
        {
            _federation = federation;
            _contentProviderChain = contentProvider;
            _namespace = ns;

            if (parameters != null)
            {
                foreach (NamespaceProviderParameter parameter in parameters)
                {
                    _parameters.Add(parameter);
                }
            }

            _contentProviderChain.Initialize(this); 
        }

		public CalendarStore(Federation fed, string ns, int year, int month)
		{
			SetFederation(fed);
			Namespace = ns;
			Year = year;
			Month = month;
			foreach (DateTime each in Dates)
			{
				AbsoluteTopicName abs = TopicNameForDate(each);
				_Topics[abs] = each;
				_Topics[abs.LocalName] = each;
			}

			AbsoluteTopicName a = new AbsoluteTopicName("_NormalBorders", Namespace);
			BackingTopic top = new BackingTopic(a, DefaultNormalBordersContent, true);
			BackingTopics[a.Name] = top;
			_Topics[a] = DateTime.MinValue;
		}

		public SqlStore(Federation aFed, string ns, string connectionString)
		{
			SetFederation(aFed);

			Namespace = ns;

			_ConnectionString = connectionString;

			_State = State.New;
			// Check if the namespace exists in the database
			// If does not exist then create the database.
			if( SqlNamespaceProvider.Exists(Namespace, ConnectionString) )
			{
				Read();
			}
			else
			{
				SqlHelper.CreateNamespace(Namespace, ConnectionString);
			}
		}

		/// <summary>
		/// Answer the formatted text for a given topic, formatted using a given OutputFormat and possibly showing diffs with the previous revision
		/// </summary>
		/// <param name="topic">The topic</param>
		/// <param name="format">What format</param>
		/// <param name="showDiffs">true to show diffs</param>
		/// <param name="accumulator">composite cache rule in which to accumulate cache rules</param>
		/// <returns></returns>
		public static string FormattedTopic(AbsoluteTopicName topic, OutputFormat format, AbsoluteTopicName previousVersion, Federation aFederation, LinkMaker lm, CompositeCacheRule accumulator)
		{ 
			ContentBase relativeToBase = aFederation.ContentBaseForNamespace(topic.Namespace);
			return FormattedTopicWithSpecificDiffs(topic, format, previousVersion, aFederation, lm, accumulator);
		}

 // Constructors
 public TopicVersionInfo(Federation aFed, QualifiedTopicRevision name)
 {
     _topicVersionKey = name;
     _federation = aFed;
 }

 internal void Initialize(Federation federation)
 {
   _federation = federation; 
   _configurationProvider.Initialize(federation); 
 }