public void SetDefaultsWorks()
{
var viewModel = new IndenterSettingsViewModel(GetNondefaultConfig());
var defaultConfig = GetDefaultConfig();
viewModel.SetToDefaults(defaultConfig);
MultiAssert.Aggregate(
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.AlignCommentsWithCode, viewModel.AlignCommentsWithCode),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.AlignContinuations, viewModel.AlignContinuations),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.AlignDimColumn, viewModel.AlignDimColumn),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.AlignDims, viewModel.AlignDims),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.EndOfLineCommentColumnSpaceAlignment, viewModel.EndOfLineCommentColumnSpaceAlignment),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.EndOfLineCommentStyle, viewModel.EndOfLineCommentStyle),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.ForceCompilerDirectivesInColumn1, viewModel.ForceCompilerDirectivesInColumn1),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.ForceDebugStatementsInColumn1, viewModel.ForceDebugStatementsInColumn1),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IgnoreOperatorsInContinuations, viewModel.IgnoreOperatorsInContinuations),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentCase, viewModel.IndentCase),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentEnumTypeAsProcedure, viewModel.IndentEnumTypeAsProcedure),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentCompilerDirectives, viewModel.IndentCompilerDirectives),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentEntireProcedureBody, viewModel.IndentEntireProcedureBody),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentFirstCommentBlock, viewModel.IndentFirstCommentBlock),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentFirstDeclarationBlock, viewModel.IndentFirstDeclarationBlock),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentSpaces, viewModel.IndentSpaces),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.VerticallySpaceProcedures, viewModel.VerticallySpaceProcedures),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.LinesBetweenProcedures, viewModel.LinesBetweenProcedures));
}
public static void WittyerVariantIntervalCorrect([NotNull] string variant, uint start, uint end,
uint posStart, uint posEnd, uint endStart, uint endEnd)
{
const string sampleName = "tumor";
var vcfVariant = VcfVariant.TryParse(variant,
VcfVariantParserSettings.Create(ImmutableList.Create("normal", sampleName), GenomeAssembly.Hg38))
.GetOrThrowDebug();
var _ = WittyerType.ParseFromVariant(vcfVariant, false, sampleName, out var type);
if (type == null)
{
throw new NotSupportedException("This test does not handle svType null");
}
var wittyerVariant = WittyerVariantInternal
.Create(vcfVariant, vcfVariant.Samples[sampleName], type, Bins, PercentDistance, BasepairDistance);
var expectedStart = ContigAndInterval.Create(vcfVariant.Contig, start, end);
var expectedPos = BedInterval.Create(posStart, posEnd);
var expectedEnd = BedInterval.Create(endStart, endEnd);
MultiAssert.Equal(expectedStart, wittyerVariant);
MultiAssert.Equal(expectedPos, wittyerVariant.CiPosInterval);
MultiAssert.Equal(expectedEnd, wittyerVariant.CiEndInterval);
MultiAssert.AssertAll();
}
public void SkippedBinsAreIgnoredInStats()
{
var outputDirectory = Path.GetRandomFileName().ToDirectoryInfo();
var alternatingBins = ImmutableList <(uint size, bool skip)> .Empty
.Add((1, true))
.Add((100000, false))
.Add((200000, true))
.Add((300000, false));
var inputSpecs = InputSpec.GenerateDefaultInputSpecs(true)
.Select(i => InputSpec.Create(i.VariantType, alternatingBins,
1, 1, i.ExcludedFilters, i.IncludedFilters, i.IncludedRegions))
.ToDictionary(i => i.VariantType, i => i);
var wittyerSettings = WittyerSettings.Create(outputDirectory, TinyTruth, TinyQuery,
ImmutableList <ISamplePair> .Empty, EvaluationMode.SimpleCounting,
inputSpecs);
var(_, query, truth) = MainLauncher.GenerateResults(wittyerSettings).EnumerateSuccesses().First();
var results = MainLauncher.GenerateSampleMetrics(truth, query, false, inputSpecs);
MultiAssert.Equal(2U, results.OverallStats[StatsType.Event].QueryStats.TrueCount);
MultiAssert.Equal(1U, results.OverallStats[StatsType.Event].QueryStats.FalseCount);
MultiAssert.Equal(0.6666666666666666, results.EventLevelRecallOverall.First(typeRecallTuple => typeRecallTuple.type == WittyerType.CopyNumberGain).recall);
var numberOfBinsReportedOn = results.EventLevelRecallPerBin.First().perBinRecall.Count();
MultiAssert.Equal(2, numberOfBinsReportedOn);
MultiAssert.AssertAll();
}
public void SaveConfigWorks()
{
var customConfig = GetNondefaultConfig();
var viewModel = new IndenterSettingsViewModel(customConfig);
var config = GetDefaultConfig();
viewModel.UpdateConfig(config);
MultiAssert.Aggregate(
() => Assert.AreEqual(config.UserSettings.IndenterSettings.AlignCommentsWithCode, viewModel.AlignCommentsWithCode),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.AlignContinuations, viewModel.AlignContinuations),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.AlignDimColumn, viewModel.AlignDimColumn),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.AlignDims, viewModel.AlignDims),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.EnableUndo, viewModel.EnableUndo),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.EndOfLineCommentColumnSpaceAlignment, viewModel.EndOfLineCommentColumnSpaceAlignment),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.EndOfLineCommentStyle, viewModel.EndOfLineCommentStyle),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.ForceCompilerDirectivesInColumn1, viewModel.ForceCompilerDirectivesInColumn1),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.ForceDebugStatementsInColumn1, viewModel.ForceDebugStatementsInColumn1),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.IgnoreOperatorsInContinuations, viewModel.IgnoreOperatorsInContinuations),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.IndentCase, viewModel.IndentCase),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.IndentCompilerDirectives, viewModel.IndentCompilerDirectives),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.IndentEntireProcedureBody, viewModel.IndentEntireProcedureBody),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.IndentFirstCommentBlock, viewModel.IndentFirstCommentBlock),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.IndentFirstDeclarationBlock, viewModel.IndentFirstDeclarationBlock),
() => Assert.AreEqual(config.UserSettings.IndenterSettings.IndentSpaces, viewModel.IndentSpaces));
}
public void InsertSameTreeIntoTree()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
foreach (var target in ExistingIntervals)
{
tree.Add(target);
}
// non-overlapping should have one more interval
MultiAssert.True(ExistingIntervals.SequenceEqual(tree));
// subtract back the stuff we added to get leftovers.
var fpTree = MergedIntervalTree.Create <uint>();
foreach (var interval in tree)
{
var overlaps = ExistingTree.Search(interval).ToList();
if (overlaps.Count == 0)
{
fpTree.Add(interval);
}
else
{
fpTree.AddRange(interval.Subtract(overlaps));
}
}
// since we added the same, leftovers should be none.
MultiAssert.False(fpTree.Any());
MultiAssert.AssertAll();
}
public void InsertTotallyOverlappingBecomesOneInterval()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target =
new ClosedOpenInterval <uint>(ExistingIntervals[0].Stop - 1, ExistingIntervals.Last().Start + 1);
tree.Add(target);
MultiAssert.Equal(1, tree.Count());
MultiAssert.Equal(ExistingIntervals.First().Start, tree.First().Start);
MultiAssert.Equal(ExistingIntervals.Last().Stop, tree.Last().Stop);
// subtract back the stuff we added to get leftovers.
var fpTree = MergedIntervalTree.Create <uint>();
foreach (var interval in tree)
{
var overlaps = ExistingTree.Search(interval).ToList();
if (overlaps.Count == 0)
{
fpTree.Add(interval);
}
else
{
fpTree.AddRange(interval.Subtract(overlaps));
}
}
// should be one less since it's the # of gaps
MultiAssert.Equal(ExistingIntervals.Count - 1, fpTree.Count());
MultiAssert.AssertAll();
}
public void InsertNonOverlappingAtEnd()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target = new ClosedOpenInterval <uint>(ExistingIntervals.Last().Stop, uint.MaxValue);
tree.Add(target);
MultiAssert.Equal(ExistingIntervals.Count + 1, tree.Count());
MultiAssert.Equal(target, tree.Last());
// subtract back the stuff we added to get leftovers.
var fpTree = MergedIntervalTree.Create <uint>();
foreach (var interval in tree)
{
var overlaps = ExistingTree.Search(interval).ToList();
if (overlaps.Count == 0)
{
fpTree.Add(interval);
}
else
{
fpTree.AddRange(interval.Subtract(overlaps));
}
}
MultiAssert.Equal(1, fpTree.Count());
MultiAssert.Equal(target.GetLength(), fpTree.FirstOrDefault()?.GetLength());
MultiAssert.AssertAll();
}
public void GetInsertionIntervalNoLenIns()
{
var variant = VcfVariant
.TryParse(UnknownLength, VcfVariantParserSettings.Create(ImmutableList.Create("blah"))).GetOrThrow();
var bedInterval = WittyerBndInternal.GetInsertionInterval(variant);
MultiAssert.Equal(null, bedInterval?.GetLength());
MultiAssert.AssertAll();
}
public void InsertNonOverlappingAtEnd()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target = new InclusiveInterval <uint>(ExistingIntervals.Last().Stop + 1, uint.MaxValue);
tree.Add(target);
MultiAssert.Equal(ExistingIntervals.Count + 1, tree.Count());
MultiAssert.Equal(target, tree.Last());
MultiAssert.AssertAll();
}
public void InsertTotallyOverlappingBecomesOneInterval()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target = new InclusiveInterval <uint>(ExistingIntervals[0].Stop, ExistingIntervals.Last().Start);
tree.Add(target);
MultiAssert.Equal(1, tree.Count());
MultiAssert.Equal(ExistingIntervals.First().Start, tree.First().Start);
MultiAssert.Equal(ExistingIntervals.Last().Stop, tree.Last().Stop);
MultiAssert.AssertAll();
}
public static void WorksWithCi()
{
var query = CreateWittyerVariant(QueryWithCiPos);
var truth = CreateWittyerVariant(TruthWithCiEnd);
var expected = BorderDistance.CreateFromVariant(query, truth);
MultiAssert.Equal(87U, expected.PosBorderLeft);
MultiAssert.Equal(287U, expected.PosBorderRight);
MultiAssert.Equal(686U, expected.EndBorderLeft);
MultiAssert.Equal(986U, expected.EndBorderRight);
MultiAssert.AssertAll();
}
public static void MergeMultipleIntervalWorks()
{
var tree = GetOriginalTree();
tree.Add(new InclusiveInterval <uint>(9, 30));
var mergedIntervals = tree.ToMergedIntervalTree();
MultiAssert.Equal(1, mergedIntervals.Count());
MultiAssert.Equal(22L, tree.GetTotalMergedLength());
MultiAssert.AssertAll();
}
public void InsertNonOverlappingAtBeginning()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target = new InclusiveInterval <uint>(uint.MinValue, ExistingIntervals[0].Start - 1);
tree.Add(target);
// non-overlapping should have one more interval
MultiAssert.Equal(ExistingIntervals.Count + 1, tree.Count());
MultiAssert.Equal(tree.First().Start, target.Start);
MultiAssert.Equal(tree.First().Stop, target.Stop);
MultiAssert.AssertAll();
}
public static void WorksWithBreakend()
{
var query = CreateWittyerBnd(QueryBnd1, QueryBnd2);
var truth = CreateWittyerBnd(TruthBnd1, TruthBnd2);
var expected = BorderDistance.CreateFromVariant(query, truth);
MultiAssert.Equal(85U, expected.PosBorderLeft);
MultiAssert.Equal(117U, expected.PosBorderRight);
MultiAssert.Equal(72U, expected.EndBorderLeft);
MultiAssert.Equal(28U, expected.EndBorderRight);
MultiAssert.AssertAll();
}
public void CancelButtonDoesNothing()
{
var nondefaultConfig = GetNondefaultConfig();
var configLoader = GetConfigLoader(nondefaultConfig);
var viewModel = GetDefaultViewModel(configLoader);
var defaultConfig = GetDefaultConfig();
foreach (var view in viewModel.SettingsViews)
{
view.Control.ViewModel.SetToDefaults(defaultConfig);
}
viewModel.CancelButtonCommand.Execute(null);
var updatedConfig = configLoader.LoadConfiguration();
MultiAssert.Aggregate(
() => MultiAssert.Aggregate(
() => Assert.AreEqual(nondefaultConfig.UserSettings.GeneralSettings.Language, updatedConfig.UserSettings.GeneralSettings.Language),
() => Assert.IsTrue(nondefaultConfig.UserSettings.GeneralSettings.HotkeySettings.SequenceEqual(updatedConfig.UserSettings.GeneralSettings.HotkeySettings)),
() => Assert.AreEqual(nondefaultConfig.UserSettings.GeneralSettings.AutoSaveEnabled, updatedConfig.UserSettings.GeneralSettings.AutoSaveEnabled),
() => Assert.AreEqual(nondefaultConfig.UserSettings.GeneralSettings.AutoSavePeriod, updatedConfig.UserSettings.GeneralSettings.AutoSavePeriod)
),
() => Assert.IsTrue(nondefaultConfig.UserSettings.ToDoListSettings.ToDoMarkers.SequenceEqual(updatedConfig.UserSettings.ToDoListSettings.ToDoMarkers)),
() => Assert.IsTrue(nondefaultConfig.UserSettings.CodeInspectionSettings.CodeInspections.SequenceEqual(updatedConfig.UserSettings.CodeInspectionSettings.CodeInspections)),
() => MultiAssert.Aggregate(
() => Assert.AreEqual(nondefaultConfig.UserSettings.UnitTestSettings.BindingMode, updatedConfig.UserSettings.UnitTestSettings.BindingMode),
() => Assert.AreEqual(nondefaultConfig.UserSettings.UnitTestSettings.AssertMode, updatedConfig.UserSettings.UnitTestSettings.AssertMode),
() => Assert.AreEqual(nondefaultConfig.UserSettings.UnitTestSettings.ModuleInit, updatedConfig.UserSettings.UnitTestSettings.ModuleInit),
() => Assert.AreEqual(nondefaultConfig.UserSettings.UnitTestSettings.MethodInit, updatedConfig.UserSettings.UnitTestSettings.MethodInit),
() => Assert.AreEqual(nondefaultConfig.UserSettings.UnitTestSettings.DefaultTestStubInNewModule, updatedConfig.UserSettings.UnitTestSettings.DefaultTestStubInNewModule)
),
() => MultiAssert.Aggregate(
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.AlignCommentsWithCode, updatedConfig.UserSettings.IndenterSettings.AlignCommentsWithCode),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.AlignContinuations, updatedConfig.UserSettings.IndenterSettings.AlignContinuations),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.AlignDimColumn, updatedConfig.UserSettings.IndenterSettings.AlignDimColumn),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.AlignDims, updatedConfig.UserSettings.IndenterSettings.AlignDims),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.EnableUndo, updatedConfig.UserSettings.IndenterSettings.EnableUndo),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.EndOfLineCommentColumnSpaceAlignment, updatedConfig.UserSettings.IndenterSettings.EndOfLineCommentColumnSpaceAlignment),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.EndOfLineCommentStyle, updatedConfig.UserSettings.IndenterSettings.EndOfLineCommentStyle),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.ForceCompilerDirectivesInColumn1, updatedConfig.UserSettings.IndenterSettings.ForceCompilerDirectivesInColumn1),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.ForceDebugStatementsInColumn1, updatedConfig.UserSettings.IndenterSettings.ForceDebugStatementsInColumn1),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.IgnoreOperatorsInContinuations, updatedConfig.UserSettings.IndenterSettings.IgnoreOperatorsInContinuations),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.IndentCase, updatedConfig.UserSettings.IndenterSettings.IndentCase),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.IndentCompilerDirectives, updatedConfig.UserSettings.IndenterSettings.IndentCompilerDirectives),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.IndentEntireProcedureBody, updatedConfig.UserSettings.IndenterSettings.IndentEntireProcedureBody),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.IndentFirstCommentBlock, updatedConfig.UserSettings.IndenterSettings.IndentFirstCommentBlock),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.IndentFirstDeclarationBlock, updatedConfig.UserSettings.IndenterSettings.IndentFirstDeclarationBlock),
() => Assert.AreEqual(nondefaultConfig.UserSettings.IndenterSettings.IndentSpaces, updatedConfig.UserSettings.IndenterSettings.IndentSpaces)));
}
public void MergeHeaderWorks()
{
string GetPrefix(string line)
=> line.Split(new[] { VcfConstants.Header.MetaInfoLines.KeyValueDelimiter[0] }, 4)
.Where(it => it.Length > 2).Skip(2).FirstOrDefault();
var queryHeader = VcfHeader
.TryCreate(Path.Combine("Resources", "VcfHeaders", "query.wit-141.vcf").ToFileInfo()).GetOrThrow();
var truthHeader = VcfHeader
.TryCreate(Path.Combine("Resources", "VcfHeaders", "truth.wit-141.vcf").ToFileInfo()).GetOrThrow();
var vcfLines = truthHeader.MergedWith(queryHeader, SamplePair.Default, null).ToList();
var merged = VcfHeader.TryCreate(vcfLines)
.GetOrThrow();
MultiAssert.True(
merged.ColumnMetaInfoLines.SampleFormatLines.ContainsKey(WittyerConstants.WittyerMetaInfoLineKeys
.What));
MultiAssert.True(
merged.ColumnMetaInfoLines.SampleFormatLines.ContainsKey(WittyerConstants.WittyerMetaInfoLineKeys
.Why));
MultiAssert.True(
merged.ColumnMetaInfoLines.SampleFormatLines.ContainsKey(WittyerConstants.WittyerMetaInfoLineKeys
.Wit));
MultiAssert.True(
merged.ColumnMetaInfoLines.InfoLines.ContainsKey(WittyerConstants.WittyerMetaInfoLineKeys
.Who));
MultiAssert.True(
merged.ColumnMetaInfoLines.InfoLines.ContainsKey(WittyerConstants.WittyerMetaInfoLineKeys
.Where));
MultiAssert.True(
merged.ColumnMetaInfoLines.InfoLines.ContainsKey(WittyerConstants.WittyerMetaInfoLineKeys
.Win));
MultiAssert.True(
merged.ColumnMetaInfoLines.InfoLines.ContainsKey(WittyerConstants.WittyerMetaInfoLineKeys
.Wow));
// 1 different because of date in
// ##bcftools_viewCommand=view -h /home/hking/manta_2by250_sv_dragen/manta_2by250_sv_dragen.sv.vcf.gz; Date=Fri Jul 19 07:39:26 2019
var diffs = queryHeader.Select(GetPrefix).Where(it => it != null).ToImmutableHashSet()
.Except(merged.Select(GetPrefix).Where(it => it != null));
MultiAssert.True(diffs.Count == 1);
// 1 different because of date in
// ##bcftools_viewCommand=view -h NA12878_pbmm_v1.0.0_pbsv_v2.2.0_hg38_20190430_witty_format.vcf.gz; Date=Fri Jul 19 07:38:56 2019
diffs = truthHeader.Select(GetPrefix).Where(it => it != null).ToImmutableHashSet()
.Except(merged.Select(GetPrefix).Where(it => it != null));
MultiAssert.True(diffs.Count == 1);
MultiAssert.AssertAll();
}
public void SetDefaultsWorks()
{
var viewModel = new GeneralSettingsViewModel(GetNondefaultConfig(), GetOperatingSystemMock().Object);
var defaultConfig = GetDefaultConfig();
viewModel.SetToDefaults(defaultConfig);
MultiAssert.Aggregate(
() => Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.Language, viewModel.SelectedLanguage),
() => Assert.IsTrue(defaultConfig.UserSettings.HotkeySettings.Settings.SequenceEqual(viewModel.Hotkeys)),
() => Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.AutoSaveEnabled, viewModel.AutoSaveEnabled),
() => Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.AutoSavePeriod, viewModel.AutoSavePeriod));
}
public void SetDefaultsWorks()
{
var viewModel = new UnitTestSettingsViewModel(GetNondefaultConfig());
var defaultConfig = GetDefaultConfig();
viewModel.SetToDefaults(defaultConfig);
MultiAssert.Aggregate(
() => Assert.AreEqual(defaultConfig.UserSettings.UnitTestSettings.BindingMode, viewModel.BindingMode),
() => Assert.AreEqual(defaultConfig.UserSettings.UnitTestSettings.AssertMode, viewModel.AssertMode),
() => Assert.AreEqual(defaultConfig.UserSettings.UnitTestSettings.ModuleInit, viewModel.ModuleInit),
() => Assert.AreEqual(defaultConfig.UserSettings.UnitTestSettings.MethodInit, viewModel.MethodInit),
() => Assert.AreEqual(defaultConfig.UserSettings.UnitTestSettings.DefaultTestStubInNewModule, viewModel.DefaultTestStubInNewModule));
}
public void InsertIntervalBarelyOverlappingFirstTwoInterval()
{
var tree = MergedIntervalTree.Create(ExistingIntervals);
var target = new InclusiveInterval <uint>(ExistingIntervals[0].Stop, ExistingIntervals[1].Start);
tree.Add(target);
// insert one, but remove 2 would be net of - 1
MultiAssert.Equal(ExistingIntervals.Count - 1, tree.Count());
MultiAssert.Equal(ExistingIntervals.First().Start, tree.First().Start);
// overlapping the two first ones means the second's stop is the stop of first in tree
MultiAssert.Equal(ExistingIntervals.Skip(1).First().Stop, tree.First().Stop);
MultiAssert.AssertAll();
}
public void SaveConfigWorks()
{
var customConfig = GetNondefaultConfig();
var viewModel = new GeneralSettingsViewModel(customConfig);
var config = GetDefaultConfig();
viewModel.UpdateConfig(config);
MultiAssert.Aggregate(
() => Assert.AreEqual(config.UserSettings.GeneralSettings.Language, viewModel.SelectedLanguage),
() => Assert.IsTrue(config.UserSettings.GeneralSettings.HotkeySettings.SequenceEqual(viewModel.Hotkeys)),
() => Assert.AreEqual(config.UserSettings.GeneralSettings.AutoSaveEnabled, viewModel.AutoSaveEnabled),
() => Assert.AreEqual(config.UserSettings.GeneralSettings.AutoSavePeriod, viewModel.AutoSavePeriod));
}
public void CrossType_Works()
{
var outputDirectory = Path.GetRandomFileName().ToDirectoryInfo();
var inputSpecs = InputSpec.GenerateDefaultInputSpecs(false).Select(i => InputSpec.Create(i.VariantType, i.BinSizes,
10000, i.PercentDistance, i.ExcludedFilters, i.IncludedFilters, i.IncludedRegions))
.ToDictionary(i => i.VariantType, i => i);
var wittyerSettings = WittyerSettings.Create(outputDirectory, TinyTruth, TinyQuery,
ImmutableList <ISamplePair> .Empty, EvaluationMode.CrossTypeAndSimpleCounting,
inputSpecs);
var(_, query, truth) = MainLauncher.GenerateResults(wittyerSettings).EnumerateSuccesses().First();
var results = MainLauncher.GenerateSampleMetrics(truth, query, false, inputSpecs);
MultiAssert.Equal(5U, results.OverallStats[StatsType.Event].QueryStats.TrueCount);
MultiAssert.Equal(1461995U, results.OverallStats[StatsType.Base].QueryStats.TrueCount);
MultiAssert.Equal(1461995U, results.OverallStats[StatsType.Base].TruthStats.TrueCount);
MultiAssert.AssertAll();
}
public void SvWorksWithDefault()
{
if (MiscUtils.IsRunningAnyLinux)
{
return; // currently failing on linux :(
}
var outputDirectory = Path.GetRandomFileName().ToDirectoryInfo();
var wittyerSettings = WittyerSettings.Create(outputDirectory, GermlineTruth, GermlineQuery,
ImmutableList <ISamplePair> .Empty, EvaluationMode.Default, InputSpecs);
var json = MainLauncher.GenerateJson(wittyerSettings, MainLauncher.GenerateResults(wittyerSettings).EnumerateSuccesses(), EmptyCmd);
//var str = JsonConvert.SerializeObject(json, Formatting.Indented);
var stats = json.GetOrThrow().PerSampleStats.First();
var expectedStats = JsonConvert.DeserializeObject <GeneralStats>(File.ReadAllText(SvJsonGt.FullName))
.PerSampleStats.First();
var expectedOverallEventStats = expectedStats.OverallStats.Single(x => x.StatsType.Equals(StatsType.Event));
var actualOverallEventStats = stats.OverallStats.Single(x => x.StatsType.Equals(StatsType.Event));
MultiAssert.Equal(expectedOverallEventStats, actualOverallEventStats);
foreach (var type in WittyerType.AllTypes)
{
var typeString = type.Name;
var expectedTypedStats = expectedStats.DetailedStats.Single(x => x.VariantType.Equals(typeString));
var actualTypedStats = stats.DetailedStats.Single(x => x.VariantType.Equals(typeString));
var expectedTypedEventStats =
expectedTypedStats.OverallStats.Single(x => x.StatsType == StatsType.Event);
var actualTypedEventStats = actualTypedStats.OverallStats.Single(x => x.StatsType == StatsType.Event);
MultiAssert.Equal(expectedTypedEventStats, actualTypedEventStats);
if (!type.HasBaseLevelStats)
{
continue;
}
var expectedTypedBaseStats = expectedTypedStats.OverallStats.Single(x => x.StatsType == StatsType.Base);
var actualTypedBaseStats = actualTypedStats.OverallStats.Single(x => x.StatsType == StatsType.Base);
MultiAssert.Equal(expectedTypedBaseStats, actualTypedBaseStats);
}
MultiAssert.AssertAll();
}
public void ResetButtonResetsVMs()
{
var nondefaultConfig = GetNondefaultConfig();
var configLoader = GetConfigLoader(nondefaultConfig);
var viewModel = GetDefaultViewModel(configLoader);
var defaultConfig = GetDefaultConfig();
viewModel.ResetButtonCommand.Execute(null);
MultiAssert.Aggregate(
() => MultiAssert.Aggregate(
() => Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.Language, ((GeneralSettingsViewModel)viewModel.SettingsViews[0].Control.ViewModel).SelectedLanguage),
() => Assert.IsTrue(defaultConfig.UserSettings.GeneralSettings.HotkeySettings.SequenceEqual(((GeneralSettingsViewModel)viewModel.SettingsViews[0].Control.ViewModel).Hotkeys)),
() => Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.AutoSaveEnabled, ((GeneralSettingsViewModel)viewModel.SettingsViews[0].Control.ViewModel).AutoSaveEnabled),
() => Assert.AreEqual(defaultConfig.UserSettings.GeneralSettings.AutoSavePeriod, ((GeneralSettingsViewModel)viewModel.SettingsViews[0].Control.ViewModel).AutoSavePeriod)
),
() => Assert.IsTrue(defaultConfig.UserSettings.ToDoListSettings.ToDoMarkers.SequenceEqual(viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <TodoSettingsViewModel>().First().TodoSettings)),
() => Assert.IsTrue(defaultConfig.UserSettings.CodeInspectionSettings.CodeInspections.SequenceEqual(viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <InspectionSettingsViewModel>().First().InspectionSettings.SourceCollection.Cast <CodeInspectionSetting>()), "test"),
() => MultiAssert.Aggregate(
() => Assert.AreEqual(defaultConfig.UserSettings.UnitTestSettings.BindingMode, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <UnitTestSettingsViewModel>().First().BindingMode),
() => Assert.AreEqual(defaultConfig.UserSettings.UnitTestSettings.AssertMode, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <UnitTestSettingsViewModel>().First().AssertMode),
() => Assert.AreEqual(defaultConfig.UserSettings.UnitTestSettings.ModuleInit, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <UnitTestSettingsViewModel>().First().ModuleInit),
() => Assert.AreEqual(defaultConfig.UserSettings.UnitTestSettings.MethodInit, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <UnitTestSettingsViewModel>().First().MethodInit),
() => Assert.AreEqual(defaultConfig.UserSettings.UnitTestSettings.DefaultTestStubInNewModule, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <UnitTestSettingsViewModel>().First().DefaultTestStubInNewModule)
),
() => MultiAssert.Aggregate(
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.AlignCommentsWithCode, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().AlignCommentsWithCode),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.AlignContinuations, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().AlignContinuations),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.AlignDimColumn, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().AlignDimColumn),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.AlignDims, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().AlignDims),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.EnableUndo, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().EnableUndo),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.EndOfLineCommentColumnSpaceAlignment, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().EndOfLineCommentColumnSpaceAlignment),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.EndOfLineCommentStyle, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().EndOfLineCommentStyle),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.ForceCompilerDirectivesInColumn1, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().ForceCompilerDirectivesInColumn1),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.ForceDebugStatementsInColumn1, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().ForceDebugStatementsInColumn1),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IgnoreOperatorsInContinuations, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().IgnoreOperatorsInContinuations),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentCase, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().IndentCase),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentCompilerDirectives, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().IndentCompilerDirectives),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentEntireProcedureBody, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().IndentEntireProcedureBody),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentFirstCommentBlock, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().IndentFirstCommentBlock),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentFirstDeclarationBlock, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().IndentFirstDeclarationBlock),
() => Assert.AreEqual(defaultConfig.UserSettings.IndenterSettings.IndentSpaces, viewModel.SettingsViews.Select(v => v.Control.ViewModel).OfType <IndenterSettingsViewModel>().First().IndentSpaces)));
}
public void CnvWorksWithCrossType()
{
if (MiscUtils.IsRunningAnyLinux)
{
return; // currently failing on linux :(
}
var outputDirectory = Path.GetRandomFileName().ToDirectoryInfo();
var wittyerSettings = WittyerSettings.Create(outputDirectory, CnvTruth, CnvQuery,
ImmutableList <ISamplePair> .Empty, EvaluationMode.CrossTypeAndSimpleCounting, InputSpecs);
var results = MainLauncher.GenerateResults(wittyerSettings).EnumerateSuccesses().ToList();
var(_, query, truth) = results.First();
var testStrings = WittyerVcfWriter.GenerateVcfStrings(query, null, null).Where(line => !line.StartsWith(VcfConstants.Header.Prefix));
MultiAssert.True(testStrings.All(s => ParseVariantGetTag(s, WitDecision.FalsePositive)));
testStrings = WittyerVcfWriter.GenerateVcfStrings(null, truth, null).Where(line => !line.StartsWith(VcfConstants.Header.Prefix));
MultiAssert.True(testStrings.All(s => ParseVariantGetTag(s, WitDecision.FalseNegative)));
var stats = MainLauncher
.GenerateJson(wittyerSettings, results,
EmptyCmd).GetOrThrow().PerSampleStats.First();
// make sure to check for null
MultiAssert.True(stats.QuerySampleName != null);
MultiAssert.True(stats.TruthSampleName != null);
var expectedStats = JsonConvert.DeserializeObject <GeneralStats>(File.ReadAllText(CnvJsonCts.FullName))
.PerSampleStats.First();
var expectedOverallEventStats = expectedStats.OverallStats.Single(x => x.StatsType.Equals(StatsType.Event));
var actualOverallEventStats = stats.OverallStats.Single(x => x.StatsType.Equals(StatsType.Event));
MultiAssert.Equal(expectedOverallEventStats.QueryFpCount, actualOverallEventStats.QueryFpCount);
MultiAssert.Equal(expectedOverallEventStats.QueryTpCount, actualOverallEventStats.QueryTpCount);
MultiAssert.Equal(expectedOverallEventStats.QueryTotalCount, actualOverallEventStats.QueryTotalCount);
MultiAssert.Equal(expectedOverallEventStats.TruthTpCount, actualOverallEventStats.TruthTpCount);
MultiAssert.Equal(expectedOverallEventStats.TruthFnCount, actualOverallEventStats.TruthFnCount);
MultiAssert.Equal(expectedOverallEventStats.TruthTotalCount, actualOverallEventStats.TruthTotalCount);
MultiAssert.AssertAll();
}
public void Bed_Counts_Bases_Of_FP_Events()
{
var outputDirectory = Path.GetRandomFileName().ToDirectoryInfo();
var inputSpecs = InputSpec.GenerateDefaultInputSpecs(false).Select(i => InputSpec.Create(i.VariantType, i.BinSizes,
10000, i.PercentDistance, i.ExcludedFilters, i.IncludedFilters, IncludeBedFile.CreateFromBedFile(Bed)))
.ToDictionary(i => i.VariantType, i => i);
var wittyerSettings = WittyerSettings.Create(outputDirectory, Truth, Query,
ImmutableList <ISamplePair> .Empty, EvaluationMode.CrossTypeAndSimpleCounting,
inputSpecs);
var(_, query, truth) = MainLauncher.GenerateResults(wittyerSettings).EnumerateSuccesses().First();
var results = MainLauncher.GenerateSampleMetrics(truth, query, false, inputSpecs);
// should be end of bed - start of query + 1 = 149835000 - 145395620 + 1 = 4439381
MultiAssert.Equal(4439381U, results.OverallStats[StatsType.Base].QueryStats.TrueCount);
MultiAssert.Equal(4439381U, results.OverallStats[StatsType.Base].TruthStats.TrueCount);
MultiAssert.Equal(0U, results.OverallStats[StatsType.Event].QueryStats.TrueCount);
MultiAssert.Equal(0U, results.OverallStats[StatsType.Event].TruthStats.TrueCount);
MultiAssert.AssertAll();
}
public static void WittyerIntraBndWorkCorrectly()
{
var vcfSettings =
VcfVariantParserSettings.Create(ImmutableList.Create("proband", "father"), GenomeAssembly.Grch37);
var bnd1 = VcfVariant.TryParse(GenotypedIntraBnd, vcfSettings).GetOrThrowDebug();
var bnd2 = VcfVariant.TryParse(GenotypedIntraBndPair, vcfSettings).GetOrThrowDebug();
var wittyerBnd = WittyerBndInternal
.Create(bnd2, bnd2.Samples["father"], WittyerType.IntraChromosomeBreakend, Bins, BasepairDistance,
PercentDistance, bnd1);
var distance = Math.Round(Math.Abs(bnd1.Position - bnd2.Position) * PercentDistance);
var expectedEndInterval = ContigAndInterval.Create(wittyerBnd.Contig, bnd1.Position - (uint)distance - 1,
bnd1.Position + (uint)distance);
MultiAssert.Equal(expectedEndInterval, wittyerBnd.EndInterval);
MultiAssert.Equal(10000U, wittyerBnd.Win.End);
MultiAssert.AssertAll();
Assert.IsType <WittyerGenotypedSample>(wittyerBnd.Sample);
}
public void CrossType_ComplexBed_Works()
{
var outputDirectory = Path.GetRandomFileName().ToDirectoryInfo();
var inputSpecs = InputSpec.CreateSpecsFromString(
File.ReadAllText(Config.FullName), IncludeBedFile.CreateFromBedFile(Bed))
?.ToDictionary(i => i.VariantType, i => i)
?? new Dictionary <WittyerType, InputSpec>();
var wittyerSettings = WittyerSettings.Create(outputDirectory, Truth, Query,
ImmutableList <ISamplePair> .Empty, EvaluationMode.CrossTypeAndSimpleCounting,
inputSpecs);
var(_, query, truth) = MainLauncher.GenerateResults(wittyerSettings)
.EnumerateSuccesses().First();
var results = MainLauncher
.GenerateSampleMetrics(truth, query, false, inputSpecs);
var baseStats = results.DetailedStats[WittyerType.Deletion].OverallStats[StatsType.Base];
MultiAssert.Equal(206678U, baseStats.QueryStats.TrueCount);
MultiAssert.Equal(206678U, baseStats.TruthStats.TrueCount);
MultiAssert.AssertAll();
}
public void ProviderCommits_NotificationOnSuccess()
{
//arrange
var vm = new ChangesViewViewModel
{
Provider = _provider.Object,
CommitAction = CommitAction.Commit,
IncludedChanges =
new ObservableCollection <IFileStatusEntry>
{
new FileStatusEntry(@"C:\path\to\module.bas", FileStatus.Modified)
}
};
var errorThrown = bool.FalseString; // need a reference type
vm.ErrorThrown += (sender, e) =>
{
lock (errorThrown)
{
MultiAssert.Aggregate(
() => Assert.AreEqual(e.Message, Rubberduck.UI.RubberduckUI.SourceControl_CommitStatus),
() =>
Assert.AreEqual(e.InnerMessage,
Rubberduck.UI.RubberduckUI.SourceControl_CommitStatus_CommitSuccess),
() => Assert.AreEqual(e.NotificationType, NotificationType.Info));
errorThrown = bool.TrueString;
}
};
//act
vm.CommitCommand.Execute(null);
//assert
lock (errorThrown)
{
Assert.IsTrue(bool.Parse(errorThrown));
}
}
public async Task GetUserMustReturnRequestedUserWhenThereIsNoAddressRow()
{
const int userId = 42;
const string userName = "******";
// Given aka. Arrange aka. setup initial context/state:
_contextBuilder
// Slightly contrived, but I wanted to show how to build a value:
.WithData(new UserRowBuilder().WithUserId(userId).WithName(userName).Build())
.Build();
// When aka. Act aka. an event occurs:
HttpResponseMessage actual = await _target.GetAsync($"users?userId={userId}&includeInvoices=true");
// Then aka. Assert aka. ensure some outcomes:
Assert.Equal(HttpStatusCode.OK, actual.StatusCode);
User actualUser = await actual.Deserialize <User>();
MultiAssert.Aggregate(
() => Assert.Equal(userId, actualUser.UserId),
() => Assert.Equal(userName, actualUser.Name));
}
public async Task GetUserMustReturnRequestedUser()
{
// Given aka. Arrange aka. setup initial context/state:
_contextBuilder
.WithData(TestData.UserRows.JohnDoe42)
.WithData(TestData.AddressRows.JaneDoeStreetForUser42)
.WithData(TestData.InvoiceDtos.NoLinesForUser42)
.Build();
// When aka. Act aka. an event occurs:
HttpResponseMessage actual = await _target.GetAsync("users?userId=42&includeInvoices=true");
// Then aka. Assert aka. ensure some outcomes:
Assert.Equal(HttpStatusCode.OK, actual.StatusCode);
User actualUser = await actual.Deserialize <User>();
MultiAssert.Aggregate(
() => Assert.Equal(42, actualUser.UserId),
() => Assert.Equal("John Doe", actualUser.Name),
() => Assert.EndsWith("Jane Doe Street", actualUser.Address.StreetAddress),
() => Assert.Empty(actualUser.Invoices.First().InvoiceLines));
}
