private void CheckOutput(IProjectFile projectFile, Encoding encoding)
 {
     Assert.IsNotNull(projectFile, "projectFile == null");
     this.ExecuteWithGold(
         projectFile.Location.Name,
         sw =>
         {
             using (var sr = new StreamReader(projectFile.Location.OpenFileForReadingExclusive(), encoding, true))
             {
                 var lexer = this.CreateLexer(projectFile, sr);
                 int position = 0;
                 lexer.Start();
                 while (lexer.TokenType != null)
                 {
                     Assert.AreEqual(
                         lexer.TokenStart,
                         position,
                         "Token start error. Expected: {0}, actual: {1}",
                         position,
                         lexer.TokenStart);
                     position = lexer.TokenEnd;
                     this.WriteToken(sw, lexer);
                     lexer.Advance();
                 }
                 Assert.AreEqual(lexer.Buffer.Length, position, "position == lexer.Buffer.Length");
             }
         });
 }

        //private readonly IWordIndexLanguageProvider m_WordIndexLanguageProvider = new XmlWordIndexLanguageProvider();

        public ProjectFileType GetProjectFileType(IProjectFile file) {
            //Logger.LogMessage("MappingFileProjectFileLanguageService.GetProjectFileType for file {0}", file.Name);
            if (file.Name.EndsWith(Constants.MappingFileExtension)) {
                return MAPPING_FILE;
            }
            return ProjectFileType.UNKNOWN;
        }

       public IEnumerable<JetTuple<IProjectFile, string>> GetRelatedFiles(IProjectFile projectFile)
       {
           return new List<JetTuple<IProjectFile, string>>();
 //          IDeclarationsCache dc = CacheManager.GetInstance(_provider.Solution).GetDeclarationsCache(
 //_provider.PsiModule, true, true);
 //          var inheritors = dc.GetPossibleInheritors("BuisnessObjectBuilder").Select(type => type.GetAttributeInstances());
 //          var shortNames = dc.GetAllShortNames();
 //          foreach (var file in projectFile.EnumeratePsiFiles().OfType<ICSharpFile>())
 //          {
 //              var classDeclaration =file.Get
 //              var attribute = file.GetContainingNode<IAttribute>();
 //              if (attribute != null)
 //              {
 //                  var literal = attribute.Arguments.OfType<ICSharpLiteralExpression>();
 //                  //TODO get value and compare with class's name
 //              }
 //          }
 //          // original implementation
 //          return
 //              from file in projectFile.EnumeratePsiFiles()
 //              from reference in new ReferenceCollector<IPathReference>().Process(file).References 
 //              where reference.CheckResolveResult() == ResolveErrorType.OK 
 //              let declaredElement = reference.Resolve().DeclaredElement 
 //              where declaredElement != null 
 //              from a in declaredElement.GetSourceFiles().SelectNotNull(f => f.ToProjectFile()) 
 //              select JetTuple.Of(a, GetRelationPresentation(reference));
       }

        public static UnitTestElementDisposition BuildDisposition(UnitTestElement element, ScenarioLocation location, IProjectFile  projectFile)
        {
            var contents = File.ReadAllText(location.Path);
            var range = new TextRange(LineToOffset(contents, location.FromLine), LineToOffset(contents, location.ToLine));

            return new UnitTestElementDisposition(element, projectFile, range, new TextRange(0));
        }

 public ErrorStripeRequest InitialErrorStripe(IProjectFile file) {
     if (PsiSupportManager.Instance.ShouldBuildPsi(file) &&
         (ProjectFileLanguageServiceManager.Instance.GetPsiLanguageType(file) == MappingFileLanguageService.MAPPING_FILE)) {
         return ErrorStripeRequest.STRIPE_AND_ERRORS;
     }
     return ErrorStripeRequest.NONE;
 }

		internal IList<IPsiSourceFile> GetPsiSourceFilesFor(IProjectFile projectFile) {
			_shellLocks.AssertReadAccessAllowed();

			ModuleWrapper wrapper;
			return projectFile != null && projectFile.IsValid() && _modules.TryGetValue(projectFile, out wrapper) && wrapper.Module.IsValid()
				? new[] { wrapper.Module.SourceFile }
				: EmptyList<IPsiSourceFile>.InstanceList;
		}

 ///<summary>
 ///
 ///            If any of the registered checked answer 
 ///<c>true</c> for the given project file, then PSI will be built
 ///            
 ///</summary>
 ///
 public BuildPsiResult Check(IProjectFile projectFile)
 {
     if (projectFile.LanguageType != NHProjectFileLanguageService.NH)
     {
         return BuildPsiResult.UNDEF;
     }
     return BuildPsiResult.DO_BUILD;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="startLineNumber">Indexed from 1</param>
 /// <param name="endLineNumber">Indexed from 1</param>
 /// <param name="projectFile"></param>
 /// <param name="set"></param>
 /// <param name="range"></param>
 public Block(int startLineNumber, int endLineNumber, IProjectFile projectFile, Set set, DocumentRange? range)
 {
     Range = range;
     this.set = set;
     this.projectFile = projectFile;
     this.startLineNumber = startLineNumber;
     this.endLineNumber = endLineNumber;
 }

 ///<returns>
 ///True if further search is not needed
 ///</returns>
 ///
 public bool ProcessProjectItem(IProjectFile projectItem)
 {
     IFile psiFile = PsiManager.GetInstance(projectItem.GetSolution()).GetPsiFile(projectItem);
     if (psiFile != null)
     {
         return this.ProcessElement(psiFile);
     }
     return false;
 }

 public override IPsiSourceFileProperties GetPsiProperties(IProjectFile projectFile, IPsiSourceFile sourceFile)
 {
     if (!projectFile.IsProjectReferencingNancyRazorViewEngine())
     {
         return base.GetPsiProperties(projectFile, sourceFile);
     }
     
     return new RazorMvcPsiProjectFileProperties(projectFile, sourceFile);
 }

        public PsiLanguageType GetPsiLanguageType(IProjectFile file)
        {
            if (file == null)
            {
                return PsiLanguageType.UNKNOWN;
            }

            return GetPsiLanguageType(file.LanguageType);
        }

        public override PsiLanguageType GetPsiLanguageType(IProjectFile projectFile)
        {
            if (projectFile.IsProjectReferencingNancyRazorViewEngine())
            {
                return GetPsiLanguageType(projectFile.LanguageType);
            }

            return base.GetPsiLanguageType(projectFile);
        }

 public void TryRemoveFile(IProjectFile file)
 {
   XXLanguageXXFile result;
   if (_filesMap.TryGetValue(file, out result))
   {
     _filePathsMap.Remove(result.FullName);
     result.Dispose();
     _filesMap.Remove(file);
   }
 }

        public void Reset(IProjectFile<string> file, TemplateContentLanguage language)
        {
            if (file.HasContents == false)
                throw new ArgumentException("file must have contents");

            this.file = file;
            editor.Text = file.GetContents();
            editor.Document.Language = SyntaxEditorHelper.GetDynamicLanguage(language);
            errorTreeList.LicenseKey = "F962CEC7-CD8F-4911-A9E9-CAB39962FC1F";
            Reparse();
        }

 private bool IsIgnoredFile(IProjectFile projectFile)
 {
     foreach (Regex spec in SpecsToIgnore)
     {
         if (spec.IsMatch(projectFile.Location.Name))
         {
             return true;
         }
     }
     return false;
 }

 private DocumentRange? GetDocumentRange2(string sourceFile, IProjectFile projectFile, int startLineNumber, int endLineNumber)
 {
     try
     {
         return GetDocumentRange(projectFile, startLineNumber, endLineNumber, solution);
     }
     catch (ArgumentOutOfRangeException)
     {
         FilesInError.Add(projectFile);
         return null;
     }
 }

        protected NBehaveUnitTestElementBase(IProjectFile featureFile, IUnitTestProvider testProvider, string id, ProjectModelElementEnvoy pointer, NBehaveUnitTestElementBase parent)
        {
            FeatureFile = featureFile;
            //FeatureFile = featureFile.Location.FullPath;
            _project = featureFile.GetProject();
            //ProjectFile = _project.Name;

            _testProvider = testProvider;
            _id = id;
            _projectModel = pointer;
            Parent = parent;
        }

        public ProjectFileType GetProjectFileType(IProjectFile file)
        {
            if (file == null)
            {
                return ProjectFileType.UNKNOWN;
            }

            if (IsNHFile(file))
                return NH;

            return null;
        }

        ///<summary>
        ///
        ///            If any of the registered checked answer 
        ///<c>true</c> for the given project file, then PSI will be built
        ///            
        ///</summary>
        ///
        public BuildPsiResult Check(IProjectFile projectFile)
        {
            FixLangServiceOrder();

            if (projectFile.Name.EndsWith(NHProjectFileLanguageService.HBM_SUFFIX))
                return BuildPsiResult.DO_BUILD;

            if (projectFile.LanguageType != NHProjectFileLanguageService.NH)
            {
                return BuildPsiResult.UNDEF;
            }
            return BuildPsiResult.DO_BUILD;
        }

        public static DocumentRange GetDocumentRange(IProjectFile projectFile, int startLineNumber, int endLineNumber, ISolution solution)
        {
            if (startLineNumber > endLineNumber)
                throw new ArgumentException("start line must come before end line.");

            DocumentManager documentManager = DocumentManager.GetInstance(solution);
            IDocument document = documentManager.GetProjectFile(projectFile);

            int startOffset = document.GetLineStartOffset((Int32<DocLine>) (startLineNumber-1));
            int endOffset = document.GetLineEndOffsetNoLineBreak((Int32<DocLine>) (endLineNumber-1));

            return new DocumentRange(document, new TextRange(startOffset, endOffset));
        }