The pairs were counted as the parts

# Self-authored for the EML case corpus (no external origin). An integration plan
# declares all ten services tested for compatibility, and every one of the ten
# tests it lists really ran and passed. What compatibility is a property of is
# computed below.
#
# The plan is careful. It lists the real services, not a stale inventory; every
# listed test was executed by the engine, not ticked by hand; every service
# appears in at least one test; and the intent is exactly 'the services are
# compatible with each other'.
#
# Compatibility is a property of pairs, and ten services form forty-five pairs;
# the plan counted the parts and tested ten.

10 => services
10 => pairs_tested

services - 1 => services_minus_one
int(services * services_minus_one / 2) => pairs_that_exist
pairs_that_exist - pairs_tested => pairs_never_tested
int(pairs_tested * 10000 / pairs_that_exist) => pair_coverage_per_myriad

"services                        : " + str(services) ^0
"tests in the plan               : " + str(pairs_tested) ^0
"services covered by a test      : " + str(services) + " of " + str(services) ^0
"" ^0
"pairs of services that exist    : " + str(pairs_that_exist) ^0
"pairs actually tested           : " + str(pairs_tested) ^0
"pairs never tested together     : " + str(pairs_never_tested) ^0
"pair coverage                   : " + str(pair_coverage_per_myriad) + " per ten thousand" ^0
"" ^0

# ---- what the plan verified ----

"the compatibility plan" ^0
"  lists : the real services, not a stale inventory" ^0
"  executes : every listed test, by the engine" ^0
"  covers : every service in at least one test" ^0
"  intent : the services are compatible with each other" ^0
"  services with no test : 0" ^0
"  verdict : ALL TEN SERVICES TESTED" ^0
"" ^0
"  running every listed test for real over every service is" ^0
"  the part done right here, and it is why each of the ten" ^0
"  tested combinations is known to work" ^0
"" ^0

# ---- what compatibility is a property of ----

"pairs, not parts" ^0
"  what 'A is compatible with B' is about : the pair A, B" ^0
"  how many pairs ten services form : ten times nine over" ^0
"    two, " + str(pairs_that_exist) ^0
"  how many the plan tested : " + str(pairs_tested) + ", one per service" ^0
"  so the untested pairs : " + str(pairs_never_tested) ^0
"  where the incompatibility was : between two services that" ^0
"    were each tested, and never together" ^0
"" ^0

# ---- what the caller got ----

"the sign-off" ^0
"  claim : all ten services compatible" ^0
"  pairs the claim covers : " + str(pairs_tested) + " of " + str(pairs_that_exist) ^0
"  is any listed test wrong : no; all ten passed" ^0
"  is 'every service tested' the same as 'every pair" ^0
"    tested' : no; it is " + str(pair_coverage_per_myriad) + " per ten thousand of it" ^0
"" ^0

# ---- null control ----

# The same plan, enumerating the pairs instead of the services, so the count of
# tests is the count of pairs.
10 => nc_tests_when_counting_services
45 => nc_tests_when_counting_pairs
35 => nc_pairs_the_enumeration_adds

"null control - enumerate the pairs" ^0
"  tests, counting services : " + str(nc_tests_when_counting_services) ^0
"  tests, counting pairs : " + str(nc_tests_when_counting_pairs) ^0
"  pairs the enumeration adds : " + str(nc_pairs_the_enumeration_adds) ^0
"  no service and no test changed; the unit of the claim" ^0
"  stopped being a service and started being a pair" ^0
"" ^0

# ---- the rule ----

"what a one-test-per-service plan guarantees" ^0
"  every service works in at least one tested combination :" ^0
"    exactly, ten real tests over ten real services" ^0
"  every service works with every other : not addressed;" ^0
"    compatibility is pairwise and ten services have " + str(pairs_that_exist) ^0
"    pairs, of which " + str(pairs_never_tested) + " were never exercised" ^0
"" ^0

"a property of pairs grows with the square of the parts; counting the parts and" ^0
"calling them covered tests a straight line through a triangle, and the" ^0
"incompatibility lives in the triangle" ^0
"" ^0

"It runs every listed test for real over every service - all ten pass. But" ^0
"compatibility is a property of pairs, and ten services form " + str(pairs_that_exist) + " of them; the" ^0
"plan tested " + str(pairs_tested) + ", " + str(pair_coverage_per_myriad) + " per ten thousand of the pairs, and the failing pair" ^0
"was one of the " + str(pairs_never_tested) + " it never ran together." ^0

services = 10
pairs_tested = 10
services_minus_one = services - 1
pairs_that_exist = int(services * services_minus_one / 2)
pairs_never_tested = pairs_that_exist - pairs_tested
pair_coverage_per_myriad = int(pairs_tested * 10000 / pairs_that_exist)
print("services                        : " + str(services))
print("tests in the plan               : " + str(pairs_tested))
print("services covered by a test      : " + str(services) + " of " + str(services))
print("")
print("pairs of services that exist    : " + str(pairs_that_exist))
print("pairs actually tested           : " + str(pairs_tested))
print("pairs never tested together     : " + str(pairs_never_tested))
print("pair coverage                   : " + str(pair_coverage_per_myriad) + " per ten thousand")
print("")
print("the compatibility plan")
print("  lists : the real services, not a stale inventory")
print("  executes : every listed test, by the engine")
print("  covers : every service in at least one test")
print("  intent : the services are compatible with each other")
print("  services with no test : 0")
print("  verdict : ALL TEN SERVICES TESTED")
print("")
print("  running every listed test for real over every service is")
print("  the part done right here, and it is why each of the ten")
print("  tested combinations is known to work")
print("")
print("pairs, not parts")
print("  what 'A is compatible with B' is about : the pair A, B")
print("  how many pairs ten services form : ten times nine over")
print("    two, " + str(pairs_that_exist))
print("  how many the plan tested : " + str(pairs_tested) + ", one per service")
print("  so the untested pairs : " + str(pairs_never_tested))
print("  where the incompatibility was : between two services that")
print("    were each tested, and never together")
print("")
print("the sign-off")
print("  claim : all ten services compatible")
print("  pairs the claim covers : " + str(pairs_tested) + " of " + str(pairs_that_exist))
print("  is any listed test wrong : no; all ten passed")
print("  is 'every service tested' the same as 'every pair")
print("    tested' : no; it is " + str(pair_coverage_per_myriad) + " per ten thousand of it")
print("")
nc_tests_when_counting_services = 10
nc_tests_when_counting_pairs = 45
nc_pairs_the_enumeration_adds = 35
print("null control - enumerate the pairs")
print("  tests, counting services : " + str(nc_tests_when_counting_services))
print("  tests, counting pairs : " + str(nc_tests_when_counting_pairs))
print("  pairs the enumeration adds : " + str(nc_pairs_the_enumeration_adds))
print("  no service and no test changed; the unit of the claim")
print("  stopped being a service and started being a pair")
print("")
print("what a one-test-per-service plan guarantees")
print("  every service works in at least one tested combination :")
print("    exactly, ten real tests over ten real services")
print("  every service works with every other : not addressed;")
print("    compatibility is pairwise and ten services have " + str(pairs_that_exist))
print("    pairs, of which " + str(pairs_never_tested) + " were never exercised")
print("")
print("a property of pairs grows with the square of the parts; counting the parts and")
print("calling them covered tests a straight line through a triangle, and the")
print("incompatibility lives in the triangle")
print("")
print("It runs every listed test for real over every service - all ten pass. But")
print("compatibility is a property of pairs, and ten services form " + str(pairs_that_exist) + " of them; the")
print("plan tested " + str(pairs_tested) + ", " + str(pair_coverage_per_myriad) + " per ten thousand of the pairs, and the failing pair")
print("was one of the " + str(pairs_never_tested) + " it never ran together.")

services                        : 10
tests in the plan               : 10
services covered by a test      : 10 of 10

pairs of services that exist    : 45
pairs actually tested           : 10
pairs never tested together     : 35
pair coverage                   : 2222 per ten thousand

the compatibility plan
  lists : the real services, not a stale inventory
  executes : every listed test, by the engine
  covers : every service in at least one test
  intent : the services are compatible with each other
  services with no test : 0
  verdict : ALL TEN SERVICES TESTED

  running every listed test for real over every service is
  the part done right here, and it is why each of the ten
  tested combinations is known to work

pairs, not parts
  what 'A is compatible with B' is about : the pair A, B
  how many pairs ten services form : ten times nine over
    two, 45
  how many the plan tested : 10, one per service
  so the untested pairs : 35
  where the incompatibility was : between two services that
    were each tested, and never together

the sign-off
  claim : all ten services compatible
  pairs the claim covers : 10 of 45
  is any listed test wrong : no; all ten passed
  is 'every service tested' the same as 'every pair
    tested' : no; it is 2222 per ten thousand of it

null control - enumerate the pairs
  tests, counting services : 10
  tests, counting pairs : 45
  pairs the enumeration adds : 35
  no service and no test changed; the unit of the claim
  stopped being a service and started being a pair

what a one-test-per-service plan guarantees
  every service works in at least one tested combination :
    exactly, ten real tests over ten real services
  every service works with every other : not addressed;
    compatibility is pairwise and ten services have 45
    pairs, of which 35 were never exercised

a property of pairs grows with the square of the parts; counting the parts and
calling them covered tests a straight line through a triangle, and the
incompatibility lives in the triangle

It runs every listed test for real over every service - all ten pass. But
compatibility is a property of pairs, and ten services form 45 of them; the
plan tested 10, 2222 per ten thousand of the pairs, and the failing pair
was one of the 35 it never ran together.

Trace event types