leo_test_framework/
fetch.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
// Copyright (C) 2019-2025 Provable Inc.
// This file is part of the Leo library.

// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.

use std::{
    fs,
    path::{Path, PathBuf},
};

use walkdir::WalkDir;

pub fn find_tests(path: &Path) -> impl Iterator<Item = (PathBuf, String)> {
    WalkDir::new(path).into_iter().flatten().filter_map(move |f| {
        // Get the path.
        let path = f.path();
        // Check if the file is a .leo file.
        let is_leo_file = path.extension().filter(|s| *s == "leo").is_some();
        // Read the test filter from the environment.
        let filter = std::env::var("TEST_FILTER").unwrap_or_default();
        // Check if the path contains the filter.
        let satisfies_filter = filter.is_empty() || path.to_string_lossy().contains(&filter);
        // If the file is a .leo file and satisfies the filter, return the path and the file contents.
        if is_leo_file && satisfies_filter {
            Some((path.to_path_buf(), fs::read_to_string(path).expect("failed to read test")))
        } else {
            None
        }
    })
}

pub fn split_tests_one_line(source: &str) -> Vec<&str> {
    source.lines().map(|x| x.trim()).filter(|x| !x.is_empty()).collect()
}

pub fn split_tests_two_line(source: &str) -> Vec<String> {
    let mut out = vec![];
    let mut lines = vec![];
    for line in source.lines() {
        let line = line.trim();
        if line.is_empty() {
            if !lines.is_empty() {
                out.push(lines.join("\n"));
            }
            lines.clear();
            continue;
        }
        lines.push(line);
    }
    let last_test = lines.join("\n");
    if !last_test.trim().is_empty() {
        out.push(last_test.trim().to_string());
    }
    out
}