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

21 KiB
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 ListT 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 (ListInt on a List of three)? observed
list-slice-negative what happens when a List is sliced from a negative start (ListInt)? observed
list-slice-reversed what happens when a List is sliced with its start past its end (ListInt)? 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
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 infDType.float64 and nanDType.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