about summary refs log tree commit diff
path: root/src/libstd/getopts.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstd/getopts.rs')
-rw-r--r--src/libstd/getopts.rs170
1 files changed, 85 insertions, 85 deletions
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 4e851005de5..2090a3728db 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -480,7 +480,7 @@ pub mod groups {
     pub fn reqopt(short_name: &str, long_name: &str,
                   desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
-        assert len == 1 || len == 0;
+        fail_unless!(len == 1 || len == 0);
         return OptGroup { short_name: str::from_slice(short_name),
                 long_name: str::from_slice(long_name),
                 hint: str::from_slice(hint),
@@ -493,7 +493,7 @@ pub mod groups {
     pub fn optopt(short_name: &str, long_name: &str,
                   desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
-        assert len == 1 || len == 0;
+        fail_unless!(len == 1 || len == 0);
         return OptGroup {short_name: str::from_slice(short_name),
                 long_name: str::from_slice(long_name),
                 hint: str::from_slice(hint),
@@ -506,7 +506,7 @@ pub mod groups {
     pub fn optflag(short_name: &str, long_name: &str,
                    desc: &str) -> OptGroup {
         let len = short_name.len();
-        assert len == 1 || len == 0;
+        fail_unless!(len == 1 || len == 0);
         return OptGroup {short_name: str::from_slice(short_name),
                 long_name: str::from_slice(long_name),
                 hint: ~"",
@@ -519,7 +519,7 @@ pub mod groups {
     pub fn optflagopt(short_name: &str, long_name: &str,
                       desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
-        assert len == 1 || len == 0;
+        fail_unless!(len == 1 || len == 0);
         return OptGroup {short_name: str::from_slice(short_name),
                 long_name: str::from_slice(long_name),
                 hint: str::from_slice(hint),
@@ -535,7 +535,7 @@ pub mod groups {
     pub fn optmulti(short_name: &str, long_name: &str,
                     desc: &str, hint: &str) -> OptGroup {
         let len = short_name.len();
-        assert len == 1 || len == 0;
+        fail_unless!(len == 1 || len == 0);
         return OptGroup {short_name: str::from_slice(short_name),
                 long_name: str::from_slice(long_name),
                 hint: str::from_slice(hint),
@@ -647,11 +647,11 @@ mod tests {
 
     pub fn check_fail_type(f: Fail_, ft: FailType) {
         match f {
-          ArgumentMissing(_) => assert ft == ArgumentMissing_,
-          UnrecognizedOption(_) => assert ft == UnrecognizedOption_,
-          OptionMissing(_) => assert ft == OptionMissing_,
-          OptionDuplicated(_) => assert ft == OptionDuplicated_,
-          UnexpectedArgument(_) => assert ft == UnexpectedArgument_
+          ArgumentMissing(_) => fail_unless!(ft == ArgumentMissing_),
+          UnrecognizedOption(_) => fail_unless!(ft == UnrecognizedOption_),
+          OptionMissing(_) => fail_unless!(ft == OptionMissing_),
+          OptionDuplicated(_) => fail_unless!(ft == OptionDuplicated_),
+          UnexpectedArgument(_) => fail_unless!(ft == UnexpectedArgument_)
         }
     }
 
@@ -664,8 +664,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_present(m, ~"test"));
-            assert (opt_str(m, ~"test") == ~"20");
+            fail_unless!((opt_present(m, ~"test")));
+            fail_unless!((opt_str(m, ~"test") == ~"20"));
           }
           _ => { fail!(~"test_reqopt_long failed"); }
         }
@@ -711,8 +711,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_present(m, ~"t"));
-            assert (opt_str(m, ~"t") == ~"20");
+            fail_unless!((opt_present(m, ~"t")));
+            fail_unless!((opt_str(m, ~"t") == ~"20"));
           }
           _ => fail!()
         }
@@ -760,8 +760,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_present(m, ~"test"));
-            assert (opt_str(m, ~"test") == ~"20");
+            fail_unless!((opt_present(m, ~"test")));
+            fail_unless!((opt_str(m, ~"test") == ~"20"));
           }
           _ => fail!()
         }
@@ -773,7 +773,7 @@ mod tests {
         let opts = ~[optopt(~"test")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => assert (!opt_present(m, ~"test")),
+          Ok(ref m) => fail_unless!(!opt_present(m, ~"test")),
           _ => fail!()
         }
     }
@@ -807,8 +807,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_present(m, ~"t"));
-            assert (opt_str(m, ~"t") == ~"20");
+            fail_unless!((opt_present(m, ~"t")));
+            fail_unless!((opt_str(m, ~"t") == ~"20"));
           }
           _ => fail!()
         }
@@ -820,7 +820,7 @@ mod tests {
         let opts = ~[optopt(~"t")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => assert (!opt_present(m, ~"t")),
+          Ok(ref m) => fail_unless!(!opt_present(m, ~"t")),
           _ => fail!()
         }
     }
@@ -855,7 +855,7 @@ mod tests {
         let opts = ~[optflag(~"test")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => assert (opt_present(m, ~"test")),
+          Ok(ref m) => fail_unless!(opt_present(m, ~"test")),
           _ => fail!()
         }
     }
@@ -866,7 +866,7 @@ mod tests {
         let opts = ~[optflag(~"test")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => assert (!opt_present(m, ~"test")),
+          Ok(ref m) => fail_unless!(!opt_present(m, ~"test")),
           _ => fail!()
         }
     }
@@ -902,7 +902,7 @@ mod tests {
         let opts = ~[optflag(~"t")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => assert (opt_present(m, ~"t")),
+          Ok(ref m) => fail_unless!(opt_present(m, ~"t")),
           _ => fail!()
         }
     }
@@ -913,7 +913,7 @@ mod tests {
         let opts = ~[optflag(~"t")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => assert (!opt_present(m, ~"t")),
+          Ok(ref m) => fail_unless!(!opt_present(m, ~"t")),
           _ => fail!()
         }
     }
@@ -927,7 +927,7 @@ mod tests {
           Ok(ref m) => {
             // The next variable after the flag is just a free argument
 
-            assert (m.free[0] == ~"20");
+            fail_unless!((m.free[0] == ~"20"));
           }
           _ => fail!()
         }
@@ -952,7 +952,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_count(m, ~"v") == 1);
+            fail_unless!((opt_count(m, ~"v") == 1));
           }
           _ => fail!()
         }
@@ -965,7 +965,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_count(m, ~"v") == 2);
+            fail_unless!((opt_count(m, ~"v") == 2));
           }
           _ => fail!()
         }
@@ -978,7 +978,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_count(m, ~"v") == 2);
+            fail_unless!((opt_count(m, ~"v") == 2));
           }
           _ => fail!()
         }
@@ -991,7 +991,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_count(m, ~"verbose") == 1);
+            fail_unless!((opt_count(m, ~"verbose") == 1));
           }
           _ => fail!()
         }
@@ -1004,7 +1004,7 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_count(m, ~"verbose") == 2);
+            fail_unless!((opt_count(m, ~"verbose") == 2));
           }
           _ => fail!()
         }
@@ -1018,8 +1018,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_present(m, ~"test"));
-            assert (opt_str(m, ~"test") == ~"20");
+            fail_unless!((opt_present(m, ~"test")));
+            fail_unless!((opt_str(m, ~"test") == ~"20"));
           }
           _ => fail!()
         }
@@ -1031,7 +1031,7 @@ mod tests {
         let opts = ~[optmulti(~"test")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => assert (!opt_present(m, ~"test")),
+          Ok(ref m) => fail_unless!(!opt_present(m, ~"test")),
           _ => fail!()
         }
     }
@@ -1054,11 +1054,11 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-              assert (opt_present(m, ~"test"));
-              assert (opt_str(m, ~"test") == ~"20");
+              fail_unless!((opt_present(m, ~"test")));
+              fail_unless!((opt_str(m, ~"test") == ~"20"));
               let pair = opt_strs(m, ~"test");
-              assert (pair[0] == ~"20");
-              assert (pair[1] == ~"30");
+              fail_unless!((pair[0] == ~"20"));
+              fail_unless!((pair[1] == ~"30"));
           }
           _ => fail!()
         }
@@ -1071,8 +1071,8 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_present(m, ~"t"));
-            assert (opt_str(m, ~"t") == ~"20");
+            fail_unless!((opt_present(m, ~"t")));
+            fail_unless!((opt_str(m, ~"t") == ~"20"));
           }
           _ => fail!()
         }
@@ -1084,7 +1084,7 @@ mod tests {
         let opts = ~[optmulti(~"t")];
         let rs = getopts(args, opts);
         match rs {
-          Ok(ref m) => assert (!opt_present(m, ~"t")),
+          Ok(ref m) => fail_unless!(!opt_present(m, ~"t")),
           _ => fail!()
         }
     }
@@ -1107,11 +1107,11 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (opt_present(m, ~"t"));
-            assert (opt_str(m, ~"t") == ~"20");
+            fail_unless!((opt_present(m, ~"t")));
+            fail_unless!((opt_str(m, ~"t") == ~"20"));
             let pair = opt_strs(m, ~"t");
-            assert (pair[0] == ~"20");
-            assert (pair[1] == ~"30");
+            fail_unless!((pair[0] == ~"20"));
+            fail_unless!((pair[1] == ~"30"));
           }
           _ => fail!()
         }
@@ -1152,20 +1152,20 @@ mod tests {
         let rs = getopts(args, opts);
         match rs {
           Ok(ref m) => {
-            assert (m.free[0] == ~"prog");
-            assert (m.free[1] == ~"free1");
-            assert (opt_str(m, ~"s") == ~"20");
-            assert (m.free[2] == ~"free2");
-            assert (opt_present(m, ~"flag"));
-            assert (opt_str(m, ~"long") == ~"30");
-            assert (opt_present(m, ~"f"));
+            fail_unless!((m.free[0] == ~"prog"));
+            fail_unless!((m.free[1] == ~"free1"));
+            fail_unless!((opt_str(m, ~"s") == ~"20"));
+            fail_unless!((m.free[2] == ~"free2"));
+            fail_unless!((opt_present(m, ~"flag")));
+            fail_unless!((opt_str(m, ~"long") == ~"30"));
+            fail_unless!((opt_present(m, ~"f")));
             let pair = opt_strs(m, ~"m");
-            assert (pair[0] == ~"40");
-            assert (pair[1] == ~"50");
+            fail_unless!((pair[0] == ~"40"));
+            fail_unless!((pair[1] == ~"50"));
             let pair = opt_strs(m, ~"n");
-            assert (pair[0] == ~"-A B");
-            assert (pair[1] == ~"-60 70");
-            assert (!opt_present(m, ~"notpresent"));
+            fail_unless!((pair[0] == ~"-A B"));
+            fail_unless!((pair[1] == ~"-60 70"));
+            fail_unless!((!opt_present(m, ~"notpresent")));
           }
           _ => fail!()
         }
@@ -1179,17 +1179,17 @@ mod tests {
           result::Ok(m) => m,
           result::Err(_) => fail!()
         };
-        assert opts_present(matches, ~[~"e"]);
-        assert opts_present(matches, ~[~"encrypt"]);
-        assert opts_present(matches, ~[~"encrypt", ~"e"]);
-        assert opts_present(matches, ~[~"e", ~"encrypt"]);
-        assert !opts_present(matches, ~[~"thing"]);
-        assert !opts_present(matches, ~[]);
+        fail_unless!(opts_present(matches, ~[~"e"]));
+        fail_unless!(opts_present(matches, ~[~"encrypt"]));
+        fail_unless!(opts_present(matches, ~[~"encrypt", ~"e"]));
+        fail_unless!(opts_present(matches, ~[~"e", ~"encrypt"]));
+        fail_unless!(!opts_present(matches, ~[~"thing"]));
+        fail_unless!(!opts_present(matches, ~[]));
 
-        assert opts_str(matches, ~[~"e"]) == ~"foo";
-        assert opts_str(matches, ~[~"encrypt"]) == ~"foo";
-        assert opts_str(matches, ~[~"e", ~"encrypt"]) == ~"foo";
-        assert opts_str(matches, ~[~"encrypt", ~"e"]) == ~"foo";
+        fail_unless!(opts_str(matches, ~[~"e"]) == ~"foo");
+        fail_unless!(opts_str(matches, ~[~"encrypt"]) == ~"foo");
+        fail_unless!(opts_str(matches, ~[~"e", ~"encrypt"]) == ~"foo");
+        fail_unless!(opts_str(matches, ~[~"encrypt", ~"e"]) == ~"foo");
     }
 
     #[test]
@@ -1200,68 +1200,68 @@ mod tests {
           result::Ok(m) => m,
           result::Err(_) => fail!()
         };
-        assert opts_present(matches, ~[~"L"]);
-        assert opts_str(matches, ~[~"L"]) == ~"foo";
-        assert opts_present(matches, ~[~"M"]);
-        assert opts_str(matches, ~[~"M"]) == ~".";
+        fail_unless!(opts_present(matches, ~[~"L"]));
+        fail_unless!(opts_str(matches, ~[~"L"]) == ~"foo");
+        fail_unless!(opts_present(matches, ~[~"M"]));
+        fail_unless!(opts_str(matches, ~[~"M"]) == ~".");
 
     }
 
     #[test]
     pub fn test_groups_reqopt() {
         let opt = groups::reqopt(~"b", ~"banana", ~"some bananas", ~"VAL");
-        assert opt == OptGroup { short_name: ~"b",
+        fail_unless!(opt == OptGroup { short_name: ~"b",
                         long_name: ~"banana",
                         hint: ~"VAL",
                         desc: ~"some bananas",
                         hasarg: Yes,
-                        occur: Req }
+                        occur: Req })
     }
 
     #[test]
     pub fn test_groups_optopt() {
         let opt = groups::optopt(~"a", ~"apple", ~"some apples", ~"VAL");
-        assert opt == OptGroup { short_name: ~"a",
+        fail_unless!(opt == OptGroup { short_name: ~"a",
                         long_name: ~"apple",
                         hint: ~"VAL",
                         desc: ~"some apples",
                         hasarg: Yes,
-                        occur: Optional }
+                        occur: Optional })
     }
 
     #[test]
     pub fn test_groups_optflag() {
         let opt = groups::optflag(~"k", ~"kiwi", ~"some kiwis");
-        assert opt == OptGroup { short_name: ~"k",
+        fail_unless!(opt == OptGroup { short_name: ~"k",
                         long_name: ~"kiwi",
                         hint: ~"",
                         desc: ~"some kiwis",
                         hasarg: No,
-                        occur: Optional }
+                        occur: Optional })
     }
 
     #[test]
     pub fn test_groups_optflagopt() {
         let opt = groups::optflagopt(~"p", ~"pineapple",
                                        ~"some pineapples", ~"VAL");
-        assert opt == OptGroup { short_name: ~"p",
+        fail_unless!(opt == OptGroup { short_name: ~"p",
                         long_name: ~"pineapple",
                         hint: ~"VAL",
                         desc: ~"some pineapples",
                         hasarg: Maybe,
-                        occur: Optional }
+                        occur: Optional })
     }
 
     #[test]
     pub fn test_groups_optmulti() {
         let opt = groups::optmulti(~"l", ~"lime",
                                      ~"some limes", ~"VAL");
-        assert opt == OptGroup { short_name: ~"l",
+        fail_unless!(opt == OptGroup { short_name: ~"l",
                         long_name: ~"lime",
                         hint: ~"VAL",
                         desc: ~"some limes",
                         hasarg: Yes,
-                        occur: Multi }
+                        occur: Multi })
     }
 
     #[test]
@@ -1270,7 +1270,7 @@ mod tests {
         let verbose = groups::reqopt(~"b", ~"banana",
                                        ~"some bananas", ~"VAL");
 
-        assert groups::long_to_short(&verbose) == short;
+        fail_unless!(groups::long_to_short(&verbose) == short);
     }
 
     #[test]
@@ -1295,8 +1295,8 @@ mod tests {
                             ~"-p", ~"16", ~"l", ~"35"];
 
         // FIXME #4681: sort options here?
-        assert getopts(sample_args, short)
-            == groups::getopts(sample_args, verbose);
+        fail_unless!(getopts(sample_args, short)
+            == groups::getopts(sample_args, verbose));
     }
 
     #[test]
@@ -1327,7 +1327,7 @@ Options:
 
         debug!("expected: <<%s>>", expected);
         debug!("generated: <<%s>>", generated_usage);
-        assert generated_usage == expected;
+        fail_unless!(generated_usage == expected);
     }
 
     #[test]
@@ -1356,7 +1356,7 @@ Options:
 
         debug!("expected: <<%s>>", expected);
         debug!("generated: <<%s>>", usage);
-        assert usage == expected
+        fail_unless!(usage == expected)
     }
 }
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-10-26 20:33:54 +0000