public void FixtureSetUp()
        {
            tfsUrl = Environment.GetEnvironmentVariable("TFS_URL");
            if (String.IsNullOrEmpty(tfsUrl))
                {
                    Console.WriteLine("Warning: Environment variable TFS_URL not set.");
                    Console.WriteLine("					Some tests cannot be executed without TFS_URL.");
                    return;
                }

            string username = Environment.GetEnvironmentVariable("TFS_USERNAME");
            if (String.IsNullOrEmpty(username))
                {
                    Console.WriteLine("Warning: No TFS user credentials specified.");
                    return;
                }

            credentials = new NetworkCredential(username,
                                                                                    Environment.GetEnvironmentVariable("TFS_PASSWORD"),
                                                                                    Environment.GetEnvironmentVariable("TFS_DOMAIN"));

            // need TFS_ envvars for this test
            if (String.IsNullOrEmpty(tfsUrl)) return;
            TeamFoundationServer tfs = new TeamFoundationServer(tfsUrl, credentials);
            versionControlServer = (VersionControlServer) tfs.GetService(typeof(VersionControlServer));

            workspace = versionControlServer.CreateWorkspace("WorkspaceTest",
                                                                            Environment.GetEnvironmentVariable("TFS_USERNAME"));
        }

 public ShelveWindow(ObservableCollection<changeItem> changeCollection, Workspace activeWorkspace)
 {
     InitializeComponent();
     this.DataContext = this;
     shelveCollection = changeCollection;
     this.activeWorkspace = activeWorkspace;
 }

 public ChangesetVisitEventArgs(Changeset changeset, IEnumerable<string> localizedServerItems, Workspace workspace)
 {
     LocalizedServerItems = localizedServerItems;
     Workspace = workspace;
     Changeset = changeset;
     Committer = changeset.Committer;
 }

        public bool AddToTFVC(string[] _files, WorkItem _wi, Workspace _ws)
        {
            try
             {
                 _ws.Get();
                 // Now add everything.
                 _ws.PendAdd(_files, false);
                 WorkItemCheckinInfo[] _wici = new WorkItemCheckinInfo[1];

                 _wici[0] = new WorkItemCheckinInfo(_wi, WorkItemCheckinAction.Associate);

                 if (_ws.CheckIn(_ws.GetPendingChanges(), null, null, _wici, null) > 0)
                 {
                     _ws.Delete();
                     return true;

                 }
                 else
                 {
                     return false;
                 }

             }
             catch
             {
                 return false;
             }
        }

        public GettingDialog(VersionControlServer vcs, Workspace workspace, GetRequest[] requests)
            : base("Progress")
        {
            VBox.Spacing = 10;
                VBox.Add(new Label("Getting files from the server..."));

                progressBar = new ProgressBar();
                VBox.Add(progressBar);

                fileLabel = new Label("");
                VBox.Add(fileLabel);

                AddCloseButton("Cancel");
                DefaultResponse = ResponseType.Cancel;

                ShowAll();

                getLatestList.Clear();
                vcs.Getting += MyGettingEventHandler;

                GetStatus status = workspace.Get(requests, GetOptions.GetAll|GetOptions.Overwrite);
                foreach (string file in getLatestList)
                    {
                        Console.WriteLine(file);
                        Pulse("Setting permissions: " + file);
                        if (! FileTypeDatabase.ShouldBeExecutable(file)) continue;
                        FileType.MakeExecutable(file);
                    }
        }

		internal ConflictEventArgs(Workspace workspace, string message,
															 string serverItem)
			{
				this.workspace = workspace;
				this.message = message;
				this.serverItem = serverItem;
			}

 public TfsWorkspace(Workspace workspace, string localDirectory, TextWriter stdout, TfsChangesetInfo contextVersion, IGitTfsRemote remote)
 {
     _workspace = workspace;
     _contextVersion = contextVersion;
     _remote = remote;
     _localDirectory = localDirectory;
     _stdout = stdout;
 }

        internal GettingEventArgs(Workspace workspace, GetOperation operation)
        {
            this.workspace = workspace;
                this.operation = operation;

                if (operation.ChangeType == ChangeType.Delete)
                    status = OperationStatus.Deleting;
                else status = OperationStatus.Getting;
        }

        public WorkspaceServiceModel(ITeamPilgrimServiceModelProvider teamPilgrimServiceModelProvider, ITeamPilgrimVsService teamPilgrimVsService, ProjectCollectionServiceModel projectCollectionServiceModel, Workspace workspace)
            : base(teamPilgrimServiceModelProvider, teamPilgrimVsService)
        {
            _projectCollectionServiceModel = projectCollectionServiceModel;
            Workspace = workspace;

            var versionControlServer = _projectCollectionServiceModel.TfsTeamProjectCollection.GetVersionControlServer();

            this.Logger().Debug("VersionControlServer - WebServiceLevel: {0}, SupportedFeatures: {1}", versionControlServer.WebServiceLevel, versionControlServer.SupportedFeatures);

            versionControlServer.PendingChangesChanged += VersionControlServerOnPendingChangesChanged;

            checkinNotesCacheWrapper = new CheckinNotesCacheWrapper(versionControlServer);

            ShelveCommand = new RelayCommand(Shelve, CanShelve);
            UnshelveCommand = new RelayCommand(Unshelve, CanUnshelve);
            CheckInCommand = new RelayCommand(CheckIn, CanCheckIn);
            RefreshPendingChangesCommand = new RelayCommand(RefreshPendingChanges, CanRefreshPendingChanges);
            RefreshSelectedDefinitionWorkItemsCommand = new RelayCommand(RefreshSelectedDefinitionWorkItems, CanRefreshSelectedDefinitionWorkItems);
            ShowSelectWorkItemQueryCommand = new RelayCommand(ShowSelectWorkItemQuery, CanShowSelectWorkItemQuery);
            EvaluateCheckInCommand = new RelayCommand(EvaluateCheckIn, CanEvaluateCheckIn);

            SelectPendingChangesCommand = new RelayCommand<SelectPendingChangesCommandArgument>(SelectPendingChanges, CanSelectPendingChanges);
            SelectWorkItemsCommand = new RelayCommand<SelectWorkItemsCommandArgument>(SelectWorkItems, CanSelectWorkItems);

            ViewWorkItemCommand = new RelayCommand<ObservableCollection<object>>(ViewWorkItem, CanViewWorkItem);
            ViewPendingChangeCommand = new RelayCommand<ObservableCollection<object>>(ViewPendingChange, CanViewPendingChange);
            CompareWithLatestCommand = new RelayCommand<ObservableCollection<object>>(CompareWithLatest, CanCompareWithLatest);
            CompareWithWorkspaceCommand = new RelayCommand<ObservableCollection<object>>(CompareWithWorkspace, CanCompareWithWorkspace);
            UndoPendingChangeCommand = new RelayCommand<ObservableCollection<object>>(UndoPendingChange, CanUndoPendingChange);
            PendingChangePropertiesCommand = new RelayCommand<ObservableCollection<object>>(PendingChangeProperties, CanPendingChangeProperties);

            CheckinNotes = new ObservableCollection<CheckinNoteModel>();

            PendingChanges = new ObservableCollection<PendingChangeModel>();
            _backgroundFunctionPreventDataUpdate = true;

            PendingChanges.CollectionChanged += PendingChangesOnCollectionChanged;

            _populatePendingChangedBackgroundWorker = new BackgroundWorker();
            _populatePendingChangedBackgroundWorker.DoWork += PopulatePendingChangedBackgroundWorkerOnDoWork;
            _populatePendingChangedBackgroundWorker.RunWorkerAsync();

            SolutionIsOpen = teamPilgrimVsService.Solution.IsOpen && !string.IsNullOrEmpty(teamPilgrimVsService.Solution.FileName);
            teamPilgrimVsService.SolutionStateChanged += () =>
            {
                FilterSolution = false;
                SolutionIsOpen = teamPilgrimVsService.Solution.IsOpen && !string.IsNullOrEmpty(teamPilgrimVsService.Solution.FileName);
            };

            WorkItems = new ObservableCollection<WorkItemModel>();
            WorkItems.CollectionChanged += WorkItemsOnCollectionChanged;

            PopulatePreviouslySelectedWorkItemQueryModels();

            _backgroundFunctionPreventDataUpdate = false;
        }

        public InternalServerInfo(string uri, Guid repositoryGuid, Workspace workspace)
        {
            this.uri = new Uri(uri);
            this.repositoryGuid = repositoryGuid;

            List<WorkspaceInfo> infos = new List<WorkspaceInfo>();
            infos.Add(new WorkspaceInfo(this, workspace));
            Workspaces = infos.ToArray();
        }

        public TfsWorkspaceWrapper(Workspace workspace)
        {
            if (workspace == null)
            {
                throw new ArgumentNullException("workspace");
            }

            _workspace = workspace;
        }

 public ElPackager(string root, TfsChangesets changesets)
 {
     _root = root;
     var tpc = new TfsTeamProjectCollection(new Uri(TfsUrl));
     var vc = tpc.GetService<VersionControlServer>();
     _workspace = vc.GetWorkspace(root);
     var serverFolder = _workspace.GetServerItemForLocalItem(root);
     changesets.LoadChangesets(vc, serverFolder);
     _changesets = changesets;
 }

        public string GetBranchNameForItem(string localFullPath, out Workspace workspace, out BranchObject branchObject)
        {
            workspace = null;
            branchObject = null;

            return GetBranchNameForItem(
                localFullPath,
                waitForConnection: true,
                timeout: TimeSpan.FromSeconds(5),
                workspace: out workspace,
                branchObject: out branchObject);
        }

 public WorkspaceAddEditDialog(Microsoft.TeamFoundation.VersionControl.Client.Workspace workspace, Microsoft.TeamFoundation.Client.ProjectCollection projectCollection)
 {
     this.projectCollection = projectCollection;
     if (workspace == null)
     {
         _action = DialogAction.Create;
     }
     else
     {
         this._workspace = workspace;
         _action = DialogAction.Edit;
     }
     _workingFoldersStore = new ListStore(_tfsFolder, _localFolder);
     BuildGui();
 }

		public TfsSourceControlProvider()
		{
			var info = Workstation.Current.GetLocalWorkspaceInfo(Vs.Helper.SolutionFolder);
			if (info == null)
			{
				Console.WriteLine("Cannot Find Tfs Workspace at " + Vs.Helper.SolutionFolder);
				return;
			}
			var uri = info.ServerUri;

			var projectCollection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(uri);
			var cssService = projectCollection.GetService<ICommonStructureService4>();
			workspace = info.GetWorkspace(projectCollection);
			IsActive = true;
		}

        public bool TryCheckin(Workspace workspace, PendingChange[] changes, string comment, CheckinNote checkinNote = null, WorkItemCheckinInfo[] workItemChanges = null, PolicyOverrideInfo policyOverride = null)
        {
            try
            {
                _teamPilgrimTfsService.WorkspaceCheckin(workspace, changes, comment, checkinNote, workItemChanges, policyOverride);
                return true;
            }
            catch (Exception ex)
            {
                this.Logger().DebugException(ex);
                LastException = ex;
            }

            return false;
        }

        internal WorkspaceInfo(InternalServerInfo server, Workspace workspace)
        {
            this.server = server;
            comment = workspace.Comment;
            computer = workspace.Computer;
            name = workspace.Name;
            ownerName = workspace.OwnerName;

            List<string> paths = new List<string>();
            foreach (WorkingFolder folder in workspace.Folders)
                {
                    paths.Add(folder.LocalItem);
                }

            mappedPaths = paths.ToArray();
        }

        public CachedWorkspace(string solutionFilePath)
        {
            WorkspaceInfo workspaceInfo = Workstation.Current.GetLocalWorkspaceInfo(solutionFilePath);
            var server = new TfsTeamProjectCollection(workspaceInfo.ServerUri);
            this.workspace = workspaceInfo.GetWorkspace(server);

            this.changedFilePaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            foreach (PendingChange pendingChange in this.workspace.GetPendingChangesEnumerable())
            {
                if (!String.IsNullOrEmpty(pendingChange.LocalItem) &&
                    (pendingChange.IsAdd || pendingChange.IsEdit))
                {
                    this.changedFilePaths.Add(Path.GetFullPath(pendingChange.LocalItem));
                }
            }
        }

        public RepositoryDialog(Workspace workspace)
            : base((workspace == null)? "Add Repository" : "Edit Repository")
        {
            Table table = new Table(3, 2, false);
                table.RowSpacing = ((uint)(6));
                table.ColumnSpacing = ((uint)(6));
                table.BorderWidth = ((uint)(12));

                name = AddLabeledEntry(table, "_Name:", 1, 2);
                server = AddLabeledEntry(table, "_Server:", 2, 3);
                table.Attach(new Gtk.HSeparator(), 0, 2, 3, 4);

                username = AddLabeledEntry(table, "_Username:", 4, 5);
                password = AddLabeledEntry(table, "_Password:", 5, 6);
                VBox.Add(table);

                okButton = AddButton ("OK", ResponseType.Ok) as Button;
                AddCloseButton("Cancel");
                DefaultResponse = ResponseType.Ok;

                if (workspace != null)
                    {
                        name.Text = workspace.Name;
                        Uri uri = workspace.VersionControlServer.TeamFoundationServer.Uri;
                        server.Text = uri.Host.ToString();

                        string creds = Keyring.GetCredentials(uri.ToString());
                        int comma = creds.IndexOf(",");

                        if (comma != -1)
                            {
                                username.Text = creds.Substring(0, comma);
                                password.Text = creds.Substring(comma+1);
                            }
                        else username.Text = creds;
                    }
                else
                    {
                        name.Text = "CodePlex";
                        server.Text = "https://tfs01.codeplex.com";
                        username.Text = "snd\\";
                    }

                ShowAll();
        }

        public WorkingFolderDialog(Workspace workspace, string serverPath)
            : base("Working Folder Mapping")
        {
            this.serverPath = serverPath;
                Table table = new Table(3, 3, false);
                table.RowSpacing = ((uint)(6));
                table.ColumnSpacing = ((uint)(6));
                table.BorderWidth = ((uint)(12));

                Label label = new Label("_Server Path: ");
                table.Attach(label, 0, 1, 1, 2);
                Label labelPath = new Label(serverPath);
                labelPath.Xalign = 0;
                table.Attach(labelPath, 1, 2, 1, 2);

                localPath = AddLabeledEntry(table, "_Local Path:", 2, 3);
                localPath.WidthChars = 32;

                browseButton = new Button("Browse...");
                table.Attach(browseButton, 2, 3, 2, 3);

                string lpath = workspace.TryGetLocalItemForServerItem(serverPath);
                if (!String.IsNullOrEmpty(lpath))
                    {
                        localPath.Text = lpath;
                        deleteButton = AddButton("Remove Mapping", ResponseType.Reject) as Button;
                    }

                VBox.Add(table);

                okButton = AddButton("OK", ResponseType.Ok) as Button;
                browseButton.Pressed += OnBrowseButtonPressed;

                AddCloseButton("Cancel");
                DefaultResponse = ResponseType.Ok;
                ShowAll();
        }