rustfmt: libflate, libfmt_macros, libgetopts, libgraphviz, liblog, librand

1 files changed, 449 insertions, 426 deletions

diff --git a/src/libgetopts/lib.rs b/src/libgetopts/lib.rs
index f49451f827d..c744121f843 100644
--- a/src/libgetopts/lib.rs
+++ b/src/libgetopts/lib.rs
@@ -98,7 +98,9 @@
 #![feature(str_char)]
 #![cfg_attr(test, feature(rustc_private))]
 
-#[cfg(test)] #[macro_use] extern crate log;
+#[cfg(test)]
+#[macro_use]
+extern crate log;
 
 use self::Name::*;
 use self::HasArg::*;
@@ -174,7 +176,7 @@ pub struct OptGroup {
     /// Whether option has an argument
     pub hasarg: HasArg,
     /// How often it can occur
-    pub occur: Occur
+    pub occur: Occur,
 }
 
 /// Describes whether an option is given at all or has a value.
@@ -239,7 +241,7 @@ impl Name {
     fn to_string(&self) -> String {
         match *self {
             Short(ch) => ch.to_string(),
-            Long(ref s) => s.to_owned()
+            Long(ref s) => s.to_owned(),
         }
     }
 }
@@ -257,33 +259,37 @@ impl OptGroup {
         } = (*self).clone();
 
         match (short_name.len(), long_name.len()) {
-            (0,0) => panic!("this long-format option was given no name"),
-            (0,_) => Opt {
-                name: Long((long_name)),
-                hasarg: hasarg,
-                occur: occur,
-                aliases: Vec::new()
-            },
-            (1,0) => Opt {
-                name: Short(short_name.char_at(0)),
-                hasarg: hasarg,
-                occur: occur,
-                aliases: Vec::new()
-            },
-            (1,_) => Opt {
-                name: Long((long_name)),
-                hasarg: hasarg,
-                occur: occur,
-                aliases: vec!(
-                    Opt {
-                        name: Short(short_name.char_at(0)),
-                        hasarg: hasarg,
-                        occur:  occur,
-                        aliases: Vec::new()
-                    }
-                )
-            },
-            (_,_) => panic!("something is wrong with the long-form opt")
+            (0, 0) => panic!("this long-format option was given no name"),
+            (0, _) => {
+                Opt {
+                    name: Long((long_name)),
+                    hasarg: hasarg,
+                    occur: occur,
+                    aliases: Vec::new(),
+                }
+            }
+            (1, 0) => {
+                Opt {
+                    name: Short(short_name.char_at(0)),
+                    hasarg: hasarg,
+                    occur: occur,
+                    aliases: Vec::new(),
+                }
+            }
+            (1, _) => {
+                Opt {
+                    name: Long((long_name)),
+                    hasarg: hasarg,
+                    occur: occur,
+                    aliases: vec![Opt {
+                                      name: Short(short_name.char_at(0)),
+                                      hasarg: hasarg,
+                                      occur: occur,
+                                      aliases: Vec::new(),
+                                  }],
+                }
+            }
+            (_, _) => panic!("something is wrong with the long-form opt"),
         }
     }
 }
@@ -292,7 +298,7 @@ impl Matches {
     fn opt_vals(&self, nm: &str) -> Vec<Optval> {
         match find_opt(&self.opts[..], Name::from_str(nm)) {
             Some(id) => self.vals[id].clone(),
-            None => panic!("No option '{}' defined", nm)
+            None => panic!("No option '{}' defined", nm),
         }
     }
 
@@ -331,7 +337,7 @@ impl Matches {
         for nm in names {
             match self.opt_val(&nm[..]) {
                 Some(Val(ref s)) => return Some(s.clone()),
-                _ => ()
+                _ => (),
             }
         }
         None
@@ -347,7 +353,7 @@ impl Matches {
         for v in &r {
             match *v {
                 Val(ref s) => acc.push((*s).clone()),
-                _ => ()
+                _ => (),
             }
         }
         acc
@@ -361,7 +367,7 @@ impl Matches {
         }
         match vals[0] {
             Val(ref s) => Some((*s).clone()),
-            _ => None
+            _ => None,
         }
     }
 
@@ -378,11 +384,10 @@ impl Matches {
         } else {
             match vals[0] {
                 Val(ref s) => Some((*s).clone()),
-                _ => Some(def.to_owned())
+                _ => Some(def.to_owned()),
             }
         }
     }
-
 }
 
 fn is_arg(arg: &str) -> bool {
@@ -393,7 +398,7 @@ fn find_opt(opts: &[Opt], nm: Name) -> Option<usize> {
     // Search main options.
     let pos = opts.iter().position(|opt| opt.name == nm);
     if pos.is_some() {
-        return pos
+        return pos;
     }
 
     // Search in aliases.
@@ -422,7 +427,7 @@ pub fn reqopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptG
         hint: hint.to_owned(),
         desc: desc.to_owned(),
         hasarg: Yes,
-        occur: Req
+        occur: Req,
     }
 }
 
@@ -442,7 +447,7 @@ pub fn optopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptG
         hint: hint.to_owned(),
         desc: desc.to_owned(),
         hasarg: Yes,
-        occur: Optional
+        occur: Optional,
     }
 }
 
@@ -460,7 +465,7 @@ pub fn optflag(short_name: &str, long_name: &str, desc: &str) -> OptGroup {
         hint: "".to_owned(),
         desc: desc.to_owned(),
         hasarg: No,
-        occur: Optional
+        occur: Optional,
     }
 }
 
@@ -479,7 +484,7 @@ pub fn optflagmulti(short_name: &str, long_name: &str, desc: &str) -> OptGroup {
         hint: "".to_owned(),
         desc: desc.to_owned(),
         hasarg: No,
-        occur: Multi
+        occur: Multi,
     }
 }
 
@@ -499,7 +504,7 @@ pub fn optflagopt(short_name: &str, long_name: &str, desc: &str, hint: &str) ->
         hint: hint.to_owned(),
         desc: desc.to_owned(),
         hasarg: Maybe,
-        occur: Optional
+        occur: Optional,
     }
 }
 
@@ -520,7 +525,7 @@ pub fn optmulti(short_name: &str, long_name: &str, desc: &str, hint: &str) -> Op
         hint: hint.to_owned(),
         desc: desc.to_owned(),
         hasarg: Yes,
-        occur: Multi
+        occur: Multi,
     }
 }
 
@@ -530,7 +535,8 @@ pub fn opt(short_name: &str,
            desc: &str,
            hint: &str,
            hasarg: HasArg,
-           occur: Occur) -> OptGroup {
+           occur: Occur)
+           -> OptGroup {
     let len = short_name.len();
     assert!(len == 1 || len == 0);
     OptGroup {
@@ -539,28 +545,18 @@ pub fn opt(short_name: &str,
         hint: hint.to_owned(),
         desc: desc.to_owned(),
         hasarg: hasarg,
-        occur: occur
+        occur: occur,
     }
 }
 
 impl fmt::Display for Fail {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            ArgumentMissing(ref nm) => {
-                write!(f, "Argument to option '{}' missing.", *nm)
-            }
-            UnrecognizedOption(ref nm) => {
-                write!(f, "Unrecognized option: '{}'.", *nm)
-            }
-            OptionMissing(ref nm) => {
-                write!(f, "Required option '{}' missing.", *nm)
-            }
-            OptionDuplicated(ref nm) => {
-                write!(f, "Option '{}' given more than once.", *nm)
-            }
-            UnexpectedArgument(ref nm) => {
-                write!(f, "Option '{}' does not take an argument.", *nm)
-            }
+            ArgumentMissing(ref nm) => write!(f, "Argument to option '{}' missing.", *nm),
+            UnrecognizedOption(ref nm) => write!(f, "Unrecognized option: '{}'.", *nm),
+            OptionMissing(ref nm) => write!(f, "Required option '{}' missing.", *nm),
+            OptionDuplicated(ref nm) => write!(f, "Option '{}' given more than once.", *nm),
+            UnexpectedArgument(ref nm) => write!(f, "Option '{}' does not take an argument.", *nm),
         }
     }
 }
@@ -577,7 +573,9 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
     let opts: Vec<Opt> = optgrps.iter().map(|x| x.long_to_short()).collect();
     let n_opts = opts.len();
 
-    fn f(_x: usize) -> Vec<Optval> { Vec::new() }
+    fn f(_x: usize) -> Vec<Optval> {
+        Vec::new()
+    }
 
     let mut vals: Vec<_> = (0..n_opts).map(f).collect();
     let mut free: Vec<String> = Vec::new();
@@ -590,7 +588,10 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
             free.push(cur);
         } else if cur == "--" {
             let mut j = i + 1;
-            while j < l { free.push(args[j].clone()); j += 1; }
+            while j < l {
+                free.push(args[j].clone());
+                j += 1;
+            }
             break;
         } else {
             let mut names;
@@ -599,10 +600,9 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                 let tail = &cur[2..curlen];
                 let tail_eq: Vec<&str> = tail.split('=').collect();
                 if tail_eq.len() <= 1 {
-                    names = vec!(Long(tail.to_owned()));
+                    names = vec![Long(tail.to_owned())];
                 } else {
-                    names =
-                        vec!(Long(tail_eq[0].to_owned()));
+                    names = vec![Long(tail_eq[0].to_owned())];
                     i_arg = Some(tail_eq[1].to_owned());
                 }
             } else {
@@ -612,23 +612,22 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
                     let ch = cur.char_at(j);
                     let opt = Short(ch);
 
-                    /* In a series of potential options (eg. -aheJ), if we
-                       see one which takes an argument, we assume all
-                       subsequent characters make up the argument. This
-                       allows options such as -L/usr/local/lib/foo to be
-                       interpreted correctly
-                    */
+                    // In a series of potential options (eg. -aheJ), if we
+                    // see one which takes an argument, we assume all
+                    // subsequent characters make up the argument. This
+                    // allows options such as -L/usr/local/lib/foo to be
+                    // interpreted correctly
 
                     let opt_id = match find_opt(&opts, opt.clone()) {
-                      Some(id) => id,
-                      None => return Err(UnrecognizedOption(opt.to_string()))
+                        Some(id) => id,
+                        None => return Err(UnrecognizedOption(opt.to_string())),
                     };
 
                     names.push(opt);
 
                     let arg_follows = match opts[opt_id].hasarg {
                         Yes | Maybe => true,
-                        No => false
+                        No => false,
                     };
 
                     let next = j + ch.len_utf8();
@@ -644,44 +643,42 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
             for nm in &names {
                 name_pos += 1;
                 let optid = match find_opt(&opts, (*nm).clone()) {
-                  Some(id) => id,
-                  None => return Err(UnrecognizedOption(nm.to_string()))
+                    Some(id) => id,
+                    None => return Err(UnrecognizedOption(nm.to_string())),
                 };
                 match opts[optid].hasarg {
-                  No => {
-                    if name_pos == names.len() && !i_arg.is_none() {
-                        return Err(UnexpectedArgument(nm.to_string()));
-                    }
-                    let v = &mut vals[optid];
-                    v.push(Given);
-                  }
-                  Maybe => {
-                    if !i_arg.is_none() {
-                        let v = &mut vals[optid];
-                        v.push(Val((i_arg.clone())
-                            .unwrap()));
-                    } else if name_pos < names.len() || i + 1 == l ||
-                            is_arg(&args[i + 1][..]) {
+                    No => {
+                        if name_pos == names.len() && !i_arg.is_none() {
+                            return Err(UnexpectedArgument(nm.to_string()));
+                        }
                         let v = &mut vals[optid];
                         v.push(Given);
-                    } else {
-                        i += 1;
-                        let v = &mut vals[optid];
-                        v.push(Val(args[i].clone()));
                     }
-                  }
-                  Yes => {
-                    if !i_arg.is_none() {
-                        let v = &mut vals[optid];
-                        v.push(Val(i_arg.clone().unwrap()));
-                    } else if i + 1 == l {
-                        return Err(ArgumentMissing(nm.to_string()));
-                    } else {
-                        i += 1;
-                        let v = &mut vals[optid];
-                        v.push(Val(args[i].clone()));
+                    Maybe => {
+                        if !i_arg.is_none() {
+                            let v = &mut vals[optid];
+                            v.push(Val((i_arg.clone()).unwrap()));
+                        } else if name_pos < names.len() || i + 1 == l || is_arg(&args[i + 1][..]) {
+                            let v = &mut vals[optid];
+                            v.push(Given);
+                        } else {
+                            i += 1;
+                            let v = &mut vals[optid];
+                            v.push(Val(args[i].clone()));
+                        }
+                    }
+                    Yes => {
+                        if !i_arg.is_none() {
+                            let v = &mut vals[optid];
+                            v.push(Val(i_arg.clone().unwrap()));
+                        } else if i + 1 == l {
+                            return Err(ArgumentMissing(nm.to_string()));
+                        } else {
+                            i += 1;
+                            let v = &mut vals[optid];
+                            v.push(Val(args[i].clone()));
+                        }
                     }
-                  }
                 }
             }
         }
@@ -700,7 +697,7 @@ pub fn getopts(args: &[String], optgrps: &[OptGroup]) -> Result {
     Ok(Matches {
         opts: opts,
         vals: vals,
-        free: free
+        free: free,
     })
 }
 
@@ -783,7 +780,8 @@ pub fn usage(brief: &str, opts: &[OptGroup]) -> String {
         row
     });
 
-    format!("{}\n\nOptions:\n{}\n", brief,
+    format!("{}\n\nOptions:\n{}\n",
+            brief,
             rows.collect::<Vec<String>>().join("\n"))
 }
 
@@ -836,19 +834,19 @@ pub fn short_usage(program_name: &str, opts: &[OptGroup]) -> String {
 
 #[derive(Copy, Clone)]
 enum SplitWithinState {
-    A,  // leading whitespace, initial state
-    B,  // words
-    C,  // internal and trailing whitespace
+    A, // leading whitespace, initial state
+    B, // words
+    C, // internal and trailing whitespace
 }
 #[derive(Copy, Clone)]
 enum Whitespace {
     Ws, // current char is whitespace
-    Cr  // current char is not whitespace
+    Cr, // current char is not whitespace
 }
 #[derive(Copy, Clone)]
 enum LengthLimit {
     UnderLim, // current char makes current substring still fit in limit
-    OverLim   // current char makes current substring no longer fit in limit
+    OverLim, // current char makes current substring no longer fit in limit
 }
 
 
@@ -863,8 +861,8 @@ enum LengthLimit {
 ///
 /// Panics during iteration if the string contains a non-whitespace
 /// sequence longer than the limit.
-fn each_split_within<F>(ss: &str, lim: usize, mut it: F) -> bool where
-    F: FnMut(&str) -> bool
+fn each_split_within<F>(ss: &str, lim: usize, mut it: F) -> bool
+    where F: FnMut(&str) -> bool
 {
     // Just for fun, let's write this as a state machine:
 
@@ -883,18 +881,31 @@ fn each_split_within<F>(ss: &str, lim: usize, mut it: F) -> bool where
     }
 
     let mut machine = |cont: &mut bool, (i, c): (usize, char)| -> bool {
-        let whitespace = if c.is_whitespace() { Ws }       else { Cr };
-        let limit      = if (i - slice_start + 1) <= lim  { UnderLim } else { OverLim };
+        let whitespace = if c.is_whitespace() {
+            Ws
+        } else {
+            Cr
+        };
+        let limit = if (i - slice_start + 1) <= lim {
+            UnderLim
+        } else {
+            OverLim
+        };
 
         state = match (state, whitespace, limit) {
-            (A, Ws, _)        => { A }
-            (A, Cr, _)        => { slice_start = i; last_start = i; B }
-
-            (B, Cr, UnderLim) => { B }
-            (B, Cr, OverLim)  if (i - last_start + 1) > lim
-                            => panic!("word starting with {} longer than limit!",
-                                      &ss[last_start..i + 1]),
-            (B, Cr, OverLim)  => {
+            (A, Ws, _) => A,
+            (A, Cr, _) => {
+                slice_start = i;
+                last_start = i;
+                B
+            }
+
+            (B, Cr, UnderLim) => B,
+            (B, Cr, OverLim) if (i - last_start + 1) > lim => {
+                panic!("word starting with {} longer than limit!",
+                       &ss[last_start..i + 1])
+            }
+            (B, Cr, OverLim) => {
                 *cont = it(&ss[slice_start..last_end]);
                 slice_start = last_start;
                 B
@@ -903,7 +914,7 @@ fn each_split_within<F>(ss: &str, lim: usize, mut it: F) -> bool where
                 last_end = i;
                 C
             }
-            (B, Ws, OverLim)  => {
+            (B, Ws, OverLim) => {
                 last_end = i;
                 *cont = it(&ss[slice_start..last_end]);
                 A
@@ -913,20 +924,18 @@ fn each_split_within<F>(ss: &str, lim: usize, mut it: F) -> bool where
                 last_start = i;
                 B
             }
-            (C, Cr, OverLim)  => {
+            (C, Cr, OverLim) => {
                 *cont = it(&ss[slice_start..last_end]);
                 slice_start = i;
                 last_start = i;
                 last_end = i;
                 B
             }
-            (C, Ws, OverLim)  => {
+            (C, Ws, OverLim) => {
                 *cont = it(&ss[slice_start..last_end]);
                 A
             }
-            (C, Ws, UnderLim) => {
-                C
-            }
+            (C, Ws, UnderLim) => C,
         };
 
         *cont
@@ -935,7 +944,11 @@ fn each_split_within<F>(ss: &str, lim: usize, mut it: F) -> bool where
     ss.char_indices().all(|x| machine(&mut cont, x));
 
     // Let the automaton 'run out' by supplying trailing whitespace
-    while cont && match state { B | C => true, A => false } {
+    while cont &&
+          match state {
+        B | C => true,
+        A => false,
+    } {
         machine(&mut cont, (fake_i, ' '));
         fake_i += 1;
     }
@@ -946,19 +959,21 @@ fn each_split_within<F>(ss: &str, lim: usize, mut it: F) -> bool where
 fn test_split_within() {
     fn t(s: &str, i: usize, u: &[String]) {
         let mut v = Vec::new();
-        each_split_within(s, i, |s| { v.push(s.to_string()); true });
-        assert!(v.iter().zip(u).all(|(a,b)| a == b));
+        each_split_within(s, i, |s| {
+            v.push(s.to_string());
+            true
+        });
+        assert!(v.iter().zip(u).all(|(a, b)| a == b));
     }
     t("", 0, &[]);
     t("", 15, &[]);
     t("hello", 15, &["hello".to_string()]);
-    t("\nMary had a little lamb\nLittle lamb\n", 15, &[
-        "Mary had a".to_string(),
-        "little lamb".to_string(),
-        "Little lamb".to_string()
-    ]);
-    t("\nMary had a little lamb\nLittle lamb\n", ::std::usize::MAX,
-        &["Mary had a little lamb\nLittle lamb".to_string()]);
+    t("\nMary had a little lamb\nLittle lamb\n",
+      15,
+      &["Mary had a".to_string(), "little lamb".to_string(), "Little lamb".to_string()]);
+    t("\nMary had a little lamb\nLittle lamb\n",
+      ::std::usize::MAX,
+      &["Mary had a little lamb\nLittle lamb".to_string()]);
 }
 
 #[cfg(test)]
@@ -972,442 +987,446 @@ mod tests {
     // Tests for reqopt
     #[test]
     fn test_reqopt() {
-        let long_args = vec!("--test=20".to_string());
-        let opts = vec!(reqopt("t", "test", "testing", "TEST"));
+        let long_args = vec!["--test=20".to_string()];
+        let opts = vec![reqopt("t", "test", "testing", "TEST")];
         let rs = getopts(&long_args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert!(m.opt_present("test"));
-            assert_eq!(m.opt_str("test").unwrap(), "20");
-            assert!(m.opt_present("t"));
-            assert_eq!(m.opt_str("t").unwrap(), "20");
-          }
-          _ => { panic!("test_reqopt failed (long arg)"); }
+            Ok(ref m) => {
+                assert!(m.opt_present("test"));
+                assert_eq!(m.opt_str("test").unwrap(), "20");
+                assert!(m.opt_present("t"));
+                assert_eq!(m.opt_str("t").unwrap(), "20");
+            }
+            _ => {
+                panic!("test_reqopt failed (long arg)");
+            }
         }
-        let short_args = vec!("-t".to_string(), "20".to_string());
+        let short_args = vec!["-t".to_string(), "20".to_string()];
         match getopts(&short_args, &opts) {
-          Ok(ref m) => {
-            assert!((m.opt_present("test")));
-            assert_eq!(m.opt_str("test").unwrap(), "20");
-            assert!((m.opt_present("t")));
-            assert_eq!(m.opt_str("t").unwrap(), "20");
-          }
-          _ => { panic!("test_reqopt failed (short arg)"); }
+            Ok(ref m) => {
+                assert!((m.opt_present("test")));
+                assert_eq!(m.opt_str("test").unwrap(), "20");
+                assert!((m.opt_present("t")));
+                assert_eq!(m.opt_str("t").unwrap(), "20");
+            }
+            _ => {
+                panic!("test_reqopt failed (short arg)");
+            }
         }
     }
 
     #[test]
     fn test_reqopt_missing() {
-        let args = vec!("blah".to_string());
-        let opts = vec!(reqopt("t", "test", "testing", "TEST"));
+        let args = vec!["blah".to_string()];
+        let opts = vec![reqopt("t", "test", "testing", "TEST")];
         let rs = getopts(&args, &opts);
         match rs {
-          Err(OptionMissing(_)) => {},
-          _ => panic!()
+            Err(OptionMissing(_)) => {}
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_reqopt_no_arg() {
-        let long_args = vec!("--test".to_string());
-        let opts = vec!(reqopt("t", "test", "testing", "TEST"));
+        let long_args = vec!["--test".to_string()];
+        let opts = vec![reqopt("t", "test", "testing", "TEST")];
         let rs = getopts(&long_args, &opts);
         match rs {
-          Err(ArgumentMissing(_)) => {},
-          _ => panic!()
+            Err(ArgumentMissing(_)) => {}
+            _ => panic!(),
         }
-        let short_args = vec!("-t".to_string());
+        let short_args = vec!["-t".to_string()];
         match getopts(&short_args, &opts) {
-          Err(ArgumentMissing(_)) => {},
-          _ => panic!()
+            Err(ArgumentMissing(_)) => {}
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_reqopt_multi() {
-        let args = vec!("--test=20".to_string(), "-t".to_string(), "30".to_string());
-        let opts = vec!(reqopt("t", "test", "testing", "TEST"));
+        let args = vec!["--test=20".to_string(), "-t".to_string(), "30".to_string()];
+        let opts = vec![reqopt("t", "test", "testing", "TEST")];
         let rs = getopts(&args, &opts);
         match rs {
-          Err(OptionDuplicated(_)) => {},
-          _ => panic!()
+            Err(OptionDuplicated(_)) => {}
+            _ => panic!(),
         }
     }
 
     // Tests for optopt
     #[test]
     fn test_optopt() {
-        let long_args = vec!("--test=20".to_string());
-        let opts = vec!(optopt("t", "test", "testing", "TEST"));
+        let long_args = vec!["--test=20".to_string()];
+        let opts = vec![optopt("t", "test", "testing", "TEST")];
         let rs = getopts(&long_args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert!(m.opt_present("test"));
-            assert_eq!(m.opt_str("test").unwrap(), "20");
-            assert!((m.opt_present("t")));
-            assert_eq!(m.opt_str("t").unwrap(), "20");
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert!(m.opt_present("test"));
+                assert_eq!(m.opt_str("test").unwrap(), "20");
+                assert!((m.opt_present("t")));
+                assert_eq!(m.opt_str("t").unwrap(), "20");
+            }
+            _ => panic!(),
         }
-        let short_args = vec!("-t".to_string(), "20".to_string());
+        let short_args = vec!["-t".to_string(), "20".to_string()];
         match getopts(&short_args, &opts) {
-          Ok(ref m) => {
-            assert!((m.opt_present("test")));
-            assert_eq!(m.opt_str("test").unwrap(), "20");
-            assert!((m.opt_present("t")));
-            assert_eq!(m.opt_str("t").unwrap(), "20");
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert!((m.opt_present("test")));
+                assert_eq!(m.opt_str("test").unwrap(), "20");
+                assert!((m.opt_present("t")));
+                assert_eq!(m.opt_str("t").unwrap(), "20");
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optopt_missing() {
-        let args = vec!("blah".to_string());
-        let opts = vec!(optopt("t", "test", "testing", "TEST"));
+        let args = vec!["blah".to_string()];
+        let opts = vec![optopt("t", "test", "testing", "TEST")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert!(!m.opt_present("test"));
-            assert!(!m.opt_present("t"));
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert!(!m.opt_present("test"));
+                assert!(!m.opt_present("t"));
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optopt_no_arg() {
-        let long_args = vec!("--test".to_string());
-        let opts = vec!(optopt("t", "test", "testing", "TEST"));
+        let long_args = vec!["--test".to_string()];
+        let opts = vec![optopt("t", "test", "testing", "TEST")];
         let rs = getopts(&long_args, &opts);
         match rs {
-          Err(ArgumentMissing(_)) => {},
-          _ => panic!()
+            Err(ArgumentMissing(_)) => {}
+            _ => panic!(),
         }
-        let short_args = vec!("-t".to_string());
+        let short_args = vec!["-t".to_string()];
         match getopts(&short_args, &opts) {
-          Err(ArgumentMissing(_)) => {},
-          _ => panic!()
+            Err(ArgumentMissing(_)) => {}
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optopt_multi() {
-        let args = vec!("--test=20".to_string(), "-t".to_string(), "30".to_string());
-        let opts = vec!(optopt("t", "test", "testing", "TEST"));
+        let args = vec!["--test=20".to_string(), "-t".to_string(), "30".to_string()];
+        let opts = vec![optopt("t", "test", "testing", "TEST")];
         let rs = getopts(&args, &opts);
         match rs {
-          Err(OptionDuplicated(_)) => {},
-          _ => panic!()
+            Err(OptionDuplicated(_)) => {}
+            _ => panic!(),
         }
     }
 
     // Tests for optflag
     #[test]
     fn test_optflag() {
-        let long_args = vec!("--test".to_string());
-        let opts = vec!(optflag("t", "test", "testing"));
+        let long_args = vec!["--test".to_string()];
+        let opts = vec![optflag("t", "test", "testing")];
         let rs = getopts(&long_args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert!(m.opt_present("test"));
-            assert!(m.opt_present("t"));
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert!(m.opt_present("test"));
+                assert!(m.opt_present("t"));
+            }
+            _ => panic!(),
         }
-        let short_args = vec!("-t".to_string());
+        let short_args = vec!["-t".to_string()];
         match getopts(&short_args, &opts) {
-          Ok(ref m) => {
-            assert!(m.opt_present("test"));
-            assert!(m.opt_present("t"));
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert!(m.opt_present("test"));
+                assert!(m.opt_present("t"));
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optflag_missing() {
-        let args = vec!("blah".to_string());
-        let opts = vec!(optflag("t", "test", "testing"));
+        let args = vec!["blah".to_string()];
+        let opts = vec![optflag("t", "test", "testing")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert!(!m.opt_present("test"));
-            assert!(!m.opt_present("t"));
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert!(!m.opt_present("test"));
+                assert!(!m.opt_present("t"));
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optflag_long_arg() {
-        let args = vec!("--test=20".to_string());
-        let opts = vec!(optflag("t", "test", "testing"));
+        let args = vec!["--test=20".to_string()];
+        let opts = vec![optflag("t", "test", "testing")];
         let rs = getopts(&args, &opts);
         match rs {
-          Err(UnexpectedArgument(_)) => {},
-          _ => panic!()
+            Err(UnexpectedArgument(_)) => {}
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optflag_multi() {
-        let args = vec!("--test".to_string(), "-t".to_string());
-        let opts = vec!(optflag("t", "test", "testing"));
+        let args = vec!["--test".to_string(), "-t".to_string()];
+        let opts = vec![optflag("t", "test", "testing")];
         let rs = getopts(&args, &opts);
         match rs {
-          Err(OptionDuplicated(_)) => {},
-          _ => panic!()
+            Err(OptionDuplicated(_)) => {}
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optflag_short_arg() {
-        let args = vec!("-t".to_string(), "20".to_string());
-        let opts = vec!(optflag("t", "test", "testing"));
+        let args = vec!["-t".to_string(), "20".to_string()];
+        let opts = vec![optflag("t", "test", "testing")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-            // The next variable after the flag is just a free argument
+            Ok(ref m) => {
+                // The next variable after the flag is just a free argument
 
-            assert!(m.free[0] == "20");
-          }
-          _ => panic!()
+                assert!(m.free[0] == "20");
+            }
+            _ => panic!(),
         }
     }
 
     // Tests for optflagmulti
     #[test]
     fn test_optflagmulti_short1() {
-        let args = vec!("-v".to_string());
-        let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+        let args = vec!["-v".to_string()];
+        let opts = vec![optflagmulti("v", "verbose", "verbosity")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert_eq!(m.opt_count("v"), 1);
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert_eq!(m.opt_count("v"), 1);
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optflagmulti_short2a() {
-        let args = vec!("-v".to_string(), "-v".to_string());
-        let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+        let args = vec!["-v".to_string(), "-v".to_string()];
+        let opts = vec![optflagmulti("v", "verbose", "verbosity")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert_eq!(m.opt_count("v"), 2);
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert_eq!(m.opt_count("v"), 2);
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optflagmulti_short2b() {
-        let args = vec!("-vv".to_string());
-        let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+        let args = vec!["-vv".to_string()];
+        let opts = vec![optflagmulti("v", "verbose", "verbosity")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert_eq!(m.opt_count("v"), 2);
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert_eq!(m.opt_count("v"), 2);
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optflagmulti_long1() {
-        let args = vec!("--verbose".to_string());
-        let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+        let args = vec!["--verbose".to_string()];
+        let opts = vec![optflagmulti("v", "verbose", "verbosity")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert_eq!(m.opt_count("verbose"), 1);
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert_eq!(m.opt_count("verbose"), 1);
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optflagmulti_long2() {
-        let args = vec!("--verbose".to_string(), "--verbose".to_string());
-        let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+        let args = vec!["--verbose".to_string(), "--verbose".to_string()];
+        let opts = vec![optflagmulti("v", "verbose", "verbosity")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert_eq!(m.opt_count("verbose"), 2);
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert_eq!(m.opt_count("verbose"), 2);
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optflagmulti_mix() {
-        let args = vec!("--verbose".to_string(), "-v".to_string(),
-                        "-vv".to_string(), "verbose".to_string());
-        let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+        let args = vec!["--verbose".to_string(),
+                        "-v".to_string(),
+                        "-vv".to_string(),
+                        "verbose".to_string()];
+        let opts = vec![optflagmulti("v", "verbose", "verbosity")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert_eq!(m.opt_count("verbose"), 4);
-            assert_eq!(m.opt_count("v"), 4);
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert_eq!(m.opt_count("verbose"), 4);
+                assert_eq!(m.opt_count("v"), 4);
+            }
+            _ => panic!(),
         }
     }
 
     // Tests for optmulti
     #[test]
     fn test_optmulti() {
-        let long_args = vec!("--test=20".to_string());
-        let opts = vec!(optmulti("t", "test", "testing", "TEST"));
+        let long_args = vec!["--test=20".to_string()];
+        let opts = vec![optmulti("t", "test", "testing", "TEST")];
         let rs = getopts(&long_args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert!((m.opt_present("test")));
-            assert_eq!(m.opt_str("test").unwrap(), "20");
-            assert!((m.opt_present("t")));
-            assert_eq!(m.opt_str("t").unwrap(), "20");
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert!((m.opt_present("test")));
+                assert_eq!(m.opt_str("test").unwrap(), "20");
+                assert!((m.opt_present("t")));
+                assert_eq!(m.opt_str("t").unwrap(), "20");
+            }
+            _ => panic!(),
         }
-        let short_args = vec!("-t".to_string(), "20".to_string());
+        let short_args = vec!["-t".to_string(), "20".to_string()];
         match getopts(&short_args, &opts) {
-          Ok(ref m) => {
-            assert!((m.opt_present("test")));
-            assert_eq!(m.opt_str("test").unwrap(), "20");
-            assert!((m.opt_present("t")));
-            assert_eq!(m.opt_str("t").unwrap(), "20");
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert!((m.opt_present("test")));
+                assert_eq!(m.opt_str("test").unwrap(), "20");
+                assert!((m.opt_present("t")));
+                assert_eq!(m.opt_str("t").unwrap(), "20");
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optmulti_missing() {
-        let args = vec!("blah".to_string());
-        let opts = vec!(optmulti("t", "test", "testing", "TEST"));
+        let args = vec!["blah".to_string()];
+        let opts = vec![optmulti("t", "test", "testing", "TEST")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert!(!m.opt_present("test"));
-            assert!(!m.opt_present("t"));
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert!(!m.opt_present("test"));
+                assert!(!m.opt_present("t"));
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optmulti_no_arg() {
-        let long_args = vec!("--test".to_string());
-        let opts = vec!(optmulti("t", "test", "testing", "TEST"));
+        let long_args = vec!["--test".to_string()];
+        let opts = vec![optmulti("t", "test", "testing", "TEST")];
         let rs = getopts(&long_args, &opts);
         match rs {
-          Err(ArgumentMissing(_)) => {},
-          _ => panic!()
+            Err(ArgumentMissing(_)) => {}
+            _ => panic!(),
         }
-        let short_args = vec!("-t".to_string());
+        let short_args = vec!["-t".to_string()];
         match getopts(&short_args, &opts) {
-          Err(ArgumentMissing(_)) => {},
-          _ => panic!()
+            Err(ArgumentMissing(_)) => {}
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_optmulti_multi() {
-        let args = vec!("--test=20".to_string(), "-t".to_string(), "30".to_string());
-        let opts = vec!(optmulti("t", "test", "testing", "TEST"));
+        let args = vec!["--test=20".to_string(), "-t".to_string(), "30".to_string()];
+        let opts = vec![optmulti("t", "test", "testing", "TEST")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-              assert!(m.opt_present("test"));
-              assert_eq!(m.opt_str("test").unwrap(), "20");
-              assert!(m.opt_present("t"));
-              assert_eq!(m.opt_str("t").unwrap(), "20");
-              let pair = m.opt_strs("test");
-              assert!(pair[0] == "20");
-              assert!(pair[1] == "30");
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert!(m.opt_present("test"));
+                assert_eq!(m.opt_str("test").unwrap(), "20");
+                assert!(m.opt_present("t"));
+                assert_eq!(m.opt_str("t").unwrap(), "20");
+                let pair = m.opt_strs("test");
+                assert!(pair[0] == "20");
+                assert!(pair[1] == "30");
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_unrecognized_option() {
-        let long_args = vec!("--untest".to_string());
-        let opts = vec!(optmulti("t", "test", "testing", "TEST"));
+        let long_args = vec!["--untest".to_string()];
+        let opts = vec![optmulti("t", "test", "testing", "TEST")];
         let rs = getopts(&long_args, &opts);
         match rs {
-          Err(UnrecognizedOption(_)) => {},
-          _ => panic!()
+            Err(UnrecognizedOption(_)) => {}
+            _ => panic!(),
         }
-        let short_args = vec!("-u".to_string());
+        let short_args = vec!["-u".to_string()];
         match getopts(&short_args, &opts) {
-          Err(UnrecognizedOption(_)) => {},
-          _ => panic!()
+            Err(UnrecognizedOption(_)) => {}
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_combined() {
-        let args =
-            vec!("prog".to_string(),
-                 "free1".to_string(),
-                 "-s".to_string(),
-                 "20".to_string(),
-                 "free2".to_string(),
-                 "--flag".to_string(),
-                 "--long=30".to_string(),
-                 "-f".to_string(),
-                 "-m".to_string(),
-                 "40".to_string(),
-                 "-m".to_string(),
-                 "50".to_string(),
-                 "-n".to_string(),
-                 "-A B".to_string(),
-                 "-n".to_string(),
-                 "-60 70".to_string());
-        let opts =
-            vec!(optopt("s", "something", "something", "SOMETHING"),
-              optflag("", "flag", "a flag"),
-              reqopt("", "long", "hi", "LONG"),
-              optflag("f", "", "another flag"),
-              optmulti("m", "", "mmmmmm", "YUM"),
-              optmulti("n", "", "nothing", "NOTHING"),
-              optopt("", "notpresent", "nothing to see here", "NOPE"));
+        let args = vec!["prog".to_string(),
+                        "free1".to_string(),
+                        "-s".to_string(),
+                        "20".to_string(),
+                        "free2".to_string(),
+                        "--flag".to_string(),
+                        "--long=30".to_string(),
+                        "-f".to_string(),
+                        "-m".to_string(),
+                        "40".to_string(),
+                        "-m".to_string(),
+                        "50".to_string(),
+                        "-n".to_string(),
+                        "-A B".to_string(),
+                        "-n".to_string(),
+                        "-60 70".to_string()];
+        let opts = vec![optopt("s", "something", "something", "SOMETHING"),
+                        optflag("", "flag", "a flag"),
+                        reqopt("", "long", "hi", "LONG"),
+                        optflag("f", "", "another flag"),
+                        optmulti("m", "", "mmmmmm", "YUM"),
+                        optmulti("n", "", "nothing", "NOTHING"),
+                        optopt("", "notpresent", "nothing to see here", "NOPE")];
         let rs = getopts(&args, &opts);
         match rs {
-          Ok(ref m) => {
-            assert!(m.free[0] == "prog");
-            assert!(m.free[1] == "free1");
-            assert_eq!(m.opt_str("s").unwrap(), "20");
-            assert!(m.free[2] == "free2");
-            assert!((m.opt_present("flag")));
-            assert_eq!(m.opt_str("long").unwrap(), "30");
-            assert!((m.opt_present("f")));
-            let pair = m.opt_strs("m");
-            assert!(pair[0] == "40");
-            assert!(pair[1] == "50");
-            let pair = m.opt_strs("n");
-            assert!(pair[0] == "-A B");
-            assert!(pair[1] == "-60 70");
-            assert!((!m.opt_present("notpresent")));
-          }
-          _ => panic!()
+            Ok(ref m) => {
+                assert!(m.free[0] == "prog");
+                assert!(m.free[1] == "free1");
+                assert_eq!(m.opt_str("s").unwrap(), "20");
+                assert!(m.free[2] == "free2");
+                assert!((m.opt_present("flag")));
+                assert_eq!(m.opt_str("long").unwrap(), "30");
+                assert!((m.opt_present("f")));
+                let pair = m.opt_strs("m");
+                assert!(pair[0] == "40");
+                assert!(pair[1] == "50");
+                let pair = m.opt_strs("n");
+                assert!(pair[0] == "-A B");
+                assert!(pair[1] == "-60 70");
+                assert!((!m.opt_present("notpresent")));
+            }
+            _ => panic!(),
         }
     }
 
     #[test]
     fn test_multi() {
-        let opts = vec!(optopt("e", "", "encrypt", "ENCRYPT"),
-                     optopt("", "encrypt", "encrypt", "ENCRYPT"),
-                     optopt("f", "", "flag", "FLAG"));
+        let opts = vec![optopt("e", "", "encrypt", "ENCRYPT"),
+                        optopt("", "encrypt", "encrypt", "ENCRYPT"),
+                        optopt("f", "", "flag", "FLAG")];
 
-        let args_single = vec!("-e".to_string(), "foo".to_string());
+        let args_single = vec!["-e".to_string(), "foo".to_string()];
         let matches_single = &match getopts(&args_single, &opts) {
-          result::Result::Ok(m) => m,
-          result::Result::Err(_) => panic!()
+            result::Result::Ok(m) => m,
+            result::Result::Err(_) => panic!(),
         };
         assert!(matches_single.opts_present(&["e".to_string()]));
         assert!(matches_single.opts_present(&["encrypt".to_string(), "e".to_string()]));
@@ -1422,11 +1441,13 @@ mod tests {
         assert_eq!(matches_single.opts_str(&["encrypt".to_string(), "e".to_string()]).unwrap(),
                    "foo");
 
-        let args_both = vec!("-e".to_string(), "foo".to_string(), "--encrypt".to_string(),
-                             "foo".to_string());
+        let args_both = vec!["-e".to_string(),
+                             "foo".to_string(),
+                             "--encrypt".to_string(),
+                             "foo".to_string()];
         let matches_both = &match getopts(&args_both, &opts) {
-          result::Result::Ok(m) => m,
-          result::Result::Err(_) => panic!()
+            result::Result::Ok(m) => m,
+            result::Result::Err(_) => panic!(),
         };
         assert!(matches_both.opts_present(&["e".to_string()]));
         assert!(matches_both.opts_present(&["encrypt".to_string()]));
@@ -1437,7 +1458,8 @@ mod tests {
         assert!(!matches_both.opts_present(&[]));
 
         assert_eq!(matches_both.opts_str(&["e".to_string()]).unwrap(), "foo");
-        assert_eq!(matches_both.opts_str(&["encrypt".to_string()]).unwrap(), "foo");
+        assert_eq!(matches_both.opts_str(&["encrypt".to_string()]).unwrap(),
+                   "foo");
         assert_eq!(matches_both.opts_str(&["e".to_string(), "encrypt".to_string()]).unwrap(),
                    "foo");
         assert_eq!(matches_both.opts_str(&["encrypt".to_string(), "e".to_string()]).unwrap(),
@@ -1446,12 +1468,12 @@ mod tests {
 
     #[test]
     fn test_nospace() {
-        let args = vec!("-Lfoo".to_string(), "-M.".to_string());
-        let opts = vec!(optmulti("L", "", "library directory", "LIB"),
-                     optmulti("M", "", "something", "MMMM"));
+        let args = vec!["-Lfoo".to_string(), "-M.".to_string()];
+        let opts = vec![optmulti("L", "", "library directory", "LIB"),
+                        optmulti("M", "", "something", "MMMM")];
         let matches = &match getopts(&args, &opts) {
-          result::Result::Ok(m) => m,
-          result::Result::Err(_) => panic!()
+            result::Result::Ok(m) => m,
+            result::Result::Err(_) => panic!(),
         };
         assert!(matches.opts_present(&["L".to_string()]));
         assert_eq!(matches.opts_str(&["L".to_string()]).unwrap(), "foo");
@@ -1462,12 +1484,12 @@ mod tests {
 
     #[test]
     fn test_nospace_conflict() {
-        let args = vec!("-vvLverbose".to_string(), "-v".to_string() );
-        let opts = vec!(optmulti("L", "", "library directory", "LIB"),
-                     optflagmulti("v", "verbose", "Verbose"));
+        let args = vec!["-vvLverbose".to_string(), "-v".to_string()];
+        let opts = vec![optmulti("L", "", "library directory", "LIB"),
+                        optflagmulti("v", "verbose", "Verbose")];
         let matches = &match getopts(&args, &opts) {
-          result::Result::Ok(m) => m,
-          result::Result::Err(e) => panic!( "{}", e )
+            result::Result::Ok(m) => m,
+            result::Result::Err(e) => panic!("{}", e),
         };
         assert!(matches.opts_present(&["L".to_string()]));
         assert_eq!(matches.opts_str(&["L".to_string()]).unwrap(), "verbose");
@@ -1483,10 +1505,12 @@ mod tests {
             occur: Occur::Req,
             aliases: Vec::new(),
         };
-        short.aliases = vec!(Opt { name: Name::Short('b'),
-                                hasarg: HasArg::Yes,
-                                occur: Occur::Req,
-                                aliases: Vec::new() });
+        short.aliases = vec![Opt {
+                                 name: Name::Short('b'),
+                                 hasarg: HasArg::Yes,
+                                 occur: Occur::Req,
+                                 aliases: Vec::new(),
+                             }];
         let verbose = reqopt("b", "banana", "some bananas", "VAL");
 
         assert!(verbose.long_to_short() == short);
@@ -1494,10 +1518,9 @@ mod tests {
 
     #[test]
     fn test_aliases_long_and_short() {
-        let opts = vec!(
-            optflagmulti("a", "apple", "Desc"));
+        let opts = vec![optflagmulti("a", "apple", "Desc")];
 
-        let args = vec!("-a".to_string(), "--apple".to_string(), "-a".to_string());
+        let args = vec!["-a".to_string(), "--apple".to_string(), "-a".to_string()];
 
         let matches = getopts(&args, &opts).unwrap();
         assert_eq!(3, matches.opt_count("a"));
@@ -1506,13 +1529,11 @@ mod tests {
 
     #[test]
     fn test_usage() {
-        let optgroups = vec!(
-            reqopt("b", "banana", "Desc", "VAL"),
-            optopt("a", "012345678901234567890123456789",
-                             "Desc", "VAL"),
-            optflag("k", "kiwi", "Desc"),
-            optflagopt("p", "", "Desc", "VAL"),
-            optmulti("l", "", "Desc", "VAL"));
+        let optgroups = vec![reqopt("b", "banana", "Desc", "VAL"),
+                             optopt("a", "012345678901234567890123456789", "Desc", "VAL"),
+                             optflag("k", "kiwi", "Desc"),
+                             optflagopt("p", "", "Desc", "VAL"),
+                             optmulti("l", "", "Desc", "VAL")];
 
         let expected =
 "Usage: fruits
@@ -1538,11 +1559,13 @@ Options:
         // indentation should be 24 spaces
         // lines wrap after 78: or rather descriptions wrap after 54
 
-        let optgroups = vec!(
-            optflag("k", "kiwi",
-                "This is a long description which won't be wrapped..+.."), // 54
-            optflag("a", "apple",
-                "This is a long description which _will_ be wrapped..+.."));
+        let optgroups = vec![optflag("k",
+                                     "kiwi",
+                                     // 54
+                                     "This is a long description which won't be wrapped..+.."),
+                             optflag("a",
+                                     "apple",
+                                     "This is a long description which _will_ be wrapped..+..")];
 
         let expected =
 "Usage: fruits
@@ -1562,12 +1585,14 @@ Options:
 
     #[test]
     fn test_usage_description_multibyte_handling() {
-        let optgroups = vec!(
-            optflag("k", "k\u{2013}w\u{2013}",
-                "The word kiwi is normally spelled with two i's"),
-            optflag("a", "apple",
-                "This \u{201C}description\u{201D} has some characters that could \
-confuse the line wrapping; an apple costs 0.51€ in some parts of Europe."));
+        let optgroups = vec![optflag("k",
+                                     "k\u{2013}w\u{2013}",
+                                     "The word kiwi is normally spelled with two i's"),
+                             optflag("a",
+                                     "apple",
+                                     "This \u{201C}description\u{201D} has some characters that \
+                                      could confuse the line wrapping; an apple costs 0.51€ in \
+                                      some parts of Europe.")];
 
         let expected =
 "Usage: fruits
@@ -1588,13 +1613,11 @@ Options:
 
     #[test]
     fn test_short_usage() {
-        let optgroups = vec!(
-            reqopt("b", "banana", "Desc", "VAL"),
-            optopt("a", "012345678901234567890123456789",
-                     "Desc", "VAL"),
-            optflag("k", "kiwi", "Desc"),
-            optflagopt("p", "", "Desc", "VAL"),
-            optmulti("l", "", "Desc", "VAL"));
+        let optgroups = vec![reqopt("b", "banana", "Desc", "VAL"),
+                             optopt("a", "012345678901234567890123456789", "Desc", "VAL"),
+                             optflag("k", "kiwi", "Desc"),
+                             optflagopt("p", "", "Desc", "VAL"),
+                             optmulti("l", "", "Desc", "VAL")];
 
         let expected = "Usage: fruits -b VAL [-a VAL] [-k] [-p [VAL]] [-l VAL]..".to_string();
         let generated_usage = short_usage("fruits", &optgroups);