feat: publish Dever core with project scaffolding and versioned AI skills

test/dever-tests/tests/standard_library.rs

@@ -0,0 +1,124 @@
+mod support;
+
+use dever_runtime::{number, text, time};
+use std::process::Command;
+
+#[test]
+fn unicode_text_uses_scalar_positions_and_explicit_invalid_ranges() {
+    let value = "a中😀e\u{301}";
+    assert_eq!(text::codepoint("😀"), Some(0x1f600));
+    assert_eq!(text::codepoint("ab"), None);
+    assert_eq!(text::from_codepoint(0x1f600).as_deref(), Some("😀"));
+    assert_eq!(text::from_codepoint(0xd800), None);
+    assert_eq!(text::from_codepoint(i64::MAX), None);
+    assert_eq!(text::at(value, 2).as_deref(), Some("😀"));
+    assert_eq!(text::at(value, 5), None);
+    assert_eq!(text::at(value, -1), None);
+    assert_eq!(text::slice(value, 1, 3).as_deref(), Some("中😀"));
+    assert_eq!(text::slice(value, 5, 5).as_deref(), Some(""));
+    assert_eq!(text::slice(value, 3, 2), None);
+    assert_eq!(text::slice(value, 5, 6), None);
+    assert_eq!(text::index_of(value, "e"), Some(3));
+    assert_eq!(text::index_of(value, "x"), None);
+    assert_eq!(text::split("a中", "").values(), &["a", "中"]);
+    assert!(text::split("", "").values().is_empty());
+    assert_eq!(text::split(",a,,", ",").values(), &["", "a", "", ""]);
+}
+
+#[test]
+fn numeric_parsing_preserves_precision_boundaries_and_ieee_values() {
+    assert_eq!(number::parse_int("-9223372036854775808"), Some(i64::MIN));
+    assert_eq!(number::parse_int("9223372036854775808"), None);
+    assert_eq!(number::parse_int(" 2"), None);
+    assert_eq!(
+        number::parse_decimal("0.10000000000000000000000000000000001"),
+        None
+    );
+    assert_eq!(number::parse_decimal("1.25e2").unwrap().to_string(), "125");
+    assert_eq!(number::parse_decimal("NaN"), None);
+    assert_eq!(number::parse_decimal(" 1.2"), None);
+    assert_eq!(
+        number::parse_float("-0").unwrap().to_bits(),
+        (-0.0f64).to_bits()
+    );
+    assert!(number::parse_float("NaN").unwrap().is_nan());
+    assert_eq!(number::parse_float("-inf"), Some(f64::NEG_INFINITY));
+    assert_eq!(number::parse_float("1_000"), None);
+}
+
+#[test]
+fn official_text_and_number_sources_execute_as_normal_packages() {
+    let output = support::stdout(
+        r#"public main() (joined: Text, empty: Text, character: Text?, slice: Text?, position: Int?, absent: Text?, pieces: List<Text>, replaced: Text, predicates: Bool, number: Int?, invalid: Decimal?, exact: Text, converted: Text, floating: Text) {
+  joined = text.join(["", "中", ""], "|")
+  empty = text.join([], "|")
+  character = text.at("a😀中", 1)
+  slice = text.slice("a😀中", 1, 3)
+  position = text.index_of("a😀中", "中")
+  absent = text.slice("a", 0, 2)
+  pieces = text.split("a,,b", ",")
+  replaced = text.replace("中a中", "中", "字")
+  predicates = text.starts_with("abc", "a") and text.ends_with("abc", "c") and text.contains("abc", "b") and text.is_empty("")
+  number = int.parse("-17")
+  invalid = decimal.parse("bad")
+  exact = decimal.to_text(1.25)
+  converted = int.to_text(-17)
+  floating = float.to_text(float.from_int(8))
+}
+"#,
+    );
+    assert_eq!(
+        output,
+        "joined = |中|\nempty = \ncharacter = 😀\nslice = 😀中\nposition = 2\nabsent = null\npieces = [a, , b]\nreplaced = 字a字\npredicates = true\nnumber = -17\ninvalid = null\nexact = 1.25\nconverted = -17\nfloating = 8\n"
+    );
+}
+
+#[test]
+fn process_inputs_are_explicit_and_do_not_require_build_tools() {
+    let sources = support::sources(
+        r#"public main() (args: dever.process.ArgumentsResult) {
+  args = result(dever.process.arguments())
+}
+"#,
+    );
+    let program = support::checked(&sources);
+    let compiler = std::env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
+    let native = dever_core::native::compile(&program, &sources, "main.main", &compiler).unwrap();
+    let output = Command::new(native.executable())
+        .env_clear()
+        .args(["first", "arg with spaces"])
+        .output()
+        .unwrap();
+    assert!(
+        output.status.success(),
+        "{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    let output = String::from_utf8(output.stdout).unwrap();
+    assert!(
+        output.contains("Read([first, arg with spaces])"),
+        "{output}"
+    );
+}
+
+#[test]
+fn clock_failures_are_results() {
+    let before = time::monotonic_nanos().unwrap();
+    time::sleep(0).unwrap();
+    assert!(time::monotonic_nanos().unwrap() >= before);
+    assert!(time::unix_millis().unwrap() > 0);
+    assert!(time::sleep(-1).is_err());
+    assert_eq!(
+        support::stdout(
+            r#"valid(result: dever.time.ClockResult.Read(value)) (answer: Bool) recover("test observes valid failures in its assertions") { answer = value >= 0 }
+valid(result: other) (answer: Bool) recover("test observes valid failures in its assertions") { answer = false }
+public main() (wall: Bool, elapsed: Bool, invalid: dever.time.SleepResult) {
+  wall = valid(result(dever.time.unix_millis()))
+  elapsed = valid(result(dever.time.monotonic_nanos()))
+  invalid = result(dever.time.sleep(-1))
+}
+"#
+        ),
+        "wall = true\nelapsed = true\ninvalid = dever.time.SleepResult.Failed(sleep duration must not be negative)\n"
+    );
+}