Restructurization

tests/fec.rs

@@ -1,13 +1,13 @@
 //! Test that supplying empty packets does forward error correction.
 
-extern crate opus;
-use opus::*;
+extern crate magnum_opus;
+use magnum_opus::*;
 
 #[test]
 fn blah() {
-    let mut opus = Decoder::new(48000, Channels::Mono).unwrap();
+    let mut magnum_opus = Decoder::new(48000, Channels::Mono).unwrap();
 
     let mut output = vec![0i16; 5760];
-    let size = opus.decode(&[], &mut output[..], true).unwrap();
+    let size = magnum_opus.decode(&[], &mut output[..], true).unwrap();
     assert_eq!(size, 5760);
 }

tests/opus-padding.rs

@@ -1,15 +1,15 @@
-// Based on libopus/tests/test_opus_padding.c
+// Based on libmagnum_opus/tests/test_magnum_opus_padding.c
 
 /* Check for overflow in reading the padding length.
- * http://lists.xiph.org/pipermail/opus/2012-November/001834.html
+ * http://lists.xiph.org/pipermail/magnum_opus/2012-November/001834.html
  */
 
-extern crate opus;
+extern crate magnum_opus;
 
 #[test]
 fn test_overflow() {
     const PACKETSIZE: usize = 16909318;
-    const CHANNELS: opus::Channels = opus::Channels::Stereo;
+    const CHANNELS: magnum_opus::Channels = magnum_opus::Channels::Stereo;
     const FRAMESIZE: usize = 5760;
 
     let mut input = vec![0xff; PACKETSIZE];
@@ -19,11 +19,11 @@ fn test_overflow() {
     input[1] = 0x41;
     *input.last_mut().unwrap() = 0x0b;
 
-    let mut decoder = opus::Decoder::new(48000, CHANNELS).unwrap();
+    let mut decoder = magnum_opus::Decoder::new(48000, CHANNELS).unwrap();
     let result = decoder.decode(&input[..], &mut output[..], false);
     drop(decoder);
     drop(input);
     drop(output);
 
-    assert_eq!(result.unwrap_err().code(), opus::ErrorCode::InvalidPacket);
+    assert_eq!(result.unwrap_err().code(), magnum_opus::ErrorCode::InvalidPacket);
 }

tests/tests.rs

@@ -1,4 +1,4 @@
-extern crate opus;
+extern crate magnum_opus;
 
 fn check_ascii(s: &str) -> &str {
 	for &b in s.as_bytes() {
@@ -10,9 +10,9 @@ fn check_ascii(s: &str) -> &str {
 
 #[test]
 fn strings_ascii() {
-	use opus::ErrorCode::*;
+	use magnum_opus::ErrorCode::*;
 
-	println!("\nVersion: {}", check_ascii(opus::version()));
+	println!("\nVersion: {}", check_ascii(magnum_opus::version()));
 
 	let codes = [BadArg, BufferTooSmall, InternalError, InvalidPacket,
 		Unimplemented, InvalidState, AllocFail, Unknown];
@@ -26,7 +26,7 @@ const MONO_20MS: usize = 48000 * 1 * 20 / 1000;
 
 #[test]
 fn encode_mono() {
-	let mut encoder = opus::Encoder::new(48000, opus::Channels::Mono, opus::Application::Audio).unwrap();
+	let mut encoder = magnum_opus::Encoder::new(48000, magnum_opus::Channels::Mono, magnum_opus::Application::Audio).unwrap();
 
 	let mut output = [0; 256];
 	let len = encoder.encode(&[0_i16; MONO_20MS], &mut output).unwrap();
@@ -47,7 +47,7 @@ fn encode_mono() {
 
 #[test]
 fn encode_stereo() {
-	let mut encoder = opus::Encoder::new(48000, opus::Channels::Stereo, opus::Application::Audio).unwrap();
+	let mut encoder = magnum_opus::Encoder::new(48000, magnum_opus::Channels::Stereo, magnum_opus::Application::Audio).unwrap();
 
 	let mut output = [0; 512];
 	let len = encoder.encode(&[0_i16; 2 * MONO_20MS], &mut output).unwrap();
@@ -72,24 +72,24 @@ fn encode_stereo() {
 
 #[test]
 fn encode_bad_rate() {
-	match opus::Encoder::new(48001, opus::Channels::Mono, opus::Application::Audio) {
+	match magnum_opus::Encoder::new(48001, magnum_opus::Channels::Mono, magnum_opus::Application::Audio) {
 		Ok(_) => panic!("Encoder::new did not return BadArg"),
-		Err(err) => assert_eq!(err.code(), opus::ErrorCode::BadArg),
+		Err(err) => assert_eq!(err.code(), magnum_opus::ErrorCode::BadArg),
 	}
 }
 
 #[test]
 fn encode_bad_buffer() {
-	let mut encoder = opus::Encoder::new(48000, opus::Channels::Stereo, opus::Application::Audio).unwrap();
+	let mut encoder = magnum_opus::Encoder::new(48000, magnum_opus::Channels::Stereo, magnum_opus::Application::Audio).unwrap();
 	match encoder.encode(&[1_i16; 2 * MONO_20MS], &mut [0; 0]) {
 		Ok(_) => panic!("encode with 0-length buffer did not return BadArg"),
-		Err(err) => assert_eq!(err.code(), opus::ErrorCode::BadArg),
+		Err(err) => assert_eq!(err.code(), magnum_opus::ErrorCode::BadArg),
 	}
 }
 
 #[test]
 fn repacketizer() {
-	let mut rp = opus::Repacketizer::new().unwrap();
+	let mut rp = magnum_opus::Repacketizer::new().unwrap();
 	let mut out = [0; 256];
 
 	for _ in 0..2 {