From dc1f3b79f8b528659e39057ac733d07e1051bc4d Mon Sep 17 00:00:00 2001 From: liv Date: Wed, 23 Jan 2019 20:48:01 +0100 Subject: add tests; refactor exercise links --- exercises/if/if1.rs | 1 + exercises/primitive_types/primitive_types4.rs | 4 ++-- exercises/primitive_types/primitive_types5.rs | 2 +- exercises/primitive_types/primitive_types6.rs | 2 +- exercises/strings/strings3.rs | 21 --------------------- exercises/test1.rs | 25 +++++++++++++++---------- exercises/test2.rs | 22 ++++++++++++++++++++++ exercises/test3.rs | 24 ++++++++++++++++++++++++ exercises/test4.rs | 12 ++++++++++++ exercises/tests/tests1.rs | 2 +- exercises/tests/tests3.rs | 4 ++-- exercises/tests/tests4.rs | 19 ------------------- src/verify.rs | 17 +++++++++-------- 13 files changed, 90 insertions(+), 65 deletions(-) delete mode 100755 exercises/strings/strings3.rs create mode 100755 exercises/test2.rs create mode 100755 exercises/test3.rs create mode 100644 exercises/test4.rs delete mode 100755 exercises/tests/tests4.rs diff --git a/exercises/if/if1.rs b/exercises/if/if1.rs index 5118657..6dd64c0 100755 --- a/exercises/if/if1.rs +++ b/exercises/if/if1.rs @@ -9,6 +9,7 @@ pub fn bigger(a: i32, b:i32) -> i32 { // Scroll down for hints. } +// Don't mind this for now :) #[cfg(test)] mod tests { use super::*; diff --git a/exercises/primitive_types/primitive_types4.rs b/exercises/primitive_types/primitive_types4.rs index 7dc9e47..1147cf7 100755 --- a/exercises/primitive_types/primitive_types4.rs +++ b/exercises/primitive_types/primitive_types4.rs @@ -39,11 +39,11 @@ fn main() { // Take a look at the Understanding Ownership -> Slices -> Other Slices section of the book: -// https://doc.rust-lang.org/stable/book/second-edition/ch04-03-slices.html#other-slices +// https://doc.rust-lang.org/book/ch04-03-slices.html // and use the starting and ending indices of the items in the Array // that you want to end up in the slice. // If you're curious why the right hand of the `==` comparison does not // have an ampersand for a reference since the left hand side is a // reference, take a look at the Deref coercions section of the book: -// https://doc.rust-lang.org/stable/book/second-edition/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods +// https://doc.rust-lang.org/book/ch15-02-deref.html diff --git a/exercises/primitive_types/primitive_types5.rs b/exercises/primitive_types/primitive_types5.rs index 4045e78..ae849b4 100755 --- a/exercises/primitive_types/primitive_types5.rs +++ b/exercises/primitive_types/primitive_types5.rs @@ -39,7 +39,7 @@ fn main() { // Take a look at the Data Types -> The Tuple Type section of the book: -// https://doc.rust-lang.org/stable/book/second-edition/ch03-02-data-types.html#the-tuple-type +// https://doc.rust-lang.org/stable/book/ch03-02-data-types.html#the-tuple-type // Particularly the part about destructuring (second to last example in the section). // You'll need to make a pattern to bind `name` and `age` to the appropriate parts // of the tuple. You can do it!! diff --git a/exercises/primitive_types/primitive_types6.rs b/exercises/primitive_types/primitive_types6.rs index 439a56b..634e56b 100755 --- a/exercises/primitive_types/primitive_types6.rs +++ b/exercises/primitive_types/primitive_types6.rs @@ -41,5 +41,5 @@ fn main() { // While you could use a destructuring `let` for the tuple here, try // indexing into it instead, as explained in the last example of the // Data Types -> The Tuple Type section of the book: -// https://doc.rust-lang.org/stable/book/second-edition/ch03-02-data-types.html#the-tuple-type +// https://doc.rust-lang.org/stable/book/ch03-02-data-types.html#the-tuple-type // Now you have another tool in your toolbox! diff --git a/exercises/strings/strings3.rs b/exercises/strings/strings3.rs deleted file mode 100755 index b6f6a1e..0000000 --- a/exercises/strings/strings3.rs +++ /dev/null @@ -1,21 +0,0 @@ -// strings3.rs -// Ok, here are a bunch of values-- some are `Strings`, some are `&strs`. Your -// task is to call one of these two functions on each value depending on what -// you think each value is. That is, add either `string_slice` or `string` -// before the parentheses on each line. If you're right, it will compile! - -fn string_slice(arg: &str) { println!("{}", arg); } -fn string(arg: String) { println!("{}", arg); } - -fn main() { - ("blue"); - ("red".to_string()); - (String::from("hi")); - ("rust is fun!".to_owned()); - ("nice weather".into()); - (format!("Interpolation {}", "Station")); - (&String::from("abc")[0..1]); - (" hello there ".trim()); - ("Happy Monday!".to_string().replace("Mon", "Tues")); - ("mY sHiFt KeY iS sTiCkY".to_lowercase()); -} diff --git a/exercises/test1.rs b/exercises/test1.rs index 6d7a2e8..f52513d 100644 --- a/exercises/test1.rs +++ b/exercises/test1.rs @@ -1,15 +1,20 @@ // test1.rs -// Make me compile! Scroll down for hints :) +// This is a test for the following sections: +// - Variables +// - Functions -fn something() -> [f32; 120] { - ??? -} - -fn something_else() -> String { - ??? -} +// Mary is buying apples. One apple usually costs 2 dollars, but if you buy +// more than 40 at once, each apple only costs 1! Write a function that calculates +// the price of an order of apples given the order amount. fn main() { - println!("This array is {} items long, and it should be 120", something().len()); - println!("This function returns a string: {}", something_else()); + let price1 = calculateprice(55); + let price2 = calculateprice(40); + + // Don't modify this! + if price1 == 55 && price2 == 80 { + println!("Good job!"); + } else { + panic!("Uh oh! Wrong price!"); + } } diff --git a/exercises/test2.rs b/exercises/test2.rs new file mode 100755 index 0000000..249abbc --- /dev/null +++ b/exercises/test2.rs @@ -0,0 +1,22 @@ +// test2.rs +// This is a test for the following sections: +// - Tests + +// This test isn't testing our function -- make it do that in such a way that +// the test passes. Then write a second test that tests that we get the result +// we expect to get when we call `times_two` with a negative number. +// No hints, you can do this :) + +pub fn times_two(num: i32) -> i32 { + num * 2 +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn returns_twice_of_positive_numbers() { + assert_eq!(4, 4); + } +} diff --git a/exercises/test3.rs b/exercises/test3.rs new file mode 100755 index 0000000..e94b069 --- /dev/null +++ b/exercises/test3.rs @@ -0,0 +1,24 @@ +// strings3.rs +// This is a test for the following sections: +// - Strings + +// Ok, here are a bunch of values-- some are `Strings`, some are `&strs`. Your +// task is to call one of these two functions on each value depending on what +// you think each value is. That is, add either `string_slice` or `string` +// before the parentheses on each line. If you're right, it will compile! + +fn string_slice(arg: &str) { println!("{}", arg); } +fn string(arg: String) { println!("{}", arg); } + +fn main() { + ("blue"); + ("red".to_string()); + (String::from("hi")); + ("rust is fun!".to_owned()); + ("nice weather".into()); + (format!("Interpolation {}", "Station")); + (&String::from("abc")[0..1]); + (" hello there ".trim()); + ("Happy Monday!".to_string().replace("Mon", "Tues")); + ("mY sHiFt KeY iS sTiCkY".to_lowercase()); +} diff --git a/exercises/test4.rs b/exercises/test4.rs new file mode 100644 index 0000000..e50f1b0 --- /dev/null +++ b/exercises/test4.rs @@ -0,0 +1,12 @@ +// test4.rs +// This test covers the sections: +// - Modules +// - Macros + +// Write a macro that passes the test! No hints this time, you can do it! + +fn main() { + if my_macro!("world!") != "Hello world!" { + panic!("Oh no! Wrong output!"); + } +} diff --git a/exercises/tests/tests1.rs b/exercises/tests/tests1.rs index 959ed85..b11221f 100755 --- a/exercises/tests/tests1.rs +++ b/exercises/tests/tests1.rs @@ -1,7 +1,7 @@ // tests1.rs // Tests are important to ensure that your code does what you think it should do. // Tests can be run on this file with the following command: -// rustc --test tests1.rs +// rustlings run --test exercises/tests/tests1.rs // This test has a problem with it -- make the test compile! Make the test // pass! Make the test fail! Scroll down for hints :) diff --git a/exercises/tests/tests3.rs b/exercises/tests/tests3.rs index e041f38..e10d2aa 100755 --- a/exercises/tests/tests3.rs +++ b/exercises/tests/tests3.rs @@ -1,6 +1,6 @@ // tests3.rs // This test isn't testing our function -- make it do that in such a way that -// the test passes. Then write a second test that tests that we get the result +// the test passes. Then write a second test that tests whether we get the result // we expect to get when we call `is_even(5)`. Scroll down for hints! pub fn is_even(num: i32) -> bool { @@ -13,7 +13,7 @@ mod tests { #[test] fn is_true_when_even() { - assert!(false); + assert!(); } } diff --git a/exercises/tests/tests4.rs b/exercises/tests/tests4.rs deleted file mode 100755 index 23d444a..0000000 --- a/exercises/tests/tests4.rs +++ /dev/null @@ -1,19 +0,0 @@ -// tests4.rs -// This test isn't testing our function -- make it do that in such a way that -// the test passes. Then write a second test that tests that we get the result -// we expect to get when we call `times_two` with a negative number. -// No hints, you can do this :) - -pub fn times_two(num: i32) -> i32 { - num * 2 -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn returns_twice_of_positive_numbers() { - assert_eq!(4, 4); - } -} diff --git a/src/verify.rs b/src/verify.rs index c5f3266..9aa3a4b 100644 --- a/src/verify.rs +++ b/src/verify.rs @@ -8,36 +8,37 @@ pub fn verify() -> Result<(), ()> { compile_only("exercises/variables/variables2.rs")?; compile_only("exercises/variables/variables3.rs")?; compile_only("exercises/variables/variables4.rs")?; + test("exercises/if/if1.rs")?; compile_only("exercises/functions/functions1.rs")?; compile_only("exercises/functions/functions2.rs")?; compile_only("exercises/functions/functions3.rs")?; compile_only("exercises/functions/functions4.rs")?; compile_only("exercises/functions/functions5.rs")?; + compile_only("exercises/test1.rs")?; compile_only("exercises/primitive_types/primitive_types1.rs")?; compile_only("exercises/primitive_types/primitive_types2.rs")?; compile_only("exercises/primitive_types/primitive_types3.rs")?; compile_only("exercises/primitive_types/primitive_types4.rs")?; compile_only("exercises/primitive_types/primitive_types5.rs")?; compile_only("exercises/primitive_types/primitive_types6.rs")?; - compile_only("exercises/test1.rs")?; test("exercises/tests/tests1.rs")?; test("exercises/tests/tests2.rs")?; test("exercises/tests/tests3.rs")?; - test("exercises/tests/tests4.rs")?; - test("exercises/if/if1.rs")?; + test("exercises/test2.rs")?; compile_only("exercises/strings/strings1.rs")?; compile_only("exercises/strings/strings2.rs")?; - compile_only("exercises/strings/strings3.rs")?; - compile_only("exercises/move_semantics/move_semantics1.rs")?; - compile_only("exercises/move_semantics/move_semantics2.rs")?; - compile_only("exercises/move_semantics/move_semantics3.rs")?; - compile_only("exercises/move_semantics/move_semantics4.rs")?; + compile_only("exercises/test3.rs")?; compile_only("exercises/modules/modules1.rs")?; compile_only("exercises/modules/modules2.rs")?; compile_only("exercises/macros/macros1.rs")?; compile_only("exercises/macros/macros2.rs")?; compile_only("exercises/macros/macros3.rs")?; compile_only("exercises/macros/macros4.rs")?; + compile_only("exercises/test4.rs")?; + compile_only("exercises/move_semantics/move_semantics1.rs")?; + compile_only("exercises/move_semantics/move_semantics2.rs")?; + compile_only("exercises/move_semantics/move_semantics3.rs")?; + compile_only("exercises/move_semantics/move_semantics4.rs")?; test("exercises/error_handling/errors1.rs")?; test("exercises/error_handling/errors2.rs")?; test("exercises/error_handling/errors3.rs")?; -- cgit v1.2.3