mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-17 15:03:25 +09:00
[MG_IntegrationTest, ci] (P7): the verify-split arm proof is a per-entry census, not a floor
- the landing shape was a count - at least 850 armed of at least 1000 client logs - which leaves the remaining 155 unnamed: the lane could lose fifty arms, gain fifty skips, and the floor would not move - the rule is now per entry and two-sided, the one dualblock-expected-fatals.txt already rides: each client log must carry the arming line, or belong to an entry ctest reported SKIPPED, or be named in the new Harness/verify-split-unarmed-expected.txt - a gtest skip is the recognised no-verb marker and is NOT named, because the skip set moves with the driver - naming it would ratchet on lavapipe rather than on the comparator - both other directions fail: a listed entry that armed, and a listed name with no client log in this run - split_log_paths.py gains the verify-split-arming mode; the lane step gains --output-junit so a skip can be told from a pass; test_split_log_paths.py gains six controls covering the four ways the census can be wrong - measured on the host over 1064 private client logs: 909 armed, 99 unarmed and skipped, 56 unarmed and named in five classes - caps/limits/extension advertisement 22, shader and program object surfaces 16, object state written and read back or a call rejected before it becomes a verb 14, framebuffer completeness queries 2 (DirectGLES only; DirectVulkan skips both), the poison parent that only forks 2
This commit is contained in:
@@ -202,6 +202,105 @@ def require_green(document, junit_path, required):
|
||||
print(f"SplitLogPaths require-green: {len(by_name)} PASS, 0 skip, 0 failed, complete discovery")
|
||||
|
||||
|
||||
VERIFY_ARMED_LINE = "MGPipe: verify armed"
|
||||
|
||||
|
||||
def verify_split_arming(logs_dir, junit_path, expected_path):
|
||||
"""THE VERIFY-SPLIT LANE'S ARM PROOF, PER ENTRY (P7 wave 3, V1 fix round).
|
||||
|
||||
What this replaces: a COUNT. The landing shape of the lane's arm proof asserted that at
|
||||
least 850 of at least 1000 per-entry client logs carried `MGPipe: verify armed`, which
|
||||
leaves ~117 entries unnamed and therefore unaccounted - a lane can lose fifty arms and
|
||||
gain fifty skips and the floor never moves. The census is the point (dualblock-expected-
|
||||
fatals.txt's rule, ID-119), so this is the same two-sided ratchet applied to arming:
|
||||
|
||||
* an entry whose client log carries the arming line is ARMED and needs nothing else;
|
||||
* an entry that ctest reported SKIPPED is recognised without a name - a gtest skip is a
|
||||
process that brought a session up and left before any verb, which is honestly unarmed,
|
||||
and the skip set is driver-dependent (a GitHub runner's lavapipe/llvmpipe skips more
|
||||
or fewer than the host's), so naming those would ratchet on the driver;
|
||||
* every OTHER unarmed entry must be named in the committed expected file, which says why
|
||||
each class is there.
|
||||
|
||||
Two-sided, and both directions are failures:
|
||||
* an unlisted, unskipped entry that did not arm - the comparator stopped reaching it, or
|
||||
a case stopped issuing a verb, and either way the lane is quieter than it looks;
|
||||
* a LISTED entry that armed - the name is stale and the file must lose the row in the
|
||||
commit that made it arm, or the exception set rots into a permanent amnesty;
|
||||
* a LISTED entry with no client log in this run at all - the name no longer matches an
|
||||
entry (a rename, a filter change), which would otherwise be an invisible amnesty too.
|
||||
A listed entry that SKIPPED on this run is neither: it is reported and allowed, because a
|
||||
driver difference is exactly what the skip recognition above exists to absorb."""
|
||||
directory = Path(logs_dir)
|
||||
logs = sorted(directory.glob("*.client.log"))
|
||||
if not logs:
|
||||
raise ValueError(f"verify-split arming: no *.client.log under {directory} - the per-entry "
|
||||
f"private log paths did not take, so nothing here is a per-entry proof")
|
||||
status = {}
|
||||
for case in ET.parse(junit_path).getroot().iter("testcase"):
|
||||
name = case.get("name")
|
||||
if case.find("skipped") is not None:
|
||||
status[name] = "skipped"
|
||||
elif (case.find("failure") is not None or case.find("error") is not None
|
||||
or case.get("status") == "fail"):
|
||||
status[name] = "failed"
|
||||
else:
|
||||
status[name] = "passed"
|
||||
|
||||
expected = read_pair_set(expected_path)
|
||||
armed, skipped, named, unnamed, listed_armed, no_result = [], [], [], [], [], []
|
||||
for path in logs:
|
||||
entry = path.name[: -len(".client.log")]
|
||||
if entry not in status:
|
||||
no_result.append(entry)
|
||||
continue
|
||||
if VERIFY_ARMED_LINE in path.read_text(errors="replace"):
|
||||
armed.append(entry)
|
||||
if entry in expected:
|
||||
listed_armed.append(entry)
|
||||
elif status[entry] == "skipped":
|
||||
skipped.append(entry)
|
||||
elif entry in expected:
|
||||
named.append(entry)
|
||||
else:
|
||||
unnamed.append(entry)
|
||||
|
||||
seen = set(armed) | set(skipped) | set(named) | set(unnamed)
|
||||
stale = sorted(expected - seen)
|
||||
listed_and_skipped = sorted(expected & set(skipped))
|
||||
print(f"SplitLogPaths verify-split-arming: {len(logs)} per-entry client log(s) - "
|
||||
f"{len(armed)} armed, {len(skipped)} unarmed and skipped, "
|
||||
f"{len(named)} unarmed and named in {Path(expected_path).name}")
|
||||
if listed_and_skipped:
|
||||
print(f"SplitLogPaths verify-split-arming: {len(listed_and_skipped)} named entrie(s) "
|
||||
f"skipped on this driver instead of running unarmed (allowed): "
|
||||
f"{', '.join(listed_and_skipped)}")
|
||||
problems = []
|
||||
if no_result:
|
||||
problems.append("%d private log(s) have no entry in the JUnit result: %s. The glob and "
|
||||
"the run disagree about the lane's members, so neither side is a census."
|
||||
% (len(no_result), ", ".join(sorted(no_result)[:20])))
|
||||
if unnamed:
|
||||
problems.append("%d entrie(s) ran, did not skip, and never armed the comparator: %s. Each "
|
||||
"is a process that reached no verb - add it to %s with the class it "
|
||||
"belongs to, or find out why the fill stopped happening."
|
||||
% (len(unnamed), ", ".join(sorted(unnamed)[:20]), Path(expected_path).name))
|
||||
if listed_armed:
|
||||
problems.append("%d entrie(s) are named in %s but DID arm: %s. Remove the row in the "
|
||||
"commit that made them arm - an exception set that keeps rows nothing "
|
||||
"needs any more is how this proof rots."
|
||||
% (len(listed_armed), Path(expected_path).name,
|
||||
", ".join(sorted(listed_armed)[:20])))
|
||||
if stale:
|
||||
problems.append("%d name(s) in %s match no per-entry client log in this run: %s. The "
|
||||
"entry was renamed or filtered out; drop the row in the same commit."
|
||||
% (len(stale), Path(expected_path).name, ", ".join(stale[:20])))
|
||||
if problems:
|
||||
raise ValueError("the verify-split arm proof: " + " | ".join(problems))
|
||||
print(f"SplitLogPaths verify-split-arming: per-entry arm proof OK - every log armed, skipped "
|
||||
f"or named ({len(expected)} name(s) in the expected set)")
|
||||
|
||||
|
||||
def expect_fatal(document, junit_path, expected_path):
|
||||
"""THE DUAL-BLOCK LANE'S CENSUS AND TWO-SIDED RATCHET (P5f f1, P5F §4/§6).
|
||||
|
||||
@@ -372,6 +471,13 @@ def main():
|
||||
if mode == "expect-fatal":
|
||||
expect_fatal(json.loads(Path(sys.argv[2]).read_text()), sys.argv[3], sys.argv[4])
|
||||
return
|
||||
if mode == "verify-split-arming":
|
||||
# <logs dir> <junit xml> <expected names>. It takes the LOG DIRECTORY rather than the
|
||||
# discovery JSON on purpose: the claim is about the files a run left on disk, and a
|
||||
# helper that rebuilt the set from discovery could not notice a log that was never
|
||||
# written.
|
||||
verify_split_arming(sys.argv[2], sys.argv[3], sys.argv[4])
|
||||
return
|
||||
if mode == "require-green":
|
||||
require_green(json.loads(Path(sys.argv[2]).read_text()), sys.argv[3], sys.argv[4:])
|
||||
return
|
||||
|
||||
@@ -117,5 +117,79 @@ class ResultAccountingTest(unittest.TestCase):
|
||||
helper.require_green(self.document, self.xml, [A, B])
|
||||
|
||||
|
||||
class VerifySplitArmProofTest(unittest.TestCase):
|
||||
"""The per-entry arm proof, BOTH SIDES (P7 wave 3, V1 fix round).
|
||||
|
||||
The thing it replaced was a count, and a count cannot be tested for the failure that
|
||||
matters - "fifty arms became fifty skips" leaves it unmoved. These four cases are the four
|
||||
ways the census can be wrong, and each one has to raise."""
|
||||
|
||||
ARMED = "DirectGLES.VerifySplit.TriangleScenario.DrawsATriangle"
|
||||
QUIET = "DirectGLES.VerifySplit.AdvertisedLimitsScenario.EveryGL45CoreMinimumIsMet"
|
||||
SKIPPED = "DirectVulkan.VerifySplit.F1WireScenario.SomethingLavapipeCannotDo"
|
||||
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory()
|
||||
self.root = Path(self.temp.name)
|
||||
self.logs = self.root / "verify-split-logs"
|
||||
self.logs.mkdir()
|
||||
self.xml = self.root / "run.xml"
|
||||
self.expected = self.root / "expected.txt"
|
||||
self.expected.write_text("# the quiet one\n" + self.QUIET + "\n")
|
||||
self.write_log(self.ARMED, helper.VERIFY_ARMED_LINE)
|
||||
self.write_log(self.QUIET, "no fill here")
|
||||
self.write_log(self.SKIPPED, "no fill here either")
|
||||
self.results([(self.ARMED, "run", None), (self.QUIET, "run", None),
|
||||
(self.SKIPPED, "notrun", "skipped")])
|
||||
|
||||
def tearDown(self):
|
||||
self.temp.cleanup()
|
||||
|
||||
def write_log(self, entry, text):
|
||||
(self.logs / (entry + ".client.log")).write_text(text + "\n")
|
||||
|
||||
def results(self, rows):
|
||||
suite = ET.Element("testsuite")
|
||||
for name, status, kind in rows:
|
||||
case = ET.SubElement(suite, "testcase", name=name, status=status)
|
||||
if kind:
|
||||
ET.SubElement(case, kind)
|
||||
ET.ElementTree(suite).write(self.xml)
|
||||
|
||||
def proof(self):
|
||||
with contextlib.redirect_stdout(io.StringIO()):
|
||||
helper.verify_split_arming(self.logs, self.xml, self.expected)
|
||||
|
||||
def test_armed_skipped_or_named_is_the_whole_rule(self):
|
||||
self.proof()
|
||||
|
||||
def test_an_unlisted_quiet_entry_fails(self):
|
||||
self.expected.write_text("# nobody\n")
|
||||
with self.assertRaisesRegex(ValueError, "never armed"):
|
||||
self.proof()
|
||||
|
||||
def test_a_listed_entry_that_armed_fails(self):
|
||||
self.write_log(self.QUIET, helper.VERIFY_ARMED_LINE)
|
||||
with self.assertRaisesRegex(ValueError, "DID arm"):
|
||||
self.proof()
|
||||
|
||||
def test_a_listed_name_with_no_log_fails(self):
|
||||
(self.logs / (self.QUIET + ".client.log")).unlink()
|
||||
self.results([(self.ARMED, "run", None), (self.SKIPPED, "notrun", "skipped")])
|
||||
with self.assertRaisesRegex(ValueError, "match no per-entry client log"):
|
||||
self.proof()
|
||||
|
||||
def test_a_log_with_no_result_fails(self):
|
||||
self.results([(self.ARMED, "run", None), (self.QUIET, "run", None)])
|
||||
with self.assertRaisesRegex(ValueError, "no entry in the JUnit result"):
|
||||
self.proof()
|
||||
|
||||
def test_an_empty_log_directory_is_not_a_green(self):
|
||||
for path in self.logs.glob("*.client.log"):
|
||||
path.unlink()
|
||||
with self.assertRaisesRegex(ValueError, "did not take"):
|
||||
self.proof()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
@@ -0,0 +1,129 @@
|
||||
# THE VERIFY-SPLIT ENTRIES THAT HONESTLY NEVER ARM THE COMPARATOR, BY NAME.
|
||||
#
|
||||
# `MGPipe: verify armed` is latched at a process's FIRST FILL, so a process that reaches no verb
|
||||
# never prints it. The lane's arm proof (.github/workflows/test.yml, integration-verify-split)
|
||||
# used to allow that with a COUNT - "at least 850 of at least 1000 client logs carry the line" -
|
||||
# which leaves the remainder unnamed: the lane could lose fifty arms, gain fifty skips, and the
|
||||
# floor would not move. This file is the census instead, and split_log_paths.py's
|
||||
# `verify-split-arming` mode is what reads it.
|
||||
#
|
||||
# THE RULE, PER ENTRY. Every verify-split-logs/*.client.log must either
|
||||
# (a) carry the arming line, or
|
||||
# (b) belong to an entry ctest reported SKIPPED - a gtest skip is a process that brought a
|
||||
# session up and left before any verb, and the skip set is DRIVER-DEPENDENT (a GitHub
|
||||
# runner's lavapipe/llvmpipe skips more or fewer cases than the host's), so naming those
|
||||
# would ratchet on the driver rather than on the comparator, or
|
||||
# (c) be named below.
|
||||
#
|
||||
# TWO-SIDED, the rule dualblock-expected-fatals.txt already rides (ID-119):
|
||||
# * an unlisted, unskipped entry that did not arm FAILS - a case stopped issuing a verb, or
|
||||
# the comparator stopped reaching it, and both are quieter lanes than they look;
|
||||
# * a LISTED entry that ARMED fails - remove the row in the commit that made it arm;
|
||||
# * a LISTED name with no client log in this run fails - the entry was renamed or filtered
|
||||
# out, and the row is an amnesty nobody asked for.
|
||||
# A listed entry that SKIPS on some driver is allowed and reported: that is (b) doing its job.
|
||||
#
|
||||
# HOW TO REFRESH (never by hand from a guess):
|
||||
# ctest --test-dir build-split -L '^integration-verify-split$' -j 6 \
|
||||
# --output-junit /tmp/verify-split.xml
|
||||
# python3 MobileGL/MG_IntegrationTest/Harness/split_log_paths.py verify-split-arming \
|
||||
# build-split/MobileGL/MG_IntegrationTest/verify-split-logs /tmp/verify-split.xml this-file
|
||||
# and put the names it prints here, under the class they belong to.
|
||||
#
|
||||
# MEASURED ON THE HOST (WSL Arch + lavapipe, build-split, 1064 entries with a private log):
|
||||
# 909 armed, 99 unarmed and skipped, 56 unarmed and named below.
|
||||
|
||||
# --------------------------------------------------------------------------------------------
|
||||
# CAPS, LIMITS AND EXTENSION ADVERTISEMENT - answered from the client's CapsMirror, no verb (22)
|
||||
# These call glGetIntegerv / glGetString / glGetInternalformativ and compare the answer
|
||||
# against a floor or against the other width of the same query. Nothing in them reaches a fill
|
||||
# point, so the arming line - latched at the process's FIRST fill - is honestly absent. They are
|
||||
# the same 13 entries per backend that tier 3 measured as reds under MGITEST_SPLIT_LANE=1, for
|
||||
# the same reason (a query answered without moving the encoder's record ordinal).
|
||||
# --------------------------------------------------------------------------------------------
|
||||
DirectGLES.VerifySplit.AdvertisedLimitsScenario.ComputeLocalSizeComesFromTheLinkedProgram
|
||||
DirectGLES.VerifySplit.AdvertisedLimitsScenario.ComputeUniformBlocksIsAnAmountAnApplicationCouldActuallyAllocate
|
||||
DirectGLES.VerifySplit.AdvertisedLimitsScenario.ComputeWorkGroupLimitsAreTheCapsBlocksAnswer
|
||||
DirectGLES.VerifySplit.AdvertisedLimitsScenario.EveryBufferLimitIsWithinItsAdvertisedRange
|
||||
DirectGLES.VerifySplit.AdvertisedLimitsScenario.EveryGL45CoreMinimumIsMet
|
||||
DirectGLES.VerifySplit.AdvertisedLimitsScenario.IndexedBufferBindingsAreReportedVerbatimOnBothWidths
|
||||
DirectGLES.VerifySplit.AdvertisedLimitsScenario.IndexedTargetSizeSurvivesDivisionByItsBindingCount
|
||||
DirectGLES.VerifySplit.AdvertisedLimitsScenario.PerStageBlockCountsFitInTheirBindingPoints
|
||||
DirectGLES.VerifySplit.AdvertisedLimitsScenario.ViewportArrayLimitsMeetTheirGL43Floors
|
||||
DirectGLES.VerifySplit.DoublePrecisionScenario.TheFp64ExtensionIsNotAdvertised
|
||||
DirectGLES.VerifySplit.SpirvShaderBinaryScenario.ShaderBinaryFormatIsAdvertisedExactlyOnce
|
||||
DirectVulkan.VerifySplit.AdvertisedLimitsScenario.ComputeLocalSizeComesFromTheLinkedProgram
|
||||
DirectVulkan.VerifySplit.AdvertisedLimitsScenario.ComputeUniformBlocksIsAnAmountAnApplicationCouldActuallyAllocate
|
||||
DirectVulkan.VerifySplit.AdvertisedLimitsScenario.ComputeWorkGroupLimitsAreTheCapsBlocksAnswer
|
||||
DirectVulkan.VerifySplit.AdvertisedLimitsScenario.EveryBufferLimitIsWithinItsAdvertisedRange
|
||||
DirectVulkan.VerifySplit.AdvertisedLimitsScenario.EveryGL45CoreMinimumIsMet
|
||||
DirectVulkan.VerifySplit.AdvertisedLimitsScenario.IndexedBufferBindingsAreReportedVerbatimOnBothWidths
|
||||
DirectVulkan.VerifySplit.AdvertisedLimitsScenario.IndexedTargetSizeSurvivesDivisionByItsBindingCount
|
||||
DirectVulkan.VerifySplit.AdvertisedLimitsScenario.PerStageBlockCountsFitInTheirBindingPoints
|
||||
DirectVulkan.VerifySplit.AdvertisedLimitsScenario.ViewportArrayLimitsMeetTheirGL43Floors
|
||||
DirectVulkan.VerifySplit.DoublePrecisionScenario.TheFp64ExtensionIsNotAdvertised
|
||||
DirectVulkan.VerifySplit.SpirvShaderBinaryScenario.ShaderBinaryFormatIsAdvertisedExactlyOnce
|
||||
|
||||
# --------------------------------------------------------------------------------------------
|
||||
# SHADER AND PROGRAM OBJECT SURFACES - compile, link, specialize, query, glGetError (16)
|
||||
# glShaderBinary / glSpecializeShader / glCompileShader / glGetUniformdv / the compiler
|
||||
# thread pool's settle-and-join, and the reserved-name pipeline case. Every one of them asserts on
|
||||
# an error code or a program query; none issues a draw, a dispatch, a clear or a readback.
|
||||
# --------------------------------------------------------------------------------------------
|
||||
DirectGLES.VerifySplit.AsyncCompileScenario.CompletionStatusPollingThenForcedJoin
|
||||
DirectGLES.VerifySplit.AsyncCompileScenario.ZeroCompilerThreadsSettlesEverythingImmediately
|
||||
DirectGLES.VerifySplit.DoublePrecisionScenario.GetUniformdvReadsBackWhatWasStored
|
||||
DirectGLES.VerifySplit.DoublePrecisionScenario.TheUniformIsStillReportedAsADouble
|
||||
DirectGLES.VerifySplit.ProgramPipelineScenario.AReservedNameTakesStateBeforeItIsAProgramPipeline
|
||||
DirectGLES.VerifySplit.SpirvShaderBinaryScenario.AnUnsupportedBinaryFormatIsRejectedInsteadOfSilentlyAccepted
|
||||
DirectGLES.VerifySplit.SpirvShaderBinaryScenario.CompileShaderOnASpirvShaderIsInvalidOperationAndShaderSourceTakesItBack
|
||||
DirectGLES.VerifySplit.SpirvShaderBinaryScenario.SpecializeShaderErrorSurfaceMatchesTheExtension
|
||||
DirectVulkan.VerifySplit.AsyncCompileScenario.CompletionStatusPollingThenForcedJoin
|
||||
DirectVulkan.VerifySplit.AsyncCompileScenario.ZeroCompilerThreadsSettlesEverythingImmediately
|
||||
DirectVulkan.VerifySplit.DoublePrecisionScenario.GetUniformdvReadsBackWhatWasStored
|
||||
DirectVulkan.VerifySplit.DoublePrecisionScenario.TheUniformIsStillReportedAsADouble
|
||||
DirectVulkan.VerifySplit.ProgramPipelineScenario.AReservedNameTakesStateBeforeItIsAProgramPipeline
|
||||
DirectVulkan.VerifySplit.SpirvShaderBinaryScenario.AnUnsupportedBinaryFormatIsRejectedInsteadOfSilentlyAccepted
|
||||
DirectVulkan.VerifySplit.SpirvShaderBinaryScenario.CompileShaderOnASpirvShaderIsInvalidOperationAndShaderSourceTakesItBack
|
||||
DirectVulkan.VerifySplit.SpirvShaderBinaryScenario.SpecializeShaderErrorSurfaceMatchesTheExtension
|
||||
|
||||
# --------------------------------------------------------------------------------------------
|
||||
# OBJECT STATE WRITTEN AND READ BACK, OR A CALL REJECTED BEFORE IT BECOMES A VERB (14)
|
||||
# glVertexAttribLFormat then glGetVertexAttribiv (the 64-bit format case does NOT draw - the
|
||||
# comment above it names the Adreno null-deref that is why), glTexBufferRange then the level
|
||||
# queries, glEnable then glIsEnabled, glGetIntegerv(GL_SAMPLE_MASK_WORDS) then glSampleMaski, the
|
||||
# two glCopyImageSubData level-range REJECTIONS (the call errors out, so no verb is filled), and
|
||||
# the arena readback, which is glBufferSubData + glGetBufferSubData and not a pipe verb.
|
||||
# --------------------------------------------------------------------------------------------
|
||||
DirectGLES.VerifySplit.BufferTextureScenario.LevelQueriesDescribeTheAttachedBufferRange
|
||||
DirectGLES.VerifySplit.ClipDistanceScenario.EnableIsObservableThroughIsEnabled
|
||||
DirectGLES.VerifySplit.CopyImageLevelRangeScenario.LevelOneOfASingleLevelTextureIsRejected
|
||||
DirectGLES.VerifySplit.CopyImageLevelRangeScenario.LevelTwoOfATwoLevelTextureIsRejected
|
||||
DirectGLES.VerifySplit.DoublePrecisionScenario.A64BitVertexFormatIsRecordedAndItsArrayIsDroppedAtDraw
|
||||
DirectGLES.VerifySplit.LargeArenaAdoptionScenario.ReadbackSeesTheLatestCpuWrite
|
||||
DirectGLES.VerifySplit.SampleMaskScopeScenario.TheAdvertisedSampleMaskWordCountMatchesWhatSampleMaskiAccepts
|
||||
DirectVulkan.VerifySplit.BufferTextureScenario.LevelQueriesDescribeTheAttachedBufferRange
|
||||
DirectVulkan.VerifySplit.ClipDistanceScenario.EnableIsObservableThroughIsEnabled
|
||||
DirectVulkan.VerifySplit.CopyImageLevelRangeScenario.LevelOneOfASingleLevelTextureIsRejected
|
||||
DirectVulkan.VerifySplit.CopyImageLevelRangeScenario.LevelTwoOfATwoLevelTextureIsRejected
|
||||
DirectVulkan.VerifySplit.DoublePrecisionScenario.A64BitVertexFormatIsRecordedAndItsArrayIsDroppedAtDraw
|
||||
DirectVulkan.VerifySplit.LargeArenaAdoptionScenario.ReadbackSeesTheLatestCpuWrite
|
||||
DirectVulkan.VerifySplit.SampleMaskScopeScenario.TheAdvertisedSampleMaskWordCountMatchesWhatSampleMaskiAccepts
|
||||
|
||||
# --------------------------------------------------------------------------------------------
|
||||
# FRAMEBUFFER COMPLETENESS QUERIES - attach and ask, never render (2)
|
||||
# glCheckFramebufferStatus on an attachment of that format. Only the DirectGLES half is
|
||||
# here: on DirectVulkan both cases SKIP (the format is not renderable on lavapipe), and a skip is
|
||||
# recognised without a name.
|
||||
# --------------------------------------------------------------------------------------------
|
||||
DirectGLES.VerifySplit.SnormAttachmentScenario.SignedNormalizedColorAttachmentsReportComplete
|
||||
DirectGLES.VerifySplit.ThreeChannelAttachmentScenario.ThreeChannelColorAttachmentsReportComplete
|
||||
|
||||
# --------------------------------------------------------------------------------------------
|
||||
# THE POISON PARENT THAT ONLY FORKS (2)
|
||||
# PoisonOmissionScenario.WithoutOmissionCompletes re-executes the binary and waits; the
|
||||
# frame is drawn in the CHILD, which writes its own log (<base>.poison-child). The parent process
|
||||
# brings a session up and forks, so it reaches no verb of its own.
|
||||
# --------------------------------------------------------------------------------------------
|
||||
DirectGLES.VerifySplit.PoisonOmissionScenario.WithoutOmissionCompletes
|
||||
DirectVulkan.VerifySplit.PoisonOmissionScenario.WithoutOmissionCompletes
|
||||
Reference in New Issue
Block a user