mcpp.toml

[package]
namespace   = "mcpplibs"
name        = "openkal-conformance"
version     = "0.8.0"
description = "The behavioural half of clause 9: a suite an implementation of openkal runs against itself, selectable to the interfaces it provides."
license     = "Apache-2.0"
authors     = ["mcpplibs"]
repo        = "https://github.com/mcpplibs/openkal"

# The specification, and nothing else.
#
# The suite does not import std. It is written to run against an implementation
# in either arrangement, including one in a program that carries no other
# runtime, and a suite that reached for a standard library would not link there
# --- and where it did link, it would be reporting on an implementation while
# resting on facilities that implementation may be the only supplier of.
#
# What it depends upon is therefore openkal and the language. The formatting in
# okc.report is the price of that, and it is sixty lines.
[dependencies]
openkal = "0.10.0"

# The implementation under examination is not named here.
#
# It is supplied by whoever runs the suite, as a second dependency, exactly as
# any consumer supplies one. An implementation's own continuous integration adds
# a path to itself; a reader examining a published implementation adds its
# version. Naming one here would make the suite an implementation's dependant
# rather than an implementation's instrument.

[targets.openkal-conformance]
kind = "bin"
main = "src/main.cpp"

# What is examined, selected the way openkal is provided.
#
# An interface is the unit of provision: an implementation provides one in whole
# or not at all, and one it does not provide is absent as a link-time
# definition. A suite that examined every interface unconditionally would
# therefore fail to link against a conforming implementation of five of them,
# and would report nothing at all rather than reporting five.
#
# So each interface is a feature. A section whose feature is not active is
# compiled with its body removed and reports itself as not examined, which keeps
# the count of what was skipped in the report rather than in the reader's head.
#
#     mcpp run                          the core set
#     mcpp run --features full          every interface
#     mcpp run --features fs,task       the core set, and these two
#
# The core set is the default because clause 3 says every implementation
# provides it. There is no arrangement that examines nothing.
[features]
default  = ["core"]

core     = []
env      = []
time     = []
random   = []
fs       = []
process  = ["fs"]     # a program is started relative to a directory
task     = []
exec     = []

# Every interface outside the core set is a feature, and there is no name that
# gathers a subset of them. Version 0.8 had one --- `hosted' --- and it named a
# class of environment, which is a thing a name cannot do: it was falsified
# inside this ecosystem within a release, by a C library hosted above an
# implementation providing none of the three interfaces it promised.
terminal = []
net      = []
datagram = []
space    = ["process"]   # a started context is waited for as a process
timeout  = []

# ⚠️ `hosted' AND `standard' WERE HERE AND ARE GONE, BECAUSE THE SPECIFICATION'S
# OWN NAME FOR THAT SET IS GONE.
#
# Version 0.8 named a set of interfaces after a class of environment, and a name
# that describes a class of environment is falsified by an environment nobody had
# in mind. This one was falsified inside its own ecosystem within a release: a C
# library is hosted above an implementation providing none of `openkal.fs',
# `openkal.process' or `openkal.task'.
#
# Nothing invoked them --- every workflow in this ecosystem passes `core' or
# `full,optional' --- so removing them costs nothing and removes a second
# spelling of a decision the specification has withdrawn.

# Deliberately not part of `full'. Clause 6.1 states that an implementation
# provides an interface in whole or not at all and that a missing one is not a
# deviation; a feature set named `full' that required every optional interface
# would make "optional" mean nothing, and the report would be a link failure
# rather than an observation that did not hold. The caller names this set for an
# implementation that provides these interfaces, and omits it for one that does
# not --- which is the same choice the implementation itself made.
# ⚠️ `random` IS HERE AND NOT AMONG THE INTERFACES `full` NAMES, AND THE NOTE
# ABOVE ALREADY SAID WHY.
#
# It was named there first, and the suite then failed to LINK against every
# backend that had not yet implemented it:
#
#     lld-link: error: undefined symbol: kal_random_fill
#
# — which is exactly the outcome the paragraph above warns about: a report that
# is a link failure rather than an observation that did not hold. Clause 6.1
# makes an absent interface not a deviation, so a set that demands it turns a
# permitted choice into a build error.
#
# `random` has the same shape as `exec`: every hosted platform provides it, a
# bare-metal one provides it only if its board has a source, and neither is a
# deviation. The caller names this set for an implementation that provides
# these interfaces and omits it for one that does not.
optional = ["exec", "random", "terminal", "net", "datagram", "space", "timeout"]

# The kinds of examination. Behaviour is always performed; the other three are
# selected, because each costs time that a reader running the suite to answer
# "does this implementation work" does not want to spend.
#
#   abi        the shapes the specification freezes, checked against the
#              implementation that was linked rather than against the headers
#              that were compiled
#   stability  the same operation many times, which is where a handle scheme
#              that leaks and an allocator that fragments become visible
#   cost       reported, never asserted: a number that varies with the machine
#              cannot be a verdict, and a suite that made it one would fail on a
#              loaded runner
abi       = []
stability = []
# A cost is a duration, and a duration is openkal.time. The dependency is
# declared rather than assumed, so that requesting cost without time selects
# time instead of failing to link.
cost      = ["time"]
# ⚠️⚠️ THE INTERFACES ARE NAMED HERE AND NOT THROUGH ANOTHER SET, BECAUSE A SET
# DEFINED IN TERMS OF A SET CAN SHRINK WITHOUT ANYTHING SAYING SO.
#
# This was `["standard", …]`, and `standard` was a name the specification has
# withdrawn. Removing it left `full` meaning four kinds of examination and no
# interface at all --- measured 2026-08-29: the same command reported 168 held
# before and 119 held after, WITH AN EXIT STATUS OF ZERO BOTH TIMES, because
# every section it stopped examining reported itself as not observed rather than
# as failing. A set that names its members cannot do that.
full      = ["core", "env", "time", "fs", "process", "task",
             "abi", "stability", "cost"]