SDK · crate

kinogaki-studio-api-testing

SDK

Repository: SDK (kinogaki/studio-sdk)
Folder: sdk/crates/api-testing
Source: 15 files, 2,853 lines
Tests: 1 file, 40 lines

depends onused by tests alonedependencies for tests alone are listed below, not drawn

What it is

The SDK's test support (a dev-dependency only): assert_refused for admission tests, read_hostile for a format's tests of hostile files, format for its scratch folders and round trips, workers as a host installs them, with wgpu an engine's GPU tests' device, their turns on it and counted wakes (engine), and the conformance suite of the standard data types: producers make standard values, consumers check them, and run tries every pair.

A kernel implements Producer in its own repository (its operations' outputs over the fixtures), a render engine or a format implements Consumer (it draws, writes or reads each value and checks what it got), and each runs the suite with the SDK's own parts beside its own: Fixtures (hand-built values covering every shape and attribute kind), Codecs (a bit-exact save and read) and Invariants (each value rebuilt through the validating constructors is equal, and its edges are canonical).

Depends on

Crate	Repository	As	What it is
`kinogaki-geometry`	SDK	normal	Kinogaki Studio's standard geometry values.
`kinogaki-render-api`	SDK	normal	Kinogaki's render interface: what a host (Studio) sends a render engine and what comes back, with no GPU or OS API.
`kinogaki-studio-api`	SDK	normal	Kinogaki Studio's headless plugin API.
`kinogaki-viewport-api`	SDK	normal	Kinogaki's viewport packet contract: what a data type hands Studio's viewport to draw, with no GPU or UI API.

Third-party

None.

Used by

Crate	Repository	As	What it is
`example-flat-engine`	SDK	tests	Flat: an example render engine.
`example-points-format`	SDK	tests	XYZ: an example file format.
`kinogaki-brep-mesh`	Core and the app	tests	B-reps as polygons, below the viewport, renders and file exchange alike: each body's mesh by the installed mesher, cached on its geometry (`meshed`), and a value's bodies joined into one polygons value (`joined`): each body's mesh, the faces' polygons ...
`kinogaki-core-package`	Core and the app	tests	Core's own SDK package (`kinogaki.core`): what Studio holds whatever plugins are installed.
`kinogaki-editor`	Core and the app	tests	Kinogaki Studio's editor: the document and everything the window shows of it, as parts one frame borrows one by one.
`kinogaki-exr-format`	OpenEXR	tests	OpenEXR, a format plugin: an EXR file reads as one standard `Image`, every part's channels its layers, and an Image writes as one EXR, Cryptomatte included.
`kinogaki-fbx`	FBX	tests	FBX as a read-only format plugin for Kinogaki Studio.
`kinogaki-geometry-view`	Core and the app	tests	Geometry, curves and B-reps in the viewport, independent of any GPU API: the SDK's standard values as surface packets (over the SDK's display triangulation and shading normals, so Solid draws what Render renders), the one picker that answers rays and boxes ...
`kinogaki-gltf`	glTF	tests	glTF 2.0 and GLB, a format plugin for Kinogaki Studio.
`kinogaki-harness`	Core and the app	normal	Studio's test harness: the real editor, its event routing and its background work, driven offscreen with only the packages a test names.
`kinogaki-jpeg-format`	JPEG	tests	JPEG, a format plugin: a JPEG reads as one standard `Image` as the file holds it, and an Image writes as one baseline JPEG.
`kinogaki-materialx`	MaterialX	tests	MaterialX documents (`.mtlx`), a format plugin: a document's materials read as Studio's Materials, MaterialX networks of nodes, and Materials written as one.
`kinogaki-network`	Core and the app	tests	Studio's core networks (design: core-owned networks; "Cooking DAG for nodes is studio core").
`kinogaki-obj`	OBJ	tests	Wavefront OBJ, a format plugin: an OBJ file reads as one standard `Geometry`, its material libraries (`mtllib`) as MaterialX networks (`materials`) in a materials item before it; any polygons and polylines write as ...
`kinogaki-pixel`	Pixel	tests	Pixel, a realtime pixel-art render engine, as a Kinogaki Studio plugin.
`kinogaki-png-format`	PNG	tests	PNG, a format plugin: a PNG reads as one standard `Image` as the file holds it, and an Image writes as one PNG.
`kinogaki-project`	Core and the app	tests	Studio's project files: a document as a Prism document.
`kinogaki-scene`	Core and the app	tests	Studio's scene: the document cooked object by object.
`kinogaki-spectre`	Spectre	tests	Spectre, the spectral path tracer, as a Kinogaki Studio render plugin.
`kinogaki-spectre-testing`	Spectre	normal	What Spectre's GPU tests share (a dev-dependency of the plugin's tests alone): the engine on an offscreen device, waits on its wakes, and images compared with a tolerance.
`kinogaki-studio-ui-api-testing`	SDK	normal	The UI layer's test support (a dev-dependency only): headless fakes of the host's UI for plugin unit tests: `RecordingUi` and `RecordingPainter` record what a plugin asks to show and draw, and play back scripted user actions, with no window and no GPU ...
`kinogaki-testkit`	Core and the app	normal	Kinogaki Studio's core testkit: toy packages written against the SDK alone, so core is tested with no real plugin.
`kinogaki-usd`	USD	tests	Universal Scene Description as a format plugin for Kinogaki Studio: usda, usdc and usdz files read into the standard values and written from them.
`kinogaki-workflows`	Workflows	tests	Tests alone: `tests/workflows` drives what a person does across the plugins the app ships, through the real editor offscreen.

Modules

brep (private)The B-rep fixtures: plain bodies a small kernel written on the SDK alone builds (a box, a closed cylinder with no seam, a cone with its apex a pole edge, a whole sphere with no loops, a trimmed NURBS patch), and one value holding all of them with every part ...460 lines
checks (private)The SDK's consumers: Codecs and Invariants.190 lines
colors (private)Unconverted: a color service for checks that convert no color.27 lines
engineWhat an engine's GPU tests share: this machine's device, offscreen, the tests' turns on it, the engine's wakes counted with a way to wait on them, and the engine conformance (conformance): what a host sends, rendered.96 lines
engine::conformance (private)An engine checked against what a host sends (conformance): scenes of prims built with the SDK's builders, one for each prim kind and standard type the engine declares (scenes), each rendered as a final frame and read back beside the same scene without ...202 lines
engine::conformance::lifecycle (private)What a host does to an engine over time, beside one scene's final frame: a final of an empty scene; one through a camera not in the scene, which fails at once and says why; an edit after the first frame; a view id given again at another size; a scene of 6.4 ...188 lines
engine::conformance::scenes (private)The scenes the conformance renders: one for each prim kind and standard type the engine declares, each a final frame beside the same scene without its subject (check).380 lines
engine::conformance::twins (private)Scenes an engine renders as their twins: what MaterialX and the prims define alike renders alike, whatever of it the engine renders.330 lines
engine::turns (private)GPU tests' turns on the one GPU they share.143 lines
fixtures (private)Fixtures: hand-built standard values covering every shape the types allow and every attribute type on every domain.483 lines
formatA format's test support: a folder of a test's own (Scratch), and a write read back as Import reads it (round_trip).83 lines
hostile (private)read_hostile: a format reading a hostile file as File ▸ Import reads one, for a format's tests of the files that once broke it.68 lines
refusals (private)assert_refused: a package's admission refused, saying why.24 lines
workersThe process's workers as a host installs them, for a test or a measurement of a package's parallel work: the calling thread and scoped helpers taking runs of items from a shared counter (install).69 lines

Public types and traits

At the crate root

Traits ConsumerProducer

Structs CodecsFixturesInvariantsOutcomeReportUnconverted

By module: 7 public types and traits in 6 modules

checks CodecsInvariants

colors Unconverted

engine Waiter

engine::conformance Make

fixtures Fixtures

format Scratch

Besides these, 5 public functions at module level.