4456257423

Build Type

github

Committed by GitHub

Commit Message

Merge c9ae93390 into f131491ac

Pull Request Pull Request #27: MPD and DATA extension support

Run Details

1073 of 1073 new or added lines in 7 files covered. (100.0%)

1615 of 1752 relevant lines covered (92.18%)

1.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.21

/lib/tests/parse.rs

extern crate weldr;

use weldr::{error::ResolveError, Command, FileRefResolver, SourceFile, SourceMap, SubFileRefCmd};

use std::collections::HashMap;

fn print_rec(source_map: &SourceMap, filename: &str, source_file: &SourceFile, indent: usize) {
    eprintln!("{}{}", " ".repeat(indent), filename);
    for cmd in &source_file.cmds {
        if let Command::SubFileRef(sfr_cmd) = cmd {
            let resolved_file = source_map.get(&sfr_cmd.file).unwrap();
            print_rec(source_map, &sfr_cmd.file, resolved_file, indent + 2);
        }
    }
}

/// A simple in-memory file resolver where files and their content are manually
/// added before being resolved.
struct MemoryResolver {
    /// Mapping from the filename to the file content.
    file_map: HashMap<String, Vec<u8>>,
}

impl MemoryResolver {
    fn new() -> MemoryResolver {
        MemoryResolver {
            file_map: HashMap::new(),
        }
    }

    /// Add a new file and its content to the internal cache.
    fn add(&mut self, filename: &str, content: &[u8]) {
        self.file_map.insert(filename.to_string(), content.to_vec());
    }
}

impl FileRefResolver for MemoryResolver {
    fn resolve<P: AsRef<std::path::Path>>(&self, filename: P) -> Result<Vec<u8>, ResolveError> {
        let filename = filename.as_ref().to_string_lossy().to_string();
        match self.file_map.get(&filename) {
            Some(file) => Ok(file.clone()),
            None => Err(ResolveError::new_raw(&filename)),
        }
    }
}

/// Get the sub-file reference command out of a given command.
fn get_resolved_subfile_ref(cmd: &Command) -> Option<&SubFileRefCmd> {
    match cmd {
        Command::SubFileRef(sfr_cmd) => Some(sfr_cmd),
        _ => None,
    }
}

#[test]
fn test_memory_resolver() {
    let mut memory_resolver = MemoryResolver::new();
    memory_resolver.add("root.ldr", b"1 16 0 0 0 1 0 0 0 1 0 0 0 1 a.ldr");
    assert!(memory_resolver.resolve("root.ldr").is_ok());
    assert!(memory_resolver.resolve("a.ldr").is_err());
    assert_eq!(
        "a.ldr",
        memory_resolver.resolve("a.ldr").unwrap_err().filename
    );
}

#[test]
fn parse_recursive() {
    let mut memory_resolver = MemoryResolver::new();
    memory_resolver.add("root.ldr", b"1 16 0 0 0 1 0 0 0 1 0 0 0 1 a.ldr\n1 16 0 0 0 1 0 0 0 1 0 0 0 1 b.ldr\n1 16 0 0 0 1 0 0 0 1 0 0 0 1 a.ldr");
    memory_resolver.add("a.ldr", b"4 16 1 1 0 0.9239 1 0.3827 0.9239 0 0.3827 1 0 0");
    memory_resolver.add(
        "b.ldr",
        b"4 16 1 1 0 0.9239 1 0.3827 0.9239 0 0.3827 1 0 0\n1 16 0 0 0 1 0 0 0 1 0 0 0 1 a.ldr",
    );
    let mut source_map = weldr::SourceMap::new();
    let root_file_name = weldr::parse("root.ldr", &memory_resolver, &mut source_map).unwrap();
    let root_file = source_map.get(&root_file_name).unwrap();
    assert_eq!(3, root_file.cmds.len());

    let file0 = get_resolved_subfile_ref(&root_file.cmds[0]).unwrap();
    assert_eq!(file0.file, "a.ldr");
    assert_eq!(1, source_map.get(&file0.file).unwrap().cmds.len());

    let file1 = get_resolved_subfile_ref(&root_file.cmds[1]).unwrap();
    assert_eq!(2, source_map.get(&file1.file).unwrap().cmds.len());

    let file2 = get_resolved_subfile_ref(&root_file.cmds[2]).unwrap();
    assert_eq!(1, source_map.get(&file2.file).unwrap().cmds.len());
    assert_eq!(file0, file2);

    let file1b = get_resolved_subfile_ref(&source_map.get(&file1.file).unwrap().cmds[1]).unwrap();
    assert_eq!(file0, file1b);
    print_rec(&source_map, "root.ldr", &root_file, 0);
}

#[test]
fn parse_cycle() {
    let mut memory_resolver = MemoryResolver::new();

    // Infinite recursion on a naive implementation.
    let ldr_contents = b"0 FILE a.ldr
    1 16 0 0 0 1 0 0 0 1 0 0 0 1 b.ldr

    0 FILE b.ldr
    1 16 0 0 0 1 0 0 0 1 0 0 0 1 a.ldr
    ";

    memory_resolver.add("root.ldr", ldr_contents);

    let mut source_map = weldr::SourceMap::new();

    weldr::parse("root.ldr", &memory_resolver, &mut source_map).unwrap();
    let file_a = source_map.get("a.ldr").unwrap();
    assert_eq!(2, file_a.cmds.len());

    let file_b = source_map.get("b.ldr").unwrap();
    assert_eq!(2, file_b.cmds.len());
}

1	extern crate weldr;
2
3	use weldr::{error::ResolveError, Command, FileRefResolver, SourceFile, SourceMap, SubFileRefCmd};
4
5	use std::collections::HashMap;
6
7	fn print_rec(source_map: &SourceMap, filename: &str, source_file: &SourceFile, indent: usize) {	1✔
8	eprintln!("{}{}", " ".repeat(indent), filename);	1✔
9	for cmd in &source_file.cmds {	3✔
10	if let Command::SubFileRef(sfr_cmd) = cmd {	1✔
11	let resolved_file = source_map.get(&sfr_cmd.file).unwrap();	1✔
12	print_rec(source_map, &sfr_cmd.file, resolved_file, indent + 2);	1✔
13	}
14	}
15	}
16
17	/// A simple in-memory file resolver where files and their content are manually
18	/// added before being resolved.
19	struct MemoryResolver {
20	/// Mapping from the filename to the file content.
21	file_map: HashMap<String, Vec<u8>>,
22	}
23
24	impl MemoryResolver {
25	fn new() -> MemoryResolver {	1✔
26	MemoryResolver {
27	file_map: HashMap::new(),	1✔
28	}
29	}
30
31	/// Add a new file and its content to the internal cache.
32	fn add(&mut self, filename: &str, content: &[u8]) {	1✔
33	self.file_map.insert(filename.to_string(), content.to_vec());	1✔
34	}
35	}
36
37	impl FileRefResolver for MemoryResolver {
38	fn resolve<P: AsRef<std::path::Path>>(&self, filename: P) -> Result<Vec<u8>, ResolveError> {	2✔
39	let filename = filename.as_ref().to_string_lossy().to_string();	4✔
40	match self.file_map.get(&filename) {	2✔
41	Some(file) => Ok(file.clone()),	2✔
42	None => Err(ResolveError::new_raw(&filename)),	2✔
43	}
44	}
45	}
46
47	/// Get the sub-file reference command out of a given command.
48	fn get_resolved_subfile_ref(cmd: &Command) -> Option<&SubFileRefCmd> {	1✔
49	match cmd {	1✔
50	Command::SubFileRef(sfr_cmd) => Some(sfr_cmd),	1✔
51	_ => None,	×
52	}
53	}
54
55	#[test]
56	fn test_memory_resolver() {	4✔
57	let mut memory_resolver = MemoryResolver::new();	1✔
58	memory_resolver.add("root.ldr", b"1 16 0 0 0 1 0 0 0 1 0 0 0 1 a.ldr");	1✔
59	assert!(memory_resolver.resolve("root.ldr").is_ok());	2✔
60	assert!(memory_resolver.resolve("a.ldr").is_err());	2✔
61	assert_eq!(	1✔
62	"a.ldr",
63	memory_resolver.resolve("a.ldr").unwrap_err().filename	2✔
64	);
65	}
66
67	#[test]
68	fn parse_recursive() {	3✔
69	let mut memory_resolver = MemoryResolver::new();	1✔
70	memory_resolver.add("root.ldr", b"1 16 0 0 0 1 0 0 0 1 0 0 0 1 a.ldr\n1 16 0 0 0 1 0 0 0 1 0 0 0 1 b.ldr\n1 16 0 0 0 1 0 0 0 1 0 0 0 1 a.ldr");	1✔
71	memory_resolver.add("a.ldr", b"4 16 1 1 0 0.9239 1 0.3827 0.9239 0 0.3827 1 0 0");	1✔
72	memory_resolver.add(	1✔
73	"b.ldr",
74	b"4 16 1 1 0 0.9239 1 0.3827 0.9239 0 0.3827 1 0 0\n1 16 0 0 0 1 0 0 0 1 0 0 0 1 a.ldr",
75	);
76	let mut source_map = weldr::SourceMap::new();	1✔
77	let root_file_name = weldr::parse("root.ldr", &memory_resolver, &mut source_map).unwrap();	2✔
78	let root_file = source_map.get(&root_file_name).unwrap();	2✔
79	assert_eq!(3, root_file.cmds.len());	1✔
80
81	let file0 = get_resolved_subfile_ref(&root_file.cmds[0]).unwrap();	2✔
82	assert_eq!(file0.file, "a.ldr");	1✔
83	assert_eq!(1, source_map.get(&file0.file).unwrap().cmds.len());	2✔
84
85	let file1 = get_resolved_subfile_ref(&root_file.cmds[1]).unwrap();	2✔
86	assert_eq!(2, source_map.get(&file1.file).unwrap().cmds.len());	1✔
87
88	let file2 = get_resolved_subfile_ref(&root_file.cmds[2]).unwrap();	2✔
89	assert_eq!(1, source_map.get(&file2.file).unwrap().cmds.len());	1✔
90	assert_eq!(file0, file2);	2✔
91
92	let file1b = get_resolved_subfile_ref(&source_map.get(&file1.file).unwrap().cmds[1]).unwrap();	2✔
93	assert_eq!(file0, file1b);	1✔
94	print_rec(&source_map, "root.ldr", &root_file, 0);	1✔
95	}
96
97	#[test]
98	fn parse_cycle() {	3✔
99	let mut memory_resolver = MemoryResolver::new();	1✔
100
101	// Infinite recursion on a naive implementation.
102	let ldr_contents = b"0 FILE a.ldr	1✔
103	1 16 0 0 0 1 0 0 0 1 0 0 0 1 b.ldr
104
105	0 FILE b.ldr
106	1 16 0 0 0 1 0 0 0 1 0 0 0 1 a.ldr
107	";
108
109	memory_resolver.add("root.ldr", ldr_contents);	1✔
110
111	let mut source_map = weldr::SourceMap::new();	1✔
112
113	weldr::parse("root.ldr", &memory_resolver, &mut source_map).unwrap();	2✔
114	let file_a = source_map.get("a.ldr").unwrap();	1✔
115	assert_eq!(2, file_a.cmds.len());	1✔
116
117	let file_b = source_map.get("b.ldr").unwrap();	2✔
118	assert_eq!(2, file_b.cmds.len());	1✔
119	}

djeedai / weldr / 4456257423

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous