Files
alexm 568474d52f
Test (in pplus-core) / in-core (push) Failing after 28m44s
Initial commit
2026-11-12 22:23:48 -05:00

215 lines
21 KiB
Markdown
Generated

# Corpus status against `mojo_1_2_0` (Mojo 1.2.0)
Generated by `python3 scripts/mojo/corpus.py status` from the goldens in this directory. Do not edit.
| corpus | pass | fail | observed | skipped | unverified |
|---|---|---|---|---|---|
| diagnostics | 0 | 0 | 0 | 44 | 141 |
| local | 18 | 0 | 0 | 0 | 0 |
| manual | 150 | 55 | 0 | 1 | 0 |
| probes | 37 | 0 | 102 | 0 | 0 |
| quest | 176 | 0 | 0 | 0 | 0 |
| stress | 40 | 0 | 0 | 0 | 0 |
## Failures
- `manual/code/manual/basics/python_integration`: exited abnormally (exit code 132)
- `manual/code/manual/control-flow/for_loop`: exited abnormally (exit code 132)
- `manual/code/manual/errors/conditional_context_mgr`: exited abnormally (exit code 1)
- `manual/code/manual/errors/stacktrace_error`: exited abnormally (exit code 1)
- `manual/code/manual/errors/test_conditional_context_mgr`: did not compile
- `manual/code/manual/errors/test_context_mgr`: did not compile
- `manual/code/manual/errors/test_enumerated_errors`: did not compile
- `manual/code/manual/errors/test_error_interaction`: did not compile
- `manual/code/manual/errors/test_handle_error`: did not compile
- `manual/code/manual/errors/test_never_type`: did not compile
- `manual/code/manual/errors/test_parametric_raises`: did not compile
- `manual/code/manual/errors/test_typed_errors_doc`: did not compile
- `manual/code/manual/errors/test_typed_errors_edge_cases`: did not compile
- `manual/code/manual/errors/test_typed_errors_testing`: did not compile
- `manual/code/manual/errors/test_variant_errors`: did not compile
- `manual/code/manual/lifecycle/explicit-destroy/tests`: exited abnormally (exit code 1)
- `manual/code/manual/pointers/using-pointers/python_pointer`: exited abnormally (exit code 132)
- `manual/code/manual/python/types/mojo_types`: exited abnormally (exit code 132)
- `manual/code/manual/python/types/python_compare`: exited abnormally (exit code 132)
- `manual/code/manual/python/types/python_conversions`: exited abnormally (exit code 132)
- `manual/code/manual/python/types/python_dict`: exited abnormally (exit code 132)
- `manual/code/manual/python/types/python_list`: exited abnormally (exit code 132)
- `manual/code/manual/python/types/python_tuple`: exited abnormally (exit code 132)
- `manual/code/manual/quickstart/quickstart`: exited abnormally (exit code 132)
- `manual/code/reference/simple-statements/tests`: did not compile
- `manual/code/tools/notebooks/gpu_hello`: did not compile
- `manual/code/tools/notebooks/hello_writing`: did not compile
- `manual/code/tools/notebooks/vector_addition`: did not compile
- `manual/snippet/manual-control-flow-28`: exited abnormally (exit code 132)
- `manual/snippet/manual-control-flow-29`: exited abnormally (exit code 132)
- `manual/snippet/manual-control-flow-30`: exited abnormally (exit code 132)
- `manual/snippet/manual-errors-1`: did not compile
- `manual/snippet/manual-errors-5`: did not compile
- `manual/snippet/manual-errors-6`: did not compile
- `manual/snippet/manual-errors-7`: did not compile
- `manual/snippet/manual-errors-8`: did not compile
- `manual/snippet/manual-parameters-index-1`: did not compile
- `manual/snippet/manual-parameters-index-2`: did not compile
- `manual/snippet/manual-parameters-index-4`: did not compile
- `manual/snippet/manual-parameters-index-7`: did not compile
- `manual/snippet/manual-pointers-using-pointers-4`: did not compile
- `manual/snippet/manual-python-types-1`: exited abnormally (exit code 132)
- `manual/snippet/manual-python-types-2`: exited abnormally (exit code 132)
- `manual/snippet/manual-python-types-3`: exited abnormally (exit code 132)
- `manual/snippet/manual-python-types-4`: exited abnormally (exit code 132)
- `manual/snippet/manual-python-types-5`: exited abnormally (exit code 132)
- `manual/snippet/manual-python-types-6`: did not compile
- `manual/snippet/manual-types-7`: did not compile
- `manual/snippet/manual-values-lifetimes-2`: did not compile
- `manual/snippet/manual-values-lifetimes-3`: did not compile
- `manual/snippet/manual-values-ownership-1`: did not compile
- `manual/snippet/manual-values-ownership-2`: did not compile
- `manual/snippet/manual-values-ownership-3`: did not compile
- `manual/snippet/manual-values-ownership-4`: did not compile
- `manual/snippet/manual-values-ownership-5`: did not compile
## Probes
| probe | question | verdict |
|---|---|---|
| `all-generator` | can all() take a generator expression, as in Python? (no: Mojo 1.2.0 has no generator expressions) | pass |
| `atof-hex` | does atof() read hexadecimal text such as "0x10"? (no: it raises) | observed |
| `check-aliasing` | the compiler's words for passing one value as mut and as a second argument | pass |
| `check-implicit-copy` | the compiler's words for copying a type that is not ImplicitlyCopyable | pass |
| `check-implicit-declaration` | 1.1.0 notes: assigning an undeclared name is an error | pass |
| `check-missing-raises` | calling a raising function from a non-raising one | pass |
| `check-uninitialized` | the compiler's words for reading a variable before it is set | pass |
| `check-use-after-move-on-one-path` | moved out on one path, read after the branch: the compiler's words | pass |
| `check-use-after-move` | the compiler's words for using a value after ^ moved it | pass |
| `comptime-if-for` | comptime for and comptime if in a function body | observed |
| `dialect-del` | 1.0.0 notes said __del__ still works, deprecated; does it in 1.1.0? | observed |
| `dialect-fn` | 1.1.0 notes: fn is removed | pass |
| `dialect-read` | 1.1.0 notes: the read convention is a hard error | pass |
| `dialect-register-passable` | deprecated in 0.26.2: is @register_passable("trivial") an error or a warning in 1.1.0? | observed |
| `dialect-value` | is the @value decorator still accepted? | observed |
| `dict-missing-key` | what does reading a missing Dict key raise, and how is it printed? | observed |
| `dict-order` | does a Dict iterate in insertion order, and after a pop and re-insert? | observed |
| `error-assert-statement` | is there an assert statement, and what does a failing one do? | observed |
| `error-debug-assert` | is debug_assert checked by default on godbolt's build? | observed |
| `error-exit-code` | does std.sys.exit set the exit code after output? | observed |
| `error-try-finally` | the order of try, except and finally | observed |
| `error-unhandled` | what reaches stdout, stderr, and the exit code when main raises? | observed |
| `float-compare-literal-left` | can a whole-number literal stand left of a Float64 in a comparison? (no: 90 <= x has no overload; x >= 90 does) | pass |
| `float-contract-runtime-off` | with contraction off (--fp-mode contract=off, as the pin builds), is x * x - x rounded twice, as IEEE arithmetic one operation at a time, both when x arrives at run time and when it is a literal? (float-contract-runtime is the same program with contraction on, where the run-time line comes out -0.22222222222222224) | pass |
| `float-contract-runtime` | with contraction on (--fp-mode contract=fast, Mojo's default; the pin builds with it off), is x * x - x rounded the same when x is known at build time and when it arrives at run time? (no: from stdin the built program fuses it into one rounding, -0.22222222222222224; from a literal the compiler works it out while building, rounded twice, -0.2222222222222222; float-contract-runtime-off is the same program with contraction off) | pass |
| `float-contract` | with contraction on (--fp-mode contract=fast, Mojo's default; the pin builds with it off), does the compiler fuse a * b - c into one rounding when the operands are literals? (fused, 0.1 * 10.0 - 1.0 is 5.551115123125783e-17; rounded twice it is 0.0) | observed |
| `float-cosh-accuracy` | how accurate are cosh, sinh and exp of a Float64 far from zero? (true values: cosh(100) = sinh(100) = 1.3440585709080678e43, exp(100) = 2.6881171418161356e43, cosh(1) = 1.5430806348152437) | observed |
| `float-literal-mixing` | which mixes of a Float64 with a whole-number literal does the compiler accept, and what do they print? | observed |
| `float-log2-accuracy` | how accurate are log2, log10 and log on a Float64? (true values: 0.5 3.321928094887362 0.3010299956639812 0.6931471805599453) | observed |
| `float-mixed` | can an Int and a Float64 be combined without a conversion? | observed |
| `float-overflow` | does a Float64 product past the largest double give inf at run time, and inf - inf nan? | observed |
| `float-place-int-literal` | a whole-number literal assigned to a Float64 variable, field, List element or Dict entry or key, or handed to a Float64 field by @fieldwise_init: is it a Float64? | observed |
| `float-pow-accuracy` | how accurate are ** with a fractional exponent, exp and sqrt on a Float64? (true values: 1.4142135623730951 2.718281828459045 0.36787944117144233 1.4142135623730951) | observed |
| `float-pow-huge` | what does a Float64 raised to a very large whole exponent do? (1.0000001 ** 1e7 is fine; ** 1e10 stops the program, and so does 0.5 ** 4503599627370497.0) | observed |
| `float-pow-whole` | how is a Float64 raised to a whole power computed? (by squaring: 1.1 ** 20 is 6.727499949325609, not the correctly rounded 6.727499949325611) | observed |
| `float-print` | how does print format Float64 values? | observed |
| `float-round-sign` | does round() keep the sign when the result is zero? (yes: round(-0.3) is -0.0) | observed |
| `float-round` | what does round() do on halves? | observed |
| `float-scale-exact` | does Float64(atol(m)) doubled or halved e times give m * 2^e exactly? (yes, for m below 2^53: 0.1, 2^1000, a subnormal, -0.0, an overflow to inf, 1e-16, the double below 1) | pass |
| `float-special` | how are inf, -inf and nan printed after a run-time division by zero? | observed |
| `float-to-int` | does Int(x) truncate toward zero? | observed |
| `float32-literal-left` | can a float literal stand left of a Float32 in a comparison? (no: 0.1 == x has no overload; left of a Float64 it does) | pass |
| `float32-literal` | what type does a float literal take beside a Float32? (the Float32: x == 0.1 is True for a Float32 x holding 0.1) | observed |
| `float32-print` | how does print format Float32 values? | observed |
| `global-var` | can a program have a variable at file scope? (no: "global variables are not supported") | pass |
| `godbolt-asm-and-run` | does one request return both the listing and the program's output? | observed |
| `godbolt-asm` | the listing for a small function: labels, and source line numbers on instructions | observed |
| `godbolt-compile-button` | the Compile button's request: -O0, line tables, listing and output in one answer | pass |
| `godbolt-line-tables-O0` | with -O0 and line tables, are source lines attached, and is the function list unchanged? | observed |
| `godbolt-line-tables` | with --debug-level=line-tables, does godbolt attach source lines to instructions (optimized build)? | observed |
| `godbolt-opt-O0` | is -O0 accepted, and how does the listing change? | observed |
| `godbolt-stdin` | does the Compile button's request (compile and run in one) deliver stdin? (yes, and so does run mode: see input-lines for why two input() calls fail there) | pass |
| `godbolt-target-cpu` | built with --target-cpu x86-64-v3, does the listing of String's ==, which the standard library compares with SIMD, use 256-bit AVX2 (ymm) and never AVX-512 (zmm), whichever of godbolt's machines answers? (without a target CPU, mojo build targets the machine it runs on, and on 2026-11-12 one of godbolt's answered library/mojo/local/demo.mojo with zmm) | pass |
| `input-eof` | what does input() do at the end of input? | observed |
| `input-lines` | does input() read one line per call? (on a terminal, yes; on piped input the first call takes every line and the second raises EOF, which is what godbolt shows) | observed |
| `input-parse-error` | what does atol raise on text that is not a number? | observed |
| `input-pipe-first-line` | on piped input, what does one input() return? (the first line, without its line break and with its spaces; the rest of the pipe is read and dropped, so a second input() raises EOF: see input-lines) | pass |
| `int-convert-narrow` | what does a conversion to a narrower whole-number type keep? (the low bits: Int8(300) is 44, UInt8(-1) is 255) | pass |
| `int-div-zero` | what happens on integer division by zero at run time (output, exit code)? | observed |
| `int-floordiv` | does // floor toward negative infinity on Int? | observed |
| `int-literal-too-big` | is a literal too big for Int a compile error? | observed |
| `int-mod-zero` | what do % and // by zero do on Int and Int8 at run time? (0, and the program goes on; the notation stops) | pass |
| `int-mod` | what sign does % give with negative operands? | observed |
| `int-of-float-literal` | is Int(0.1) accepted? (no: a float literal is not made an Int at compile time; Int(x) of a Float64 value drops the fraction) | pass |
| `int-overflow-int` | what is Int.MAX, and what is Int.MAX + 1 at run time? | observed |
| `int-overflow-int8` | does Int8 wrap on overflow at run time? | observed |
| `int-pow-shift` | what do ** and shifts give on Int at run time? | observed |
| `int-truediv` | what does / do on two Int values, positive and negative? | observed |
| `int-uint-wrap` | does UInt8 wrap below zero? | observed |
| `lib-parallelize` | is parallelize importable from std.algorithm in 1.1.0? | observed |
| `lib-vectorize` | is vectorize importable from std.algorithm in 1.1.0? | observed |
| `life-asap-expression` | the manual's ASAP example: which values are destroyed, in what order, inside one expression? | observed |
| `life-borrow-lifetime` | Stage 4 prediction: an unread value dies after its declaration; a value borrowed by print lives until print returns | pass |
| `life-branch-both-sides` | used in both branches: does it die right after its last use in each? | observed |
| `life-branch-declared-inside` | declared inside a branch and used there: does it die within the branch? | observed |
| `life-branch-one-side` | used in the then branch only: in the else branch, where does it die (before the else body, after it, or after the if)? | observed |
| `life-copy-move` | which lifecycle methods run for .copy(), ^, and the end of main? | observed |
| `life-early-return` | an early return: is the value destroyed before the return on that path? | observed |
| `life-field-order` | in what order are a struct's fields destroyed? | observed |
| `life-last-use` | is a variable destroyed at its last use, before later statements run? | observed |
| `life-list-elements` | when a List of values is destroyed, in what order do its elements go? | observed |
| `life-loop-local` | declared inside a loop body: does each pass destroy its own value at its last use? | observed |
| `life-loop-outer-read-inside` | declared before a loop, read in every pass: does it die after the loop, or in the last pass? | observed |
| `life-loop-outer-unused-after` | read before a loop and never after: does it die before the loop starts? | observed |
| `life-move-into-var-arg` | Stage 4 prediction: x^ into a var argument runs no constructor; into a new variable the move constructor runs | pass |
| `life-moved-on-one-path` | moved out on one path only: on the other path, when does it die? | observed |
| `life-mut-arg` | a mut argument changes the caller's variable | observed |
| `life-reassign-in-loop` | reassigned in every pass and read after the loop: when does each old value die? | observed |
| `life-reassign` | when a variable is reassigned, when is the old value destroyed? | observed |
| `life-var-arg` | passing to a var argument: with ^, and with .copy() | observed |
| `list-index-oob` | what happens when a List is indexed past its end at run time? | observed |
| `list-literal-into-place` | a list in brackets assigned to a List variable, a struct field, a List element or a Dict entry: is it a List (append works), and do its items take the element type? | observed |
| `list-literal-typed` | where does a list in brackets become a List? (an annotated var, an argument, a returned value, an assignment, a Dict value) | pass |
| `list-negative-index` | is a run-time negative index allowed on a List? | observed |
| `list-ops` | append, sort, pop and len on a List | observed |
| `list-slice-copy` | List[T](l[lo:hi]) is a new List holding copies of the items, not a view of l: changes to either afterwards stay apart; empty, whole and open-ended slices | observed |
| `list-slice-end-oob` | what happens when a List is sliced past its end (List[Int](l[1:9]) on a List of three)? | observed |
| `list-slice-negative` | what happens when a List is sliced from a negative start (List[Int](l[-1:2]))? | observed |
| `list-slice-reversed` | what happens when a List is sliced with its start past its end (List[Int](l[2:1]))? | observed |
| `list-variadic-init` | is List[Int](1, 2, 3) a constructor? (no: only brackets make a list of values) | pass |
| `match-literal-capture-guard` | match on an Int and on a String: literal cases, alternatives with |, a capture with a guard, _ with a guard, a bare capture, no case matching, the first matching case winning, and a variable every case assigns | observed |
| `match-statement` | does Mojo 1.2.0 have a match statement? (yes) | pass |
| `math-copysign-nextafter-ulp` | copysign, nextafter and ulp from std.math on Float64, at zero, at the ends of the range and across signs | observed |
| `math-float-classify` | isinf, isnan and isfinite from std.math on Float64 values, infinities and NaN made at run time among them | observed |
| `math-fma-hypot` | fma and hypot from std.math on Float64: fma rounds once, and hypot does not overflow or underflow in between | observed |
| `math-gcd-lcm-comb` | gcd, lcm and comb from std.math on whole numbers, with negative and zero arguments, and a comb whose value does not fit in an Int | observed |
| `math-inf-nan` | inf[DType.float64]() and nan[DType.float64]() from std.math (and their Float32 forms): how they print, compare and classify | observed |
| `math-pi-literal` | std.math's pi: as a Float64, and in arithmetic and comparisons with literals (folded exactly at compile time?) and with Float64 values | observed |
| `min-of-list` | can min() take one List? (no: min and max compare their arguments; the smallest item of a list is a loop) | pass |
| `mut-uninitialized` | can a variable with no value yet be passed to a mut parameter? (no: "use of uninitialized value") | pass |
| `print-bool-optional` | how are Bool and Optional printed? | observed |
| `print-dict` | can a Dict be printed directly? | observed |
| `print-list` | can a List be printed, and how do its elements look? | observed |
| `print-sep-end` | do print's sep and end work as in Python? | observed |
| `print-tuple` | can a Tuple be printed directly? | observed |
| `range-forms` | range with a negative step, an empty range, and a reversed bound | observed |
| `set-comprehension` | does Mojo 1.2.0 have set comprehensions? (yes) | pass |
| `set-discard-dict-pop` | Set.discard of a member and of a missing one; Dict.pop with a default, on a present and a missing key, and without one on a missing key | observed |
| `set-order` | in what order does a Set of Int iterate? | observed |
| `simd-basics` | printing a SIMD value, elementwise *, and reduce_add | observed |
| `split-empty-fields` | what does split on a space give for two spaces in a row? (an empty piece between them, as Python's str.split(" ") does) | pass |
| `string-atof-decimal` | which decimal texts does atof read, and as which Float64? (signs, exponents, leading zeros, a bare point, many digits, the smallest subnormal, past the range) | observed |
| `string-atof-other` | the other texts atof reads or refuses: spaces around a number, underscores, a lone exponent, words, an empty text, inf and nan | observed |
| `string-build` | String(n), +, and t-string interpolation | observed |
| `string-codepoint-negative` | what happens when a String is indexed by codepoint= at a negative index? | observed |
| `string-codepoint-oob` | what happens when a String is indexed by codepoint= past its end? | observed |
| `string-compare` | how do String comparisons and chained comparisons behave? | observed |
| `string-index` | what do s[byte=i] and s[codepoint=i] return on a non-ASCII string? | observed |
| `string-iterate` | what does iterating codepoint_slices() yield? | observed |
| `string-length` | len(String) counts bytes; what do byte_length and count_codepoints give? | observed |
| `string-literal-replace` | does a string literal have replace()? (no: it is a StringLiteral; upper, lower, find and split it has) | pass |
| `string-ord-chr` | ord of a one-character String (ASCII and not), and chr of a code point | observed |
| `string-replace-escapes` | does replace() on a String replace every occurrence, so a chain of them undoes percent escapes? (yes: %2520 becomes %20, not a space) | pass |
| `string-slice` | does s[codepoint=a:b] slice by codepoint? | observed |
| `struct-field-loop-copy` | is a struct's List field safe to assign in a loop when nothing reads the struct afterwards? (no: the built program crashes on a later pass; with the last line uncommented it runs) | observed |
| `struct-writable` | a struct that implements write_to prints through print() | observed |
| `upper-sharp-s` | what does upper() make of "ß"? ("SS": the text gets longer) | pass |
| `var-block-scope` | is a var declared inside an if still there after it? (no: the name ends with the block) | pass |
| `var-maybe-unset` | can a variable be read after an if that gives it a value on one path only? (no, even when the path is taken at run time) | pass |