public async Task CHI24()
{
string testName = "CHI24";
//Arrange
HttpClient client = _factory.CreateClient();
ChiSquaredAndFishersExactTestModel model = new ChiSquaredAndFishersExactTestModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Chi-sq and Fishers Exact").Key;
model.Response = "CountEF";
model.GroupingFactor = "Bin(E";
model.ResponseCategories = "Bin(F";
model.ChiSquaredTest = true;
model.FishersExactTest = true;
model.BarnardsTest = true;
model.Hypothesis = "Greater-than";
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "ChiSquaredAndFishersExactTest", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("ChiSquaredAndFishersExactTest", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "ChiSquaredAndFishersExactTest", testName + ".html"));
Assert.Equal(Helpers.FixForUnixOSs(expectedHtml), Helpers.FixForUnixOSs(statsOutput.HtmlResults));
}
public async Task SURV16()
{
string testName = "SURV16";
//Arrange
HttpClient client = _factory.CreateClient();
SurvivalAnalysisModel model = new SurvivalAnalysisModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Survival").Key;
model.Response = "Resp4";
model.Treatment = "Group 8";
model.Censorship = "Censor9";
model.CompareSurvivalCurves = true;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "SurvivalAnalysis", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("SurvivalAnalysis", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "SurvivalAnalysis", testName + ".html"));
Assert.Equal(Helpers.FixForUnixOSs(expectedHtml), Helpers.FixForUnixOSs(statsOutput.HtmlResults));
}
public async Task PSS15()
{
string testName = "PSS15";
//Arrange
HttpClient client = _factory.CreateClient();
ComparisonOfMeansPowerAnalysisDatasetBasedInputsModel model = new ComparisonOfMeansPowerAnalysisDatasetBasedInputsModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Power - Means Comp").Key;
model.Response = "Resp1";
model.Treatment = "Trea t1";
model.ControlGroup = "x";
model.PercentChange = "40, 60, 80,100";
model.ChangeType = ChangeTypeOption.Percent;
model.PlottingRangeType = PlottingRangeTypeOption.SampleSize;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "ComparisonOfMeansPowerAnalysisDatasetBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("ComparisonOfMeansPowerAnalysisDatasetBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "ComparisonOfMeansPowerAnalysisDatasetBasedInputs", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public static async Task <StatsOutput> SubmitAnalysis(HttpClient client, string analysisName, FormUrlEncodedContent content)
{
HttpResponseMessage response = await client.PostAsync("Analyses/" + analysisName, content);
HtmlDocument doc = await GetHtml(response);
var scriptBlock = doc.DocumentNode.Descendants().LastOrDefault(n => n.Name == "script");
if (scriptBlock == null)
{
throw new InvalidOperationException("HTML OUTPUT ERROR:" + doc.ParsedText);
}
if (String.IsNullOrEmpty(scriptBlock.InnerText))
{
throw new InvalidOperationException("ERRORS/WARNINGS PREVENTED ANALYSIS:" + doc.ParsedText);
}
else if (doc.ParsedText.Contains("An unhandled exception occurred while processing the request."))
{
string error = doc.DocumentNode.Descendants().First(x => x.HasClass("titleerror")).InnerText;
throw new InvalidOperationException(error);
}
string analysisGuid = scriptBlock.InnerText.Split("\"", StringSplitOptions.RemoveEmptyEntries)[1];
string jsonResponse = null;
while (jsonResponse != "true")
{
Thread.Sleep(1000);
HttpResponseMessage completedResponse = await client.PostAsync("/Analyses/AnalysisCompleted?analysisGuid=" + analysisGuid, null);
jsonResponse = await completedResponse.Content.ReadAsStringAsync();
}
HttpResponseMessage viewResultsResponse = await client.GetAsync("/Analyses/ViewResults?analysisGuid=" + analysisGuid);
HtmlDocument htmlResultsOutputDocument = await GetHtml(viewResultsResponse);
HtmlNode resultsOutputNode = htmlResultsOutputDocument.GetElementbyId("resultsOutput");
string formattedHtml = null;
if (resultsOutputNode != null) //if its null then an error has occurred but we don't throw here as we still want the log
{
string rawHtml = resultsOutputNode.InnerHtml;
formattedHtml = File.ReadAllText("ResultFormatting.txt") + rawHtml;
}
HttpResponseMessage viewLogOutput = await client.GetAsync("/Analyses/ViewLog?analysisGuid=" + analysisGuid);
HtmlDocument htmlLogOutputDocument = await GetHtml(viewLogOutput);
HtmlNode logOutputNode = htmlLogOutputDocument.GetElementbyId("logOutput");
StatsOutput statsOutput = new StatsOutput(formattedHtml, logOutputNode.InnerText);
return(statsOutput);
}
public async Task PVA18()
{
string testName = "PVA18";
//Arrange
HttpClient client = _factory.CreateClient();
PValueAdjustmentUserBasedInputsModel model = new PValueAdjustmentUserBasedInputsModel();
model.PValues = "<0.001,0.4";
model.SelectedTest = "Hochberg";
model.Significance = "0.10";
//Act
HttpResponseMessage response = await client.PostAsync("Analyses/PValueAdjustmentUserBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
IEnumerable <string> warnings = await Helpers.ExtractWarnings(response);
//Assert
Assert.Contains("You have entered unadjusted p-value(s) of the form <0.001. For the purposes of the numerical calculations this value has been replaced with 0.00099 and hence the adjusted p-values may be unduly conservative.", warnings);
Helpers.SaveOutput("PValueAdjustmentUserBasedInputs", testName, warnings);
//Act - ignore warnings
var modelIgnoreWarnings = model.ToKeyValue();
modelIgnoreWarnings.Add("ignoreWarnings", "true");
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "PValueAdjustmentUserBasedInputs", new FormUrlEncodedContent(modelIgnoreWarnings));
Helpers.SaveTestOutput("PValueAdjustmentUserBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "PValueAdjustmentUserBasedInputs", testName + ".html"));
Assert.Equal(Helpers.FixForUnixOSs(expectedHtml), Helpers.FixForUnixOSs(statsOutput.HtmlResults));
}
public async Task OSTT17()
{
string testName = "OSTT17";
//Arrange
HttpClient client = _factory.CreateClient();
OneSampleTTestAnalysisModel model = new OneSampleTTestAnalysisModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "One Sample t-test").Key;
model.Responses = new string[] { "Resp 1", "Resp2", "Resp 3", "Resp4" };
model.ResponseTransformation = "None";
model.Significance = "0.05";
model.TargetValue = 1m;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "OneSampleTTestAnalysis", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("OneSampleTTestAnalysis", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "OneSampleTTestAnalysis", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public async Task PSS18()
{
string testName = "PSS18";
//Arrange
HttpClient client = _factory.CreateClient();
OneWayANOVAPowerAnalysisUserBasedInputsModel model = new OneWayANOVAPowerAnalysisUserBasedInputsModel();
model.Means = "3.5,3.75,5.5,8";
model.VariabilityEstimate = VariabilityEstimate.Variance;
model.Variance = 8;
model.Significance = "0.001";
model.PlottingRangeType = PlottingRangeTypeOption.SampleSize;
model.SampleSizeFrom = 2;
model.SampleSizeTo = 20;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "OneWayANOVAPowerAnalysisUserBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("OneWayANOVAPowerAnalysisUserBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "OneWayANOVAPowerAnalysisUserBasedInputs", testName + ".html"));
Assert.Equal(Helpers.FixForUnixOSs(expectedHtml), Helpers.FixForUnixOSs(statsOutput.HtmlResults));
}
public async Task PSS30()
{
string testName = "PSS30";
//Arrange
HttpClient client = _factory.CreateClient();
ComparisonOfMeansPowerAnalysisDatasetBasedInputsModel model = new ComparisonOfMeansPowerAnalysisDatasetBasedInputsModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Power - Means Comp").Key;
model.Response = "Resp1";
model.Treatment = null;
model.ControlGroup = null;
model.Significance = "0.01";
model.AbsoluteChange = "0.25, 0.5, 0.75, 1";
model.ChangeType = ChangeTypeOption.Absolute;
model.PlottingRangeType = PlottingRangeTypeOption.Power;
model.PowerFrom = 50;
model.PowerTo = 80;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "ComparisonOfMeansPowerAnalysisDatasetBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("ComparisonOfMeansPowerAnalysisDatasetBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "ComparisonOfMeansPowerAnalysisDatasetBasedInputs", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public async Task PVA2()
{
string testName = "PVA2";
//Arrange
HttpClient client = _factory.CreateClient();
PValueAdjustmentDatasetBasedInputsModel model = new PValueAdjustmentDatasetBasedInputsModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "P-value Adjustment Dataset").Key;
model.PValues = "p-value - PVA2";
model.DatasetLabels = "Comparison - PVA2";
model.SelectedTest = "Hochberg";
model.Significance = "0.05";
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "PValueAdjustmentDatasetBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("PValueAdjustmentDatasetBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "PValueAdjustmentDatasetBasedInputs", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public async Task PSS19()
{
string testName = "PSS19";
//Arrange
HttpClient client = _factory.CreateClient();
ComparisonOfMeansPowerAnalysisUserBasedInputsModel model = new ComparisonOfMeansPowerAnalysisUserBasedInputsModel();
model.GroupMean = 10;
model.DeviationType = DeviationType.StandardDeviation;
model.StandardDeviation = 2;
model.Significance = "0.1";
model.AbsoluteChange = "0.5,1,2,4";
model.ChangeType = ChangeTypeOption.Absolute;
model.PlottingRangeType = PlottingRangeTypeOption.Power;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "ComparisonOfMeansPowerAnalysisUserBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("ComparisonOfMeansPowerAnalysisUserBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "ComparisonOfMeansPowerAnalysisUserBasedInputs", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public async Task UPTT21()
{
string testName = "UPTT21";
//Arrange
HttpClient client = _factory.CreateClient();
UnpairedTTestAnalysisModel model = new UnpairedTTestAnalysisModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Unpaired t-test").Key;
model.Response = "PVTestresponse2";
model.ResponseTransformation = "None";
model.Treatment = "PVTestgroup";
model.NormalProbabilityPlotSelected = true;
model.ResidualsVsPredictedPlotSelected = true;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "UnpairedTTestAnalysis", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("UnpairedTTestAnalysis", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "UnpairedTTestAnalysis", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public async Task SMA25()
{
string testName = "SMA25";
//Arrange
HttpClient client = _factory.CreateClient();
OneWayANOVAPowerAnalysisDatasetBasedInputsModel model = new OneWayANOVAPowerAnalysisDatasetBasedInputsModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Power - One-way ANOVA").Key;
model.Response = "Resp1";
model.ResponseTransformation = "Square Root";
model.Treatment = "Treat1";
model.Significance = "0.1";
model.PlottingRangeType = PlottingRangeTypeOption.Power;
model.PowerFrom = 70;
model.PowerTo = 90;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "OneWayANOVAPowerAnalysisDatasetBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("OneWayANOVAPowerAnalysisDatasetBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "OneWayANOVAPowerAnalysisDatasetBasedInputs", testName + ".html"));
Assert.Equal(Helpers.FixForUnixOSs(expectedHtml), Helpers.FixForUnixOSs(statsOutput.HtmlResults));
}
public async Task MVA24()
{
string testName = "MVA24";
//Arrange
HttpClient client = _factory.CreateClient();
MultivariateAnalysisModel model = new MultivariateAnalysisModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Multivariate").Key;
model.Responses = new string[] { "Sepal length", "Sepal width", "Petal width", "Petal length" };
model.ResponseTransformation = "Square Root";
model.CategoricalPredictor = "Categorical Binary 2";
model.CaseID = "Case ID";
model.AnalysisType = MultivariateAnalysisModel.AnalysisOption.LinearDiscriminantAnalysis;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "MultivariateAnalysis", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("MultivariateAnalysis", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "MultivariateAnalysis", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public async Task PSS23()
{
string testName = "PSS23";
//Arrange
HttpClient client = _factory.CreateClient();
OneWayANOVAPowerAnalysisUserBasedInputsModel model = new OneWayANOVAPowerAnalysisUserBasedInputsModel();
model.Means = "3.5,3.75,5.5,8";
model.VariabilityEstimate = VariabilityEstimate.StandardDeviation;
model.StandardDeviation = 3;
model.Significance = "0.05";
model.PlottingRangeType = PlottingRangeTypeOption.Power;
model.PowerFrom = 50;
model.PowerTo = 70;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "OneWayANOVAPowerAnalysisUserBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("OneWayANOVAPowerAnalysisUserBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "OneWayANOVAPowerAnalysisUserBasedInputs", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public async Task SS22()
{
string testName = "SS22";
//Arrange
HttpClient client = _factory.CreateClient();
SummaryStatisticsModel model = new SummaryStatisticsModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Summary Statistics").Key;
model.Responses = new string[] { "Resp 2", "Resp8", "Resp9" };
model.Transformation = "Log10";
model.Mean = true;
model.N = true;
model.StandardDeviation = true;
model.Variance = true;
model.StandardErrorOfMean = true;
model.MinAndMax = true;
model.MedianAndQuartiles = true;
model.CoefficientOfVariation = true;
model.NormalProbabilityPlot = true;
model.CoefficientOfVariation = true;
model.ByCategoriesAndOverall = true;
model.ConfidenceInterval = true;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "SummaryStatistics", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("SummaryStatistics", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "SummaryStatistics", testName + ".html"));
Assert.Equal(Helpers.FixForUnixOSs(expectedHtml), Helpers.FixForUnixOSs(statsOutput.HtmlResults));
}
public static async Task <StatsOutput> SubmitAnalysis(HttpClient client, string analysisName, FormUrlEncodedContent content)
{
HttpResponseMessage response = await client.PostAsync("Analyses/" + analysisName, content);
HtmlDocument doc = await GetHtml(response);
string script = doc.DocumentNode.Descendants().Last(n => n.Name == "script").InnerText;
if (String.IsNullOrEmpty(script))
{
throw new InvalidOperationException("script is null - warnings/errors present?");
}
else if (doc.ParsedText.Contains("An unhandled exception occurred while processing the request."))
{
string error = doc.DocumentNode.Descendants().First(x => x.HasClass("titleerror")).InnerText;
throw new InvalidOperationException(error);
}
string analysisGuid = script.Split("\"", StringSplitOptions.RemoveEmptyEntries)[1];
string jsonResponse = null;
while (jsonResponse != "true")
{
Thread.Sleep(1000);
HttpResponseMessage completedResponse = await client.PostAsync("/Analyses/AnalysisCompleted?analysisGuid=" + analysisGuid, null);
jsonResponse = await completedResponse.Content.ReadAsStringAsync();
}
HttpResponseMessage viewResultsResponse = await client.GetAsync("/Analyses/ViewResults?analysisGuid=" + analysisGuid);
HtmlDocument htmlResultsOutputDocument = await GetHtml(viewResultsResponse);
HtmlNode resultsOutputNode = htmlResultsOutputDocument.GetElementbyId("resultsOutput");
if (resultsOutputNode == null)
{
throw new Exception("No results output!");
}
string rawHtml = resultsOutputNode.InnerHtml;
string formattedHtml = File.ReadAllText("ResultFormatting.txt") + rawHtml;
HttpResponseMessage viewLogOutput = await client.GetAsync("/Analyses/ViewLog?analysisGuid=" + analysisGuid);
HtmlDocument htmlLogOutputDocument = await GetHtml(viewLogOutput);
HtmlNode logOutputNode = htmlLogOutputDocument.GetElementbyId("logOutput");
StatsOutput statsOutput = new StatsOutput(formattedHtml, logOutputNode.InnerText);
return(statsOutput);
}
public async Task SS28()
{
string testName = "SS28";
//Arrange
HttpClient client = _factory.CreateClient();
SummaryStatisticsModel model = new SummaryStatisticsModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Summary Statistics").Key;
model.Responses = new string[] { "Resp 2", "Resp3", "Resp6" };
model.FirstCatFactor = "Cat6";
model.Transformation = "ArcSine";
model.Mean = true;
model.N = true;
model.StandardDeviation = true;
model.Variance = true;
model.StandardErrorOfMean = true;
model.MinAndMax = true;
model.MedianAndQuartiles = true;
model.CoefficientOfVariation = true;
model.NormalProbabilityPlot = true;
model.CoefficientOfVariation = true;
model.ByCategoriesAndOverall = true;
model.ConfidenceInterval = true;
model.Significance = 95;
//Act
HttpResponseMessage response = await client.PostAsync("Analyses/SummaryStatistics", new FormUrlEncodedContent(model.ToKeyValue()));
IEnumerable <string> warnings = await Helpers.ExtractWarnings(response);
//Assert
Assert.Contains("You have ArcSine transformed the Resp3 variable. Unfortunately some of the Resp3 values are <0 or >1. These values have been ignored in the analysis as it is not possible to transform them.", warnings);
Helpers.SaveOutput("SummaryStatistics", testName, warnings);
//Act - ignore warnings
var modelIgnoreWarnings = model.ToKeyValue();
modelIgnoreWarnings.Add("ignoreWarnings", "true");
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "SummaryStatistics", new FormUrlEncodedContent(modelIgnoreWarnings));
Helpers.SaveTestOutput("SummaryStatistics", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "SummaryStatistics", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public async Task CHI27()
{
string testName = "CHI27";
//Arrange
HttpClient client = _factory.CreateClient();
ChiSquaredAndFishersExactTestModel model = new ChiSquaredAndFishersExactTestModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Chi-sq and Fishers Exact").Key;
model.Response = "CountGH";
model.GroupingFactor = "TreatmentG";
model.ResponseCategories = "TreatmentH";
model.ChiSquaredTest = true;
model.FishersExactTest = true;
model.BarnardsTest = true;
model.Hypothesis = "Greater-than";
//Act
HttpResponseMessage response = await client.PostAsync("Analyses/ChiSquaredAndFishersExactTest", new FormUrlEncodedContent(model.ToKeyValue()));
IEnumerable <string> warnings = await Helpers.ExtractWarnings(response);
//Assert
Assert.Contains("Grouping factor or the Response categories have more than two levels. Barnard's test can only be performed when there are two levels of the Grouping factor and two Response categories.", warnings);
Helpers.SaveOutput("ChiSquaredAndFishersExactTest", testName, warnings);
//Act - ignore warnings
model.BarnardsTest = true; //Deselecting Barnards test!
var modelIgnoreWarnings = model.ToKeyValue();
modelIgnoreWarnings.Add("ignoreWarnings", "true");
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "ChiSquaredAndFishersExactTest", new FormUrlEncodedContent(modelIgnoreWarnings));
Helpers.SaveTestOutput("ChiSquaredAndFishersExactTest", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "ChiSquaredAndFishersExactTest", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public async Task SMA26()
{
string testName = "SMA26";
//Arrange
HttpClient client = _factory.CreateClient();
OneWayANOVAPowerAnalysisDatasetBasedInputsModel model = new OneWayANOVAPowerAnalysisDatasetBasedInputsModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Power - One-way ANOVA").Key;
model.Response = "Resp5";
model.ResponseTransformation = "ArcSine";
model.Treatment = "Treat2";
model.Significance = "0.05";
model.PlottingRangeType = PlottingRangeTypeOption.Power;
model.PowerFrom = 50;
model.PowerTo = 70;
//Act
HttpResponseMessage response = await client.PostAsync("Analyses/OneWayANOVAPowerAnalysisDatasetBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
IEnumerable <string> warnings = await Helpers.ExtractWarnings(response);
//Assert
Assert.Contains("The Response (Resp5) contains missing data. Any rows of the dataset that contain missing responses will be excluded prior to the analysis.", warnings);
Helpers.SaveOutput("OneWayANOVAPowerAnalysisDatasetBasedInputs", testName, warnings);
//Act - ignore warnings
var modelIgnoreWarnings = model.ToKeyValue();
modelIgnoreWarnings.Add("ignoreWarnings", "true");
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "OneWayANOVAPowerAnalysisDatasetBasedInputs", new FormUrlEncodedContent(modelIgnoreWarnings));
Helpers.SaveTestOutput("OneWayANOVAPowerAnalysisDatasetBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "OneWayANOVAPowerAnalysisDatasetBasedInputs", testName + ".html"));
Assert.Equal(Helpers.FixForUnixOSs(expectedHtml), Helpers.FixForUnixOSs(statsOutput.HtmlResults));
}
public async Task PVA8()
{
string testName = "PVA8";
//Arrange
HttpClient client = _factory.CreateClient();
PValueAdjustmentUserBasedInputsModel model = new PValueAdjustmentUserBasedInputsModel();
model.PValues = "0.06,0.1,0.2";
model.SelectedTest = "Holm";
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "PValueAdjustmentUserBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("PValueAdjustmentUserBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "PValueAdjustmentUserBasedInputs", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public async Task PVA16()
{
string testName = "PVA16";
//Arrange
HttpClient client = _factory.CreateClient();
PValueAdjustmentUserBasedInputsModel model = new PValueAdjustmentUserBasedInputsModel();
model.PValues = "0.001,0.002,0.003,0.004,0.4";
model.SelectedTest = "Hochberg";
model.Significance = "0.10";
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "PValueAdjustmentUserBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("PValueAdjustmentUserBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "PValueAdjustmentUserBasedInputs", testName + ".html"));
Assert.Equal(Helpers.FixForUnixOSs(expectedHtml), Helpers.FixForUnixOSs(statsOutput.HtmlResults));
}
public async Task SURV7()
{
string testName = "SURV7";
//Arrange
HttpClient client = _factory.CreateClient();
SurvivalAnalysisModel model = new SurvivalAnalysisModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Survival").Key;
model.Response = "Resp3";
model.Treatment = "Group 1";
model.Censorship = "Censor1";
model.CompareSurvivalCurves = true;
//Act
HttpResponseMessage response = await client.PostAsync("Analyses/SurvivalAnalysis", new FormUrlEncodedContent(model.ToKeyValue()));
IEnumerable <string> warnings = await Helpers.ExtractWarnings(response);
//Assert
Assert.Contains("The Response (Resp3) contains missing data. Any rows of the dataset that contain missing responses will be excluded prior to the analysis.", warnings);
Helpers.SaveOutput("SurvivalAnalysis", testName, warnings);
//Act - ignore warnings
var modelIgnoreWarnings = model.ToKeyValue();
modelIgnoreWarnings.Add("ignoreWarnings", "true");
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "SurvivalAnalysis", new FormUrlEncodedContent(modelIgnoreWarnings));
Helpers.SaveTestOutput("SurvivalAnalysis", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "SurvivalAnalysis", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public async Task MVA15()
{
string testName = "MVA15";
//Arrange
HttpClient client = _factory.CreateClient();
MultivariateAnalysisModel model = new MultivariateAnalysisModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Multivariate").Key;
model.Responses = new string[] { "Sepal length", "Sepal width", "Petal width", "Petal length" };
model.ResponseTransformation = "Log10";
model.AnalysisType = MultivariateAnalysisModel.AnalysisOption.PrincipalComponentsAnalysis;
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "MultivariateAnalysis", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("MultivariateAnalysis", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "MultivariateAnalysis", testName + ".html"));
Assert.Equal(Helpers.FixForUnixOSs(expectedHtml), Helpers.FixForUnixOSs(statsOutput.HtmlResults));
}
public async Task SMA14()
{
string testName = "SMA14";
//Arrange
HttpClient client = _factory.CreateClient();
OneWayANOVAPowerAnalysisDatasetBasedInputsModel model = new OneWayANOVAPowerAnalysisDatasetBasedInputsModel();
model.DatasetID = _factory.SheetNames.Single(x => x.Value == "Power - One-way ANOVA").Key;
model.Response = "Resp8";
model.Treatment = "Treat6";
model.Significance = "0.05";
//Act
StatsOutput statsOutput = await Helpers.SubmitAnalysis(client, "OneWayANOVAPowerAnalysisDatasetBasedInputs", new FormUrlEncodedContent(model.ToKeyValue()));
Helpers.SaveTestOutput("OneWayANOVAPowerAnalysisDatasetBasedInputs", model, testName, statsOutput);
//Assert
string expectedHtml = File.ReadAllText(Path.Combine("ExpectedResults", "OneWayANOVAPowerAnalysisDatasetBasedInputs", testName + ".html"));
Assert.Equal(Helpers.RemoveAllImageNodes(expectedHtml), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
}
public static void SaveTestOutput(string moduleName, AnalysisModelBase analysisModel, string testName, StatsOutput statsOutput)
{
Directory.CreateDirectory("ActualResults");
Directory.CreateDirectory(Path.Combine("ActualResults", moduleName));
File.WriteAllText(Path.Combine("ActualResults", moduleName, testName + ".html"), Helpers.RemoveAllImageNodes(statsOutput.HtmlResults));
List <string> logOutput = new List <string>();
logOutput.Add(ObjectDumper.Dump(analysisModel));
logOutput.Add("------------------------------------------------------------------------------------------------------------------");
logOutput.Add(statsOutput.LogText);
File.WriteAllLines(Path.Combine("ActualResults", moduleName, testName + ".log"), logOutput);
}
public static void SaveTestOutput(string moduleName, AnalysisModelBase analysisModel, string testName, StatsOutput statsOutput)
{
Directory.CreateDirectory("ActualResults");
Directory.CreateDirectory(Path.Combine("ActualResults", moduleName));
//write the log first
List <string> logOutput = new List <string>();
logOutput.Add(ObjectDumper.Dump(analysisModel));
logOutput.Add("------------------------------------------------------------------------------------------------------------------");
logOutput.Add(statsOutput.LogText);
File.WriteAllLines(Path.Combine("ActualResults", moduleName, testName + ".log"), logOutput);
//write the results if it exists
if (statsOutput.HtmlResults == null)
{
throw new Exception("No results output!");
}
File.WriteAllText(Path.Combine("ActualResults", moduleName, testName + ".html"), Helpers.FixForUnixOSs(statsOutput.HtmlResults));
}
