Initial Dever 0.0.1

test/rust/native/bytes.rs

@@ -0,0 +1,122 @@
+use super::{Directory, fixture};
+use dever::compiler::{build, project::Project};
+
+#[test]
+fn bytes_preserve_utf8_bounds_failures_and_traversal_order() {
+    let directory = Directory::new();
+    let project = Project::load(&fixture().with_file_name("bytes.dever")).unwrap();
+    let program = project.check().unwrap();
+    for (entry, expected) in [
+        ("verify", None),
+        (
+            "joinedSeedErrorEntry",
+            Some((
+                "lib/dever/bytes.dever",
+                "BufferResult.Failed",
+                "fail(BufferResult.Failed(message))",
+            )),
+        ),
+        (
+            "concatArgumentEntry",
+            Some((
+                "lib/dever/bytes.dever",
+                "BufferResult.Failed",
+                "fail(BufferResult.Failed(message))",
+            )),
+        ),
+        (
+            "concatLeftErrorEntry",
+            Some((
+                "lib/dever/bytes.dever",
+                "DecodeResult.Failed",
+                "fail(DecodeResult.Failed(message))",
+            )),
+        ),
+        (
+            "invalidEntry",
+            Some((
+                "lib/dever/bytes.dever",
+                "DecodeResult.Failed",
+                "fail(DecodeResult.Failed(message))",
+            )),
+        ),
+        (
+            "invalidListEntry",
+            Some((
+                "lib/dever/bytes.dever",
+                "DecodeResult.Failed",
+                "fail(DecodeResult.Failed(message))",
+            )),
+        ),
+        (
+            "overflowEntry",
+            Some((
+                "test/rust/fixtures/bytes.dever",
+                "integer arithmetic fault",
+                "state + item",
+            )),
+        ),
+        (
+            "argumentEntry",
+            Some((
+                "lib/dever/bytes.dever",
+                "BufferResult.Failed",
+                "fail(BufferResult.Failed(message))",
+            )),
+        ),
+    ] {
+        let binary =
+            build::build(&program, &project.sources, entry, &directory.0.join(entry)).unwrap();
+        let output = std::process::Command::new(binary).output().unwrap();
+        if let Some((source, message, needle)) = expected {
+            assert!(!output.status.success());
+            assert!(output.stdout.is_empty());
+            let stderr = String::from_utf8(output.stderr).unwrap();
+            let source = project
+                .sources
+                .iter()
+                .find(|item| item.path.ends_with(source))
+                .unwrap();
+            let offset = source.text.find(needle).unwrap();
+            let offset = if needle.starts_with("fail(") {
+                offset + 5
+            } else {
+                offset
+            };
+            let (line, column) = source.position(offset);
+            assert!(stderr.contains(message), "{stderr}");
+            assert!(
+                stderr.contains(&format!("{}:{line}:{column}:", source.path.display())),
+                "{stderr}"
+            );
+        } else {
+            assert!(
+                output.status.success(),
+                "{}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+            assert_eq!(output.stdout, b"true\n");
+        }
+    }
+}
+
+#[test]
+fn literal_prefix_evaluates_the_suffix_once() {
+    let directory = Directory::new();
+    let project = Project::load(&fixture().with_file_name("bytes.dever")).unwrap();
+    let program = project.check().unwrap();
+    let binary = build::build(
+        &program,
+        &project.sources,
+        "concatOrderEntry",
+        &directory.0.join("concat-order"),
+    )
+    .unwrap();
+    let output = std::process::Command::new(binary).output().unwrap();
+    assert!(
+        output.status.success(),
+        "{}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    assert_eq!(output.stdout, b"suffix\ntrue\n");
+}