Eve Feature Tests
The feature tests of Eve (the conformity tests), by level. Every test is a script (or a project folder) with its expected output in a comment block at the end: a driver passes when the machine prints exactly that and ends with the expected exit code. Each row shows what the test checks, taken from the first comment line of the file, and a link to the file in the code viewer. The tests are the specification that an implementation must pass:
python script/runtest.py all runs them, and Smoke and Performance have their own pages.Level 1: Scripts
The language of a single script. Version 0.1, 65 tests. The folder on GitHub.
| Code | Test | What it checks | Source |
|---|---|---|---|
| a01 | a01_driver | Test driver structure and single line comments | a01_driver.eve |
| a02 | a02_comments | Every comment form of the language, then a negative end | a02_comments.eve |
| a03 | a03_print | print writes a string and a new line; no import is needed | a03_print.eve |
| a04 | a04_free_script | a free script: sequential statements, no driver and no process | a04_free_script.eve |
| a05 | a05_print_write | print adds a new line and separates its arguments with sep, write adds nothing; a list is one argument (Q-019b) | a05_print_write.eve |
| a06 | a06_new_set_let | new creates variables, set creates constants, let changes a value (D-076, D-079) | a06_new_set_let.eve |
| a07 | a07_arithmetic | numeric operators and their precedence (D-019) | a07_arithmetic.eve |
| a08 | a08_logic | relation and logical operators, conditional statement and expression | a08_logic.eve |
| a09 | a09_literals | literals of the primitive types (D-032, D-080) | a09_literals.eve |
| a10 | a10_strings | strings are immutable UTF-8 text (D-058, D-080) | a10_strings.eve |
| a11 | a11_interpolation | placeholders {name} and {name % format}: a name, a literal or a simple expression, written by its type; \{ \} are literal braces; {U+H} Unicode (D-096, D-102, formats are a draft) | a11_interpolation.eve |
| a12 | a12_if | if, else if, else and the conditional statement (D-016) | a12_if.eve |
| a13 | a13_while | while loop with a header, break, else and then (D-030, D-033, D-034) | a13_while.eve |
| a14 | a14_for | for loop over ranges and collections (D-022) | a14_for.eve |
| a15 | a15_match | match with values, lists of values, ranges, other, then, one and all (D-016, D-030) | a15_match.eve |
| a16 | a16_ordinal | an Ordinal is a set of named integer values; the first value is 1 unless one is given (Q-029, D-096) | a16_ordinal.eve |
| a17 | a17_list | list: literal, index, append, remove, capture, delete, builder, deconstruct (D-058 to D-060, D-077, D-079, D-096) | a17_list.eve |
| a18 | a18_array | array: literal, index, slice, view and clone, bulk assignment, builder (D-021, D-022, D-049, D-079) | a18_array.eve |
| a19 | a19_matrix | matrix: two indexes, last index, absolute index, [*] selects a dimension (D-058, D-064, D-079) | a19_matrix.eve |
| a20 | a20_dataset | DataSet: sorted unique values, union, intersection, difference (D-058) | a20_dataset.eve |
| a21 | a21_datamap | DataMap: a sorted map of key:value pairs; quoted or numeric keys (D-058, D-080) | a21_datamap.eve |
| a22 | a22_object | Object: unquoted keys make an object, quoted or numeric keys make a DataMap (D-058, D-080) | a22_object.eve |
| a23 | a23_clone_view | := shares a collection or an object, :: makes a deep copy, native values are always copied (D-049) | a23_clone_view.eve |
| a27 | a27_text_literal | a text literal is raw and keeps the line breaks; the indentation of the closing quotes is removed (Q-014) | a27_text_literal.eve |
| a28 | a28_regex | regular expressions: =~ matches, not (...) negates; a string that starts with / is a regex literal and keeps its backslashes (D-079, D-097) | a28_regex.eve |
| a29 | a29_expect_fail | a failed expect ends the process with exit code 2 (D-010) | a29_expect_fail.eve |
| a30 | a30_over | over ends the process it is in with exit code 0 | a30_over.eve |
| a31 | a31_recover | an error jumps to recover; reaching the end of recover handles the error (D-020) | a31_recover.eve |
| a32 | a32_finalize | finalize runs after the process ends normally, and after recover (D-020) | a32_finalize.eve |
| a33 | a33_over_finalize | over skips recover but runs finalize: a clean exit never skips cleanup (D-081) | a33_over_finalize.eve |
| a34 | a34_jobs | jobs: retry runs a failed job again, resume goes on after it (D-020, D-034) | a34_jobs.eve |
| a35 | a35_index_error | index 0 is an error: indexes start at 1 (D-021) | a35_index_error.eve |
| a36 | a36_map_key_error | += on a missing key of a map raises an error (D-058) | a36_map_key_error.eve |
| a37 | a37_division_error | a division by zero raises an error, also for Real: no infinity, no NaN (Q-019a) | a37_division_error.eve |
| a38 | a38_matrix_index | matrix and tensor indexes: [x, y] is the same as [x][y]; a range selects a part (D-064) | a38_matrix_index.eve |
| a39 | a39_repeat | loop tested at the end: loop … do … repeat [while c]; and skip (D-074) | a39_repeat.eve |
| a43 | a43_let_creates_name | let changes names and creates the ones that are missing, by type inference (Q-017, D-096) | a43_let_creates_name.eve |
| a44 | a44_bare_assignment | a change without let is a syntax error (D-076) | a44_bare_assignment.eve |
| a45 | a45_redeclare | redeclaring a name in the same scope is an error (D-076) | a45_redeclare.eve |
| a46 | a46_light_assignment | = is the light assignment of a declaration; it never changes a variable (D-079) | a46_light_assignment.eve |
| a47 | a47_string_plus_number | + between a string and a number is a type error; <+ converts the number (D-080) | a47_string_plus_number.eve |
| a48 | a48_single_quote_text | a rune holds one code point; 'one' is a lexical error (D-063) | a48_single_quote_text.eve |
| a49 | a49_stop_in_job | stop ends a job without error; the process goes on with the next statement (D-020) | a49_stop_in_job.eve |
| a50 | a50_exit | exit ends the process without error and runs finalize (D-020) | a50_exit.eve |
| a51 | a51_unhandled_error | an error without recover ends the process with the exit code 4, after finalize (D-081) | a51_unhandled_error.eve |
| a52 | a52_assert | a failed assert is an error with code 3: the process stops when it is not recovered (Q-031h, D-096) | a52_assert.eve |
| a53 | a53_abort | abort in recover ends the process, runs finalize and passes the error on (D-020) | a53_abort.eve |
| a54 | a54_panic | panic ends the whole application at once with code 1, without finalize (D-038) | a54_panic.eve |
| a57 | a57_conversion | explicit conversions do what the developer asked: floor, ceiling, round, parse (D-080; from demo/explicit_coercion.eve and demo/string_to_number.eve, D-099) | a57_conversion.eve |
| a58 | a58_rune_range | a range of runes: ('a'..'c') visits the code points in order (from demo/symbol_range.eve, D-099) | a58_rune_range.eve |
| a59 | a59_optional_null | a variable without a value has the zero value of its type, never null; an optional type T? may hold null (D-080; from demo/null_strings.eve, D-099) | a59_optional_null.eve |
| a60 | a60_process_args | the process receives the command-line arguments; a vararg collects them (D-029, D-040; from demo/method_call.eve and demo/test_args.eve, D-099) | a60_process_args.eve |
| a62 | a62_multi_line | a statement ends with ; so an expression or a literal may span several lines (from demo/multi_line.eve, D-099) | a62_multi_line.eve |
| a63 | a63_range_domain | a range is a domain of values: limits included or excluded, open ends, a step that sets the precision (D-022; from demo/domain_demo.eve and demo/numeric_range.eve, D-099) | a63_range_domain.eve |
| a66 | a66_bad_placeholder | in a string every unescaped brace opens a placeholder {name}; a literal brace is \{ or \} (D-102) | a66_bad_placeholder.eve |
| a68 | a68_undefined_name | an undefined name is a compile error: the script does not start (D-110) | a68_undefined_name.eve |
| a75 | a75_raise_code | raise "text" creates an error with code 4 and that message (D-054, D-109) | a75_raise_code.eve |
| a76 | a76_overflow | integer overflow is an error with its own code, 13 (D-109) | a76_overflow.eve |
| a77 | a77_system_variable | a driver can set a system variable and define its own $name (D-109) | a77_system_variable.eve |
| a78 | a78_digit_separator | the digit separator _ is not accepted in a number: a lexical error (Q-013, D-095) | a78_digit_separator.eve |
| a80 | a80_let_capture_loop | in a loop a capture creates its name once: the next turns assign it, they do not create it again (D-104) | a80_let_capture_loop.eve |
| a81 | a81_let_undeclared | let creates a missing name only in a capture: let y := 5 with no y is an error (D-104) | a81_let_undeclared.eve |
| a82 | a82_list_ends | list modifiers: <+ appends at the end, +> puts in front; the list stays after +> and before <+ (D-107) | a82_list_ends.eve |
| a83 | a83_bulk_scalar | collection op scalar: the operator applies to every element (D-118) | a83_bulk_scalar.eve |
| a84 | a84_bulk_string_error | a bulk operation never builds strings: a string element or scalar is an error (D-118) | a84_bulk_string_error.eve |
Level 2: Subprograms
A project: functions, procedures, lambdas and closures, and aspects. Version 0.1, 63 tests. The folder on GitHub.
| Code | Test | What it checks | Source |
|---|---|---|---|
| b01 | b01_apply_aspect | apply runs the main process of an aspect from asp/ and waits (D-066) | b01_apply_aspect.eve |
| b01 | b01_test1 (variation) | variation 1 of b01: the same aspect, called in a loop with a computed argument (D-133) | b01_test1.eve |
| b02 | b02_apply_output | an aspect gives results back through @ output parameters (D-048, D-066) | b02_apply_output.eve |
| b02 | b02_test1 (variation) | variation 1 of b02: results used as inputs, in a loop (D-133) | b02_test1.eve |
| b03 | b03_apply_state | each apply creates a new state of the aspect: a second call sees nothing of the first (D-066) | b03_apply_state.eve |
| b03 | b03_test1 (variation) | variation 1 of b03: three applies, three fresh states (D-133) | b03_test1.eve |
| b04 | b04_apply_named_args | apply with arguments by position, by name and with a default value (D-028, D-066) | b04_apply_named_args.eve |
| b04 | b04_test1 (variation) | variation 1 of b04: every argument by name, in another order (D-133) | b04_test1.eve |
| b05 | b05_apply_spread | spreading a list into positional arguments and a map into named arguments (D-072 i) | b05_apply_spread.eve |
| b05 | b05_test1 (variation) | variation 1 of b05: spread of a whole list and of a whole map (D-133) | b05_test1.eve |
| b06 | b06_aspect_error | an error not recovered in the aspect is raised in the driver at the apply line (D-072 d) | b06_aspect_error.eve |
| b06 | b06_test1 (variation) | variation 1 of b06: the error code of the aspect is the code of the raise (D-133) | b06_test1.eve |
| b07 | b07_aspect_over | over in an aspect ends the aspect; the driver goes on after apply (D-072 d) | b07_aspect_over.eve |
| b07 | b07_test1 (variation) | variation 1 of b07: over in the aspect twice: the driver goes on each time (D-133) | b07_test1.eve |
| b08 | b08_aspect_panic | panic in an aspect ends the whole application with exit code 1 (D-072 d) | b08_aspect_panic.eve |
| b08 | b08_test1 (variation) | variation 1 of b08: panic ends the application: the finalize of the driver does not run (D-133) | b08_test1.eve |
| b09 | b09_log_files | log_err and log_wrn write log files in the output folder out/ (D-057, D-114) | b09_log_files.eve |
| b10 | b10_aspect_function | a function declared in an aspect is used by its main (D-066, D-100) | b10_aspect_function.eve |
| b10 | b10_test1 (variation) | variation 1 of b10: the function of the aspect with its default and by name (D-133) | b10_test1.eve |
| b11 | b11_aspect_procedure | a procedure of an aspect changes an aspect-level variable; the driver's own variable is not touched (D-066, D-100) | b11_aspect_procedure.eve |
| b11 | b11_test1 (variation) | variation 1 of b11: the state of the aspect is new in every call (D-133) | b11_test1.eve |
| b12 | b12_aspect_fresh_state | main and the procedures of an aspect share its variables, and every apply starts them again (D-066) | b12_aspect_fresh_state.eve |
| b12 | b12_test1 (variation) | variation 1 of b12: the list of the aspect is new in every call, in a loop (D-133) | b12_test1.eve |
| b13 | b13_aspect_missing | apply of an aspect that has no file is an error before the run (D-112) | b13_aspect_missing.eve |
| b14 | b14_aspect_too_many_args | more positional arguments than parameters is a check-time error (D-112) | b14_aspect_too_many_args.eve |
| b14 | b14_test1 (variation) | variation 1 of b14: the right call: two arguments, then one (D-133) | b14_test1.eve |
| b15 | b15_aspect_apply_aspect | an aspect can't apply another aspect: compile error (D-066) | b15_aspect_apply_aspect.eve |
| b16 | b16_aspect_recover | an aspect recovers its own error: the driver never sees it (D-020, D-072) | b16_aspect_recover.eve |
| b16 | b16_test1 (variation) | variation 1 of b16: the aspect recovers its own error, twice (D-133) | b16_test1.eve |
| b17 | b17_aspect_trace | an error nobody recovers: the error first, then the frames in order of call (D-113) | b17_aspect_trace.eve |
| b18 | b18_lambda | a lambda is an anonymous function: held by a name, passed as an argument, held by a function type (D-109, D-147) | b18_lambda.eve |
| b19 | b19_closure | a closure keeps the state of the function that made it; every apply makes new closures (D-101, D-109) | b19_closure.eve |
| b20 | b20_aspect_unknown_param | an argument named like no parameter is a check-time error (D-112) | b20_aspect_unknown_param.eve |
| b20 | b20_test1 (variation) | variation 1 of b20: the right name of the optional parameter (D-133) | b20_test1.eve |
| b21 | b21_aspect_missing_arg | a missing mandatory argument is a check-time error (D-112) | b21_aspect_missing_arg.eve |
| b21 | b21_test1 (variation) | variation 1 of b21: the mandatory argument by name (D-133) | b21_test1.eve |
| b22 | b22_aspect_wrong_type | an argument of the wrong type is a check-time error (D-112) | b22_aspect_wrong_type.eve |
| b23 | b23_aspect_default_exclusive | an aspect without a kind word is exclusive (D-130) | b23_aspect_default_exclusive.eve |
| b24 | b24_aspect_second_process | an aspect has one process and it is named main (D-066) | b24_aspect_second_process.eve |
| b25 | b25_aspect_driver_variable | an aspect can't read a variable of the driver (D-072) | b25_aspect_driver_variable.eve |
| b26 | b26_aspect_finalize | finalize of an aspect runs when main ends, also by over; then the driver goes on (D-063, D-072) | b26_aspect_finalize.eve |
| b26 | b26_test1 (variation) | variation 1 of b26: finalize in a loop, by return and by over (D-133) | b26_test1.eve |
| b27 | b27_aspect_concurrent | a concurrent aspect can also be applied, one call after the other (D-090) | b27_aspect_concurrent.eve |
| b27 | b27_test1 (variation) | variation 1 of b27: a concurrent aspect applied with other texts (D-133) | b27_test1.eve |
| b28 | b28_aspect_folder | apply with a folder: the aspect is searched there first, then in asp/ and in the root (D-112) | b28_aspect_folder.eve |
| b28 | b28_test1 (variation) | variation 1 of b28: only the aspect of the default folder (D-133) | b28_test1.eve |
| b29 | b29_aspect_output_named | an @ output parameter that follows optional parameters is named at the call (D-106) | b29_aspect_output_named.eve |
| b29 | b29_test1 (variation) | variation 1 of b29: the default exponent, then both by name (D-133) | b29_test1.eve |
| b30 | b30_function | functions: result, named arguments, default values, several results (D-028, D-070, D-086, D-087) | b30_function.eve |
| b31 | b31_procedure | procedures: no result, side effects, @ passes by reference, no @ passes a copy (D-048, D-086, D-100) | b31_procedure.eve |
| b32 | b32_recursion | a function can call itself: Fibonacci (from demo/fibonacci.eve, D-099) | b32_recursion.eve |
| b33 | b33_function_without_result | a function must have a result: a subprogram without result is declared with procedure (D-100) | b33_function_without_result.eve |
| b34 | b34_procedure_bang | a procedure is made for side effects and is never deterministic: it never ends with ! (D-101) | b34_procedure_bang.eve |
| b35 | b35_exit_procedure | exit in a procedure leaves only the procedure; the process goes on (D-111) | b35_exit_procedure.eve |
| b36 | b36_over_procedure | over in a procedure ends the whole process, not only the procedure (D-111) | b36_over_procedure.eve |
| b37 | b37_param_order | a mandatory parameter may follow optional ones, and the call then names it (D-106) | b37_param_order.eve |
| b38 | b38_named_required | a parameter after optional parameters can't be positional: the call must name it (D-106) | b38_named_required.eve |
| b39 | b39_vararg_function | a vararg collects the rest of the arguments; an optional parameter after it is named (D-029) | b39_vararg_function.eve |
| b40 | b40_procedure_in_expression | a procedure has no value: it can't be used in an expression (D-100) | b40_procedure_in_expression.eve |
| b41 | b41_variant_params | a variant type holds one of the listed types and takes the type of the value assigned (from demo/variant_type.eve and demo/variant_params.eve, D-099) | b41_variant_params.eve |
| b42 | b42_defer_procedure | defer in a procedure runs when the procedure ends, by any path, in reverse order (D-081) | b42_defer_procedure.eve |
| b43 | b43_vararg_procedure | a vararg parameter collects the arguments of a procedure; * spreads a list into it (D-029, D-040) | b43_vararg_procedure.eve |
| b44 | b44_lambda_call | a lambda is not called where it is written: it gets a name, then the name is called (D-147) | b44_lambda_call.eve |
Level 3: Modules
Modules and imports, local libraries, then classes and methods. Version 0.2, 50 tests. The folder on GitHub.
| Code | Test | What it checks | Source |
|---|---|---|---|
| c01 | c01_import_module | Import a module with an unquoted path; members are reached as module.member (D-072) | c01_import_module.eve |
| c01 | c01_test1 (variation) | variation 1 of c01: the same module, another use case: only the constant, no call (D-133) | c01_test1.eve |
| c01 | c01_test2 (variation) | variation 2 of c01: the same module under an alias, called in a loop (D-133) | c01_test2.eve |
| c02 | c02_import_string_path | Import with a path written as a string (D-072) | c02_import_string_path.eve |
| c02 | c02_test1 (variation) | variation 1 of c02: a string path and the members without prefix (D-133) | c02_test1.eve |
| c03 | c03_import_alias | use (m as x): members are reached through the alias (D-072) | c03_import_alias.eve |
| c03 | c03_test1 (variation) | variation 1 of c03: the same module without a prefix (D-133) | c03_test1.eve |
| c04 | c04_import_members | use (m(*)): the exported members of m are used without prefix (D-072) | c04_import_members.eve |
| c04 | c04_test1 (variation) | variation 1 of c04: the same module with its name as prefix (D-133) | c04_test1.eve |
| c05 | c05_import_all | use (*): every module of the folder, names merged into the scope (D-072) | c05_import_all.eve |
| c05 | c05_test1 (variation) | variation 1 of c05: the two modules one by one, each with its prefix (D-133) | c05_test1.eve |
| c06 | c06_module_lifecycle | initialize runs at the import, finalize after the process of the driver (D-068) | c06_module_lifecycle.eve |
| c06 | c06_test1 (variation) | variation 1 of c06: a module that is imported and never called (D-133) | c06_test1.eve |
| c07 | c07_module_singleton | a module is loaded once: the driver and an aspect share the same copy (D-068) | c07_module_singleton.eve |
| c07 | c07_test1 (variation) | variation 1 of c07: the aspect applied twice shares the same module (D-133) | c07_test1.eve |
| c08 | c08_module_private | a member that a module does not export can't be used outside it (D-068, D-085, Q-022 b) | c08_module_private.eve |
| c08 | c08_test1 (variation) | variation 1 of c08: the exported members only (D-133) | c08_test1.eve |
| c09 | c09_extension_method | an extension method: a method with @self of a class, declared outside the class (D-072, D-085) | c09_extension_method.eve |
| c09 | c09_test1 (variation) | variation 1 of c09: another extension of the imported class (D-133) | c09_test1.eve |
| c10 | c10_class | class with a constructor, methods, visibility, reference and clone (D-076, D-084, D-085) | c10_class.eve |
| c11 | c11_extension_method_local | an extension method: declared outside the class, first parameter @self with the class type (D-086) | c11_extension_method_local.eve |
| c12 | c12_inheritance | a subclass builds its object through the constructor of its superclass (D-084) | c12_inheritance.eve |
| c13 | c13_visibility | a private member is seen only inside its class (D-085) | c13_visibility.eve |
| c14 | c14_attribute_outside | code outside a class can't add an attribute to an object (Q-019h, Q-031k, D-096) | c14_attribute_outside.eve |
| c15 | c15_procedure_in_class | a class hosts only methods: a procedure in a class body is a compile error (D-103, D-123) | c15_procedure_in_class.eve |
| c16 | c16_function_self | a function or a procedure can't be bound to a class with @self: only a method can (D-123) | c16_function_self.eve |
| c17 | c17_function_in_class | a class hosts only methods: a function in a class body is a compile error (D-123) | c17_function_in_class.eve |
| c18 | c18_module_conflict | use (m(*)) merges the names: two modules that export the same name are a compile error (D-112 a) | c18_module_conflict.eve |
| c18 | c18_test1 (variation) | variation 1 of c18: the right way: the two modules by name (D-133) | c18_test1.eve |
| c19 | c19_export_variable | a module has no public variables: exporting one is a compile error (D-068) | c19_export_variable.eve |
| c20 | c20_export_undeclared | export lists declared members only: an undeclared name is a compile error (proposed) | c20_export_undeclared.eve |
| c21 | c21_module_instance | a module is not a class: it has no instances (D-068) | c21_module_instance.eve |
| c22 | c22_module_init_order | dependencies are initialized first, and finalized last: the reverse order of the initialization (D-068) | c22_module_init_order.eve |
| c22 | c22_test1 (variation) | variation 1 of c22: only the module with no import (D-133) | c22_test1.eve |
| c22 | c22_test2 (variation) | variation 2 of c22: both modules, the dependent one first in the list (D-133) | c22_test2.eve |
| c23 | c23_module_free_statement | a module holds declarations and regions only: a free statement is a compile error (D-126) | c23_module_free_statement.eve |
| c24 | c24_import_free_script | a free script can't export anything and can't be imported (D-126) | c24_import_free_script.eve |
| c25 | c25_module_not_found | a module that is not found is the error $err_module (code 30), raised at the import, before the process starts (D-131) | c25_module_not_found.eve |
| c26 | c26_managed_module_variable | a managed module is rejected when it has a variable that is not atomic (D-129) | c26_managed_module_variable.eve |
| c27 | c27_managed_module_direct_call | a managed module that calls a direct module is rejected (D-129) | c27_managed_module_direct_call.eve |
| c28 | c28_managed_module | a managed module is accepted: no variable, no unsafe call (D-129) | c28_managed_module.eve |
| c28 | c28_test1 (variation) | variation 1 of c28: a managed module under an alias (D-133) | c28_test1.eve |
| c29 | c29_managed_module_atomic | a managed module is accepted when every variable is Atomic(:T) (D-129, D-132) | c29_managed_module_atomic.eve |
| c29 | c29_test1 (variation) | variation 1 of c29: the atomic counter, many times (D-133) | c29_test1.eve |
| c30 | c30_atomic_class | class Name <: Atomic(:T) declares an atomic type (D-132) | c30_atomic_class.eve |
| c30 | c30_test1 (variation) | variation 1 of c30: a type derived from Atomic, used ten times (D-133) | c30_test1.eve |
| c31 | c31_atomic_variable | Atomic(:T) is a library class: a variable is declared :Atomic(:Integer) and used like an Integer (D-132) | c31_atomic_variable.eve |
| c32 | c32_module_path_spelling | the same module reached by two spellings of the path is one module: loaded once, one state (D-068) | c32_module_path_spelling.eve |
| c33 | c33_managed_bare_call | a managed module can not call a direct module, also by a bare name from m(*) (D-129) | c33_managed_bare_call.eve |
| c33 | c33_test1 (variation) | variation 1 of c33: the bare name of a managed module is accepted (D-133) | c33_test1.eve |
Level 4: Parallel
Parallel processing and streams, generics and traits. Version 0.3, 42 tests. The folder on GitHub.
| Code | Test | What it checks | Source |
|---|---|---|---|
| d01 | d01_concurrent_direct_call | the compiler flags the call of a direct module from a concurrent aspect (D-129) | d01_concurrent_direct_call.eve |
| d02 | d02_concurrent_managed_call | a concurrent aspect calls a managed module (D-129) | d02_concurrent_managed_call.eve |
| d02 | d02_test1 (variation) | variation 1 of d02: the concurrent aspect with another input (D-133) | d02_test1.eve |
| d03 | d03_concurrent_bare_call | a concurrent aspect can not call an unsafe member, also by a bare name from m(*) (D-129) | d03_concurrent_bare_call.eve |
| d04 | d04_parallel_group | two parallel groups run one after the other; the output of a group is in the order of start (D-140) | d04_parallel_group.eve |
| d05 | d05_parallel_outputs | each started aspect writes its own element of an array; the results are ready after done (D-140) | d05_parallel_outputs.eve |
| d05 | d05_test1 (variation) | variation 1 of d05: start inside if, inputs by value, a declaration local to the group (D-140) | d05_test1.eve |
| d06 | d06_start_exclusive | start of an aspect without a kind word is a compile error: it is exclusive (D-130, D-140) | d06_start_exclusive.eve |
| d07 | d07_start_outside_group | start outside the do region of a parallel group is a compile error (D-140) | d07_start_outside_group.eve |
| d08 | d08_same_output | two starts of a group can not receive the same output variable (D-140, $err_output) | d08_same_output.eve |
| d08 | d08_test1 (variation) | variation 1 of d08: an output with a computed index is checked at start: $err_output 43 (D-140) | d08_test1.eve |
| d09 | d09_parallel_error | failed tasks do not stop the others; done raises ParallelError with the errors in the order of start (D-140) | d09_parallel_error.eve |
| d09 | d09_test1 (variation) | variation 1 of d09: nobody recovers the ParallelError: exit 4, one line per failed task (D-140) | d09_test1.eve |
| d09 | d09_test2 (variation) | variation 2 of d09: retry in recover runs the whole group again (D-066, D-140) | d09_test2.eve |
| d10 | d10_on_error_cancel | on error cancel stops the other tasks after the first failure; they are counted, not listed (D-140) | d10_on_error_cancel.eve |
| d11 | d11_within_timeout | within sets a deadline: a task still running gets a TimeoutError (D-140, D-144) | d11_within_timeout.eve |
| d12 | d12_channel_pipeline | a pipeline: one producer, four workers and a collector connected by two channels (D-141) | d12_channel_pipeline.eve |
| d13 | d13_channel_closed | send into a closed channel raises ChannelError, code 46 (D-141) | d13_channel_closed.eve |
| d14 | d14_deadlock | a consumer that waits on a channel nobody sends to is a deadlock; the error names it (D-141) | d14_deadlock.eve |
| d15 | d15_atomic_counter | eight tasks add to an Atomic(:Integer) of a managed module: the total is exact (D-132, D-140) | d15_atomic_counter.eve |
| d16 | d16_split_batch | split(k) and batch(n) cut a list; the parts are summed in parallel and combined by index (D-142) | d16_split_batch.eve |
| d17 | d17_job_spawn | spawn starts async procedures in a job, await waits for an async function; done waits for every task (D-143) | d17_job_spawn.eve |
| d18 | d18_spawn_function | spawn of an async function is a compile error: its result would be lost (D-143) | d18_spawn_function.eve |
| d19 | d19_async_plain_call | an async procedure called without spawn or await is a compile error (D-104 b) | d19_async_plain_call.eve |
| d20 | d20_trait | a class adopts a trait: it writes the required method and gets the provided one (D-145) | d20_trait.eve |
| d21 | d21_trait_missing_method | a class that does not write a required method of its trait is a compile error (D-145) | d21_trait_missing_method.eve |
| d22 | d22_abstract_class | an abstract class is built only by the constructor of a subclass that writes its required method (D-145) | d22_abstract_class.eve |
| d23 | d23_abstract_new | an abstract class can not be created outside the constructor of a subclass (D-145) | d23_abstract_new.eve |
| d24 | d24_generic_class | a generic class is made with its type argument written; a constraint asks for a trait (D-145) | d24_generic_class.eve |
| d25 | d25_nested_group | an aspect started by the driver opens a group of two leaf aspects; outputs keep the order of start (D-081, D-140) | d25_nested_group.eve |
| d26 | d26_nested_too_many | an aspect group holds at most two start statements (D-081, D-140) | d26_nested_too_many.eve |
| d27 | d27_start_order | the output of a group is written in the order of start, whatever task ends first (D-140, D-144) | d27_start_order.eve |
| d28 | d28_channel_receive | receive(@x) takes one value; a for loop takes the rest until the channel is closed (D-141) | d28_channel_receive.eve |
| d28 | d28_test1 (variation) | variation 1 of d28: receive from a closed, empty channel raises ChannelError 46 (D-141) | d28_test1.eve |
| d28 | d28_test2 (variation) | variation 2 of d28: a close beyond the number of senders is an error (D-141) | d28_test2.eve |
| d29 | d29_auto_close | a failing producer does not close its channel: the machine closes it, so the consumer ends (D-141) | d29_auto_close.eve |
| d30 | d30_channel_timeout | a wait on a channel longer than $timeout raises TimeoutError in that task (D-081, D-141) | d30_channel_timeout.eve |
| d31 | d31_leaf_group | an aspect started by an aspect is a leaf: a parallel group in it is a compile error (D-081, D-140) | d31_leaf_group.eve |
| d32 | d32_parallel_in_procedure | a parallel group in a procedure is a compile error: only in the main of a driver or of an aspect (D-140) | d32_parallel_in_procedure.eve |
| d33 | d33_job_spawn_error | a failing spawned task does not stop the others; the done of the job raises ParallelError (D-143) | d33_job_spawn_error.eve |
| d34 | d34_trait_conflict | two traits that provide the same method force the class to write it (D-145) | d34_trait_conflict.eve |
| d35 | d35_library_traits | a Printable object prints its describe; Comparable gives compare to numbers and texts (D-145) | d35_library_traits.eve |
Level 5: Data
Data language (types, records, generators, files, formats, HTTP client), database layer and the Eve database. Version 0.4, 22 tests. The folder on GitHub.
| Code | Test | What it checks | Source |
|---|---|---|---|
| e01 | e01_generic_function | a generic function has a list of types before its parameters; the call infers the types or writes them (D-148) | e01_generic_function.eve |
| e02 | e02_generic_procedure | a generic procedure takes a list of types; the call infers it or writes it (D-148) | e02_generic_procedure.eve |
| e03 | e03_generic_method | a method has its own list of types, in a generic class or in a plain class (D-148) | e03_generic_method.eve |
| e04 | e04_generic_process | the process of an aspect takes a list of types; apply infers it or writes it (D-148); one Eve macro (D-152) | e04_generic_process.eve |
| e05 | e05_overload_types | functions and procedures share a name when the types of their parameters differ (D-149) | e05_overload_types.eve |
| e06 | e06_overload_count | functions and procedures share a name when the number of their parameters differs (D-149) | e06_overload_count.eve |
| e07 | e07_overload_result | functions that differ only by the type of the result: the type expected at the call selects one (D-149) | e07_overload_result.eve |
| e08 | e08_overload_ambiguous | a call that does not fix the type of the result of an overloaded function is ambiguous: compile error (D-149) | e08_overload_ambiguous.eve |
| e09 | e09_overload_defaults | a default value can make two signatures match the same call: compile error (D-149) | e09_overload_defaults.eve |
| e10 | e10_overload_no_match | a call that matches no signature of an overloaded name is a compile error (D-149) | e10_overload_no_match.eve |
| e11 | e11_function_procedure_name | a function and a procedure never share a name: compile error (D-149) | e11_function_procedure_name.eve |
| e12 | e12_same_signature | two declarations with the same signature are a compile error (D-149) | e12_same_signature.eve |
| e13 | e13_method_result_or_not | a method without a result and one with a result share a name: a statement calls the first, an expression the second (D-149) | e13_method_result_or_not.eve |
| e14 | e14_generic_lambda | a lambda has no list of types: compile error (D-148) | e14_generic_lambda.eve |
| e15 | e15_type_not_inferred | a type that the arguments do not give must be written at the call: compile error (D-148) | e15_type_not_inferred.eve |
| e16 | e16_macro_apply | an Eve macro: shared declarations, an exclusive aspect and the driver in one file (D-152) | e16_macro_apply.eve |
| e17 | e17_macro_parallel | an Eve macro starts its concurrent aspects in a parallel group; a shared class carries the results (D-152) | e17_macro_parallel.eve |
| e18 | e18_macro_atomic | concurrent aspects of a macro add to a shared atomic variable: the total is exact (D-152, D-132) | e18_macro_atomic.eve |
| e19 | e19_macro_unsafe_variable | a concurrent aspect of a macro can not use a shared variable that is not atomic: compile error (D-152) | e19_macro_unsafe_variable.eve |
| e20 | e20_macro_unsafe_procedure | a concurrent aspect of a macro can not call a shared procedure that changes a plain variable: compile error (D-152) | e20_macro_unsafe_procedure.eve |
| e21 | e21_macro_two_drivers | a macro has one driver: a second one is a compile error (D-152) | e21_macro_two_drivers.eve |
| e22 | e22_macro_statement | a statement outside a declaration is a compile error in a macro (D-152) | e22_macro_statement.eve |
Level 6: Server
The Eve machine and the server. Version 0.5, no tests yet. The folder on GitHub.
Level 7: Web
Web: HTML and WebAssembly. Version 0.6, no tests yet. The folder on GitHub.