public void PostBelongsToBlog()
		{
			InitKernel();
			IRelationshipInferenceService relService = ObtainService();

			TableDefinition blogTable;
			TableDefinition postTable;

			BuildBlogPostsStructure(out blogTable, out postTable);

			BuildContext context = new BuildContext();

			ActiveRecordDescriptor arDesc = new ActiveRecordDescriptor();

			ActiveRecordPropertyDescriptor[] descs = relService.InferRelations( arDesc, postTable, context );

			Assert.IsNotNull(descs);
			Assert.AreEqual( 1, descs.Length );

			ActiveRecordBelongsToDescriptor desc1 = descs[0] as ActiveRecordBelongsToDescriptor;
			Assert.IsNotNull(desc1);
			Assert.IsNotNull(desc1.TargetType);
			Assert.IsNull(desc1.PropertyType);

			Assert.AreEqual( "Blog", desc1.PropertyName );
			Assert.AreEqual( "blog_id", desc1.ColumnName );

			ActiveRecordDescriptor targetARDescriptor = context.GetNextPendent();
			Assert.AreSame( blogTable, targetARDescriptor.Table );
		}

		public override bool IsApplied(BuildContext context, AbstractTypeBuilderList builders)
		{
			if (_interceptorType == null && _interceptType == 0)
				return false;

			foreach (var builder in builders)
			{
				var interceptor = builder as InterceptorAspectBuilder;

				if (interceptor != null)
				{
					if (interceptor._interceptorType == null && interceptor._interceptType == 0)
						return false;

					if (builder == this)
						break;
				}
			}

			if (context.IsMethodOrProperty) switch (context.Step)
			{
				case BuildStep.Begin:   return true;
				case BuildStep.Before:  return (_interceptType & InterceptType.BeforeCall) != 0;
				case BuildStep.After:   return (_interceptType & InterceptType.AfterCall)  != 0;
				case BuildStep.Catch:   return (_interceptType & InterceptType.OnCatch)    != 0;
				case BuildStep.Finally: return (_interceptType & InterceptType.OnFinally)  != 0;
				case BuildStep.End:     return true;
			}

			return false;
		}

        /// <summary>
        /// Called before the project's help build starts.
        /// </summary>
        /// <param name="context">Provides information about the build process.</param>
        public override void BuildStarting(BuildContext context)
        {
            // Uncomment the following line to break into the debugger: 
            // System.Diagnostics.Debugger.Break();

            buildStart = DateTime.Now;
        }

        public void SetStyle(BuildContext context)
        {
            context.Cell.SetRowHeight(18);

            //context.Cell.SetColumnWidth(15);

            context.Cell.CellStyle = this.CenterStyle;
        }

 private static void EmbedVirtualFile(BuildContext context, string relativePath)
 {
     var file = new VirtualPackageFile(
         context.SourceFolder,
         context.SourcePath + relativePath,
         context.TargetPath + relativePath);
     context.Builder.Files.Add(file);
 }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="sourceStream"></param>
		/// <param name="targetStream"></param>
		public override void Process ( AssetSource assetFile, BuildContext context )
		{
			using ( var sourceStream = assetFile.OpenSourceStream() ) {
				using ( var targetStream = assetFile.OpenTargetStream() ) {
					sourceStream.CopyTo( targetStream );
				}
			}
		}

        private void BuildClass(
            DocumentMapping documentMapping, bool isRoot,
            string path, BuildContext context
            )
        {
            IList<System.Type> hierarchy = new List<System.Type>();
            System.Type currClass = documentMapping.MappedClass;

            do {
                hierarchy.Add(currClass);
                currClass = currClass.BaseType;
                // NB Java stops at null we stop at object otherwise we process the class twice
                // We also need a null test for things like ISet which have no base class/interface
            } while (currClass != null && currClass != typeof(object));

            for (int index = hierarchy.Count - 1; index >= 0; index--)
            {
                currClass = hierarchy[index];
                /**
                 * Override the default analyzer for the properties if the class hold one
                 * That's the reason we go down the hierarchy
                 */

                // NB Must cast here as we want to look at the type's metadata
                var localAnalyzer = GetAnalyzer(currClass);
                var analyzer = documentMapping.Analyzer ?? localAnalyzer;

                // Check for any ClassBridges
                var classBridgeAttributes = AttributeUtil.GetAttributes<ClassBridgeAttribute>(currClass);
                AttributeUtil.GetClassBridgeParameters(currClass, classBridgeAttributes);

                // Now we can process the class bridges
                foreach (var classBridgeAttribute in classBridgeAttributes)
                {
                    var bridge = BuildClassBridge(classBridgeAttribute, analyzer);
                    documentMapping.ClassBridges.Add(bridge);
                }

                // NB As we are walking the hierarchy only retrieve items at this level
                var propertyInfos = currClass.GetProperties(
                    BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance
                );
                foreach (var propertyInfo in propertyInfos)
                {
                    BuildProperty(documentMapping, propertyInfo, analyzer, isRoot, path, context);
                }

                var fields = currClass.GetFields(
                    BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance
                );
                foreach (var fieldInfo in fields)
                {
                    BuildProperty(documentMapping, fieldInfo, analyzer, isRoot, path, context);
                }
            }
        }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="sourceStream"></param>
		/// <param name="targetStream"></param>
		public override void Process ( AssetSource assetFile, BuildContext context )
		{
			var src	=	assetFile.FullSourcePath;
			var dst	=	context.GetTempFileName( assetFile.KeyPath, ".dds" );

			RunNVCompress( context, src, dst, NoMips, Fast, ToNormal, Color, Alpha, Normal, Compression );

			using ( var target = assetFile.OpenTargetStream() ) {
				context.CopyFileTo( dst, target );
			}
		}

		public override void Build ( BuildContext buildContext )
		{
			var src	=	buildContext.Resolve( SourceFile );
			var dst	=	buildContext.GetTempFileName( Hash, ".dds" );

			RunNVCompress( buildContext, src, dst, NoMips, Fast, ToNormal, Color, Alpha, Normal, Compression );

			using ( var target = buildContext.OpenTargetStream( this ) ) {
				buildContext.CopyTo( dst, target );
			}
		}

        public override void Compile(ICompileContext context, IProjectItem projectItem)
        {
            var item = projectItem as Item;
            Assert.Cast(item, nameof(item));

            var fileName = item.GetValue<string>(LayoutPage)?.Trim() ?? string.Empty;
            if (string.IsNullOrEmpty(fileName))
            {
                return;
            }

            var property = item.GetProperty<string>(LayoutPage);

            // find page html file
            var rendering = item.Project.Files.FirstOrDefault(i => string.Equals(i.FilePath, fileName, StringComparison.OrdinalIgnoreCase));
            if (rendering == null)
            {
                context.Trace.TraceError(Msg.C1047, Texts.Rendering_reference_not_found, TraceHelper.GetTextNode(property), fileName);
            }

            // find MvcLayout
            var layoutItem = item.Project.ProjectItems.OfType<Item>().FirstOrDefault(i => i.ItemIdOrPath == "/sitecore/layout/Layouts/MvcLayout");
            if (layoutItem == null)
            {
                context.Trace.TraceError(Msg.C1048, Texts.Layout_reference_not_found, TraceHelper.GetTextNode(property), "/sitecore/layout/Layouts/MvcLayout");
            }

            if (rendering == null || layoutItem == null)
            {
                return;
            }

            var sourceFile = rendering.Snapshots.First().SourceFile;

            var writer = new StringWriter();
            var output = new XmlTextWriter(writer);
            output.Formatting = Formatting.Indented;

            var buildContext = new BuildContext(context, sourceFile, output, item, layoutItem);

            var literalRendering = FindRendering(buildContext, "Literal", string.Empty, TextSpan.Empty);
            if (literalRendering == null)
            {
                return;
            }

            buildContext.Placeholder = layoutItem["Place Holders"];
            buildContext.LiteralRendering = literalRendering;

            ParseHtml(buildContext);

            SetRenderingsField(buildContext, buildContext.Item, writer.ToString());
        }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="sourceStream"></param>
		/// <param name="targetStream"></param>
		public override void Process ( AssetSource assetFile, BuildContext context )
		{
			string tempFileName		= context.GetTempFileName( assetFile.KeyPath, ".fnt" );
			string resolvedPath		= assetFile.FullSourcePath;	

			//	Launch 'bmfont.com' with temporary output file :
			context.RunTool( @"bmfont.com",  string.Format("-c \"{0}\" -o \"{1}\"", resolvedPath, tempFileName ) );


			//	load temporary output :
			SpriteFont.FontFile font;
			using ( var stream = File.OpenRead( tempFileName ) ) {
				font = SpriteFont.FontLoader.Load( stream );
			}


			//	perform some checks :
			if (font.Common.Pages!=1) {
				throw new BuildException("Only one page of font image is supported");
			}


			//	patch font description and add children (e.g. "secondary") content :
			using ( var stream = assetFile.OpenTargetStream() ) {

				using ( var sw = new BinaryWriter( stream ) ) {

					var xml = SpriteFont.FontLoader.SaveToString( font );

					sw.Write( xml );

					//	write pages :
					foreach (var p in font.Pages) {

						var pageFile	=	Path.Combine( Path.GetDirectoryName( tempFileName ), p.File );

						if ( Path.GetExtension( pageFile ).ToLower() == ".dds" ) {

							context.CopyFileTo( pageFile, sw );

						} else {

							TextureProcessor.RunNVCompress( context, pageFile, pageFile + ".dds", true, false, false, true, true, false, TextureProcessor.TextureCompression.RGB );

							context.CopyFileTo( pageFile + ".dds", sw );

						}
					}
				}
			}
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="sourceStream"></param>
		/// <param name="targetStream"></param>
		public override void Process ( AssetSource assetFile, BuildContext context )
		{
			var mtrl	=	BaseIllum.ImportFromXml ( File.ReadAllText(assetFile.FullSourcePath) );

			//	get dependencies :
			var deps	=	mtrl.GetDependencies().ToArray();

			var file	=	BaseIllum.ExportToXml(mtrl);

			using ( var target = assetFile.OpenTargetStream(deps) ) {
				using ( var bw = new BinaryWriter(target) ) {
					bw.Write(file);
				}
			}
		}

 private static void EmbedFiles(BuildContext context)
 {
     var basePath = context.SourcePath;
     foreach (var virtualPath in context.SourceFolder.ListFiles(context.SourcePath, true))
     {
         // skip ignores files
         if (IgnoreFile(virtualPath))
         {
             continue;
         }
         // full virtual path given but we need the relative path so it can be put into
         // the package that way (the package itself is the logical base path).
         // Get it by stripping the basePath off including the slash.
         var relativePath = virtualPath.Replace(basePath, "");
         EmbedVirtualFile(context, relativePath);
     }
 }

		public override Dictionary<string, FileOutput> Package(
			BuildContext buildContext,
			string projectId,
			Dictionary<string, ParseTree.Executable[]> finalCode,
			List<string> filesToCopyOver,
			ICollection<ParseTree.StructDefinition> structDefinitions,
			string inputFolder,
			SpriteSheetBuilder spriteSheet)
		{
			Dictionary<string, FileOutput> output = new Dictionary<string, FileOutput>();
			List<string> concatenatedCode = new List<string>();
			Dictionary<string, string> replacements = new Dictionary<string, string>()
			{
				{ "PROJECT_ID", projectId },
			};

			concatenatedCode.Add(this.GetPyGameCode("Header.py", replacements));
			concatenatedCode.Add(this.Translator.NL);
			concatenatedCode.Add(this.GetPyGameCode("AsyncHttpFetcher.py", replacements));
			concatenatedCode.Add(this.Translator.NL);
			this.Translator.TranslateGlobals(concatenatedCode, finalCode);
			concatenatedCode.Add(this.Translator.NL);
			this.Translator.TranslateSwitchLookups(concatenatedCode, finalCode);
			concatenatedCode.Add(this.Translator.NL);
			this.Translator.TranslateFunctions(concatenatedCode, finalCode);
			concatenatedCode.Add(this.Translator.NL);
			concatenatedCode.Add(this.GetPyGameCode("Footer.py", replacements));
			concatenatedCode.Add(this.Translator.NL);

			output["game.py"] = new FileOutput()
			{
				Type = FileOutputType.Text,
				TextContent = string.Join("", concatenatedCode)
			};

			foreach (string file in filesToCopyOver)
			{
				output[file] = new FileOutput()
				{
					Type = FileOutputType.Copy,
					RelativeInputPath = file,
				};
			}

			return output;
		}

        /// <summary>
        /// Builds asset
        /// </summary>
        /// <param name="buildContext"></param>
        public override void Build( BuildContext buildContext )
        {
            string tempFileName		= buildContext.GetTempFileName( AssetPath, ".fnt", false );
            string tempFileNameR	= buildContext.GetTempFileName( AssetPath, ".fnt", true );
            string resolvedPath		= buildContext.Resolve( SourcePath );

            //	Launch 'bmfont.com' with temporary output file :
            buildContext.RunTool( @"bmfont.com",  string.Format("-c \"{0}\" -o \"{1}\"", resolvedPath, tempFileNameR ) );

            //	load temporary output :
            SpriteFont.FontFile font;
            using ( var stream = File.OpenRead( tempFileNameR ) ) {
                font = SpriteFont.FontLoader.Load( stream );
            }

            //	perform some checks :
            if (font.Common.Pages!=1) {
                throw new ContentException("Only one page of font image is supported");
            }

            //	patch font description and add children (e.g. "secondary") content :
            foreach (var p in font.Pages) {

                var newAssetPath	=	Path.Combine( AssetPath, "Page#" + p.ID.ToString() );
                var newSrcPath		=	Path.Combine( Path.GetDirectoryName(tempFileName), p.File );

                if ( Path.GetExtension( newSrcPath ).ToLower() == ".dds" ) {

                    var asset			=	buildContext.AddAsset<RawFileAsset>( newAssetPath );
                    asset.SourceFile	=	newSrcPath;
                    asset.BuildOrder	=	BuildOrder + 1;

                } else {

                    var asset			=	buildContext.AddAsset<ImageFileTextureAsset>( newAssetPath );
                    asset.SourceFile	=	newSrcPath;
                    asset.BuildOrder	=	BuildOrder + 1;
                }

                p.File	=	newAssetPath;
            }

            using ( var stream = buildContext.TargetStream( this ) ) {
                SpriteFont.FontLoader.Save( stream, font );
            }
        }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="buildContext"></param>
		/// <param name="src"></param>
		/// <param name="dst"></param>
		/// <param name="noMips"></param>
		/// <param name="fast"></param>
		/// <param name="toNormal"></param>
		/// <param name="color"></param>
		/// <param name="alpha"></param>
		/// <param name="normal"></param>
		/// <param name="compression"></param>
		internal static void RunNVCompress( BuildContext buildContext, string src, string dst, bool noMips, bool fast, bool toNormal, bool color, bool alpha, bool normal, TextureCompression compression )
		{
			string commandLine = "";

			if ( noMips		) 	commandLine	+=	" -nomips"	;
			if ( fast		) 	commandLine	+=	" -fast"	;
			if ( toNormal	) 	commandLine	+=	" -tonormal";
			if ( color		) 	commandLine	+=	" -color"	;
			if ( alpha		) 	commandLine	+=	" -alpha"	;
			if ( normal		) 	commandLine	+=	" -normal"	;

			commandLine += ( " -" + compression.ToString().ToLower() );
			commandLine += ( " \"" + src + "\"" );
			commandLine += ( " \"" + dst + "\"" );

			buildContext.RunTool( @"nvcompress.exe", commandLine );//*/
		}

		public override Dictionary<string, FileOutput> Package(BuildContext buildContext, string projectId, Dictionary<string, ParseTree.Executable[]> finalCode, List<string> filesToCopyOver, ICollection<ParseTree.StructDefinition> structDefinitions, string fileCopySourceRoot, SpriteSheetBuilder spriteSheet)
		{
			Dictionary<string, string> mainFile = new Dictionary<string, string>();
			
			string nl = this.Translator.NL;

			List<string> structSection = new List<string>();
			foreach (StructDefinition structDefinition in structDefinitions)
			{
				string name = structDefinition.Name.Value;
				structSection.Add("typedef struct " + name + " {");
				for (int i = 0; i < structDefinition.Fields.Length; ++i)
				{
					string fieldName = structDefinition.FieldsByIndex[i];
					Annotation type = structDefinition.Types[i];
					string typeValue = ((StringConstant)type.Args[0]).Value;
					string typeString = this.GetTypeStringFromAnnotation(structDefinition.Fields[i], typeValue, false, false);
					structSection.Add("\t" + typeString + " " + fieldName + "; /* " + typeValue + " */");
				}
				structSection.Add("} " + name + ";");
				structSection.Add("");
			}

			mainFile["structs"] = string.Join("\n", structSection);

			Dictionary<string, FileOutput> output = new Dictionary<string, FileOutput>();

			List<string> mainC = new List<string>();
			mainC.Add(Util.ReadFileInternally("Translator/COpenGL/Project/Header.c"));
			mainC.Add(mainFile["structs"]);
			mainC.Add(this.Translator.NL);
			this.Translator.TranslateGlobals(mainC, finalCode);
			mainC.Add(this.Translator.NL);
			this.Translator.TranslateFunctions(mainC, finalCode);
			mainC.Add(this.Translator.NL);
			mainC.Add(Util.ReadFileInternally("Translator/COpenGL/Project/Footer.c"));

			output["main.c"] = new FileOutput()
			{
				Type = FileOutputType.Text,
				TextContent = string.Join("", mainC)
			};

			return output;
		}

		public override void Build ( BuildContext buildContext )
		{
			throw new NotImplementedException();

			/*
			string tempFileName = Path.GetTempFileName();

			var dir		=	Path.GetDirectoryName( item.ResolvedPath );
			var names	=	File.ReadAllLines( item.ResolvedPath );

			names		=	names.Select( n => Path.Combine( dir, n ) ).ToArray();

			//	Launch 'nvassemble.exe' with temporary output file :
			ContentProject.Instance.RunExternalTool( @"NVTT\nvassemble.exe", "-cube " + string.Join( " ", names ) );

			File.Move( "output.dds", item.TargetPath );
			*/
		}

		/// <summary>
		/// Builds asset
		/// </summary>
		/// <param name="buildContext"></param>
		public override void Build ( BuildContext buildContext )
		{
			var resolvedPath	=	buildContext.Resolve( SourceFile );
			var destPath		=	buildContext.GetTempFileName( Hash, ".scene" );
			var cmdLine			=	string.Format("\"{0}\" /out:\"{1}\" /merge:{2} {4} {5}", 
				resolvedPath, destPath, 
				MergeTolerance, 
				null, 
				ImportAnimation ? "/anim":"", 
				ImportGeometry ? "/geom":"" 
			);

			buildContext.RunTool( "Native.Fbx.exe", cmdLine );

			using ( var target = buildContext.OpenTargetStream( this ) ) {
				buildContext.CopyTo( destPath, target );
			}
		}

		public override bool IsCompatible(BuildContext context, IAbstractTypeBuilder typeBuilder)
		{
			if (context.IsBuildStep)
				return false;

			var list = new AbstractTypeBuilderList(2) { this, typeBuilder };
			var step = context.Step;

			try
			{
				context.Step = BuildStep.Build;

				return typeBuilder.IsApplied(context, list);
			}
			finally
			{
				context.Step = step;
			}
		}