public void TestIgnore()
{
CodeSweep.VSPackage.TaskProvider_Accessor accessor = new CodeSweep.VSPackage.TaskProvider_Accessor(_serviceProvider);
Project project = Utilities.SetupMSBuildProject();
Utilities.RegisterProjectWithMocks(project, _serviceProvider);
MockTermTable table = new MockTermTable("termtable.xml");
MockTerm term0 = new MockTerm("dupText", 0, "term0Class", "term0Comment", "term0recommended", table);
MockTerm term1 = new MockTerm("term2Text", 2, "term2Class", "term2Comment", "term2recommended", table);
MockScanHit hit0 = new MockScanHit("file0", 1, 5, "line text", term0, null);
MockScanHit hit1 = new MockScanHit("file1", 4, 1, "line text 2", term1, null);
MockScanHit hit2 = new MockScanHit("file2", 3, 2, "line text 3", term1, null);
MockScanResult scanResult = new MockScanResult("file0", new IScanHit[] { hit0, hit1, hit2 }, true);
accessor.AddResult(scanResult, project.FullPath);
IVsEnumTaskItems enumerator = null;
accessor.EnumTaskItems(out enumerator);
List <IVsTaskItem> items = Utilities.TasksFromEnumerator(enumerator);
CodeSweep.VSPackage.Task_Accessor task0Accessor = new CodeSweep.VSPackage.Task_Accessor(new PrivateObject(items[0]));
CodeSweep.VSPackage.Task_Accessor task1Accessor = new CodeSweep.VSPackage.Task_Accessor(new PrivateObject(items[1]));
MockTaskList taskList = _serviceProvider.GetService(typeof(SVsTaskList)) as MockTaskList;
// Ensure cmd is disabled with no selection
OleMenuCommandService mcs = _serviceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
MenuCommand command = mcs.FindCommand(new CommandID(CodeSweep.VSPackage.GuidList_Accessor.guidVSPackageCmdSet, (int)CodeSweep.VSPackage.PkgCmdIDList_Accessor.cmdidIgnore));
// NOTE: simply getting command.Supported or command.Enabled doesn't seem to invoke
// QueryStatus, so I'll explicitly call the status update method as a workaround.
accessor.QueryIgnore(null, EventArgs.Empty);
Assert.IsTrue(command.Supported, "Command not supported.");
Assert.IsFalse(command.Enabled, "Command enabled with no selection.");
// Ensure cmd is disabled with an ignored item selected
task0Accessor.Ignored = true;
taskList.SetSelected(items[0], true);
accessor.QueryIgnore(null, EventArgs.Empty);
Assert.IsFalse(command.Enabled, "Command enabled with ignored item selected.");
// Ensure cmd is enabled with one ignored and one non-ignored item selected
taskList.SetSelected(items[1], true);
accessor.QueryIgnore(null, EventArgs.Empty);
Assert.IsTrue(command.Enabled, "Command disabled with a non-ignored item selected.");
// Fire cmd, ensure selected items are ignored
command.Invoke();
accessor.QueryIgnore(null, EventArgs.Empty);
Assert.IsTrue(task0Accessor.Ignored, "Command set ignored task to non-ignored.");
Assert.IsTrue(task1Accessor.Ignored, "Command did not set non-ignored task to ignored.");
// Ensure cmd is now disabled
accessor.QueryIgnore(null, EventArgs.Empty);
Assert.IsFalse(command.Enabled, "Command still enabled after invocation.");
}
public int EnumTaskItems(out IVsEnumTaskItems ppenum)
{
// remove user deleted tasks
// tasks.RemoveAll( delegate( Task t ) { return (t==null || t.isDeleted); });
ppenum = new TaskEnumerator(tasks);
return(0);
}
static public List <IVsTaskItem> TasksOfProvider(IVsTaskProvider provider)
{
IVsEnumTaskItems enumerator = null;
provider.EnumTaskItems(out enumerator);
return(TasksFromEnumerator(enumerator));
}
List <Task> SelectedTasks()
{
List <Task> result = new List <Task>();
int hr = VSConstants.S_OK;
IVsTaskList2 taskList = _serviceProvider.GetService(typeof(SVsTaskList)) as IVsTaskList2;
IVsEnumTaskItems enumerator = null;
hr = taskList.EnumSelectedItems(out enumerator);
Debug.Assert(hr == VSConstants.S_OK, "EnumSelectedItems did not return S_OK.");
IVsTaskItem[] items = new IVsTaskItem[] { null };
uint[] fetched = new uint[] { 0 };
for (enumerator.Reset(); enumerator.Next(1, items, fetched) == VSConstants.S_OK && fetched[0] == 1; /*nothing*/)
{
Task task = items[0] as Task;
if (task != null)
{
result.Add(task);
}
}
return(result);
}
public override int EnumTaskItems(out IVsEnumTaskItems enumTaskItems)
{
// this will be called at the end of build.
// return real enumerator, rather than calling async refresh
var items = GetAllReportedTaskItems();
enumTaskItems = new TaskItemsEnum <VisualStudioTaskItem>(items);
return(VSConstants.S_OK);
}
public int EnumTaskItems(out IVsEnumTaskItems ppenum)
{
lock (_itemsLock) {
ppenum = new TaskEnum(_items
.Where(x => x.Key.Entry.FilePath != null) // don't report REPL window errors in the error list, you can't naviagate to them
.SelectMany(kv => kv.Value.Select(i => i.ToErrorTaskItem(kv.Key)))
.ToArray()
);
}
return(VSConstants.S_OK);
}
static public List <IVsTaskItem> TasksFromEnumerator(IVsEnumTaskItems enumerator)
{
List <IVsTaskItem> result = new List <IVsTaskItem>();
IVsTaskItem[] items = new IVsTaskItem[] { null };
uint[] fetched = new uint[] { 0 };
for (enumerator.Reset(); enumerator.Next(1, items, fetched) == VSConstants.S_OK && fetched[0] == 1; /*nothing*/)
{
result.Add(items[0]);
}
return(result);
}
public Threading.Task SendErrorDetails(IVsTaskList errorList)
{
Threading.Task processTaskListTask = new System.Threading.Tasks.Task(() =>
{
_processorStopwatch.Start();
IVsEnumTaskItems taskEnum = null;
IVsTaskItem[] oneItem = new IVsTaskItem[1];
if (errorList != null)
{
errorList.EnumTaskItems(out taskEnum);
if (taskEnum != null)
{
int maxItems = 10000;
Int32.TryParse(Properties.Resources.MaxErrorsToProcess, out maxItems);
taskEnum.Next(1, oneItem, null);
for (int i = 0; (i < maxItems) && (oneItem[0] != null); ++i)
{
ProcessTaskListItem(oneItem[0]);
taskEnum.Next(1, oneItem, null);
}
// send all events in case the Visual Studio instance is closed or solution unloaded
BuildTelemetryClient.FlushEvents();
}
}
_processorStopwatch.Stop();
Dictionary <string, string> perfProperties = new Dictionary <string, string>();
perfProperties.Add("BuildId", _currentBuildGuid.ToString());
perfProperties.Add("ProjectId", _firstIslandwoodProjectGuid.ToString());
Dictionary <string, double> perfMetrics = new Dictionary <string, double>();
perfMetrics.Add("ProcessTasks", _processorStopwatch.ElapsedMilliseconds);
BuildTelemetryClient.TrackEvent("IslandwoodBuildMonitorPerformance", perfProperties, perfMetrics);
// reset state in case projects/solutions are unloaded before next build
_firstIslandwoodProjectGuid = Guid.Empty;
});
processTaskListTask.Start();
return(processTaskListTask);
}
public static IEnumerable <IVsTaskItem> AsEnumerable(this IVsEnumTaskItems items)
{
var item = new IVsTaskItem[1];
while (true)
{
var hr = items.Next(1, item, null);
ErrorHandler.ThrowOnFailure(hr);
if (hr == VSConstants.S_FALSE)
{
break;
}
yield return(item[0]);
}
}
public static HashSet <string> CollectElementPathsFromToolWindowList(
ToolWindowKind toolWindowKind)
{
HashSet <string> stringSet = new HashSet <string>();
IVsTaskList2 vsTaskList2 = (IVsTaskList2)null;
switch (toolWindowKind)
{
case ToolWindowKind.ErrorList:
vsTaskList2 = CoreUtility.ServiceProvider.GetService(typeof(SVsErrorList)) as IVsTaskList2;
break;
case ToolWindowKind.TaskList:
vsTaskList2 = CoreUtility.ServiceProvider.GetService(typeof(SVsTaskList)) as IVsTaskList2;
break;
}
IVsEnumTaskItems ppEnum = (IVsEnumTaskItems)null;
if (vsTaskList2 != null && ErrorHandler.Succeeded(vsTaskList2.EnumSelectedItems(out ppEnum)))
{
IVsTaskItem[] rgelt = new IVsTaskItem[1];
uint[] pceltFetched = new uint[1];
while (ppEnum.Next(1U, rgelt, pceltFetched) == 0)
{
if (rgelt != null && ((IEnumerable <IVsTaskItem>)rgelt).Count <IVsTaskItem>() > 0 && rgelt[0] != null)
{
string pbstrMkDocument = (string)null;
if (ErrorHandler.Succeeded(rgelt[0].Document(out pbstrMkDocument)) && !string.IsNullOrWhiteSpace(pbstrMkDocument))
{
if (pbstrMkDocument.EndsWith(".xpp", StringComparison.OrdinalIgnoreCase))
{
stringSet.Add(CoreUtility.GetService <IMetadataInfoProvider>().GetXmlArtifactFilePath(pbstrMkDocument));
}
else if (pbstrMkDocument.EndsWith(".xml", StringComparison.OrdinalIgnoreCase))
{
stringSet.Add(pbstrMkDocument);
}
}
}
}
}
return(stringSet);
}
int IVsTaskProvider.EnumTaskItems(out IVsEnumTaskItems ppenum)
{
IList <CustomTask> list = null;
// ask external source for items:
if (RequestItems != null)
{
RequestItems(this, filter, out list);
}
if (list != null)
{
ppenum = new CustomTaskEnumerator(list, showIgnoredTasks);
}
else
{
ppenum = null;
}
return(VSConstants.S_OK);
}
private void IgnoreSelectedItems(bool ignore)
{
int hr = VSConstants.S_OK;
IVsTaskList2 taskList = _serviceProvider.GetService(typeof(SVsTaskList)) as IVsTaskList2;
IVsEnumTaskItems enumerator = null;
hr = taskList.EnumSelectedItems(out enumerator);
Debug.Assert(hr == VSConstants.S_OK, "EnumSelectedItems did not return S_OK.");
IVsTaskItem[] items = new IVsTaskItem[] { null };
uint[] fetched = new uint[] { 0 };
for (enumerator.Reset(); enumerator.Next(1, items, fetched) == VSConstants.S_OK && fetched[0] == 1; /*nothing*/)
{
Task task = items[0] as Task;
if (task != null)
{
task.Ignored = ignore;
}
}
Refresh();
}
public static IEnumerable <IVsTaskItem> AsEnumerable(this IVsEnumTaskItems items)
{
var item = new IVsTaskItem[1];
while (true)
{
var hr = items.Next(1, item, null);
ErrorHandler.ThrowOnFailure(hr);
if (hr == VSConstants.S_FALSE)
{
break;
}
// BEGIN WORKAROUND FOR https://github.com/dotnet/roslyn/issues/32121
// Filter out items not belonging to a currently-open project
if (ErrorHandler.Failed(((IVsErrorItem)item[0]).GetHierarchy(out _)))
{
continue;
}
// END WORKAROUND FOR https://github.com/dotnet/roslyn/issues/32121
yield return(item[0]);
}
}
// IVsTaskProvider methods
public void EnumTaskItems(out IVsEnumTaskItems ppEnum){
ppEnum = new TaskEnumerator((TaskItem[])items.ToArray(typeof(TaskItem)));
}
public virtual void Clone (out IVsEnumTaskItems ppenum) {
ppenum = new TaskEnumerator(this.items);
}
// IVsTaskProvider methods
public void EnumTaskItems(out IVsEnumTaskItems ppEnum)
{
ppEnum = new TaskEnumerator((TaskItem[])items.ToArray(typeof(TaskItem)));
}
public virtual void Clone(out IVsEnumTaskItems ppenum)
{
ppenum = new TaskEnumerator(this.items);
}
public override int EnumTaskItems(out IVsEnumTaskItems ppenum)
{
RefreshOrAddTasks(_todoItemMap.Values.SelectMany(x => x).ToArray());
return base.EnumTaskItems(out ppenum);
}
/// <summary>
/// The enum task items.
/// </summary>
/// <param name="ppenum">
/// The ppenum.
/// </param>
/// <returns>
/// The enum task items.
/// </returns>
/// <exception cref="Exception">
/// </exception>
public int EnumTaskItems(out IVsEnumTaskItems ppenum)
{
throw new Exception("The method or operation is not implemented.");
}
public int Clone(out IVsEnumTaskItems newItems)
{
newItems = new VsEnumTaskItems(tasks);
return(NativeMethods.S_OK);
}
int IVsEnumTaskItems.Clone(out IVsEnumTaskItems taskItemsEnum)
{
taskItemsEnum = new TaskItemsEnum <T>(_items);
return(VSConstants.S_OK);
}
private int InternalEnumTaskItems(out IVsEnumTaskItems ppEnum)
{
ppEnum = new VsEnumTaskItems(this);
return(NativeMethods.S_OK);
}
int IVsTaskProvider.EnumTaskItems(out IVsEnumTaskItems ppenum)
{
return(((IVsTaskProvider2)this).EnumTaskItems(out ppenum));
}
/// <summary>
/// The enum selected items.
/// </summary>
/// <param name="ppEnum">
/// The pp enum.
/// </param>
/// <returns>
/// The enum selected items.
/// </returns>
public int EnumSelectedItems(out IVsEnumTaskItems ppEnum)
{
ppEnum = new MockTaskEnum(this._selection);
return VSConstants.S_OK;
}
/// <summary>
/// The enum task items.
/// </summary>
/// <param name="ppenum">
/// The ppenum.
/// </param>
/// <returns>
/// The enum task items.
/// </returns>
/// <exception cref="Exception">
/// </exception>
public int EnumTaskItems(out IVsEnumTaskItems ppenum)
{
throw new Exception("The method or operation is not implemented.");
}
/// <include file='doc\TaskProvider.uex' path='docs/doc[@for="TaskProvider.IVsTaskProvider.EnumTaskItems"]/*' />
/// <internalonly/>
int IVsTaskProvider.EnumTaskItems(out IVsEnumTaskItems items)
{
items = new VsEnumTaskItems(Tasks);
return(NativeMethods.S_OK);
}
public int EnumTaskItems(out IVsEnumTaskItems ppenum)
{
// remove user deleted tasks
// tasks.RemoveAll( delegate( Task t ) { return (t==null || t.isDeleted); });
ppenum = new TaskEnumerator(tasks);
return 0;
}
/// <include file='doc\TaskProvider.uex' path='docs/doc[@for="TaskProvider.IVsTaskProvider2.EnumTaskItems"]/*' />
/// <internalonly/>
int IVsTaskProvider2.EnumTaskItems(out IVsEnumTaskItems items)
{
return(((IVsTaskProvider)this).EnumTaskItems(out items));
}
public int EnumTaskItems(out IVsEnumTaskItems ppenum)
{
ppenum = new TaskEnumerator(_tasks, IsShowingIgnoredInstances);
return(VSConstants.S_OK);
}
/// <summary>
/// Creates a new enumerator with identical content to this one.
/// </summary>
/// <param name="ppenum">The newly created enumerator.</param>
/// <returns>An HRESULT indicating the success of the operation.</returns>
public int Clone(out IVsEnumTaskItems ppenum)
{
ppenum = new TaskEnumerator(_items, _showIgnored);
return(VSConstants.S_OK);
}
// IVsTaskProvider methods
public int EnumTaskItems(out IVsEnumTaskItems ppEnum){
ppEnum = new TaskEnumerator((TaskItem[])items.ToArray(typeof(TaskItem)));
return 0;
}
public int Clone(out IVsEnumTaskItems ppenum)
{
ppenum = new TaskEnum(_enumerable);
return(VSConstants.S_OK);
}
public int EnumTaskItems(out IVsEnumTaskItems ppenum)
{
ppenum = new TaskEnumerator(_tasks, IsShowingIgnoredInstances);
return VSConstants.S_OK;
}
/// <summary>
/// The enum selected items.
/// </summary>
/// <param name="ppEnum">
/// The pp enum.
/// </param>
/// <returns>
/// The enum selected items.
/// </returns>
public int EnumSelectedItems(out IVsEnumTaskItems ppEnum)
{
ppEnum = new MockTaskEnum(this._selection);
return(VSConstants.S_OK);
}
/// <include file='doc\TaskProvider.uex' path='docs/doc[@for="TaskProvider.IVsTaskProvider2.EnumTaskItems"]/*' />
/// <internalonly/>
int IVsTaskProvider2.EnumTaskItems(out IVsEnumTaskItems items)
{
return ((IVsTaskProvider)this).EnumTaskItems(out items);
}
public virtual int Clone(out IVsEnumTaskItems ppenum)
{
ppenum = new TaskEnumerator(tasks);
return 0;
}
public int Clone(out IVsEnumTaskItems ppenum)
{
ppenum = null;
return VSConstants.E_NOTIMPL;
}
int IVsTaskProvider2.EnumTaskItems(out IVsEnumTaskItems ppEnum)
{
return(InternalEnumTaskItems(out ppEnum));
}
/// <summary>
/// Creates a new enumerator with identical content to this one.
/// </summary>
/// <param name="ppenum">The newly created enumerator.</param>
/// <returns>An HRESULT indicating the success of the operation.</returns>
public int Clone(out IVsEnumTaskItems ppenum)
{
ppenum = new TaskEnumerator(_items, _showIgnored);
return VSConstants.S_OK;
}
int IVsEnumTaskItems.Clone(out IVsEnumTaskItems ppEnum)
{
ppEnum = new VsEnumTaskItems(owner, items);
return(NativeMethods.S_OK);
}
public override int EnumTaskItems(out IVsEnumTaskItems ppenum)
{
RefreshOrAddTasks(_todoItemMap.Values.SelectMany(x => x).ToArray());
return(base.EnumTaskItems(out ppenum));
}
/// <include file='doc\TaskProvider.uex' path='docs/doc[@for="TaskProvider.IVsTaskProvider.EnumTaskItems"]/*' />
/// <internalonly/>
int IVsTaskProvider.EnumTaskItems(out IVsEnumTaskItems items)
{
items = new VsEnumTaskItems(Tasks);
return NativeMethods.S_OK;
}
int IVsEnumTaskItems.Clone(out IVsEnumTaskItems ppenum)
{
ppenum = new CustomTaskEnumerator(items, showIgnored);
return(VSConstants.S_OK);
}
public int Clone(out IVsEnumTaskItems newItems)
{
newItems = new VsEnumTaskItems(tasks);
return NativeMethods.S_OK;
}
// This gets called once when we register, but shouldn't get called again
// except build case. in build case, VS will refresh all errors at the end of build
public virtual int EnumTaskItems(out IVsEnumTaskItems ppenum)
{
ppenum = new EmptyVsEnumTaskItems();
return VSConstants.S_OK;
}
