2161237030

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/tremor-rs/tremor-runtime/commit/<a class=hub.com/tremor-rs/tremor-runtime/commit/<a class="double-link" href="https://git"><a class=hub.com/tremor-rs/tremor-runtime/commit/<a class="double-link" href="https://git"><a class=hub.com/tremor-rs/tremor-runtime/commit/<a class="double-link" href="https://git"><a class=hub.com/tremor-rs/tremor-runtime/commit/36fe05a1870c6b705bfcf7ec6f1fd3fd1d0a049f">36fe05a18">&lt;a href=&quot;https://github.com/tremor-rs/tremor-runtime/commit/</a><a class="double-link" href="https://github.com/tremor-rs/tremor-runtime/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tremor-rs/tremor-runtime/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tremor-rs/tremor-runtime/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tremor-rs/tremor-runtime/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/tremor-rs/tremor-runtime/commit/36fe05a1870c6b705bfcf7ec6f1fd3fd1d0a049f">36fe05a18</a><a href="https://github.com/tremor-rs/tremor-runtime/commit/36fe05a1870c6b705bfcf7ec6f1fd3fd1d0a049f">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/tremor-rs/tremor-runtime/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/tremor-rs/tremor-runtime/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tremor-rs/tremor-runtime/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tremor-rs/tremor-runtime/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tremor-rs/tremor-runtime/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/tremor-rs/tremor-runtime/commit/36fe05a1870c6b705bfcf7ec6f1fd3fd1d0a049f&quot;&gt;36fe05a18&lt;/a&gt;&lt;a href=&quot;https://github.com/tremor-rs/tremor-runtime/commit/36fe05a1870c6b705bfcf7ec6f1fd3fd1d0a049f&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/tremor-rs/tremor-runtime/commit/&amp;lt;/a&amp;gt;&amp;lt;a... (continued)

Pull Request Pull Request #1539: Compression

Run Details

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

39575 of 46375 relevant lines covered (85.34%)

3629.5 hits per line

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

69.1

/src/preprocessor/decompress.rs

// Copyright 2020-2021, The Tremor Team
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use super::Preprocessor;
use crate::errors::Result;
use simd_json::ValueAccess;
use std::io::{self, Read};
use tremor_script::Value;

#[derive(Clone, Default, Debug)]
struct Gzip {}
impl Preprocessor for Gzip {
    fn name(&self) -> &str {
        "gzip"
    }

    fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {
        use libflate::gzip::MultiDecoder;
        let mut decoder = MultiDecoder::new(data)?;
        let mut decompressed = Vec::new();
        decoder.read_to_end(&mut decompressed)?;
        Ok(vec![decompressed])
    }
}

#[derive(Clone, Default, Debug)]
struct Zlib {}
impl Preprocessor for Zlib {
    fn name(&self) -> &str {
        "zlib"
    }

    fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {
        use libflate::zlib::Decoder;
        let mut decoder = Decoder::new(data)?;
        let mut decompressed = Vec::new();
        decoder.read_to_end(&mut decompressed)?;
        Ok(vec![decompressed])
    }
}

#[derive(Clone, Default, Debug)]
struct Xz2 {}
impl Preprocessor for Xz2 {
    fn name(&self) -> &str {
        "xz2"
    }

    fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {
        use xz2::read::XzDecoder as Decoder;
        let mut decoder = Decoder::new(data);
        let mut decompressed = Vec::new();
        decoder.read_to_end(&mut decompressed)?;
        Ok(vec![decompressed])
    }
}

#[derive(Clone, Default, Debug)]
struct Snappy {}
impl Preprocessor for Snappy {
    fn name(&self) -> &str {
        "snappy"
    }

    fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {
        use snap::read::FrameDecoder;
        let mut rdr = FrameDecoder::new(data);
        let decompressed_len = snap::raw::decompress_len(data)?;
        let mut decompressed = Vec::with_capacity(decompressed_len);
        io::copy(&mut rdr, &mut decompressed)?;
        Ok(vec![decompressed])
    }
}

#[derive(Clone, Default, Debug)]
struct Lz4 {}
impl Preprocessor for Lz4 {
    fn name(&self) -> &str {
        "lz4"
    }

    fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {
        use lz4::Decoder;
        let mut decoder = Decoder::new(data)?;
        let mut decompressed = Vec::new();
        decoder.read_to_end(&mut decompressed)?;
        Ok(vec![decompressed])
    }
}

#[derive(Clone, Debug, Default)]
struct Zstd {}
impl Preprocessor for Zstd {
    fn name(&self) -> &str {
        "ztd"
    }
    fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {
        let decoded: Vec<u8> = zstd::decode_all(data)?;
        Ok(vec![decoded])
    }
}

#[derive(Clone, Default, Debug)]
struct Fingerprinted {}
impl Preprocessor for Fingerprinted {
    fn name(&self) -> &str {
        "autodetect"
    }

    fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {
        let r = match data.get(0..6) {
            Some(&[0x1f, 0x8b, _, _, _, _]) => {
                use libflate::gzip::Decoder;
                let mut decoder = Decoder::new(data)?;
                let mut decompressed = Vec::new();
                decoder.read_to_end(&mut decompressed)?;
                decompressed
            }
            // ZLib magic headers
            Some(&[0x78, 0x01 | 0x5e | 0x9c | 0xda, _, _, _, _]) => {
                use libflate::zlib::Decoder;
                let mut decoder = Decoder::new(data)?;
                let mut decompressed = Vec::new();
                decoder.read_to_end(&mut decompressed)?;
                decompressed
            }
            Some(&[0xfd, b'7', b'z', b'X', b'Z', 0x00]) => {
                use xz2::read::XzDecoder as Decoder;
                let mut decoder = Decoder::new(data);
                let mut decompressed = Vec::new();
                decoder.read_to_end(&mut decompressed)?;
                decompressed
            }
            Some(b"sNaPpY" | &[0xff, _, _, _, _, _]) => {
                use snap::read::FrameDecoder;
                let mut rdr = FrameDecoder::new(data);
                let decompressed_len = snap::raw::decompress_len(data)?;
                let mut decompressed = Vec::with_capacity(decompressed_len);
                io::copy(&mut rdr, &mut decompressed)?;
                decompressed
            }
            Some(&[0x04, 0x22, 0x4D, 0x18, _, _]) => {
                use lz4::Decoder;
                let mut decoder = Decoder::new(data)?;
                let mut decompressed = Vec::new();
                decoder.read_to_end(&mut decompressed)?;
                decompressed
            }
            // Zstd Magic : 0xFD2FB528 (but little endian)
            Some(&[0x28, 0xb5, 0x2f, 0xfd, _, _]) => zstd::decode_all(data)?,
            _ => data.to_vec(),
        };
        Ok(vec![r])
    }
}

pub(crate) struct Decompress {
    codec: Box<dyn Preprocessor>,
}
impl Decompress {
    pub(crate) fn from_config(config: Option<&Value>) -> Result<Self> {
        let codec: Box<dyn Preprocessor> = match config.get_str("algorithm") {
            Some("gzip") => Box::new(Gzip::default()),
            Some("zlib") => Box::new(Zlib::default()),
            Some("xz2") => Box::new(Xz2::default()),
            Some("snappy") => Box::new(Snappy::default()),
            Some("lz4") => Box::new(Lz4::default()),
            Some("zstd") => Box::new(Zstd::default()),
            Some("autodetect") | None => Box::new(Fingerprinted::default()),
            Some(other) => return Err(format!("Unknown decompression algorithm: {other}").into()),
        };
        Ok(Decompress { codec })
    }
}
impl Preprocessor for Decompress {
    fn name(&self) -> &str {
        "decompress"
    }
    fn process(&mut self, ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {
        self.codec.process(ingest_ns, data)
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::postprocessor::Postprocessor;
    use crate::preprocessor::Preprocessor;
    use tremor_value::literal;
    fn decode_magic(data: &[u8]) -> &'static str {
        match data.get(0..6) {
            Some(&[0x1f, 0x8b, _, _, _, _]) => "gzip",
            Some(&[0x78, _, _, _, _, _]) => "zlib",
            Some(&[0xfd, b'7', b'z', _, _, _]) => "xz2",
            Some(b"sNaPpY") => "snappy",
            Some(&[0xff, 0x6, 0x0, 0x0, _, _]) => "snappy",
            Some(&[0x04, 0x22, 0x4d, 0x18, _, _]) => "lz4",
            Some(&[0x28, 0xb5, 0x2f, 0xfd, _, _]) => "zstd",
            _ => "fail/unknown",
        }
    } // Assert pre and post processors have a sensible default() ctor

    fn assert_simple_symmetric(internal: &[u8], algo: &str) -> Result<()> {
        let config = literal!({ "algorithm": algo });
        let mut pre = super::Decompress::from_config(Some(&config))?;
        let mut post = crate::postprocessor::Compress::from_config(Some(&config))?;

        // Fake ingest_ns and egress_ns
        let mut ingest_ns = 0_u64;
        let egress_ns = 1_u64;

        let r = post.process(ingest_ns, egress_ns, internal);
        let ext = &r?[0];
        let ext = ext.as_slice();
        // Assert actual encoded form is as expected ( magic code only )
        assert_eq!(algo, decode_magic(&ext));

        let r = pre.process(&mut ingest_ns, &ext);
        let out = &r?[0];
        let out = out.as_slice();
        // Assert actual decoded form is as expected
        assert_eq!(&internal, &out);
        // assert empty finish, no leftovers
        assert!(pre.finish(None)?.is_empty());
        Ok(())
    }

    #[test]
    fn test_gzip() -> Result<()> {
        let int = "snot".as_bytes();
        assert_simple_symmetric(int, "gzip")?;
        Ok(())
    }

    #[test]
    fn test_zlib() -> Result<()> {
        let int = "snot".as_bytes();
        assert_simple_symmetric(int, "zlib")?;
        Ok(())
    }

    #[test]
    fn test_snappy() -> Result<()> {
        let int = "snot".as_bytes();
        assert_simple_symmetric(int, "snappy")?;
        Ok(())
    }

    #[test]
    fn test_xz2() -> Result<()> {
        let int = "snot".as_bytes();
        assert_simple_symmetric(int, "xz2")?;
        Ok(())
    }

    #[test]
    fn test_lz4() -> Result<()> {
        let int = "snot".as_bytes();
        assert_simple_symmetric(int, "lz4")?;
        Ok(())
    }
    #[test]
    fn test_zstd() -> Result<()> {
        let int = "snot".as_bytes();
        assert_simple_symmetric(int, "zstd")?;
        Ok(())
    }
}

1	// Copyright 2020-2021, The Tremor Team
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	use super::Preprocessor;
16	use crate::errors::Result;
17	use simd_json::ValueAccess;
18	use std::io::{self, Read};
19	use tremor_script::Value;
20
21	#[derive(Clone, Default, Debug)]	1✔
22	struct Gzip {}
23	impl Preprocessor for Gzip {
24	fn name(&self) -> &str {	×
25	"gzip"	×
26	}	×
27
28	fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {	1✔
29	use libflate::gzip::MultiDecoder;
30	let mut decoder = MultiDecoder::new(data)?;	1✔
31	let mut decompressed = Vec::new();	1✔
32	decoder.read_to_end(&mut decompressed)?;	1✔
33	Ok(vec![decompressed])	1✔
34	}	1✔
35	}
36
37	#[derive(Clone, Default, Debug)]	1✔
38	struct Zlib {}
39	impl Preprocessor for Zlib {
40	fn name(&self) -> &str {	×
41	"zlib"	×
42	}	×
43
44	fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {	1✔
45	use libflate::zlib::Decoder;
46	let mut decoder = Decoder::new(data)?;	1✔
47	let mut decompressed = Vec::new();	1✔
48	decoder.read_to_end(&mut decompressed)?;	1✔
49	Ok(vec![decompressed])	1✔
50	}	1✔
51	}
52
53	#[derive(Clone, Default, Debug)]	1✔
54	struct Xz2 {}
55	impl Preprocessor for Xz2 {
56	fn name(&self) -> &str {	×
57	"xz2"	×
58	}	×
59
60	fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {	1✔
61	use xz2::read::XzDecoder as Decoder;	1✔
62	let mut decoder = Decoder::new(data);	1✔
63	let mut decompressed = Vec::new();	1✔
64	decoder.read_to_end(&mut decompressed)?;	1✔
65	Ok(vec![decompressed])	1✔
66	}	1✔
67	}
68
69	#[derive(Clone, Default, Debug)]	1✔
70	struct Snappy {}
71	impl Preprocessor for Snappy {
72	fn name(&self) -> &str {	×
73	"snappy"	×
74	}	×
75
76	fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {	1✔
77	use snap::read::FrameDecoder;	1✔
78	let mut rdr = FrameDecoder::new(data);	1✔
79	let decompressed_len = snap::raw::decompress_len(data)?;	1✔
80	let mut decompressed = Vec::with_capacity(decompressed_len);	1✔
81	io::copy(&mut rdr, &mut decompressed)?;	1✔
82	Ok(vec![decompressed])	1✔
83	}	1✔
84	}
85
86	#[derive(Clone, Default, Debug)]	1✔
87	struct Lz4 {}
88	impl Preprocessor for Lz4 {
89	fn name(&self) -> &str {	×
90	"lz4"	×
91	}	×
92
93	fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {	1✔
94	use lz4::Decoder;
95	let mut decoder = Decoder::new(data)?;	1✔
96	let mut decompressed = Vec::new();	1✔
97	decoder.read_to_end(&mut decompressed)?;	1✔
98	Ok(vec![decompressed])	1✔
99	}	1✔
100	}
101
102	#[derive(Clone, Debug, Default)]	1✔
103	struct Zstd {}
104	impl Preprocessor for Zstd {
105	fn name(&self) -> &str {	×
106	"ztd"	×
107	}	×
108	fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {	1✔
109	let decoded: Vec<u8> = zstd::decode_all(data)?;	1✔
110	Ok(vec![decoded])	1✔
111	}	1✔
112	}
113
114	#[derive(Clone, Default, Debug)]	1✔
115	struct Fingerprinted {}
116	impl Preprocessor for Fingerprinted {
117	fn name(&self) -> &str {	×
118	"autodetect"	×
119	}	×
120
121	fn process(&mut self, _ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {	×
122	let r = match data.get(0..6) {	×
123	Some(&[0x1f, 0x8b, _, _, _, _]) => {	×
124	use libflate::gzip::Decoder;
125	let mut decoder = Decoder::new(data)?;	×
126	let mut decompressed = Vec::new();	×
127	decoder.read_to_end(&mut decompressed)?;	×
128	decompressed	×
129	}
130	// ZLib magic headers
131	Some(&[0x78, 0x01 \| 0x5e \| 0x9c \| 0xda, _, _, _, _]) => {
132	use libflate::zlib::Decoder;
133	let mut decoder = Decoder::new(data)?;	×
134	let mut decompressed = Vec::new();	×
135	decoder.read_to_end(&mut decompressed)?;	×
136	decompressed	×
137	}
138	Some(&[0xfd, b'7', b'z', b'X', b'Z', 0x00]) => {
139	use xz2::read::XzDecoder as Decoder;
140	let mut decoder = Decoder::new(data);	×
141	let mut decompressed = Vec::new();	×
142	decoder.read_to_end(&mut decompressed)?;	×
143	decompressed	×
144	}
145	Some(b"sNaPpY" \| &[0xff, _, _, _, _, _]) => {
146	use snap::read::FrameDecoder;
147	let mut rdr = FrameDecoder::new(data);	×
148	let decompressed_len = snap::raw::decompress_len(data)?;	×
149	let mut decompressed = Vec::with_capacity(decompressed_len);	×
150	io::copy(&mut rdr, &mut decompressed)?;	×
151	decompressed	×
152	}
153	Some(&[0x04, 0x22, 0x4D, 0x18, _, _]) => {
154	use lz4::Decoder;
155	let mut decoder = Decoder::new(data)?;	×
156	let mut decompressed = Vec::new();	×
157	decoder.read_to_end(&mut decompressed)?;	×
158	decompressed	×
159	}
160	// Zstd Magic : 0xFD2FB528 (but little endian)
161	Some(&[0x28, 0xb5, 0x2f, 0xfd, _, _]) => zstd::decode_all(data)?,	×
162	_ => data.to_vec(),	×
163	};
164	Ok(vec![r])	×
165	}	×
166	}
167
168	pub(crate) struct Decompress {
169	codec: Box<dyn Preprocessor>,
170	}
171	impl Decompress {
172	pub(crate) fn from_config(config: Option<&Value>) -> Result<Self> {	7✔
173	let codec: Box<dyn Preprocessor> = match config.get_str("algorithm") {	7✔
174	Some("gzip") => Box::new(Gzip::default()),	6✔
175	Some("zlib") => Box::new(Zlib::default()),	5✔
176	Some("xz2") => Box::new(Xz2::default()),	4✔
177	Some("snappy") => Box::new(Snappy::default()),	3✔
178	Some("lz4") => Box::new(Lz4::default()),	2✔
179	Some("zstd") => Box::new(Zstd::default()),	1✔
180	Some("autodetect") \| None => Box::new(Fingerprinted::default()),	1✔
181	Some(other) => return Err(format!("Unknown decompression algorithm: {other}").into()),	×
182	};
183	Ok(Decompress { codec })	7✔
184	}	7✔
185	}
186	impl Preprocessor for Decompress {
187	fn name(&self) -> &str {	×
188	"decompress"	×
189	}	×
190	fn process(&mut self, ingest_ns: &mut u64, data: &[u8]) -> Result<Vec<Vec<u8>>> {	6✔
191	self.codec.process(ingest_ns, data)	6✔
192	}	6✔
193	}
194
195	#[cfg(test)]
196	mod test {
197	use super::*;
198	use crate::postprocessor::Postprocessor;
199	use crate::preprocessor::Preprocessor;
200	use tremor_value::literal;
201	fn decode_magic(data: &[u8]) -> &'static str {	6✔
202	match data.get(0..6) {	6✔
203	Some(&[0x1f, 0x8b, _, _, _, _]) => "gzip",	6✔
204	Some(&[0x78, _, _, _, _, _]) => "zlib",	1✔
205	Some(&[0xfd, b'7', b'z', _, _, _]) => "xz2",	1✔
206	Some(b"sNaPpY") => "snappy",	×
207	Some(&[0xff, 0x6, 0x0, 0x0, _, _]) => "snappy",	1✔
208	Some(&[0x04, 0x22, 0x4d, 0x18, _, _]) => "lz4",	1✔
209	Some(&[0x28, 0xb5, 0x2f, 0xfd, _, _]) => "zstd",	1✔
210	_ => "fail/unknown",	×
211	}
212	} // Assert pre and post processors have a sensible default() ctor	6✔
213
214	fn assert_simple_symmetric(internal: &[u8], algo: &str) -> Result<()> {	6✔
215	let config = literal!({ "algorithm": algo });	6✔
216	let mut pre = super::Decompress::from_config(Some(&config))?;	6✔
217	let mut post = crate::postprocessor::Compress::from_config(Some(&config))?;	6✔
218
219	// Fake ingest_ns and egress_ns
220	let mut ingest_ns = 0_u64;	6✔
221	let egress_ns = 1_u64;	6✔
222		6✔
223	let r = post.process(ingest_ns, egress_ns, internal);	6✔
224	let ext = &r?[0];	6✔
225	let ext = ext.as_slice();	6✔
226	// Assert actual encoded form is as expected ( magic code only )	6✔
227	assert_eq!(algo, decode_magic(&ext));	6✔
228
229	let r = pre.process(&mut ingest_ns, &ext);	6✔
230	let out = &r?[0];	6✔
231	let out = out.as_slice();	6✔
232	// Assert actual decoded form is as expected	6✔
233	assert_eq!(&internal, &out);	6✔
234	// assert empty finish, no leftovers
235	assert!(pre.finish(None)?.is_empty());	6✔
236	Ok(())	6✔
237	}	6✔
238
239	#[test]	1✔
240	fn test_gzip() -> Result<()> {	1✔
241	let int = "snot".as_bytes();	1✔
242	assert_simple_symmetric(int, "gzip")?;	1✔
243	Ok(())	1✔
244	}	1✔
245
246	#[test]	1✔
247	fn test_zlib() -> Result<()> {	1✔
248	let int = "snot".as_bytes();	1✔
249	assert_simple_symmetric(int, "zlib")?;	1✔
250	Ok(())	1✔
251	}	1✔
252
253	#[test]	1✔
254	fn test_snappy() -> Result<()> {	1✔
255	let int = "snot".as_bytes();	1✔
256	assert_simple_symmetric(int, "snappy")?;	1✔
257	Ok(())	1✔
258	}	1✔
259
260	#[test]	1✔
261	fn test_xz2() -> Result<()> {	1✔
262	let int = "snot".as_bytes();	1✔
263	assert_simple_symmetric(int, "xz2")?;	1✔
264	Ok(())	1✔
265	}	1✔
266
267	#[test]	1✔
268	fn test_lz4() -> Result<()> {	1✔
269	let int = "snot".as_bytes();	1✔
270	assert_simple_symmetric(int, "lz4")?;	1✔
271	Ok(())	1✔
272	}	1✔
273	#[test]	1✔
274	fn test_zstd() -> Result<()> {	1✔
275	let int = "snot".as_bytes();	1✔
276	assert_simple_symmetric(int, "zstd")?;	1✔
277	Ok(())	1✔
278	}	1✔
279	}

tremor-rs / tremor-runtime / 2161237030

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