using Titano.Core.Advice; using Titano.Core.Analysis; using Titano.Core.Analysis.Deep; using Titano.Core.Archiving; using Titano.Core.Codecs.Dng; using Titano.Core.Codecs.Jpeg; using Titano.Core.Diagnostics.Synthetic; using Titano.Core.Imaging; using Titano.Core.Import; using Titano.Core.Localization; using Titano.Core.Metadata; using Titano.Core.Model; using Titano.Core.Project; using Titano.Data.Archiving.Jobs; using Titano.Data.Processing; using Titano.Data.Processing.Jobs; using Titano.Data.Repositories; using Titano.Testing; namespace Titano.Data.Tests.Processing; [Category("processing")] public sealed class AnalysisJobTests(TestContext context) { private static SyntheticSequence Flickering(int frames = 40) => SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = frames, FlickerEv = 0.1, StartEv = 0.5, EndEv = -1.5, Latitude = 45.4, Longitude = 12.3, }); [Test] public async Task LightAnalysisFillsAutoValuesAndKeepsManualOnes() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Flickering()); var manual = new ProjectSettings(); // The user's frame rate, and the highlight knee turned off (hard clip). manual = manual with { Timing = manual.Timing with { FrameRate = manual.Timing.FrameRate.WithManual("25") }, Exposure = manual.Exposure with { HighlightKnee = null }, }; await fx.Db.Sequences.EditAsync(sequence.Id, new SequenceEdit { SettingsJson = manual.ToJson() }, null, fx.Ct); await fx.StartEngineAsync(); var job = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id], sequence.DisplayTitle)); var done = await fx.WaitForAsync(job.Id, JobState.Done); var folder = fx.Folder(sequence); var project = ProjectSettings.FromJson(await File.ReadAllTextAsync(folder.ProjectPath, fx.Ct)); Assert.Equal((false, "25"), (project.Timing.FrameRate.IsAuto, project.Timing.FrameRate.Resolve("30"))); Assert.Null(project.Exposure.HighlightKnee); Assert.True(project.Timing.Mode.HasAdvice, "timing mode advised"); Assert.True(project.Timing.FrameRate.HasAdvice, "the advice is kept next to the manual frame rate"); var row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; Assert.Equal(project.ToJson(), ProjectSettings.FromJson(row.SettingsJson!).ToJson()); Assert.True(row.Status.HasFlag(SequenceStatus.AnalyzedLight), "index status"); Assert.False(row.Status.HasFlag(SequenceStatus.AnalyzedDeep), "no deep status without a report"); Assert.True(ManifestStore.ReadSequence(folder.ManifestPath).Status.HasFlag(SequenceStatus.AnalyzedLight), "sidecar status"); Assert.Contains(Loc.L("Advisor.Log.AutoUpdated", sequence.DisplayTitle), done.LogTail); // Idempotent: a second pass changes nothing. var version = row.SettingsVersion; var again = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); await fx.WaitForAsync(again.Id, JobState.Done); Assert.Equal(version, (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.SettingsVersion); } [Test] public async Task LightAnalysisRecordsFormatTiersAndTheAdvisorCapsTheOutputAtThePreviews() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Flickering(12)); // This host reads the first ten files only through 48×32 embedded previews and cannot decode the last one. for (var i = 0; i < 10; i++) fx.Decoder.Tiers[ProcessingFixture.FileName(i)] = new FileTier(ImageFileFormat.Jpeg, DecodeTier.EmbeddedPreview, "test-preview", "test", 48, 32); fx.Decoder.Tiers[ProcessingFixture.FileName(11)] = new FileTier(ImageFileFormat.Jpeg, DecodeTier.Unavailable, null, "test", 0, 0); await fx.StartEngineAsync(); var job = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); await fx.WaitForAsync(job.Id, JobState.Done); var folder = fx.Folder(sequence); var sidecar = ManifestStore.ReadSequence(folder.ManifestPath).Frames; Assert.Equal((DecodeTier.EmbeddedPreview, FrameFlags.PreviewOnly, (int?)48, (int?)32), (sidecar[0].Tier, sidecar[0].Flags, sidecar[0].PreviewW, sidecar[0].PreviewH)); Assert.Equal((DecodeTier.Native, FrameFlags.None), (sidecar[10].Tier, sidecar[10].Flags)); Assert.Equal((DecodeTier.Unavailable, FrameFlags.Undecodable), (sidecar[11].Tier, sidecar[11].Flags)); var rows = await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct); Assert.Equal((FrameFlags.PreviewOnly, 48, 32), (rows[3].Flags, rows[3].PreviewWidth, rows[3].PreviewHeight)); Assert.Equal(FrameFlags.Undecodable, rows[11].Flags); var row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; Assert.Equal(10, row.PreviewOnlyCount); Assert.GreaterOrEqual(row.WarningCount, 1); Assert.True(row.Status.HasFlag(SequenceStatus.HasWarnings), "the undecodable frame is a sequence warning"); // The advisor reads the preview size from the index and caps the output there (BRIEF §8.2 tier 2). var tiers = SequenceContext.FromFrames(rows); Assert.Equal((10, 48, 32), (tiers.PreviewOnlyCount, tiers.PreviewWidth, tiers.PreviewHeight)); var light = LightAnalyzer.Analyze(rows); var advice = Advisor.Recommend(light, null, tiers); Assert.Equal(AdvisorKeys.ResolutionPreview, advice.Find(AdvisorParameters.Resolution)!.ReasonKey); Assert.Contains(advice.Findings, f => f.Key == FindingKeys.PreviewOnly && Equals(f.Arguments[0], 10)); Assert.Contains(advice.Findings, f => f.Key == DeepFindingKeys.UnreadableFrames && f.Frames.SequenceEqual([11])); // Probed once: a second pass opens no file for its tier and leaves the sidecar alone. fx.Decoder.Tiers.Clear(); var written = File.GetLastWriteTimeUtc(folder.ManifestPath); var again = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); await fx.WaitForAsync(again.Id, JobState.Done); Assert.Equal(FrameFlags.PreviewOnly, ManifestStore.ReadSequence(folder.ManifestPath).Frames[0].Flags); Assert.Equal(written, File.GetLastWriteTimeUtc(folder.ManifestPath)); } [Test] public async Task DeepAnalysisFlagsFramesItCannotDecodeAndListsThemOnce() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Flickering(12)); // Damaged after indexing: the header probe still says JPEG, only decoding finds out. await File.WriteAllBytesAsync(Path.Combine(fx.Folder(sequence).Folder, ProcessingFixture.FileName(4)), new byte[3000], fx.Ct); await fx.StartEngineAsync(); var job = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); var done = await fx.WaitForAsync(job.Id, JobState.Done); var sidecar = ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames; Assert.Equal((DecodeTier.Unavailable, FrameFlags.Undecodable), (sidecar[4].Tier, sidecar[4].Flags)); Assert.Equal(DecodeTier.Native, sidecar[5].Tier); Assert.Equal(FrameFlags.Undecodable, (await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct))[4].Flags); var report = SequenceAnalyser.ReadReport(fx.Folder(sequence), sequence.FrameCount)!; var rows = await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct); var findings = Advisor.Recommend(LightAnalyzer.Analyze(rows), report, SequenceContext.FromFrames(rows)).Findings; Assert.Count(1, findings.Where(f => f.Key == DeepFindingKeys.UnreadableFrames)); Assert.True((await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.WarningCount >= 1, "listed in the sequence warnings"); Assert.Equal(JobState.Done, done.State); } [Test] public async Task AnImportedGoProRawDecodesThroughTheJpegItsImportKeptInAnotherSequence() { await using var fx = await ProcessingFixture.CreateAsync(context); // A GoPro card: each GPR (VC-5, without a usable embedded image here) has the camera's full-size JPEG beside it. // An upload may send the GPRs first: they arrive as two cards here. var raws = Path.Combine(context.CreateTempDirectory("card"), "DCIM", "100GOPRO"); var jpegs = Path.Combine(context.CreateTempDirectory("card"), "DCIM", "100GOPRO"); Directory.CreateDirectory(raws); Directory.CreateDirectory(jpegs); var start = new DateTime(2026, 9, 28, 18, 0, 0); for (var i = 0; i < 4; i++) { var metadata = new FrameMetadata { Make = "GoPro", Model = "HERO12 Black", BodySerial = "C3501", CapturedAt = start.AddSeconds(5 * i) }; using var sensor = new ImageBuffer(64, 48); File.WriteAllBytes(Path.Combine(raws, $"GOPR{i + 1:0000}.GPR"), LinearDngWriter.Write(sensor, new LinearDngOptions { Exif = ExifWriter.BuildTiff(metadata), TileSize = 64 })); using var picture = new ImageBuffer(160, 120); picture.Plane(1).Fill(0.25f * (i + 1)); File.WriteAllBytes(Path.Combine(jpegs, $"GOPR{i + 1:0000}.JPG"), JpegEncoder.Encode(picture, new JpegEncodeOptions { App1Segments = [ExifWriter.BuildJpegApp1(metadata)[4..]] })); } var service = fx.Archive.Service; async Task ImportAsync(string card) { var plan = await service.PlanImportAsync(fx.Archive.Archive.Id, Path.GetDirectoryName(Path.GetDirectoryName(card))!, new ImportOptions(), cancellationToken: fx.Ct); await service.Imports.ExecuteAsync(new ImportJobParameters(fx.Archive.Archive.Id, plan, null, true, null), Guid.NewGuid(), 0, _ => ValueTask.CompletedTask, null, fx.Ct); return plan; } var gprSession = (await ImportAsync(raws)).Sessions.Single(); Assert.Equal(ImageFileFormat.Gpr, gprSession.Format); var id = await fx.Db.Sequences.FindBySessionKeyAsync(fx.Archive.Archive.Id, gprSession.SessionKey, fx.Ct); var sequence = (await fx.Db.Sequences.GetAsync(id!.Value, fx.Ct))!; await fx.StartEngineAsync(); // Alone, a GPR without an embedded preview gives no pixels here, which proves nothing about the file. var first = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); await fx.WaitForAsync(first.Id, JobState.Done); var alone = ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames; Assert.True(alone.All(f => f is { Tier: DecodeTier.Unavailable, Flags: FrameFlags.None, PreviewW: null }), "unavailable, not flagged"); // The JPEGs arrive as a sequence of their own (the import splits per file format, DECISIONS 2026-10-02); the next // probe finds each GPR's JPEG there, so the output cap is the JPEG's size. Assert.Equal(ImageFileFormat.Jpeg, (await ImportAsync(jpegs)).Sessions.Single().Format); var jpegFrame = (await fx.Db.Frames.ListByCaptureRangeAsync(fx.Archive.Archive.Id, ImageFileFormat.Jpeg, start, start.AddMinutes(1), fx.Ct))[0]; Assert.NotEqual(Path.GetDirectoryName(fx.Folder(sequence).File(alone[0].File)), Path.GetDirectoryName(fx.Archive.Paths.FromRelative(jpegFrame.RelativePath)), "not beside the GPR"); var light = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); await fx.WaitForAsync(light.Id, JobState.Done); var sidecar = ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames; Assert.True(sidecar.All(f => f is { Tier: DecodeTier.EmbeddedPreview, Flags: FrameFlags.PreviewOnly, PreviewW: 160, PreviewH: 120 }), "preview-only at the JPEG's size"); // The deep pass decodes the GPRs through those JPEGs (decoder "managed-sidecar"), never failing a frame. var deep = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); await fx.WaitForAsync(deep.Id, JobState.Done); var gprs = fx.Decoder.Decoded.Where(d => d.File.EndsWith(".GPR", StringComparison.OrdinalIgnoreCase)).ToList(); Assert.NotEmpty(gprs); Assert.True(gprs.All(d => d.Decoder == "managed-sidecar"), string.Join(", ", gprs.Select(d => d.Decoder).Distinct())); Assert.Empty(SequenceAnalyser.ReadReport(fx.Folder(sequence), sequence.FrameCount)!.Issues.Undecodable); } [Test] public async Task DeepAnalysisNeverFlagsFramesThatVanishedOrCouldNotBeRead() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Flickering(12)); // Deleted after indexing (a verify flags it missing), and held by another program during the pass. File.Delete(Path.Combine(fx.Folder(sequence).Folder, ProcessingFixture.FileName(3))); fx.Decoder.Unreadable[ProcessingFixture.FileName(6)] = 0; await fx.StartEngineAsync(); var job = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); await fx.WaitForAsync(job.Id, JobState.Done); // The pass could not read them, so it lists them as unreadable, but nothing proves the files undecodable. var report = SequenceAnalyser.ReadReport(fx.Folder(sequence), sequence.FrameCount)!; Assert.SequenceEqual([3, 6], report.Issues.Undecodable); var sidecar = ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames; foreach (var index in new[] { 3, 6 }) { Assert.Equal(FrameFlags.None, sidecar[index].Flags & FrameFlags.Undecodable); Assert.NotEqual(DecodeTier.Unavailable, sidecar[index].Tier); } var rows = await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct); Assert.True(rows.All(f => (f.Flags & FrameFlags.Undecodable) == 0), "no frame flagged in the index"); var unreadable = Advisor.Recommend(LightAnalyzer.Analyze(rows), report, SequenceContext.FromFrames(rows)).Findings .Single(f => f.Key == DeepFindingKeys.UnreadableFrames); Assert.SequenceEqual([3, 6], unreadable.Frames); // Back in place and readable, the next pass reads both frames. fx.Decoder.Unreadable.Clear(); await File.WriteAllBytesAsync(Path.Combine(fx.Folder(sequence).Folder, ProcessingFixture.FileName(3)), await File.ReadAllBytesAsync(Path.Combine(fx.Folder(sequence).Folder, ProcessingFixture.FileName(2)), fx.Ct), fx.Ct); var again = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); await fx.WaitForAsync(again.Id, JobState.Done); Assert.Empty(SequenceAnalyser.ReadReport(fx.Folder(sequence), sequence.FrameCount)!.Issues.Undecodable); } [Test] public async Task AResumedDeepAnalysisDecodesAgainWhatTheEarlierRunCouldNotRead() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Flickering()); // The first run cannot read frame 12 (held by another program) and is cancelled later, at frame 26. fx.Decoder.Unreadable[ProcessingFixture.FileName(11)] = 0; fx.Decoder.HoldFrame(25); await fx.StartEngineAsync(); var job = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct); await fx.Engine.CancelAsync(job.Id, fx.Ct); await fx.WaitForAsync(job.Id, JobState.Cancelled); // Readable again; the resumed run takes frame 12 from its checkpoint (it is not in the region sample). fx.Decoder.Unreadable.Clear(); fx.Decoder.Hold = null; while (fx.Decoder.Requests.TryDequeue(out _)) { } await fx.Engine.ResumeAsync(job.Id, fx.Ct); await fx.WaitForAsync(job.Id, JobState.Done); Assert.Contains(11, SequenceAnalyser.ReadReport(fx.Folder(sequence), sequence.FrameCount)!.Issues.Undecodable); // That verdict was a read error: decoding the frame again shows it is fine, so nothing flags it. Assert.Count(1, fx.Decoder.Requests.Where(r => Path.GetFileName(r.Path) == ProcessingFixture.FileName(11))); var frame = ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Frames[11]; Assert.Equal((DecodeTier.Native, FrameFlags.None), (frame.Tier, frame.Flags & FrameFlags.Undecodable)); Assert.Equal(FrameFlags.None, (await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct))[11].Flags); } [Test] public async Task DeepAnalysisResumesAfterCancellationWithTheSameReport() { await using var reference = await ProcessingFixture.CreateAsync(context); var expectedSequence = await reference.AddAsync(Flickering()); await reference.StartEngineAsync(); var full = await reference.EnqueueAsync(ProcessingJobs.DeepAnalysis([expectedSequence.Id])); await reference.WaitForAsync(full.Id, JobState.Done); var expected = await File.ReadAllTextAsync(reference.Folder(expectedSequence).AnalysisPath, reference.Ct); await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Flickering()); var folder = fx.Folder(sequence); var partial = Path.Combine(folder.MetaDirectory, DeepAnalysisCheckpointFile.FileName); // Frame 25 is not in the region sample, so the hold stops the pass inside the batch of frames 24–25. fx.Decoder.HoldFrame(25); await fx.StartEngineAsync(); var job = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct); await fx.Engine.CancelAsync(job.Id, fx.Ct); await fx.WaitForAsync(job.Id, JobState.Cancelled); var saved = File.ReadAllLines(partial).Length - 1; Assert.Equal(24, saved); Assert.FileMissing(folder.AnalysisPath); fx.Decoder.Hold = null; while (fx.Decoder.Requests.TryDequeue(out _)) { } await fx.Engine.ResumeAsync(job.Id, fx.Ct); var done = await fx.WaitForAsync(job.Id, JobState.Done); Assert.Equal(expected, await File.ReadAllTextAsync(folder.AnalysisPath, fx.Ct)); Assert.FileMissing(partial); // After the region sample, only the last checkpointed frame is decoded again (to restore the comparison state). var analysed = fx.Decoder.Requests.Skip(ProcessingFixture.DeepOptions.RegionSampleFrames) .Select(r => int.Parse(Path.GetFileNameWithoutExtension(r.Path)[4..]) - 1).ToList(); Assert.Equal(saved - 1, analysed.Min()); Assert.Equal(sequence.FrameCount, (int)done.ProgressDone); var row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; Assert.True(row.Status.HasFlag(SequenceStatus.AnalyzedDeep | SequenceStatus.AnalyzedLight), "index status"); var summary = AnalysisSummary.FromJson(row.AnalysisJson!); Assert.Equal(sequence.FrameCount, summary.FrameCount); Assert.NotNull((await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct))[5].MeanLogLuminance); var project = ProjectSettings.FromJson(await File.ReadAllTextAsync(folder.ProjectPath, fx.Ct)); Assert.True(project.Exposure.Deflicker.HasAdvice, "deflicker advised from the pixels"); Assert.Contains(Loc.L("Advisor.Log.Presets", string.Empty), done.LogTail); } [Test] public async Task ASequenceThatFailsDoesNotStopTheOthersAndARetryRedoesOnlyIt() { await using var fx = await ProcessingFixture.CreateAsync(context); var a = await fx.AddAsync(Flickering(10), "A"); var b = await fx.AddAsync(Flickering(10), "B"); var c = await fx.AddAsync(Flickering(10), "C"); // B's sidecar is gone for a while: its status cannot be recorded. var sidecar = fx.Folder(b).ManifestPath; var saved = await File.ReadAllBytesAsync(sidecar, fx.Ct); File.Delete(sidecar); await fx.StartEngineAsync(); var job = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([a.Id, b.Id, c.Id])); var failed = await fx.WaitForAsync(job.Id, JobState.Failed); Assert.True(failed.Error!.StartsWith(Loc.L("Advisor.Log.Failed", b.DisplayTitle, string.Empty), StringComparison.Ordinal), failed.Error); Assert.Equal("3;1", failed.Checkpoint); Assert.SequenceEqual([true, false, true], await AnalysedAsync(fx, a, b, c)); await File.WriteAllBytesAsync(sidecar, saved, fx.Ct); await fx.Engine.ResumeAsync(job.Id, fx.Ct); var done = await fx.WaitForAsync(job.Id, JobState.Done); Assert.SequenceEqual([true, true, true], await AnalysedAsync(fx, a, b, c)); Assert.Equal((3L, 3L), (done.ProgressDone, done.ProgressTotal)); // The retry analysed B alone. var lightOfA = Loc.L("Advisor.Log.LightDone", a.DisplayTitle, 10, 0).Split(',')[0]; Assert.Equal(1, done.LogTail!.Split('\n').Count(line => line.Contains(lightOfA, StringComparison.Ordinal))); } [Test] public void AnalysisCheckpointsKeepTheFailedTargets() { Assert.Equal("3", AnalyseJobHandler.Format(3, [])); Assert.Equal("4;0,2", AnalyseJobHandler.Format(4, [2, 0])); var (next, retry) = AnalyseJobHandler.Parse("4;0,2", 5); Assert.Equal(4, next); Assert.SequenceEqual([0, 2], retry); Assert.Equal(2, AnalyseJobHandler.Parse("2", 5).Next); // Anything else starts over: no checkpoint, beyond the targets, a failed target not yet reached, garbage. foreach (var text in new[] { null, "6", "2;3", "2;x", "a" }) Assert.Equal(0, AnalyseJobHandler.Parse(text, 5).Next); } private static async Task> AnalysedAsync(ProcessingFixture fx, params Sequence[] sequences) { var analysed = new List(); foreach (var s in sequences) analysed.Add((await fx.Db.Sequences.GetAsync(s.Id, fx.Ct))!.Status.HasFlag(SequenceStatus.AnalyzedLight)); return analysed; } [Test] public async Task LightAnalysisAfterNewFramesDropsTheStaleDeepStatus() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(Flickering(12)); await fx.StartEngineAsync(); var deep = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); await fx.WaitForAsync(deep.Id, JobState.Done); Assert.True((await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.Status.HasFlag(SequenceStatus.AnalyzedDeep), "deep status"); // A thirteenth frame arrives: the report describes 12 frames, so it no longer counts. await fx.AddAsync(Flickering(13), first: 12); var light = await fx.EnqueueAsync(ProcessingJobs.LightAnalysis([sequence.Id])); await fx.WaitForAsync(light.Id, JobState.Done); var row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; Assert.Equal(13, row.FrameCount); Assert.Equal((true, false), (row.Status.HasFlag(SequenceStatus.AnalyzedLight), row.Status.HasFlag(SequenceStatus.AnalyzedDeep))); } }