public void UpdateTestWithoutFileUploadTest()
{
var analyzerController = new AnalyzerController(mockHttpContextAccessor.Object);
var result = analyzerController.Update(null);
var objectResult = Assert.IsType <BadRequestObjectResult>(result);
var model = Assert.IsAssignableFrom <string>(objectResult.Value);
Assert.Equal("Kérem töltsön fel először fájlt!", model);
}
public async Task Statistics_FullDatabase()
{
var options = new DbContextOptionsBuilder <GridBeyondDBContext>()
.UseSqlServer("[REAL_STRING_CONNECTION]").Options;
using (var context = new GridBeyondDBContext(options))
{
AnalyzerController analyzer = new AnalyzerController(context);
var statistics = await analyzer.GetCommonStatistics();
Assert.IsTrue(statistics.TotalItems == 3133);
}
}
public async Task Statistics_BadConnection()
{
var options = new DbContextOptionsBuilder <GridBeyondDBContext>()
.UseSqlServer("Bad string connection").Options;
using (var context = new GridBeyondDBContext(options))
{
AnalyzerController analyzer = new AnalyzerController(context);
//var statistics = await analyzer.GetCommonStatistics();
Assert.ThrowsAsync <ArgumentException>(() => analyzer.GetCommonStatistics());
}
}
public async Task Statistics_EmptyDatabase()
{
var options = new DbContextOptionsBuilder <GridBeyondDBContext>()
.UseSqlServer("[REAL_STRING_CONNECTION]").Options;
using (var context = new GridBeyondDBContext(options))
{
AnalyzerController analyzer = new AnalyzerController(context);
//var statistics = await analyzer.GetCommonStatistics();
Assert.ThrowsAsync <InvalidOperationException>(() => analyzer.GetCommonStatistics());
}
}
public void IsAnalysisSupported()
{
// Arrange
var analyzers = new IAnalyzer[]
{
new DummyAnalyzer(),
new DummyAnalyzer(AnalysisLanguage.CFamily),
new DummyAnalyzer(),
};
var controller = new AnalyzerController(new TestLogger(), analyzers, null);
// Act and Assert
controller.IsAnalysisSupported(new[] { AnalysisLanguage.CFamily }).Should().BeTrue();
controller.IsAnalysisSupported(new[] { AnalysisLanguage.Javascript }).Should().BeFalse();
}
public void RequestAnalysis_NotSupported_RequestAnalysisNotCalled()
{
// Arrange
var analyzers = new DummyAnalyzer[]
{
new DummyAnalyzer(),
new DummyAnalyzer(AnalysisLanguage.CFamily),
new DummyAnalyzer(),
};
var controller = new AnalyzerController(new TestLogger(), analyzers, null);
// Act
controller.ExecuteAnalysis("c:\\file.cpp", "charset1", new[] { AnalysisLanguage.Javascript }, null, null, CancellationToken.None);
analyzers.Any(x => x.RequestAnalysisCalled).Should().BeFalse();
}
public void CleanUp_MonitorDisposed()
{
// Arrange
var analyzers = new DummyAnalyzer[]
{
new DummyAnalyzer()
};
var monitorMock = new Mock <SonarLint.VisualStudio.Integration.Vsix.Analysis.IAnalysisConfigMonitor>();
var disposableMock = monitorMock.As <IDisposable>();
var controller = new AnalyzerController(new TestLogger(), analyzers, monitorMock.Object);
// Act - Dispose multiple times
controller.Dispose();
controller.Dispose();
controller.Dispose();
// Assert
disposableMock.Verify(x => x.Dispose(), Times.Once);
}
public void GetStructsTest(int no)
{
var analyzerController = new AnalyzerController(mockHttpContextAccessor.Object);
var file = new FileData {
Name = "Valami", Content = System.IO.File.ReadAllText($@"..\..\..\..\AngularApp\Files\demo{no}.txt")
};
var value = Encoding.ASCII.GetBytes(JsonSerializer.Serialize(file));
mockSession.Setup(_ => _.TryGetValue(Key.File.ToString("g"), out value)).Returns(true);
var result = analyzerController.GetStructs();
var objectResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsAssignableFrom <List <Struct> >(objectResult.Value);
var structs = Analyzer.GetStructs(file.Content);
for (var i = 0; i < structs.Count; ++i)
{
CompareStuct(structs[i], model[i]);
}
}
public void RequestAnalysis_Supported_RequestAnalysisNotCalled()
{
// Arrange
var analyzers = new DummyAnalyzer[]
{
new DummyAnalyzer(),
new DummyAnalyzer(AnalysisLanguage.CFamily),
new DummyAnalyzer(),
new DummyAnalyzer(AnalysisLanguage.CFamily),
};
var controller = new AnalyzerController(new TestLogger(), analyzers, null);
// Act
controller.ExecuteAnalysis("c:\\file.cpp", "charset1",
new[] { AnalysisLanguage.CFamily, AnalysisLanguage.Javascript }, null, null, CancellationToken.None);
analyzers[0].RequestAnalysisCalled.Should().BeFalse();
analyzers[2].RequestAnalysisCalled.Should().BeFalse();
// Both analyzers that support analysis should be given the chance to handle the request.
analyzers[1].RequestAnalysisCalled.Should().BeTrue();
analyzers[3].RequestAnalysisCalled.Should().BeTrue();
}
/// <summary>
/// Установка логики анализа в "фоне"
/// </summary>
private void TuneBackgroundWorker()
{
if (_testWorker != null)
{
_testWorker.Dispose();
_testWorker = null;
}
_testWorker = new BackgroundWorker
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = true
};
_testWorker.DoWork += (workerSender, workEventArgs) =>
{
Interlocked.Exchange(ref _isRunningNow, 1);
using (var controller = new AnalyzerController(_currentSelectedSolutions))
{
controller.AnalysisManagers.CollectionChanged +=
(ctrlSender, changedEventArgs) => // "Подписываемся" на добавление менеджера анализа
{
if (changedEventArgs.Action != NotifyCollectionChangedAction.Add)
{
return;
}
var newManager = changedEventArgs.NewItems.Cast <AnalysisManager>().FirstOrDefault();
if (newManager == null)
{
throw new InvalidOperationException("newManager can't be null");
}
newManager.AnalysisStatusChanged += (manSender, analysisEventArgs) =>
// "Подписываемся" на смену статуса анализа для очередного добавленного менеджера
{
SetNewStatusValue(
analysisEventArgs.StartupMode, analysisEventArgs.SolutionInfo, analysisEventArgs.NewStatus);
if (_testWorker.IsBusy && _testWorker.CancellationPending)
{
workEventArgs.Cancel = true;
}
};
};
controller.CurrentAnalysisDone += (ctrl, currentAnalysisDoneEventArgs) =>
// "Подписываемся" на завершение анализа для текущего менеджера
{
var currentFinishedCount = currentAnalysisDoneEventArgs.CurrentFinishedCount;
var progress = (int)(currentFinishedCount / (double)_currentTotalCount * 100);
_testWorker.ReportProgress(progress);
};
controller.RunAll(AnalysisStatus.InPending);
}
};
_testWorker.RunWorkerCompleted += (sender, completedEventArgs) =>
{
var ex = completedEventArgs.Error;
if (ex != null)
{
AppEventLogger.Log(ex.ToString(), EventLogEntryType.Warning);
}
if (!completedEventArgs.Cancelled)
{
SetUiCompletedState();
UiUtils.ResetActiveStatuses(_currentSelectedSolutions);
}
else
{
UiUtils.ResetActiveStatuses(_currentSelectedSolutions, true);
}
ProcessUtils.MandatoryKill(Process.GetCurrentProcess(), false);
if (!StartStopButton.IsEnabled)
{
StartStopButton.IsEnabled = true;
}
UiUtils.TurnButtonState(ButtonState.Running, StartStopButton, StartStopImage);
if (!completedEventArgs.Cancelled && ShutdownCheckBox.IsChecked == true)
{
AnalyzerUtilities.ShutdownPc();
}
};
_testWorker.ProgressChanged +=
(sender, changedEventArgs) => { TestingProgressBar.Value = changedEventArgs.ProgressPercentage; };
}
public void UpdateTest(int no)
{
var analyzerController = new AnalyzerController(mockHttpContextAccessor.Object);
var file = new FileData {
Name = "Valami", Content = System.IO.File.ReadAllText($@"..\..\..\..\AngularApp\Files\demo{no}.txt")
};
var value = Encoding.ASCII.GetBytes(JsonSerializer.Serialize(file));
mockSession.Setup(_ => _.TryGetValue(Key.File.ToString("g"), out value)).Returns(true);
var content = file.Content;
var controlFlowGraph = P4ToGraph.ControlFlowGraph(ref content);
var controlValue = Encoding.ASCII.GetBytes(controlFlowGraph.ToJson());
mockSession.Setup(_ => _.TryGetValue(Key.ControlFlowGraph.ToString("g"), out controlValue)).Returns(true);
var dataFlowGraph = P4ToGraph.DataFlowGraph(content, controlFlowGraph);
var dataValue = Encoding.ASCII.GetBytes(dataFlowGraph.ToJson());
mockSession.Setup(_ => _.TryGetValue(Key.DataFlowGraph.ToString("g"), out dataValue)).Returns(true);
var analyzeDatas = new List <AnalyzeData>();
for (var i = 0; i < 5; ++i)
{
var structs = Analyzer.GetStructs(file.Content);
var _struct = structs.FirstOrDefault(x => x.Name == "headers_t");
Random random = new Random();
var randomNumber = random.Next(0, 2);
var ethernet = _struct.Headers["ethernet"];
if (randomNumber == 1)
{
ethernet.Valid = true;
ethernet.Variables.ForEach(x => x.IsInitialize = true);
}
randomNumber = random.Next(0, 2);
var ipv4 = _struct.Headers["ipv4"];
if (randomNumber == 1)
{
ipv4.Valid = true;
ipv4.Variables.ForEach(x => x.IsInitialize = true);
}
analyzeDatas.Add(new AnalyzeData
{
Id = i,
StartState = structs,
EndState = structs
});
}
var result = analyzerController.Update(analyzeDatas);
var objectResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsAssignableFrom <CalculatedData>(objectResult.Value);
var analyzers = new List <Analyzer>();
analyzeDatas.ForEach(x =>
{
analyzers.Add(new Analyzer(controlFlowGraph.ToJson(), dataFlowGraph.ToJson(), x, file.Content));
});
Parallel.ForEach(analyzers, (analyzer) =>
{
analyzer.Analyze();
analyzer.FinishOperations();
});
analyzers.DistinctGraphs(out List <List <ViewNode> > controlFlowGraphs, out List <List <ViewNode> > dataFlowGraphs);
analyzers.CreateCharts(out BarChartData readAndWriteChartData, out PieChartData useVariable, out PieChartData useful, out BarChartData headers);
var calculateData = new CalculatedData
{
ControlFlowGraphs = controlFlowGraphs,
DataFlowGraphs = dataFlowGraphs,
ReadAndWriteChartData = readAndWriteChartData,
UseVariable = useVariable,
Useful = useful,
Headers = headers,
File = file
};
Assert.Equal(calculateData.File.Name, model.File.Name);
Assert.Equal(calculateData.File.Content, model.File.Content);
CompareBarChartData(calculateData.ReadAndWriteChartData, model.ReadAndWriteChartData);
CompareBarChartData(calculateData.Headers, model.Headers);
ComparePieChartData(calculateData.UseVariable, model.UseVariable);
ComparePieChartData(calculateData.Useful, model.Useful);
}
internal static int Start(IEnumerable <string> args)
{
var summaryWrapper = new SummaryWrapper();
var selectionMode = ParseArgs(args);
var testedViewModels = TestedSolutionsManager.RetrieveSlnInfoViewModels();
var summaryResults = summaryWrapper.SummaryResults;
switch (selectionMode)
{
case RunSelectionMode.All:
using (var controller = new AnalyzerController(testedViewModels))
{
controller.AnalysisManagers.CollectionChanged += (sender, changedEventArgs) =>
{
if (changedEventArgs.Action != NotifyCollectionChangedAction.Add)
{
return;
}
var newManager = changedEventArgs.NewItems.Cast <AnalysisManager>().FirstOrDefault();
if (newManager == null)
{
throw new InvalidOperationException("newManager can't be null");
}
newManager.AnalysisStatusChanged += (o, e) =>
{
var localSlnInfo = e.SolutionInfo;
var startupMode = e.StartupMode;
var newStatus = e.NewStatus;
var exitCode = e.DevenvExitCode;
var statDesc = newStatus.GetAnalysisStatusDescription();
var slnFileName = newManager.SolutionInfo.SolutionFileName;
StatWrapper summaryResult;
if (summaryResults.TryGetValue(startupMode, out summaryResult))
{
switch (newStatus)
{
case AnalysisStatus.OkFinished:
Interlocked.Increment(ref summaryResult.OkCount);
CisTsLog(() => { _DefaultWriter.WriteLine(CisFormatString, startupMode, slnFileName, statDesc); });
break;
case AnalysisStatus.DiffFinished:
Interlocked.Increment(ref summaryResult.DiffCount);
CisTsLog(() => { _DefaultWriter.WriteLine(CisFormatString, startupMode, slnFileName, statDesc); });
break;
case AnalysisStatus.PluginCrashed:
Interlocked.Increment(ref summaryResult.FailCount);
CisTsLog(() =>
{
_DefaultWriter.WriteLine(CisFormatString, startupMode, slnFileName, statDesc);
_DefaultWriter.WriteLine(Resources.CisFailMsg, slnFileName, startupMode,
e.CrashReason.GetCrashMessage());
_DefaultWriter.WriteLine(Resources.WatchActivityLog,
newManager.LogFileName.GetDevenvActivityLog());
if (exitCode != default(int))
{
_DefaultWriter.WriteLine(Resources.ExitCodeMessage, exitCode);
}
});
break;
}
}
localSlnInfo.SetStatusValue(startupMode, newStatus);
};
};
controller.RunAll();
}
break;
default:
_DefaultWriter.WriteLine("Unknown option {0}. Press any key to exit...", selectionMode);
Environment.Exit(0);
break;
}
_DefaultWriter.WriteLine(
"----------------------------------------------------------Stat----------------------------------------------------------");
foreach (var mode in summaryResults.Keys)
{
var oks = summaryResults[mode].OkCount;
var diffs = summaryResults[mode].DiffCount;
var fails = summaryResults[mode].FailCount;
_DefaultWriter.WriteLine("Mode: {0}. Oks: {1}. Diffs: {2}. Fails: {3}", mode, oks, diffs, fails);
}
return
(summaryResults.Keys.Sum(startMode => summaryResults[startMode].DiffCount) + // Кол-во Diff'ов...
summaryResults.Keys.Sum(startMode => summaryResults[startMode].FailCount)); // ... + Кол-во Fail'ов
}
