private BulkObservableCollection <BaseItem> CreateDiagnosticAndGeneratorItems(ProjectId projectId, string language, CompilationOptions options, AnalyzerConfigOptionsResult?analyzerConfigOptions)
{
// Within an analyzer assembly, an individual analyzer may report multiple different diagnostics
// with the same ID. Or, multiple analyzers may report diagnostics with the same ID. Or a
// combination of the two may occur.
// We only want to show one node in Solution Explorer for a given ID. So we pick one, but we need
// to be consistent in which one we pick. Diagnostics with the same ID may have different
// descriptions or messages, and it would be strange if the node's name changed from one run of
// VS to another. So we group the diagnostics by ID, sort them within a group, and take the first
// one.
Contract.ThrowIfFalse(HasItems);
var collection = new BulkObservableCollection <BaseItem>();
collection.AddRange(
AnalyzerReference.GetAnalyzers(language)
.SelectMany(a => _diagnosticAnalyzerService.AnalyzerInfoCache.GetDiagnosticDescriptors(a))
.GroupBy(d => d.Id)
.OrderBy(g => g.Key, StringComparer.CurrentCulture)
.Select(g =>
{
var selectedDiagnostic = g.OrderBy(d => d, s_comparer).First();
var effectiveSeverity = selectedDiagnostic.GetEffectiveSeverity(options, analyzerConfigOptions);
return(new DiagnosticItem(projectId, AnalyzerReference, selectedDiagnostic, effectiveSeverity, language, CommandHandler));
}));
collection.AddRange(
AnalyzerReference.GetGenerators(language)
.Select(g => new SourceGeneratorItem(projectId, g, AnalyzerReference)));
return(collection);
}
public void AddRangeTest()
{
CollectionChangedEventArgs args = null;
var collection = new BulkObservableCollection <int>();
collection.CollectionChanged += (sender, e) => args = e;
collection.Add(1);
Assert.IsNotNull(args);
Assert.AreEqual(NotifyCollectionChangedAction.Add, args.Action);
Assert.AreEqual(1, args.NewItems.Count);
Assert.AreEqual(1, args.NewItems[0]);
args = null;
collection.AddRange(new[] { 2, 3, 4, 5 });
Assert.IsNotNull(args);
Assert.AreEqual(NotifyCollectionChangedAction.Add, args.Action);
Assert.AreEqual(4, args.NewItems.Count);
Assert.AreEqual(2, args.NewItems[0]);
Assert.AreEqual(5, args.NewItems[3]);
Assert.AreEqual(5, collection.Count);
args = null;
collection.AddRange(new[] { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 });
Assert.IsNotNull(args);
Assert.AreEqual(NotifyCollectionChangedAction.Add, args.Action);
Assert.AreEqual(10, args.NewItems.Count);
Assert.AreEqual(6, args.NewItems[0]);
Assert.AreEqual(15, args.NewItems[9]);
Assert.AreEqual(15, collection.Count);
}
public void OperationCollapseTest()
{
var argsList = new List <CollectionChangedEventArgs>();
var collection = new BulkObservableCollection <int>();
collection.CollectionChanged += (sender, e) => argsList.Add(e);
collection.BeginBatch();
collection.Add(1); // \
collection.Add(2); // > collapse into 1 add
collection.Add(3); // /
collection.Remove(1); // \
collection.Remove(2); // > collapse into 1 remove
collection.Remove(3); // /
collection.AddRange(new[] { 1, 2, 3 }); // \
collection.Add(4); // > collapse into 1 add
collection.AddRange(new[] { 5, 6, 7 }); // /
collection.Remove(7); // \
collection.Remove(6); // > collapse into 1 clear
collection.Clear(); // /
collection.Add(1); // \
collection.Add(2); // > collapse into 1 add
collection.Add(3); // /
collection[0] = 1337; // no collapse
collection.Remove(1337); // no collapse
collection.Move(0, 1); // no collapse
collection.Clear(); // no collapse
Assert.AreEqual(0, argsList.Count);
collection.EndBatch();
Assert.AreEqual(9, argsList.Count);
Assert.AreEqual(NotifyCollectionChangedAction.Add, argsList[0].Action);
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, argsList[0].NewItems);
Assert.AreEqual(NotifyCollectionChangedAction.Remove, argsList[1].Action);
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, argsList[1].OldItems);
Assert.AreEqual(NotifyCollectionChangedAction.Add, argsList[2].Action);
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, 5, 6, 7 }, argsList[2].NewItems);
Assert.AreEqual(NotifyCollectionChangedAction.Reset, argsList[3].Action);
Assert.AreEqual(NotifyCollectionChangedAction.Add, argsList[4].Action);
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, argsList[4].NewItems);
Assert.AreEqual(NotifyCollectionChangedAction.Replace, argsList[5].Action);
Assert.AreEqual(NotifyCollectionChangedAction.Remove, argsList[6].Action);
Assert.AreEqual(NotifyCollectionChangedAction.Move, argsList[7].Action);
Assert.AreEqual(NotifyCollectionChangedAction.Reset, argsList[8].Action);
}
public ChatUserListStatsMessage(IEnumerable <EmployeeSearchResult> employees)
{
_employees.AddRange(employees);
EmployeesView = CollectionViewSource.GetDefaultView(_employees);
EmployeesView.SortDescriptions.Add(new SortDescription(nameof(EmployeeSearchResult.DisplayName), ListSortDirection.Ascending));
}
/// <summary>
/// Initializes a new instance with the specified properties.
/// </summary>
/// <param name="moniker">The unique, non-localized identifier for the
/// completion set.</param>
/// <param name="displayName">The localized name of the completion set.
/// </param>
/// <param name="applicableTo">The tracking span to which the
/// completions apply.</param>
/// <param name="completions">The list of completions.</param>
/// <param name="options">The options to use for filtering and
/// selecting items.</param>
/// <param name="comparer">The comparer to use to order the provided
/// completions.</param>
public FuzzyCompletionSet(string moniker, string displayName, ITrackingSpan applicableTo,
IEnumerable <DynamicallyVisibleCompletion> completions,
CompletionOptions options, IComparer <Completion> comparer,
Func <string, IEnumerable <DynamicallyVisibleCompletion> > deferredLoadCallback) :
base(moniker, displayName, applicableTo, null, null)
{
_options = options;
_initialComparer = comparer;
_completions = new BulkObservableCollection <Completion>();
_loadedDeferredCompletionSubsets = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
_deferredLoadCallback = deferredLoadCallback;
_completions.AddRange(completions
.Where(c => c != null && !string.IsNullOrWhiteSpace(c.DisplayText))
.OrderBy(c => c, comparer)
);
_comparer = new FuzzyStringMatcher(options.SearchMode);
_shouldFilter = options.FilterCompletions;
_shouldHideAdvanced = options.HideAdvancedMembers && !_completions.All(IsAdvanced);
if (_shouldFilter | _shouldHideAdvanced)
{
_filteredCompletions = new WritableFilteredObservableCollection <Completion>(_completions);
foreach (var c in _completions.Cast <DynamicallyVisibleCompletion>())
{
c.Visible = !_shouldHideAdvanced || !IsAdvanced(c);
}
_filteredCompletions.Filter(IsVisible);
}
}
public void BeginEndBulkOperationTest()
{
CollectionChangedEventArgs args = null;
var collection = new BulkObservableCollection <int>();
collection.CollectionChanged += (sender, e) => args = e;
collection.BeginBatch();
collection.Add(1);
Assert.IsNull(args);
collection.Add(2);
Assert.IsNull(args);
collection.EndBatch();
Assert.IsNotNull(args);
args = null;
collection.BeginBatch();
collection.AddRange(new[] { 1, 2, 3 });
Assert.IsNull(args);
collection.Add(4);
Assert.IsNull(args);
collection.Remove(4);
Assert.IsNull(args);
collection.Insert(0, 5);
Assert.IsNull(args);
collection.Move(0, 1);
Assert.IsNull(args);
collection.RemoveAt(0);
Assert.IsNull(args);
collection.Clear();
Assert.IsNull(args);
collection.EndBatch();
Assert.IsNotNull(args);
}
/// <summary>
/// Discover logs and process them.
/// </summary>
private void FindLogs(CancellationToken cancellationToken)
{
LogDataProcessor.UnscheduleAll();
// TODO: Fix the counters being off if a log is currently being processed
LogDataProcessor.ResetTotalCounters();
try
{
var newLogs = new List <LogData>();
//foreach (var log in LogFinder.GetTesting())
foreach (var log in Settings.LogRootPaths.SelectMany(x => LogFinder.GetFromDirectory(x, LogCache)))
{
newLogs.Add(log);
if (log.ParsingStatus == ParsingStatus.Parsed)
{
ApiProcessor.RegisterLog(log);
}
else
{
LogDataProcessor.Schedule(log);
}
cancellationToken.ThrowIfCancellationRequested();
}
Application.Instance.Invoke(() => { logs.AddRange(newLogs); });
}
catch (Exception e) when(!(e is OperationCanceledException))
{
Application.Instance.Invoke(() =>
{
MessageBox.Show(this, $"Logs could not be found.\nReason: {e.Message}", "Log Discovery Error",
MessageBoxType.Error);
});
}
if (LogCache.ChangedSinceLastSave)
{
LogCache.SaveToFile();
}
}
public void LoadFile(String filename)
{
Filename = Path.GetFileName(filename);
FullPath = filename;
if (_watch != null)
{
_watch.Changed -= watch_Changed;
}
_watch = new FileSystemWatcher();
_watch.Path = Path.GetDirectoryName(filename);
_watch.Filter = Filename;
_watch.NotifyFilter = NotifyFilters.LastWrite;
_watch.Changed += watch_Changed;
_watch.EnableRaisingEvents = true;
FileInfo info = new FileInfo(filename);
Created = info.CreationTime;
LastUpdated = info.LastWriteTime;
FileSize = info.Length;
var tempLines = FileHelper.ReadLines(filename);
BulkObservableCollection <LogLineData> temp = new BulkObservableCollection <LogLineData>();
temp.AddRange(tempLines, (line) => CreateLineData(line));
Lines = temp;
//create and start timer if null
if (_timer != null)
{
return;
}
_timer = new Timer(50);
_timer.Elapsed += _timer_Elapsed;
_timer.AutoReset = false;
}
/// <summary>
/// Initializes a new instance with the specified properties.
/// </summary>
/// <param name="moniker">The unique, non-localized identifier for the
/// completion set.</param>
/// <param name="displayName">The localized name of the completion set.
/// </param>
/// <param name="applicableTo">The tracking span to which the
/// completions apply.</param>
/// <param name="completions">The list of completions.</param>
/// <param name="options">The options to use for filtering and
/// selecting items.</param>
/// <param name="comparer">The comparer to use to order the provided
/// completions.</param>
/// <param name="matchInsertionText">If true, matches user input against
/// the insertion text; otherwise, uses the display text.</param>
public FuzzyCompletionSet(
string moniker,
string displayName,
ITrackingSpan applicableTo,
IEnumerable <DynamicallyVisibleCompletion> completions,
CompletionOptions options,
IComparer <Completion> comparer,
bool matchInsertionText = false
) :
base(moniker, displayName, applicableTo, null, null)
{
_matchInsertionText = matchInsertionText;
_completions = new BulkObservableCollection <Completion>();
_completions.AddRange(completions
.Where(c => c != null && !string.IsNullOrWhiteSpace(c.DisplayText))
.OrderBy(c => c, comparer)
);
_comparer = new FuzzyStringMatcher(options.SearchMode);
_shouldFilter = options.FilterCompletions;
_shouldHideAdvanced = options.HideAdvancedMembers && !_completions.All(IsAdvanced);
if (!_completions.Any())
{
_completions = null;
}
if (_completions != null && _shouldFilter | _shouldHideAdvanced)
{
_filteredCompletions = new FilteredObservableCollection <Completion>(_completions);
foreach (var c in _completions.Cast <DynamicallyVisibleCompletion>())
{
c.Visible = !_shouldHideAdvanced || !IsAdvanced(c);
}
_filteredCompletions.Filter(IsVisible);
}
CommitByDefault = DefaultCommitByDefault;
}
/// <summary>
/// Initializes a new instance with the specified properties.
/// </summary>
/// <param name="moniker">The unique, non-localized identifier for the completion set.</param>
/// <param name="displayName">The localized name of the completion set.</param>
/// <param name="applicableTo">The tracking span to which the completions apply.</param>
/// <param name="completions">The list of completions.</param>
/// <param name="options">The options to use for filtering and selecting items.</param>
/// <param name="comparer">The comparer to use to order the provided completions.</param>
/// <param name="matchInsertionText">If true, matches user input against
/// the insertion text; otherwise, uses the display text.</param>
public FuzzyCompletionSet(
string moniker,
string displayName,
ITrackingSpan applicableTo,
IEnumerable<DynamicallyVisibleCompletion> completions,
IComparer<Completion> comparer,
bool matchInsertionText = false
) :
base(moniker, displayName, applicableTo, null, null) {
_matchInsertionText = matchInsertionText;
_completions = new BulkObservableCollection<Completion>();
_completions.AddRange(completions
.Where(c => c != null && !string.IsNullOrWhiteSpace(c.DisplayText))
.OrderBy(c => c, comparer)
);
_comparer = new FuzzyStringMatcher(FuzzyMatchMode.Default);
#if FALSE
_shouldFilter = options.FilterCompletions;
_shouldHideAdvanced = options.HideAdvancedMembers && !_completions.All(IsAdvanced);
#endif
_shouldFilter = true;
_shouldHideAdvanced = false;
if (_shouldFilter | _shouldHideAdvanced) {
_filteredCompletions = new FilteredObservableCollection<Completion>(_completions);
foreach (var c in _completions.Cast<DynamicallyVisibleCompletion>()) {
c.Visible = !_shouldHideAdvanced || !IsAdvanced(c);
}
_filteredCompletions.Filter(IsVisible);
}
}
public FilteredCompletionSet(string moniker, ITrackingSpan applicableTo, IEnumerable <Completion> completions, IEnumerable <Completion> completionBuilders, IReadOnlyList <IIntellisenseFilter> filters)
: base(moniker, "All", applicableTo, completions, completionBuilders, filters)
{
_completions.AddRange(completions);
currentCompletions = new FilteredObservableCollection <Completion>(_completions);
}
public void GanttGridTests()
{
KProcess.Ksmed.Business.Tests.SampleData.ClearDatabaseThenImportDefaultProject();
// On récupère les données
var service = new AnalyzeService();
var mre = new ManualResetEvent(false);
var collection = new BulkObservableCollection <DataTreeGridItem>();
var actionsManager = new GridActionsManager(collection, null, null);
actionsManager.ChangeView(Core.GanttGridView.WBS, null);
var categories = new BulkObservableCollection <ActionCategory>();
Video[] videos = null;
Scenario[] scenarios = null;
Scenario scenario = null;
Exception ex = null;
service.GetAcquireData(SampleData.GetProjectId(),
data =>
{
categories.AddRange(data.Categories);
videos = data.Videos;
scenarios = data.Scenarios;
scenario = scenarios.First();
foreach (var action in scenario.Actions)
{
action.StartTracking();
}
mre.Set();
},
e =>
{
ex = e;
mre.Set();
});
mre.WaitOne();
AssertExt.IsExceptionNull(ex);
actionsManager.RegisterInitialActions(scenario.Actions);
Assert.IsTrue(scenario.Actions.Count > 1);
Assert.IsTrue(collection.Count > 1);
Assert.IsTrue(videos.Length > 0);
Assert.IsTrue(scenario.Actions[1].Video != null);
// Capturons l'état de toutes les éléments
var originalValues = GetCurrentValues(scenario.Actions, categories, videos);
Modify(actionsManager, collection, scenario);
var modifiedValues = GetCurrentValues(scenario.Actions, categories, videos);
Assert.IsFalse(AreDumpsEqual(originalValues, modifiedValues));
// On annule les changements
actionsManager.UnregisterAllItems();
ObjectWithChangeTrackerExtensions.CancelChanges(scenario.Actions, categories, videos);
var revertedValues = GetCurrentValues(scenario.Actions, categories, videos);
Assert.IsTrue(AreDumpsEqual(originalValues, revertedValues));
// On recommence
actionsManager.RegisterInitialActions(scenario.Actions);
Modify(actionsManager, collection, scenario);
modifiedValues = GetCurrentValues(scenario.Actions, categories, videos);
Assert.IsFalse(AreDumpsEqual(originalValues, modifiedValues));
// On annule les changements
actionsManager.UnregisterAllItems();
ObjectWithChangeTrackerExtensions.CancelChanges(scenario.Actions, categories, videos);
revertedValues = GetCurrentValues(scenario.Actions, categories, videos);
Assert.IsTrue(AreDumpsEqual(originalValues, revertedValues));
}
public override void Recalculate()
{
if (_isDismissed)
{
throw (new InvalidOperationException("Cannot recalculate. The session is dismissed."));
}
// Clear out the active set of signatures.
_activeSignatures.Clear();
// In order to find the signatures to be displayed in this session, we'll need to go through each of the signature help
// providers and ask them for signatures at the trigger point.
List <ISignature> signatures = new List <ISignature>();
foreach (ISignatureHelpSource provider in _componentContext.GetSignatureHelpSources(this))
{
provider.AugmentSignatureHelpSession(this, signatures);
// The source could have done anything to the session. Let's verify that we're still alive and well.
if (this.IsDismissed)
{
return;
}
}
if (signatures != null)
{
_activeSignatures.AddRange(signatures);
}
// If we ended-up with zero signatures, that's it. We need to dismiss and get out of here.
if (_activeSignatures.Count == 0)
{
this.Dismiss();
return;
}
// Let's determine which signature should be "selected" before we find a presenter.
if (!_activeSignatures.Contains(_selectedSignature))
{
// The old selection is no longer valid (or we never had one). Let's select the first signature.
this.SelectedSignature = _activeSignatures[0];
}
// If we don't already have a presenter for this session, find one.
if (base.presenter == null)
{
base.presenter = FindPresenter(this, _componentContext.OrderedIntellisensePresenterProviderExports, _componentContext.GuardedOperations);
if (base.presenter != null)
{
this.RaisePresenterChanged();
}
else
{
this.Dismiss();
return;
}
}
base.RaiseRecalculated();
}
/// <summary>
/// Initializes a new instance with the specified properties.
/// </summary>
/// <param name="moniker">The unique, non-localized identifier for the
/// completion set.</param>
/// <param name="displayName">The localized name of the completion set.
/// </param>
/// <param name="applicableTo">The tracking span to which the
/// completions apply.</param>
/// <param name="completions">The list of completions.</param>
/// <param name="options">The options to use for filtering and
/// selecting items.</param>
/// <param name="comparer">The comparer to use to order the provided
/// completions.</param>
public FuzzyCompletionSet(string moniker, string displayName, ITrackingSpan applicableTo, IEnumerable<DynamicallyVisibleCompletion> completions, CompletionOptions options, IComparer<Completion> comparer)
: base(moniker, displayName, applicableTo, null, null)
{
_completions = new BulkObservableCollection<Completion>();
_completions.AddRange(completions.OrderBy(c => c, comparer));
_comparer = new FuzzyStringMatcher(options.SearchMode);
_shouldFilter = options.FilterCompletions;
_shouldHideAdvanced = options.HideAdvancedMembers;
if (_shouldFilter | _shouldHideAdvanced) {
_filteredCompletions = new FilteredObservableCollection<Completion>(_completions);
foreach (var c in _completions.Cast<DynamicallyVisibleCompletion>()) {
c.Visible = !_shouldHideAdvanced || !IsAdvanced(c);
}
_filteredCompletions.Filter(IsVisible);
}
}