JMR-devandClaude Opus 5
c2c0bfa848
Each of these is a site where JaCoCo reported mi > 0 -- a concrete instruction no test
runs -- rather than a partial branch on a compound condition, which is how the group was
filtered in the first place. Six closed, one moved to the exclusions.
AndroidDeviceCodecs:35 the UNPARSEABLE sentinel, refused where an unknown name is not
ContainerCapabilities:94 accepts(container, VideoCodec.NONE, mode) -- the audio twin has
had a test since #136; the asymmetry is the argument
ContainerCapabilities:323 repairVideo's keep-the-requested-codec arm
ContainerCapabilities:348 firstContainerHolding's fallback container
OutputPublisher:230 the resolver call that throws -- the third case the KDoc names
and the one the shape list was missing
JobSnapshots:31 a job that recorded no output path at all
Every one was mutated and confirmed red, then restored. Two are worth stating because
they did not go red first time or would not have:
**The firstContainerHolding test was vacuous on its first draft.** It asserted the
refusal still offered *something*, and deleting the fallback left it green: the source
container is a candidate in its own right, so the list stays non-empty and only its
contents change. Rewritten around AVI, which has no mapping for H.265, and asserting the
codec survives -- without the fallback the app silently offers H.264 instead, which is
the actual loss. This is the failure mode CLAUDE.md records from the mutation review, met
head on rather than in the abstract.
**OutputPublisher:230 needed one line.** `a destination whose size cannot be determined is
never deleted` already walked three RowShapes; QUERY_THROWS was the fourth case its own
KDoc names -- "a resolver call that throws" -- and the only one that reaches `?: false`
through runCatching rather than through a cursor answer.
ContainerCapabilities:282's `.filter { it != exclude }` is **not** closed here and is not
a gap: nothing can make it drop anything. On the shared container `repair` always changes
at least one codec, because a codec it left alone is one validate would not have refused;
every other candidate differs by container; and the single call site passing a non-default
exclude (validateVideo:186) excludes a spec carrying VideoCodec.COPY while every repaired
candidate carries NONE. F4-shaped -- recorded rather than covered, and 550 tests agree.
550 -> 555 JVM tests, 0 failures. Five new tests rather than six: OutputPublisher:230
is one line inside a test that already existed. No production code changed.
Line 2087/2348 -> 2090/2348; branch 1011/1340 -> 1022/1340.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
571 lines
27 KiB
Kotlin
571 lines
27 KiB
Kotlin
package org.libremediaconverter.model
|
||
|
||
import org.junit.Assert.assertEquals
|
||
import org.junit.Assert.assertFalse
|
||
import org.junit.Assert.assertTrue
|
||
import org.junit.Test
|
||
|
||
/**
|
||
* The matrix that replaced the closed format enum.
|
||
*
|
||
* `OutputFormat` used to be twelve hand-picked triples, and its KDoc defended that on the grounds
|
||
* that a closed set was what made routing decidable. Opening it up moves that burden here, so this
|
||
* is where decidability now has to be proven.
|
||
*
|
||
* That includes what a refusal offers instead. `Validation.Invalid` promises every suggestion is
|
||
* itself valid and names this class as the proof, so a branch that assembles its own suggestion
|
||
* list rather than going through `suggestions()` is only checked here if some row happens to reach
|
||
* it — which is how a dead-end chip survived two widenings of that table.
|
||
*/
|
||
class ContainerCapabilitiesTest {
|
||
|
||
private val h264Source = InputProbe(
|
||
videoCodec = "h264",
|
||
audioCodec = "aac",
|
||
container = Container.MP4,
|
||
)
|
||
|
||
/**
|
||
* An MP3, and the reason several rules below need a second probe.
|
||
*
|
||
* `hasVideo = false` is the load-bearing field. Every rule that reads only the spec answers the
|
||
* same for this input as for a video file, which is exactly how a spec naming a video codec was
|
||
* called valid for a file with no video track to put in it.
|
||
*/
|
||
private val mp3Source = InputProbe(
|
||
videoCodec = null,
|
||
audioCodec = "mp3",
|
||
hasVideo = false,
|
||
kind = InputKind.AUDIO_ONLY,
|
||
container = Container.MP3,
|
||
)
|
||
|
||
/**
|
||
* An audio-only input carrying a codec MP4 has no place for at all.
|
||
*
|
||
* Vorbis lives in Ogg and Matroska; MP4 carries AAC, MP3, Opus and FLAC. That gap is what turns
|
||
* a suggestion which merely drops the video track into a second refusal.
|
||
*/
|
||
private val vorbisSource = InputProbe(
|
||
videoCodec = null,
|
||
audioCodec = "vorbis",
|
||
hasVideo = false,
|
||
kind = InputKind.AUDIO_ONLY,
|
||
container = Container.OGG,
|
||
)
|
||
|
||
/** The same shape, for the other codec MP4 refuses. One case is a coincidence; two is the rule. */
|
||
private val pcmSource = InputProbe(
|
||
videoCodec = null,
|
||
audioCodec = "pcm_s16le",
|
||
hasVideo = false,
|
||
kind = InputKind.AUDIO_ONLY,
|
||
container = Container.WAV,
|
||
)
|
||
|
||
// --- copy and encode are different questions ----------------------------
|
||
|
||
/**
|
||
* The case that makes the mode axis necessary.
|
||
*
|
||
* A single boolean would have to answer one way or the other, and either answer is wrong half
|
||
* the time: refusing AV1 in MP4 blocks a legitimate remux, allowing it promises an encode
|
||
* neither engine can deliver.
|
||
*/
|
||
@Test
|
||
fun `MP4 carries AV1 on copy but cannot encode it`() {
|
||
assertTrue(ContainerCapabilities.accepts(Container.MP4, VideoCodec.AV1, CodecMode.COPY))
|
||
assertFalse(ContainerCapabilities.accepts(Container.MP4, VideoCodec.AV1, CodecMode.ENCODE))
|
||
}
|
||
|
||
@Test
|
||
fun `Matroska carries Vorbis on copy but nothing here encodes it`() {
|
||
assertTrue(ContainerCapabilities.accepts(Container.MKV, AudioCodec.VORBIS, CodecMode.COPY))
|
||
assertFalse(
|
||
ContainerCapabilities.accepts(Container.MKV, AudioCodec.VORBIS, CodecMode.ENCODE),
|
||
)
|
||
}
|
||
|
||
@Test
|
||
fun `a codec the container cannot hold is refused in both modes`() {
|
||
listOf(CodecMode.COPY, CodecMode.ENCODE).forEach { mode ->
|
||
assertFalse(
|
||
"WebM should never accept H.264 ($mode)",
|
||
ContainerCapabilities.accepts(Container.WEBM, VideoCodec.H264, mode),
|
||
)
|
||
assertFalse(
|
||
"WAV should never accept AAC ($mode)",
|
||
ContainerCapabilities.accepts(Container.WAV, AudioCodec.AAC, mode),
|
||
)
|
||
}
|
||
}
|
||
|
||
@Test
|
||
fun `H265 in AVI is refused — AVI predates it`() {
|
||
assertFalse(ContainerCapabilities.accepts(Container.AVI, VideoCodec.H265, CodecMode.COPY))
|
||
assertTrue(ContainerCapabilities.accepts(Container.AVI, VideoCodec.H264, CodecMode.COPY))
|
||
}
|
||
|
||
@Test
|
||
fun `resolving COPY before asking the matrix is required`() {
|
||
// The matrix cannot answer for COPY; the caller has to resolve it against the probe first.
|
||
// Failing loudly is what stops a caller from silently getting "false" and refusing a
|
||
// perfectly good remux.
|
||
runCatching { ContainerCapabilities.accepts(Container.MP4, VideoCodec.COPY, CodecMode.COPY) }
|
||
.onSuccess { throw AssertionError("expected COPY to be rejected by the matrix") }
|
||
}
|
||
|
||
// --- validation ---------------------------------------------------------
|
||
|
||
@Test
|
||
fun `every preset is a valid spec`() {
|
||
OutputFormat.entries.forEach { preset ->
|
||
val result = ContainerCapabilities.validate(preset.spec, h264Source)
|
||
assertTrue("${preset.name} is not valid: $result", result.isValid)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* A suggestion that is itself invalid is worse than no suggestion.
|
||
*
|
||
* Only a branch that assembles its own suggestion list can break that promise: [suggestions]
|
||
* ends by filtering on `validate(...).isValid`, so everything routed through it is valid by
|
||
* construction. Those branches are what this table has to cover — the image output, and copy
|
||
* the video from a file that has none, which built its list by hand and came back refused for
|
||
* a Vorbis or PCM source into MP4 and an MP3 into WebM. The Advanced picker showed a one-tap
|
||
* fix that led straight to a second error, through two widenings of this table that never
|
||
* reached the branch.
|
||
*/
|
||
@Test
|
||
fun `every suggestion is itself valid`() {
|
||
val cases = listOf(
|
||
OutputSpec(Container.WEBM, VideoCodec.H264, AudioCodec.AAC) to h264Source,
|
||
// The audio-only input. Every rejection it can reach used to hand back `None + None`
|
||
// — a spec validation refuses in the next breath — because these branches built their
|
||
// suggestion by hand instead of going through the repair-and-filter path.
|
||
OutputSpec(Container.MP4, VideoCodec.H265, AudioCodec.NONE) to mp3Source,
|
||
OutputSpec(Container.MP4, VideoCodec.COPY, AudioCodec.NONE) to mp3Source,
|
||
OutputSpec(Container.MP4, VideoCodec.NONE, AudioCodec.NONE) to mp3Source,
|
||
OutputSpec(Container.MP4, VideoCodec.COPY, AudioCodec.AAC) to mp3Source,
|
||
// Copy-the-video-from-a-file-with-no-video, the last branch that built its offer by
|
||
// hand. It escaped the five rows above because `spec.copy(videoCodec = NONE)` is valid
|
||
// exactly when the audio axis happens to be fine — true for the AAC and MP3 sources
|
||
// used there, false for any audio the target container cannot carry.
|
||
OutputSpec(Container.MP4, VideoCodec.COPY, AudioCodec.COPY) to vorbisSource,
|
||
OutputSpec(Container.MP4, VideoCodec.COPY, AudioCodec.COPY) to pcmSource,
|
||
OutputSpec(Container.WEBM, VideoCodec.COPY, AudioCodec.COPY) to mp3Source,
|
||
// The same branch with audio the container *can* hold, which is the half that already
|
||
// worked and must keep working: the repair here is a copy, so the offer is the very
|
||
// spec the caller handed to `suggestions`. It survives only because the exclusion is
|
||
// against what the user asked for rather than against the repair.
|
||
OutputSpec(Container.MP4, VideoCodec.COPY, AudioCodec.COPY) to mp3Source,
|
||
// The one branch that still builds its list by hand, so that it is asserted rather
|
||
// than merely reasoned about: an image container takes `None + None` and nothing else,
|
||
// which makes its single offer valid by construction.
|
||
OutputSpec(Container.GIF, VideoCodec.H264, AudioCodec.AAC) to h264Source,
|
||
)
|
||
|
||
cases.forEach { (spec, probe) ->
|
||
val invalid = ContainerCapabilities.validate(spec, probe) as? Validation.Invalid
|
||
?: throw AssertionError("expected $spec to be rejected")
|
||
assertTrue("no alternatives offered for $spec on $probe", invalid.suggestions.isNotEmpty())
|
||
invalid.suggestions.forEach { suggestion ->
|
||
assertTrue(
|
||
"suggested $suggestion for $spec on $probe is itself invalid",
|
||
ContainerCapabilities.validate(suggestion, probe).isValid,
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
@Test
|
||
fun `an unidentifiable source codec cannot be copied`() {
|
||
val unknown = InputProbe(videoCodec = InputProbe.UNPARSEABLE, audioCodec = null)
|
||
val spec = OutputSpec(Container.MP4, VideoCodec.COPY, AudioCodec.NONE)
|
||
|
||
val result = ContainerCapabilities.validate(spec, unknown)
|
||
assertFalse("copying an unknown codec must be refused", result.isValid)
|
||
}
|
||
|
||
@Test
|
||
fun `copying a video track into an audio-only container is refused`() {
|
||
val spec = OutputSpec(Container.MP3, VideoCodec.COPY, AudioCodec.MP3)
|
||
val result = ContainerCapabilities.validate(spec, h264Source)
|
||
|
||
val invalid = result as? Validation.Invalid
|
||
?: throw AssertionError("expected video in MP3 to be rejected")
|
||
assertTrue(invalid.message.contains("audio only"))
|
||
}
|
||
|
||
@Test
|
||
fun `dropping both tracks is refused rather than producing an empty file`() {
|
||
val spec = OutputSpec(Container.MP4, VideoCodec.NONE, AudioCodec.NONE)
|
||
val result = ContainerCapabilities.validate(spec, h264Source)
|
||
|
||
assertFalse(result.isValid)
|
||
assertTrue((result as Validation.Invalid).suggestions.isNotEmpty())
|
||
}
|
||
|
||
/**
|
||
* The same rule, seen only against the probe.
|
||
*
|
||
* A video codec named for a file with no video track is dropped, not encoded — so
|
||
* MP4/H.265/None on an MP3 empties the output exactly as None/None does. Reading the spec
|
||
* alone answered "valid" because the spec names a video codec, and the job went to Media3,
|
||
* where `EditedMediaItem.Builder` refuses a composition with both tracks removed by throwing
|
||
* on Transformer's own HandlerThread.
|
||
*/
|
||
@Test
|
||
fun `a video codec named for a file with no video track and no audio is refused`() {
|
||
ContainerCapabilities.encodableVideo(Container.MP4).forEach { codec ->
|
||
val spec = OutputSpec(Container.MP4, codec, AudioCodec.NONE)
|
||
val result = ContainerCapabilities.validate(spec, mp3Source)
|
||
|
||
assertFalse(
|
||
"MP4/${codec.label}/None on an audio-only input plans to (Drop, Drop) and would " +
|
||
"produce an empty file; it must be refused. Got $result",
|
||
result.isValid,
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* The refusal is only worth having if it leads somewhere.
|
||
*
|
||
* The COPY form of this was already refused, but its one hand-built suggestion was
|
||
* `None + None` — which validation refuses in the next breath, so the Advanced picker offered
|
||
* a one-tap fix that fixed nothing. Every face of the rule now goes through the shared
|
||
* suggestion path, so the offer keeps the one track the input actually has.
|
||
*/
|
||
@Test
|
||
fun `refusing an empty output still offers a way to keep the audio`() {
|
||
listOf(VideoCodec.H265, VideoCodec.H264, VideoCodec.COPY, VideoCodec.NONE).forEach { codec ->
|
||
val spec = OutputSpec(Container.MP4, codec, AudioCodec.NONE)
|
||
val invalid = ContainerCapabilities.validate(spec, mp3Source) as? Validation.Invalid
|
||
?: throw AssertionError("expected MP4/${codec.label}/None to be rejected")
|
||
|
||
assertTrue(
|
||
"a refusal with no way out is a dead end in the Advanced picker",
|
||
invalid.suggestions.isNotEmpty(),
|
||
)
|
||
assertTrue(
|
||
"every suggestion must keep a track, got ${invalid.suggestions}",
|
||
invalid.suggestions.all { it.audioCodec != AudioCodec.NONE },
|
||
)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* A repair must not name a track the input does not have.
|
||
*
|
||
* `repairVideo` used to fall through to "the first codec this container can encode" whenever
|
||
* nothing else fitted, and for an MP3 that produced the non-sequitur `MP4 · H.264 · Copy`.
|
||
* It validated, so nothing caught it — but [CopyPlanner] drops that video track anyway, which
|
||
* makes the codec in the offer a fiction.
|
||
*/
|
||
@Test
|
||
fun `a repair for a file with no video track never names a video codec`() {
|
||
listOf(
|
||
OutputSpec(Container.MP4, VideoCodec.H265, AudioCodec.NONE),
|
||
OutputSpec(Container.MP4, VideoCodec.NONE, AudioCodec.NONE),
|
||
OutputSpec(Container.MP4, VideoCodec.COPY, AudioCodec.NONE),
|
||
).forEach { spec ->
|
||
val invalid = ContainerCapabilities.validate(spec, mp3Source) as Validation.Invalid
|
||
invalid.suggestions.forEach {
|
||
assertEquals(
|
||
"offering ${it.videoCodec.label} for a file with no video track is a fiction; " +
|
||
"CopyPlanner drops it. Suggested $it for $spec",
|
||
VideoCodec.NONE,
|
||
it.videoCodec,
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* The rule stated as the property it is, over the whole matrix.
|
||
*
|
||
* A plan of (Drop, Drop) is precisely the composition `EditedMediaItem.Builder` refuses to
|
||
* build, so no non-image spec that reaches it may be called valid. Sweeping every container ×
|
||
* codec × codec against both probes is what stops the next container or codec from
|
||
* reintroducing the gap on an axis nobody thought to write a case for.
|
||
*
|
||
* Image outputs are exempt and deliberately so: GIF and PNG frames carry no codecs at all, and
|
||
* `None + None` is the only spec they accept — but they never reach Media3, because the router
|
||
* sends every image output to FFmpeg.
|
||
*/
|
||
@Test
|
||
fun `no valid non-image spec plans to remove both tracks`() {
|
||
val specs = Container.entries
|
||
.filterNot { it == Container.GIF || it == Container.IMAGE_SEQUENCE }
|
||
.flatMap { container -> VideoCodec.entries.map { container to it } }
|
||
.flatMap { (container, video) -> AudioCodec.entries.map { OutputSpec(container, video, it) } }
|
||
val cases = specs.flatMap { spec -> listOf(h264Source, mp3Source).map { spec to it } }
|
||
|
||
val empties = cases.filter { (spec, probe) ->
|
||
val plan = CopyPlanner.plan(spec, probe)
|
||
plan.video == VideoPlan.Drop && plan.audio == AudioPlan.Drop
|
||
}
|
||
|
||
assertTrue("the sweep found nothing to check — the filter has gone wrong", empties.isNotEmpty())
|
||
empties.forEach { (spec, probe) ->
|
||
assertFalse(
|
||
"$spec on $probe plans to (Drop, Drop) — an empty file, and the composition " +
|
||
"Media3 cannot build — so it must not validate",
|
||
ContainerCapabilities.validate(spec, probe).isValid,
|
||
)
|
||
}
|
||
}
|
||
|
||
@Test
|
||
fun `copying is offered as the fix when the codec is right but unencodable`() {
|
||
val av1Source = InputProbe(videoCodec = "av1", audioCodec = "aac", container = Container.MKV)
|
||
val spec = OutputSpec(Container.MP4, VideoCodec.AV1, AudioCodec.AAC)
|
||
|
||
val invalid = ContainerCapabilities.validate(spec, av1Source) as? Validation.Invalid
|
||
?: throw AssertionError("expected an AV1 encode to be rejected")
|
||
assertTrue(
|
||
"should offer to copy the AV1 track instead, got ${invalid.suggestions}",
|
||
invalid.suggestions.any { it.videoCodec == VideoCodec.COPY },
|
||
)
|
||
}
|
||
|
||
// --- the picker reads these ---------------------------------------------
|
||
|
||
@Test
|
||
fun `encodable lists never contain a codec the container cannot hold`() {
|
||
Container.entries.forEach { container ->
|
||
ContainerCapabilities.encodableVideo(container).forEach {
|
||
assertTrue(
|
||
"$container claims to encode $it but cannot hold it",
|
||
ContainerCapabilities.accepts(container, it, CodecMode.COPY),
|
||
)
|
||
}
|
||
ContainerCapabilities.encodableAudio(container).forEach {
|
||
assertTrue(
|
||
"$container claims to encode $it but cannot hold it",
|
||
ContainerCapabilities.accepts(container, it, CodecMode.COPY),
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
@Test
|
||
fun `audio-only containers offer no video codecs`() {
|
||
listOf(Container.MP3, Container.WAV, Container.FLAC, Container.OGG, Container.AAC_ADTS)
|
||
.forEach { container ->
|
||
assertFalse("$container claims to hold video", container.canHoldVideo)
|
||
assertEquals(emptyList<VideoCodec>(), ContainerCapabilities.encodableVideo(container))
|
||
}
|
||
}
|
||
|
||
// --- the audio axis -----------------------------------------------------
|
||
//
|
||
// Every rule below has a video twin already tested above. The two halves of `validate` were
|
||
// written together and only one of them was ever checked, so these are deliberately shaped like
|
||
// their twins rather than as a fresh idea about what to assert.
|
||
|
||
@Test
|
||
fun `an unidentifiable source audio codec cannot be copied`() {
|
||
// The audio twin of `an unidentifiable source codec cannot be copied`. Never guess: a copy
|
||
// of an unidentified codec is how you ship a file that does not play.
|
||
val unknownAudio = InputProbe(videoCodec = "h264", audioCodec = null, container = Container.MP4)
|
||
val spec = OutputSpec(Container.MP4, VideoCodec.H264, AudioCodec.COPY)
|
||
|
||
val invalid = ContainerCapabilities.validate(spec, unknownAudio) as? Validation.Invalid
|
||
?: throw AssertionError("copying an unidentified audio codec must be refused")
|
||
|
||
assertTrue(invalid.message, invalid.message.contains("could not be identified"))
|
||
assertEverySuggestionValid(invalid, unknownAudio)
|
||
}
|
||
|
||
@Test
|
||
fun `copying an audio codec the container cannot hold is refused`() {
|
||
// MP4 carries AAC, MP3, Opus and FLAC. Vorbis lives in Ogg and Matroska, so a stream copy
|
||
// out of a Vorbis source into MP4 has nowhere to put the track.
|
||
val vorbisAudio = InputProbe(videoCodec = "h264", audioCodec = "vorbis", container = Container.MKV)
|
||
val spec = OutputSpec(Container.MP4, VideoCodec.H264, AudioCodec.COPY)
|
||
|
||
val invalid = ContainerCapabilities.validate(spec, vorbisAudio) as? Validation.Invalid
|
||
?: throw AssertionError("Vorbis copied into MP4 must be refused")
|
||
|
||
assertEquals("MP4 cannot hold Vorbis audio.", invalid.message)
|
||
assertEverySuggestionValid(invalid, vorbisAudio)
|
||
}
|
||
|
||
@Test
|
||
fun `an audio codec the container cannot hold is refused on the encode path too`() {
|
||
// WAV carries PCM and nothing else. The twin is `H265 in AVI is refused`.
|
||
val spec = OutputSpec(Container.WAV, VideoCodec.NONE, AudioCodec.AAC)
|
||
|
||
val invalid = ContainerCapabilities.validate(spec, mp3Source) as? Validation.Invalid
|
||
?: throw AssertionError("AAC in WAV must be refused")
|
||
|
||
assertEquals("WAV cannot hold AAC audio.", invalid.message)
|
||
assertEverySuggestionValid(invalid, mp3Source)
|
||
}
|
||
|
||
@Test
|
||
fun `an audio codec this app cannot encode is refused, and copying is offered instead`() {
|
||
// Matroska carries Vorbis; nothing here encodes it. The refusal has to say so *and* say
|
||
// what would work, which is the audio twin of `copying is offered as the fix when the codec
|
||
// is right but unencodable`.
|
||
val spec = OutputSpec(Container.MKV, VideoCodec.H264, AudioCodec.VORBIS)
|
||
|
||
val invalid = ContainerCapabilities.validate(spec, h264Source) as? Validation.Invalid
|
||
?: throw AssertionError("encoding Vorbis must be refused")
|
||
|
||
assertEquals(
|
||
"This app cannot encode Vorbis audio. It can still be copied from a Vorbis source.",
|
||
invalid.message,
|
||
)
|
||
assertEverySuggestionValid(invalid, h264Source)
|
||
}
|
||
|
||
@Test
|
||
fun `copying a video codec the container cannot hold is refused`() {
|
||
// Not the audio axis, but the one video refusal with no test: AVI predates H.265, so a
|
||
// stream copy out of an HEVC source into AVI has nowhere to put the track. `H265 in AVI is
|
||
// refused` covers the matrix; this covers what validate() does with it.
|
||
val h265Source = InputProbe(videoCodec = "hevc", audioCodec = "mp3", container = Container.MP4)
|
||
val spec = OutputSpec(Container.AVI, VideoCodec.COPY, AudioCodec.MP3)
|
||
|
||
val invalid = ContainerCapabilities.validate(spec, h265Source) as? Validation.Invalid
|
||
?: throw AssertionError("H.265 copied into AVI must be refused")
|
||
|
||
assertEquals("AVI cannot hold H.265 video.", invalid.message)
|
||
assertEverySuggestionValid(invalid, h265Source)
|
||
}
|
||
|
||
@Test
|
||
fun `no audio track is accepted by every container in both modes`() {
|
||
// The audio twin of VideoCodec.NONE -> true. A container that refused "no audio" would make
|
||
// every video-only output invalid.
|
||
Container.entries.forEach { container ->
|
||
listOf(CodecMode.COPY, CodecMode.ENCODE).forEach { mode ->
|
||
assertTrue(
|
||
"$container should accept no audio track ($mode)",
|
||
ContainerCapabilities.accepts(container, AudioCodec.NONE, mode),
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* The video twin of `no audio track is accepted by every container in both modes`.
|
||
*
|
||
* Dead in production today, and deliberately so: every caller guards `NONE` before asking the
|
||
* matrix, so nothing reaches this arm through the app. **The asymmetry is the argument, not the
|
||
* reachability** -- its audio counterpart at the top of the same `when` has had a dedicated
|
||
* test since #136, and one of a matched pair being covered is how a later reader concludes the
|
||
* other was considered and exempted. It was not; it was simply missed.
|
||
*
|
||
* Not the same shape as the two `COPY -> error(...)` arms, which `docs/coverage-read-findings.md`
|
||
* records as a named exemption (F4). Those are guards that must not be provokable. This is a
|
||
* documented answer -- "no video track fits anywhere" -- and an answer is a thing to pin.
|
||
*/
|
||
@Test
|
||
fun `no video track is accepted by every container in both modes`() {
|
||
Container.entries.forEach { container ->
|
||
listOf(CodecMode.COPY, CodecMode.ENCODE).forEach { mode ->
|
||
assertTrue(
|
||
"$container should accept no video track ($mode)",
|
||
ContainerCapabilities.accepts(container, VideoCodec.NONE, mode),
|
||
)
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* A suggestion that keeps the codec the user asked for, rather than falling back to the
|
||
* container's first encodable one.
|
||
*
|
||
* `repairVideo`'s third arm -- "the request is not a copy, and this container can encode it" --
|
||
* is the one that preserves intent, and it was the only arm of the four nothing reached. The
|
||
* property test above executes `repairVideo` on every case it walks and lands elsewhere each
|
||
* time: an explicit COPY that works, a source the container can carry untouched, or no video
|
||
* track at all.
|
||
*
|
||
* The route is indirect because it is the only one the app has. VP9 into WebM is a perfectly
|
||
* good video request; what makes it invalid is the *audio* -- WebM carries Opus and Vorbis, not
|
||
* AAC. So `validateAudio` refuses, `suggestions` looks for a container that can hold what was
|
||
* asked for, and MP4 can encode VP9. The suggestion has to come back carrying VP9: swapping to
|
||
* the container's first encodable codec would discard the choice the user made.
|
||
*/
|
||
@Test
|
||
fun `a repaired suggestion keeps the video codec the user chose`() {
|
||
val invalid = ContainerCapabilities.validate(
|
||
OutputSpec(Container.WEBM, VideoCodec.VP9, AudioCodec.AAC),
|
||
h264Source,
|
||
)
|
||
|
||
assertTrue("WebM cannot hold AAC, so this spec is invalid", invalid is Validation.Invalid)
|
||
val suggestions = (invalid as Validation.Invalid).suggestions
|
||
assertTrue(
|
||
"expected a suggestion that still encodes VP9, got $suggestions",
|
||
suggestions.any { it.videoCodec == VideoCodec.VP9 },
|
||
)
|
||
assertEverySuggestionValid(invalid, h264Source)
|
||
}
|
||
|
||
/**
|
||
* The fallback in `firstContainerHolding`: when the input's own container cannot hold the
|
||
* codec the user asked for, any container that can will do.
|
||
*
|
||
* The preferred half -- "the container the input already uses" -- is what every other case
|
||
* reaches, because they all start from a file whose own container carries the codec in
|
||
* question. The elvis after it had never run.
|
||
*
|
||
* AVI is the input that makes it run: AVI predates H.265 and has no mapping for it, so asking
|
||
* an AVI for H.265 is refused, and the container the input already uses cannot be part of the
|
||
* answer. Without the fallback the only candidates left are AVI itself and the container
|
||
* holding the *source* codec -- also AVI -- so the refusal still offers something, but what it
|
||
* offers is H.264: the app quietly declines the codec the user asked for instead of moving them
|
||
* to a container that supports it.
|
||
*
|
||
* That is why this asserts the codec survives rather than that the list is non-empty. A
|
||
* non-empty assertion passes with the fallback deleted -- measured, not assumed.
|
||
*/
|
||
@Test
|
||
fun `an input whose container cannot hold the requested codec is moved, not downgraded`() {
|
||
val aviSource = InputProbe(videoCodec = "h264", audioCodec = "aac", container = Container.AVI)
|
||
|
||
val invalid = ContainerCapabilities.validate(
|
||
OutputSpec(Container.AVI, VideoCodec.H265, AudioCodec.AAC),
|
||
aviSource,
|
||
)
|
||
|
||
assertTrue("AVI has no mapping for H.265", invalid is Validation.Invalid)
|
||
val suggestions = (invalid as Validation.Invalid).suggestions
|
||
assertTrue(
|
||
"expected a container that can actually hold H.265, got $suggestions",
|
||
suggestions.any { it.videoCodec == VideoCodec.H265 },
|
||
)
|
||
assertEverySuggestionValid(invalid, aviSource)
|
||
}
|
||
|
||
@Test
|
||
fun `resolving audio COPY before asking the matrix is required`() {
|
||
// The audio twin of `resolving COPY before asking the matrix is required`, and the reason is
|
||
// identical: silently answering "false" would refuse a perfectly good remux.
|
||
runCatching { ContainerCapabilities.accepts(Container.MP4, AudioCodec.COPY, CodecMode.COPY) }
|
||
.onSuccess { throw AssertionError("expected audio COPY to be rejected by the matrix") }
|
||
}
|
||
|
||
/**
|
||
* Every alternative a refusal offers has to be one the same input could actually take.
|
||
*
|
||
* `Validation.Invalid` promises exactly this and names this class as the proof. The global
|
||
* property test walks the presets; these paths reach `suggestions()` through `validateAudio`,
|
||
* which no preset does.
|
||
*/
|
||
private fun assertEverySuggestionValid(invalid: Validation.Invalid, probe: InputProbe) {
|
||
invalid.suggestions.forEach {
|
||
assertTrue(
|
||
"suggestion $it is itself invalid, so the chip leads to a second error",
|
||
ContainerCapabilities.validate(it, probe).isValid,
|
||
)
|
||
}
|
||
}
|
||
}
|