diff --git a/solutions/brain_fuck/Cargo.toml b/solutions/brain_fuck/Cargo.toml
index 750968ee..a680e497 100644
--- a/solutions/brain_fuck/Cargo.toml
+++ b/solutions/brain_fuck/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brain_fuck"
 version = "0.1.0"
 authors = ["OGordoo <marcosafonso8@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/brain_fuck/src/main.rs b/solutions/brain_fuck/src/main.rs
index 98df4fae..74c571b7 100644
--- a/solutions/brain_fuck/src/main.rs
+++ b/solutions/brain_fuck/src/main.rs
@@ -1,56 +1,61 @@
-pub fn brainfuck(pattern: &str) {
-    let mut ds = vec![0 as i8; 5000];
-    let mut dp: usize = 0;
+const STACK_MEM: usize = 2048;
 
-    let pattern_arr = pattern.chars().collect::<Vec<char>>();
-
-    let mut i: i32 = 0;
-
-    if pattern_arr.len() == 0 {
+pub fn brainfuck(code: &str) {
+    if code.is_empty() {
         return;
     }
-    while i as usize <= (&pattern_arr).len() - 1 {
-        match &pattern_arr[i as usize] {
-            '>' => dp += 1,
-            '<' => dp -= 1,
-            '+' => ds[dp] = ds[dp] + 1,
-            '-' => ds[dp] = ds[dp] - 1,
-            '.' => {
-                print!("{}", ds[dp] as u8 as char);
+
+    let mut mem = [0i8; STACK_MEM];
+    let mut mp = 0;
+    let code = code.as_bytes();
+    let jumps = build_jumps(code);
+    let mut ip = 0;
+
+    while ip < code.len() {
+        match code[ip] {
+            b'>' => mp = (mp + 1) % STACK_MEM,
+            b'<' => mp = (mp + STACK_MEM - 1) % STACK_MEM,
+            b'+' => mem[mp] = mem[mp].wrapping_add(1),
+            b'-' => mem[mp] = mem[mp].wrapping_sub(1),
+            b'.' => print!("{}", mem[mp] as u8 as char),
+            b'[' => {
+                if mem[mp] == 0 {
+                    ip = jumps[ip]
+                }
             }
-            '[' => {
-                if ds[dp] == 0 {
-                    let mut nc = 1;
-                    while nc > 0 {
-                        i += 1;
-                        if pattern_arr[i as usize] == '[' {
-                            nc += 1;
-                        } else if pattern_arr[i as usize] == ']' {
-                            nc -= 1;
-                        }
-                    }
+            b']' => {
+                if mem[mp] != 0 {
+                    ip = jumps[ip]
                 }
             }
-            ']' => {
-                if ds[dp] != 0 {
-                    let mut nc = 1;
-                    while nc > 0 {
-                        i -= 1;
-                        if pattern_arr[i as usize] == ']' {
-                            nc += 1;
-                        } else if pattern_arr[i as usize] == '[' {
-                            nc -= 1;
-                        }
-                    }
+            _ => (),
+        }
+        ip += 1;
+    }
+}
+
+fn build_jumps(code: &[u8]) -> Vec<usize> {
+    let mut jumps = vec![0; code.len()];
+    let mut stack = Vec::new();
+
+    for (i, &b) in code.iter().enumerate() {
+        match b {
+            b'[' => stack.push(i),
+            b']' => {
+                if let Some(start) = stack.pop() {
+                    jumps[start] = i;
+                    jumps[i] = start;
                 }
             }
-            _ => {}
+            _ => (),
         }
-        i += 1;
     }
+
+    jumps
 }
 
 fn main() {
-    let args: Vec<String> = std::env::args().collect();
-    brainfuck(&args[1]);
+    if let Some(arg) = std::env::args().nth(1) {
+        brainfuck(&arg);
+    }
 }
diff --git a/solutions/check_user_name/Cargo.toml b/solutions/check_user_name/Cargo.toml
index 3177696a..04284c45 100644
--- a/solutions/check_user_name/Cargo.toml
+++ b/solutions/check_user_name/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "check_user_name"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/check_user_name/src/lib.rs b/solutions/check_user_name/src/lib.rs
index 255e2d22..26ada66e 100644
--- a/solutions/check_user_name/src/lib.rs
+++ b/solutions/check_user_name/src/lib.rs
@@ -10,22 +10,22 @@ pub struct User {
 }
 
 impl User {
-    pub fn new(user: String, access_level: AccessLevel) -> User {
-        User {
+    pub const fn new(user: String, access_level: AccessLevel) -> Self {
+        Self {
             access_level,
             name: user,
         }
     }
 
-    pub fn send_name(&self) -> Option<&str> {
-        match &self.access_level {
+    pub const fn send_name(&self) -> Option<&str> {
+        match self.access_level {
             AccessLevel::Guest => None,
-            _ => Some(&self.name),
+            _ => Some(self.name.as_str()),
         }
     }
 }
 
-pub fn check_user_name(user: &User) -> (bool, &str) {
+pub const fn check_user_name(user: &User) -> (bool, &str) {
     match user.send_name() {
         Some(name) => (true, name),
         None => (false, "ERROR: User is guest"),
diff --git a/solutions/drop_the_blog/Cargo.toml b/solutions/drop_the_blog/Cargo.toml
index f00120a5..8808b3e2 100644
--- a/solutions/drop_the_blog/Cargo.toml
+++ b/solutions/drop_the_blog/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "drop_the_blog"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/drop_the_blog/src/lib.rs b/solutions/drop_the_blog/src/lib.rs
index 5f26c66e..6721eb63 100644
--- a/solutions/drop_the_blog/src/lib.rs
+++ b/solutions/drop_the_blog/src/lib.rs
@@ -7,20 +7,23 @@ pub struct Blog {
 }
 
 impl Blog {
-    pub fn new() -> Blog {
-        Blog::default()
+    #[inline]
+    pub fn new() -> Self {
+        Default::default()
     }
 
-    pub fn new_article(&self, body: String) -> (usize, Article) {
+    pub fn new_article(&self, body: String) -> (usize, Article<'_>) {
         let new_article = Article::new(self.new_id(), body, self);
         self.states.borrow_mut().push(false);
         (new_article.id, new_article)
     }
 
+    #[inline]
     pub fn new_id(&self) -> usize {
-        self.states.borrow().len()
+        self.states.borrow().len() // const when borrow is stabilised
     }
 
+    #[inline]
     pub fn is_dropped(&self, id: usize) -> bool {
         self.states.borrow()[id]
     }
@@ -30,7 +33,7 @@ impl Blog {
             panic!("{} is already dropped", id)
         }
         self.states.borrow_mut()[id] = true;
-        self.drops.set(self.drops.get() + 1);
+        self.drops.update(|x| x + 1);
     }
 }
 
@@ -42,16 +45,15 @@ pub struct Article<'a> {
 }
 
 impl<'a> Article<'a> {
-    pub fn new(id: usize, body: String, parent: &'a Blog) -> Article {
-        Article { id, body, parent }
+    pub const fn new(id: usize, body: String, parent: &'a Blog) -> Self {
+        Self { id, body, parent }
     }
 
-    pub fn discard(self) {
-        drop(self);
-    }
+    #[inline]
+    pub fn discard(self) {}
 }
 
-impl<'a> Drop for Article<'a> {
+impl Drop for Article<'_> {
     fn drop(&mut self) {
         self.parent.add_drop(self.id);
     }
diff --git a/solutions/flat_tree/Cargo.toml b/solutions/flat_tree/Cargo.toml
index ef7925c9..71d7e03a 100644
--- a/solutions/flat_tree/Cargo.toml
+++ b/solutions/flat_tree/Cargo.toml
@@ -2,7 +2,7 @@
 name = "flat_tree"
 version = "0.1.0"
 authors = ["Augusto <aug.ornelas@gmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/flat_tree/src/lib.rs b/solutions/flat_tree/src/lib.rs
index 6700db35..ca1905f9 100644
--- a/solutions/flat_tree/src/lib.rs
+++ b/solutions/flat_tree/src/lib.rs
@@ -1,27 +1,6 @@
-// convert a binary search tree into a sorted array
-
 use std::collections::BTreeSet;
 
-#[allow(dead_code)]
+#[inline]
 pub fn flatten_tree<T: ToOwned<Owned = T>>(tree: &BTreeSet<T>) -> Vec<T> {
-    let mut flat = Vec::new();
-    for v in tree {
-        flat.push(v.to_owned());
-    }
-    flat
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let mut tree = BTreeSet::new();
-        tree.insert(3);
-        tree.insert(0);
-        tree.insert(9);
-        tree.insert(10);
-        assert_eq!(flatten_tree(&tree), &[0, 3, 9, 10]);
-    }
+    tree.iter().map(T::to_owned).collect()
 }
diff --git a/solutions/insertion_sort/Cargo.toml b/solutions/insertion_sort/Cargo.toml
index 15c8c5d2..b9fccd06 100644
--- a/solutions/insertion_sort/Cargo.toml
+++ b/solutions/insertion_sort/Cargo.toml
@@ -2,7 +2,7 @@
 name = "insertion_sort"
 version = "0.1.0"
 authors = ["Augusto <aug.ornelas@gmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/insertion_sort/src/lib.rs b/solutions/insertion_sort/src/lib.rs
index 0e0508cb..2ee551d7 100644
--- a/solutions/insertion_sort/src/lib.rs
+++ b/solutions/insertion_sort/src/lib.rs
@@ -1,58 +1,10 @@
-// How to avoid that students use sort without creating a program to
-// restrict functions in the code??
-// Just use a grep?
-// Implement the insertion sort algorithm but implement it in a step
-// by step so we can test that each step is corresponding with the algorithm
+pub fn insertion_sort(slice: &mut [i32], steps: usize) {
+    for i in 1..=steps.min(slice.len().saturating_sub(1)) {
+        let mut j = i;
 
-// Insertion sort algorithmAlgorithm
-
-// To sort an array of size n in ascending order:
-
-// 1: Iterate from arr[1] to arr[n] over the array.
-
-// 2: Compare the current element (key) to its predecessor.
-
-// 3: If the key element is smaller than its predecessor, compare it
-// to the elements before. Move the greater elements one position up
-// to make space for the swapped element.
-
-pub fn insertion_sort<T: Ord + Clone>(ar: &mut [T], steps: usize) {
-    assert!(steps > 0);
-    for i in 1..steps + 1 {
-        let key = ar[i].to_owned();
-        let mut j: i32 = i as i32 - 1;
-        while j >= 0 && key < ar[j as usize] {
-            // move the value to the next position
-            ar[(j + 1) as usize] = ar[j as usize].to_owned();
+        while j > 0 && slice[j] < slice[j - 1] {
+            slice.swap(j, j - 1);
             j -= 1;
         }
-        ar[(j + 1) as usize] = key
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let mut target = [5, 3, 7, 2, 1, 6, 8, 4];
-        let len = target.len();
-        insertion_sort(&mut target, len - 1);
-        assert_eq!(&[1, 2, 3, 4, 5, 6, 7, 8], &target);
-    }
-
-    #[test]
-    fn test_first_step() {
-        let mut target = [5, 3, 7, 2, 1, 6, 8, 4];
-        insertion_sort(&mut target, 1);
-        assert_eq!(&[3, 5, 7, 2, 1, 6, 8, 4], &target);
-    }
-
-    #[test]
-    fn test_second_step() {
-        let mut target = [5, 3, 7, 2, 1, 6, 8, 4];
-        insertion_sort(&mut target, 2);
-        assert_eq!(&[3, 5, 7, 2, 1, 6, 8, 4], &target);
     }
 }
diff --git a/solutions/inv_pyramid/Cargo.toml b/solutions/inv_pyramid/Cargo.toml
index 9b21bb44..462afa94 100644
--- a/solutions/inv_pyramid/Cargo.toml
+++ b/solutions/inv_pyramid/Cargo.toml
@@ -2,7 +2,7 @@
 name = "inv_pyramid"
 version = "0.1.0"
 authors = ["lee <lee-dasilva@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/inv_pyramid/src/lib.rs b/solutions/inv_pyramid/src/lib.rs
index 94c3fd04..c6f525f1 100644
--- a/solutions/inv_pyramid/src/lib.rs
+++ b/solutions/inv_pyramid/src/lib.rs
@@ -1,29 +1,7 @@
-// In general it's better to use `usize` rather than `u32` for variables that represent
-// addressable memory. Like the index or length of a vector, slice or string
+#[inline]
 pub fn inv_pyramid(st: String, max: usize) -> Vec<String> {
-    // Vec::with_capacity() creates a buffer with the size that
-    // we define. This makes the first operation be more costly because it
-    // allocates the memory at that moment but make the push calls more efficient
-    // because it avoids extra allocation
-    // It's good to use it if you know the final length of
-    // the vector
-    let mut vec = Vec::with_capacity(2 * max);
-    // In truth the length of the vector will always be ( 2*max - 1 ) at the
-    // end, but it doesn't make a lot of difference to allocate an
-    // extra element and that way I don't have to handle the case
-    // where max == 0 which cause a subtraction in overflow
-
-    // Pushes a string with `amount` number of spaces and the string
-    // `st` repeated `amount` number of times
-    let mut create_line = |amount| vec.push(format!("{:>1$}", st.repeat(amount), 2 * amount));
-
-    for amount in 1..max + 1 {
-        create_line(amount)
-    }
-
-    // the `rev` method reverses the range
-    for amount in (1..max).rev() {
-        create_line(amount)
-    }
-    return vec;
+    (1..=max)
+        .chain((1..max).rev())
+        .map(|i| format!("{:>1$}", st.repeat(i), 2 * i))
+        .collect()
 }
diff --git a/solutions/nextprime/Cargo.toml b/solutions/nextprime/Cargo.toml
index 76c0ee4b..1f42c2f5 100644
--- a/solutions/nextprime/Cargo.toml
+++ b/solutions/nextprime/Cargo.toml
@@ -2,7 +2,7 @@
 name = "nextprime"
 version = "0.1.0"
 authors = ["OGordoo <marcosafonso8@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/nextprime/src/lib.rs b/solutions/nextprime/src/lib.rs
index d55940d0..2c846328 100644
--- a/solutions/nextprime/src/lib.rs
+++ b/solutions/nextprime/src/lib.rs
@@ -1,24 +1,33 @@
-pub fn next_prime(nbr: u64) -> u64 {
-    if is_prime(nbr) {
-        return nbr;
-    }
-    next_prime(nbr + 1)
+#[inline]
+pub fn next_prime(nbr: usize) -> usize {
+    (nbr..).find(|&n| is_prime(n)).unwrap()
 }
 
-fn is_prime(nbr: u64) -> bool {
-    if nbr > 0 {
-        if nbr <= 1 {
-            return false;
-        }
-        let mut d = 2;
-        while d * d <= nbr {
-            if nbr % d == 0 {
-                return false;
-            }
-            d += 1;
-        }
+fn is_prime(n: usize) -> bool {
+    if n < 2 {
+        return false;
+    }
+    if n <= 3 {
         return true;
-    } else {
+    }
+    if n.is_multiple_of(2) || n.is_multiple_of(3) {
         return false;
     }
+
+    if n.is_multiple_of(5) || n.is_multiple_of(7) || n.is_multiple_of(11) || n.is_multiple_of(13) {
+        return n <= 13;
+    }
+
+    let sqrt_n = (n as f64).sqrt() as usize;
+    let mut d = 17;
+    let mut step = 2;
+
+    while d <= sqrt_n {
+        if n % d == 0 {
+            return false;
+        }
+        d += step;
+        step = 6 - step;
+    }
+    true
 }
diff --git a/solutions/order_books/Cargo.toml b/solutions/order_books/Cargo.toml
index 720b1b99..2bef8d38 100644
--- a/solutions/order_books/Cargo.toml
+++ b/solutions/order_books/Cargo.toml
@@ -2,7 +2,7 @@
 name = "order_books"
 version = "0.1.0"
 authors = ["OGordoo <marcosafonso8@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/order_books/src/lib.rs b/solutions/order_books/src/lib.rs
index 3ff246b9..da655a8b 100644
--- a/solutions/order_books/src/lib.rs
+++ b/solutions/order_books/src/lib.rs
@@ -1,23 +1,27 @@
 pub mod library {
     pub mod writers {
         use super::books::*;
+
         pub struct Writer {
             pub first_name: String,
             pub last_name: String,
             pub books: Vec<Book>,
         }
     }
+
     pub mod books {
         pub struct Book {
             pub title: String,
-            pub year: usize,
+            pub year: u32,
         }
     }
 }
+
 pub use library::writers::Writer;
 
+#[inline]
 pub fn order_books(writer: &mut Writer) {
     writer
         .books
-        .sort_by(|a, b| a.title.to_lowercase().cmp(&b.title.to_lowercase()))
+        .sort_unstable_by_key(|b| b.title.to_lowercase());
 }
diff --git a/solutions/organize_garage/Cargo.toml b/solutions/organize_garage/Cargo.toml
index 5672e0be..bf7e1139 100644
--- a/solutions/organize_garage/Cargo.toml
+++ b/solutions/organize_garage/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "organize_garage"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/organize_garage/src/lib.rs b/solutions/organize_garage/src/lib.rs
index 442c4e25..204f1425 100644
--- a/solutions/organize_garage/src/lib.rs
+++ b/solutions/organize_garage/src/lib.rs
@@ -7,22 +7,17 @@ pub struct Garage<T> {
 }
 
 impl<T: Add<Output = T> + Copy> Garage<T> {
+    #[inline]
     pub fn move_to_right(&mut self) {
-        if let Some(left_stuff) = self.left {
-            match self.right {
-                Some(right_stuff) => self.right = Some(right_stuff + left_stuff),
-                _ => self.right = Some(left_stuff),
-            }
-            self.left = None;
-        }
+        self.left
+            .take()
+            .map(|l| self.right = Some(self.right.take().map_or(l, |r| r + l)));
     }
+
+    #[inline]
     pub fn move_to_left(&mut self) {
-        if let Some(right_stuff) = self.right {
-            match self.left {
-                Some(left_stuff) => self.left = Some(left_stuff + right_stuff),
-                _ => self.left = Some(right_stuff),
-            }
-            self.right = None;
-        }
+        self.right
+            .take()
+            .map(|r| self.left = Some(self.left.take().map_or(r, |l| l + r)));
     }
 }
diff --git a/solutions/own_and_return/Cargo.toml b/solutions/own_and_return/Cargo.toml
index ee17598e..d90d0efa 100644
--- a/solutions/own_and_return/Cargo.toml
+++ b/solutions/own_and_return/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "own_and_return"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/own_and_return/src/lib.rs b/solutions/own_and_return/src/lib.rs
index 5478814e..bf8ffd3d 100644
--- a/solutions/own_and_return/src/lib.rs
+++ b/solutions/own_and_return/src/lib.rs
@@ -2,10 +2,12 @@ pub struct Film {
     pub name: String,
 }
 
+#[inline]
 pub fn take_film_name(to_consume: Film) -> String {
     to_consume.name
 }
 
+#[inline]
 pub fn read_film_name(only_to_return: &Film) -> String {
     only_to_return.name.clone()
 }
diff --git a/solutions/prime_checker/Cargo.toml b/solutions/prime_checker/Cargo.toml
index 92b4594d..364bff6b 100644
--- a/solutions/prime_checker/Cargo.toml
+++ b/solutions/prime_checker/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "prime_checker"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/prime_checker/src/lib.rs b/solutions/prime_checker/src/lib.rs
index 58df6423..33368e50 100644
--- a/solutions/prime_checker/src/lib.rs
+++ b/solutions/prime_checker/src/lib.rs
@@ -1,26 +1,34 @@
 #[derive(PartialEq, Eq, Debug)]
 pub enum PrimeErr {
     Even,
-    Divider(u32),
+    Divider(usize),
 }
 
-pub fn prime_checker(nb: u32) -> Option<Result<u32, PrimeErr>> {
-    if nb == 0 || nb == 1 {
+pub fn prime_checker(n: usize) -> Option<Result<usize, PrimeErr>> {
+    if n < 2 {
         return None;
-    } else if nb == 2 {
-        return Some(Ok(nb));
-    } else if nb % 2 == 0 {
+    }
+    if n <= 3 {
+        return Some(Ok(n));
+    }
+    if n.is_multiple_of(2) {
         return Some(Err(PrimeErr::Even));
-    } else {
-        let mut divider = 3;
-        let max_divide = ((nb as f64).sqrt() + 1.0) as u32;
-        while divider < max_divide {
-            if nb % divider == 0 {
-                return Some(Err(PrimeErr::Divider(divider)));
-            } else {
-                divider += 2;
-            }
+    }
+    if n.is_multiple_of(3) {
+        return Some(Err(PrimeErr::Divider(3)));
+    }
+
+    let sqrt_n = (n as f64).sqrt() as usize;
+    let mut d = 5;
+    let mut step = 2;
+
+    while d <= sqrt_n {
+        if n.is_multiple_of(d) {
+            return Some(Err(PrimeErr::Divider(d)));
         }
+        d += step;
+        step = 6 - step;
     }
-    Some(Ok(nb))
+
+    Some(Ok(n))
 }
diff --git a/solutions/queens/Cargo.toml b/solutions/queens/Cargo.toml
index 43a82e93..0fdb44f8 100644
--- a/solutions/queens/Cargo.toml
+++ b/solutions/queens/Cargo.toml
@@ -2,7 +2,7 @@
 name = "queens"
 version = "0.1.0"
 authors = ["MSilva95 <miguel-silva98@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/queens/src/lib.rs b/solutions/queens/src/lib.rs
index 8e9693b2..86d7eb78 100644
--- a/solutions/queens/src/lib.rs
+++ b/solutions/queens/src/lib.rs
@@ -1,171 +1,45 @@
-/*
-Given the position of two queens on a chess board, indicate whether or not they are positioned so that they can attack each other.
-
-In the game of chess, a queen can attack pieces which are on the same row, column, or diagonal.
-
-A chessboard can be represented by an 8 by 8 array.
-
-So if you're told the white queen is at (2, 3) and the black queen at (5, 6), then you'd know you've got a set-up like so:
-
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ W _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ B _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-
-
-You'd also be able to answer whether the queens can attack each other.
-In this case, that answer would be yes, they can, because both pieces share a diagonal.
-
-
-fn main() {
-    let white_queen = Queen::new(ChessPosition::new(2, 2).unwrap());
-    let black_queen = Queen::new(ChessPosition::new(0, 4).unwrap());
-
-    println!(
-        "Is it possible for the queens to attack each other? {}",
-        white_queen.can_attack(&black_queen)
-    );
-
-    let white_queen = Queen::new(ChessPosition::new(1, 2).unwrap());
-    let black_queen = Queen::new(ChessPosition::new(0, 4).unwrap());
-
-    println!(
-        "Is it possible for the queens to attack each other? {}",
-        white_queen.can_attack(&black_queen)
-    );
-}
-*/
-
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
 pub struct ChessPosition {
-    pub rank: i32,
-    pub file: i32,
-}
-
-#[derive(Debug)]
-pub struct Queen {
-    pub position: ChessPosition,
+    pub rank: usize,
+    pub file: usize,
 }
 
 impl ChessPosition {
-    pub fn new(rank: i32, file: i32) -> Option<Self> {
-        if rank < 0 || rank > 7 || file < 0 || file > 7 {
-            None
-        } else {
+    pub const fn new(rank: usize, file: usize) -> Option<Self> {
+        if matches!(rank, 0..8) && matches!(file, 0..8) {
             Some(Self { rank, file })
+        } else {
+            None
         }
     }
 }
 
-impl Queen {
-    pub fn new(position: ChessPosition) -> Self {
-        Self { position }
-    }
-
-    pub fn can_attack(&self, other: &Queen) -> bool {
-        let self_pos = &self.position;
-        let other_pos = &other.position;
-
-        self_pos.rank == other_pos.rank
-            || self_pos.file == other_pos.file
-            || Queen::are_on_diagonal(self_pos, other_pos)
-    }
-
-    pub fn are_on_diagonal(self_pos: &ChessPosition, other_pos: &ChessPosition) -> bool {
-        let rank_diff = (self_pos.rank - other_pos.rank).abs();
-        let file_diff = (self_pos.file - other_pos.file).abs();
-
-        rank_diff == file_diff
-    }
+#[derive(Debug, Clone, Copy)]
+pub struct Queen {
+    pub position: ChessPosition,
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_position_is_valid() {
-        assert!(ChessPosition::new(2, 4).is_some());
-        assert!(ChessPosition::new(-1, 2).is_none());
-        assert!(ChessPosition::new(8, 2).is_none());
-        assert!(ChessPosition::new(5, -1).is_none());
-        assert!(ChessPosition::new(5, 8).is_none());
-    }
-
-    #[test]
-    fn test_queen_valid_position() {
-        Queen::new(ChessPosition::new(2, 4).unwrap());
+impl Queen {
+    pub const fn new(position: ChessPosition) -> Self {
+        Self { position }
     }
 
-    #[test]
-    fn test_can_not_attack() {
-        let white_queen = Queen::new(ChessPosition::new(2, 4).unwrap());
-        let black_queen = Queen::new(ChessPosition::new(6, 6).unwrap());
-        let white_queen2 = Queen::new(ChessPosition::new(1, 2).unwrap());
-        let black_queen2 = Queen::new(ChessPosition::new(0, 4).unwrap());
-        let white_queen3 = Queen::new(ChessPosition::new(5, 3).unwrap());
-        let black_queen3 = Queen::new(ChessPosition::new(0, 6).unwrap());
-        let white_queen4 = Queen::new(ChessPosition::new(3, 7).unwrap());
-        let black_queen4 = Queen::new(ChessPosition::new(2, 0).unwrap());
-
-        assert!(!white_queen.can_attack(&black_queen));
-        assert!(!white_queen2.can_attack(&black_queen2));
-        assert!(!white_queen3.can_attack(&black_queen3));
-        assert!(!white_queen4.can_attack(&black_queen4));
+    pub const fn can_attack(self, other: Self) -> bool {
+        self.can_see_rank(other) || self.can_see_file(other) || self.can_see_diagonal(other)
     }
 
-    #[test]
-    fn test_same_rank() {
-        let white_queen = Queen::new(ChessPosition::new(2, 4).unwrap());
-        let black_queen = Queen::new(ChessPosition::new(2, 6).unwrap());
-        let white_queen2 = Queen::new(ChessPosition::new(1, 2).unwrap());
-        let black_queen2 = Queen::new(ChessPosition::new(1, 6).unwrap());
-        let white_queen3 = Queen::new(ChessPosition::new(4, 7).unwrap());
-        let black_queen3 = Queen::new(ChessPosition::new(4, 3).unwrap());
-        let white_queen4 = Queen::new(ChessPosition::new(5, 3).unwrap());
-        let black_queen4 = Queen::new(ChessPosition::new(5, 1).unwrap());
-
-        assert!(white_queen.can_attack(&black_queen));
-        assert!(white_queen2.can_attack(&black_queen2));
-        assert!(white_queen3.can_attack(&black_queen3));
-        assert!(white_queen4.can_attack(&black_queen4));
+    pub const fn can_see_rank(self, other: Self) -> bool {
+        self.position.rank == other.position.rank
     }
 
-    #[test]
-    fn test_same_file() {
-        let white_queen = Queen::new(ChessPosition::new(4, 5).unwrap());
-        let black_queen = Queen::new(ChessPosition::new(3, 5).unwrap());
-        let white_queen2 = Queen::new(ChessPosition::new(2, 2).unwrap());
-        let black_queen2 = Queen::new(ChessPosition::new(3, 2).unwrap());
-        let white_queen3 = Queen::new(ChessPosition::new(2, 6).unwrap());
-        let black_queen3 = Queen::new(ChessPosition::new(1, 6).unwrap());
-        let white_queen4 = Queen::new(ChessPosition::new(2, 7).unwrap());
-        let black_queen4 = Queen::new(ChessPosition::new(5, 7).unwrap());
-
-        assert!(white_queen.can_attack(&black_queen));
-        assert!(white_queen2.can_attack(&black_queen2));
-        assert!(white_queen3.can_attack(&black_queen3));
-        assert!(white_queen4.can_attack(&black_queen4));
+    pub const fn can_see_file(self, other: Self) -> bool {
+        self.position.file == other.position.file
     }
 
-    #[test]
-    fn test_same_diagonal() {
-        let white_queen = Queen::new(ChessPosition::new(2, 2).unwrap());
-        let black_queen = Queen::new(ChessPosition::new(0, 4).unwrap());
-        let white_queen2 = Queen::new(ChessPosition::new(2, 2).unwrap());
-        let black_queen2 = Queen::new(ChessPosition::new(3, 1).unwrap());
-        let white_queen3 = Queen::new(ChessPosition::new(2, 2).unwrap());
-        let black_queen3 = Queen::new(ChessPosition::new(1, 1).unwrap());
-        let white_queen4 = Queen::new(ChessPosition::new(2, 2).unwrap());
-        let black_queen4 = Queen::new(ChessPosition::new(5, 5).unwrap());
+    pub const fn can_see_diagonal(self, other: Self) -> bool {
+        let rank_diff = self.position.rank.abs_diff(other.position.rank);
+        let file_diff = self.position.file.abs_diff(other.position.file);
 
-        assert!(white_queen.can_attack(&black_queen));
-        assert!(white_queen2.can_attack(&black_queen2));
-        assert!(white_queen3.can_attack(&black_queen3));
-        assert!(white_queen4.can_attack(&black_queen4));
+        rank_diff == file_diff
     }
 }
diff --git a/solutions/rpn/Cargo.toml b/solutions/rpn/Cargo.toml
index e775a26c..30eb9e7a 100644
--- a/solutions/rpn/Cargo.toml
+++ b/solutions/rpn/Cargo.toml
@@ -2,7 +2,7 @@
 name = "rpn"
 version = "0.1.0"
 authors = ["OGordoo <marcosafonso8@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/rpn/src/main.rs b/solutions/rpn/src/main.rs
index 993da137..c6962a56 100644
--- a/solutions/rpn/src/main.rs
+++ b/solutions/rpn/src/main.rs
@@ -1,44 +1,40 @@
 fn main() {
-    let args: Vec<String> = std::env::args().collect();
-
-    rpn(&args[1]);
+    match std::env::args().collect::<Vec<_>>().as_slice() {
+        [_, arg] => rpn(arg.as_str()),
+        _ => println!("Error"),
+    }
 }
 
+#[inline]
 pub fn rpn(input: &str) {
-    let mut values: Vec<i64> = Vec::new();
-    let op = input.split_whitespace();
-    let mut err = true;
+    if rpn_wrapper(input).is_err() {
+        println!("Error");
+    }
+}
+
+pub fn rpn_wrapper(input: &str) -> Result<(), ()> {
+    let mut values = Vec::<i64>::new();
 
-    for v in op {
+    for v in input.split_whitespace() {
         if let Ok(x) = v.parse() {
             values.push(x);
         } else {
-            if is_op(v) && values.len() < 2 {
-                err = false;
-                break;
-            }
-            let (y, x) = (values.pop().unwrap(), values.pop().unwrap());
+            let (y, x) = (values.pop().ok_or(())?, values.pop().ok_or(())?);
             match v {
                 "+" => values.push(x + y),
                 "-" => values.push(x - y),
                 "*" => values.push(x * y),
                 "/" => values.push(x / y),
                 "%" => values.push(x % y),
-                _ => {
-                    err = false;
-                    break;
-                }
+                _ => return Err(()),
             }
         }
     }
 
-    if values.len() == 1 && err {
-        println!("{}", values[0]);
+    if values.len() != 1 {
+        Err(())
     } else {
-        println!("Error");
+        println!("{}", values[0]);
+        Ok(())
     }
 }
-
-fn is_op(s: &str) -> bool {
-    s == "+" || s == "-" || s == "*" || s == "/" || s == "%"
-}
diff --git a/solutions/scytale_decoder/Cargo.toml b/solutions/scytale_decoder/Cargo.toml
index d14eea06..50348bea 100644
--- a/solutions/scytale_decoder/Cargo.toml
+++ b/solutions/scytale_decoder/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "scytale_decoder"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/solutions/scytale_decoder/src/lib.rs b/solutions/scytale_decoder/src/lib.rs
index 72d5282f..aba9eaf9 100644
--- a/solutions/scytale_decoder/src/lib.rs
+++ b/solutions/scytale_decoder/src/lib.rs
@@ -1,20 +1,16 @@
-pub fn scytale_decoder(s: String, letters_per_turn: u32) -> Option<String> {
+#[inline]
+pub fn scytale_decoder(s: String, letters_per_turn: usize) -> Option<String> {
     if s.is_empty() || letters_per_turn == 0 {
         None
     } else {
-        let mut decoded_s = "".to_string();
-        let mut start = 0;
-
-        while decoded_s.len() < s.len() {
-            decoded_s.push(s.chars().nth(start).unwrap());
-
-            let mut next = start + letters_per_turn as usize;
-            while next < s.len() {
-                decoded_s.push(s.chars().nth(next).unwrap());
-                next += letters_per_turn as usize;
-            }
-            start += 1;
-        }
-        Some(decoded_s)
+        Some(
+            (0..letters_per_turn)
+                .flat_map(|i| {
+                    (i..s.len())
+                        .step_by(letters_per_turn)
+                        .map(|j| s.chars().nth(j).unwrap())
+                })
+                .collect(),
+        )
     }
 }
diff --git a/tests/brain_fuck_test/Cargo.toml b/tests/brain_fuck_test/Cargo.toml
index c2d4f7ae..d9728bd5 100644
--- a/tests/brain_fuck_test/Cargo.toml
+++ b/tests/brain_fuck_test/Cargo.toml
@@ -2,7 +2,7 @@
 name = "brain_fuck_test"
 version = "0.1.0"
 authors = ["OGordoo <marcosafonso8@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/tests/brain_fuck_test/src/main.rs b/tests/brain_fuck_test/src/lib.rs
similarity index 67%
rename from tests/brain_fuck_test/src/main.rs
rename to tests/brain_fuck_test/src/lib.rs
index d013a62d..78455664 100644
--- a/tests/brain_fuck_test/src/main.rs
+++ b/tests/brain_fuck_test/src/lib.rs
@@ -1,5 +1,3 @@
-fn main() {}
-
 #[cfg(test)]
 mod tests {
     use std::process::Command;
@@ -20,7 +18,7 @@ mod tests {
 
     #[test]
     fn nothing_passed() {
-        assert_eq!("", run(""));
+        assert!(run("").is_empty());
     }
 
     #[test]
@@ -38,32 +36,46 @@ mod tests {
             run("++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>---------------.")
         );
     }
+
     #[test]
     fn phrases() {
         assert_eq!(
             "Wow",
-            run("++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>-------------.++++++++++++++++++++++++.++++++++.")
+            run(
+                "++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>>-------------.++++++++++++++++++++++++.++++++++."
+            )
         );
         assert_eq!(
             "Good job!",
-            run("++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>+.>+++++++++++..-----------.<<++.>>++++++.+++++.-------------.<<+.")
+            run(
+                "++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>+.>+++++++++++..-----------.<<++.>>++++++.+++++.-------------.<<+."
+            )
         );
     }
 
     #[test]
     fn with_characters_in_middle() {
-        assert_eq!("keep going", run("++++++++++[>+>ke+++>+++++++>++++++++++<<<<-]>>>>+++++++e.------p..+++++++++++.<<++.>g>---------.+o+++++++.------i.+++++.-n------.g"));
+        assert_eq!(
+            "keep going",
+            run(
+                "++++++++++[>+>ke+++>+++++++>++++++++++<<<<-]>>>>+++++++e.------p..+++++++++++.<<++.>g>---------.+o+++++++.------i.+++++.-n------.g"
+            )
+        );
     }
 
     #[test]
     fn big_test() {
         assert_eq!(
             "3, 2, 1... Happy New Year",
-            run("++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>-------------------.-------.<++.>++++++.------.<.>+++++.---...<.>++++++++++++++++++++++++++.>---.+++++++++++++++..+++++++++.<<.>++++++.>--------------------.++++++++++++++++++.<<.>+++++++++++.++++++++++++.----.>-----.")
+            run(
+                "++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>-------------------.-------.<++.>++++++.------.<.>+++++.---...<.>++++++++++++++++++++++++++.>---.+++++++++++++++..+++++++++.<<.>++++++.>--------------------.++++++++++++++++++.<<.>+++++++++++.++++++++++++.----.>-----."
+            )
         );
         assert_eq!(
-            "To be or not be, that is the question!", 
-            run("++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++++++++++++++.>+++++++++++.<<++.>>-------------.+++.<<.>>++++++++++.+++.<<.>>----.+.+++++.<<.>++++++++++++++.+++.<++++++++++++.------------.>>.<+++.-------.>.<<.>++++++++.>-.<<.>>+.<-.---.<.>>---.++++.<.>--.+.<++++.>-----.-.<<+.")
+            "To be or not be, that is the question!",
+            run(
+                "++++++++++[>+>+++>+++++++>++++++++++<<<<-]>>>++++++++++++++.>+++++++++++.<<++.>>-------------.+++.<<.>>++++++++++.+++.<<.>>----.+.+++++.<<.>++++++++++++++.+++.<++++++++++++.------------.>>.<+++.-------.>.<<.>++++++++.>-.<<.>>+.<-.---.<.>>---.++++.<.>--.+.<++++.>-----.-.<<+."
+            )
         );
     }
 }
diff --git a/tests/check_user_name_test/Cargo.toml b/tests/check_user_name_test/Cargo.toml
index a69a5743..16ed7c26 100644
--- a/tests/check_user_name_test/Cargo.toml
+++ b/tests/check_user_name_test/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "check_user_name_test"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/tests/check_user_name_test/src/lib.rs b/tests/check_user_name_test/src/lib.rs
new file mode 100644
index 00000000..dff6001d
--- /dev/null
+++ b/tests/check_user_name_test/src/lib.rs
@@ -0,0 +1,31 @@
+#[cfg(test)]
+mod tests {
+    use check_user_name::*;
+
+    #[test]
+    fn test_error() {
+        let guest_case = User::new("Michael".to_owned(), AccessLevel::Guest);
+        assert_eq!(
+            check_user_name(&guest_case),
+            (false, "ERROR: User is guest")
+        );
+    }
+
+    #[test]
+    fn test_ok() {
+        let admin_case = User::new("Fatima".to_owned(), AccessLevel::Admin);
+        let normal_case = User::new("Sara".to_owned(), AccessLevel::Normal);
+        assert_eq!(check_user_name(&admin_case), (true, "Fatima"));
+        assert_eq!(check_user_name(&normal_case), (true, "Sara"));
+    }
+
+    #[test]
+    fn test_send_name() {
+        let admin_case = User::new("Fatima".to_owned(), AccessLevel::Admin);
+        let normal_case = User::new("Sara".to_owned(), AccessLevel::Normal);
+        let guest_case = User::new("Michael".to_owned(), AccessLevel::Guest);
+        assert_eq!(admin_case.send_name(), Some("Fatima"));
+        assert_eq!(normal_case.send_name(), Some("Sara"));
+        assert_eq!(guest_case.send_name(), None);
+    }
+}
diff --git a/tests/check_user_name_test/src/main.rs b/tests/check_user_name_test/src/main.rs
deleted file mode 100644
index f7253629..00000000
--- a/tests/check_user_name_test/src/main.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use check_user_name::*;
-
-fn main() {
-    let user0 = User::new("Didier".to_string(), AccessLevel::Admin);
-    println!("{:?}", check_user_name(&user0));
-
-    let user1 = User::new("Mary".to_string(), AccessLevel::Normal);
-    println!("{:?}", check_user_name(&user1));
-
-    let user2 = User::new("John".to_string(), AccessLevel::Guest);
-    println!("{:?}", check_user_name(&user2));
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_error() {
-        let guest_case = User::new("Michael".to_string(), AccessLevel::Guest);
-        assert_eq!(
-            check_user_name(&guest_case),
-            (false, "ERROR: User is guest")
-        );
-    }
-
-    #[test]
-    fn test_ok() {
-        let admin_case = User::new("Fatima".to_string(), AccessLevel::Admin);
-        let normal_case = User::new("Sara".to_string(), AccessLevel::Normal);
-        assert_eq!(check_user_name(&admin_case), (true, "Fatima"));
-        assert_eq!(check_user_name(&normal_case), (true, "Sara"));
-    }
-
-    #[test]
-    fn test_send_name() {
-        let admin_case = User::new("Fatima".to_string(), AccessLevel::Admin);
-        let normal_case = User::new("Sara".to_string(), AccessLevel::Normal);
-        let guest_case = User::new("Michael".to_string(), AccessLevel::Guest);
-        assert_eq!(admin_case.send_name(), Some("Fatima"));
-        assert_eq!(normal_case.send_name(), Some("Sara"));
-        assert_eq!(guest_case.send_name(), None);
-    }
-}
diff --git a/tests/drop_the_blog_test/Cargo.toml b/tests/drop_the_blog_test/Cargo.toml
index e28867cd..e4d43fab 100644
--- a/tests/drop_the_blog_test/Cargo.toml
+++ b/tests/drop_the_blog_test/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "drop_the_blog_test"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/tests/drop_the_blog_test/src/main.rs b/tests/drop_the_blog_test/src/lib.rs
similarity index 50%
rename from tests/drop_the_blog_test/src/main.rs
rename to tests/drop_the_blog_test/src/lib.rs
index f037527c..2d3212ec 100644
--- a/tests/drop_the_blog_test/src/main.rs
+++ b/tests/drop_the_blog_test/src/lib.rs
@@ -1,38 +1,8 @@
-use drop_the_blog::*;
-use std::rc::Rc;
-
-fn main() {
-    let blog = Blog::new();
-    let (id, article) = blog.new_article(String::from("Winter is coming"));
-    let (id1, article1) = blog.new_article(String::from("The story of the universe"));
-
-    article.discard();
-
-    println!("{:?}", (blog.is_dropped(id), id, &blog.drops));
-
-    article1.discard();
-    println!("{:?}", (blog.is_dropped(id1), id1, &blog.drops));
-
-    let (id2, article2) = blog.new_article(String::from("How to cook 101"));
-    let article2 = Rc::new(article2);
-    let article2_clone = article2.clone();
-
-    drop(article2_clone);
-
-    println!(
-        "{:?}",
-        (
-            blog.is_dropped(id2),
-            id2,
-            &blog.drops,
-            Rc::strong_count(&article2)
-        )
-    );
-}
-
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use std::rc::Rc;
+
+    use drop_the_blog::*;
 
     #[test]
     fn test_is_dropped_and_drops() {
@@ -43,9 +13,9 @@ mod tests {
         let (pid2, article2) = blog.new_article(String::from("spotify"));
 
         article.discard();
-        assert_eq!(blog.drops.get(), 1_usize);
+        assert_eq!(blog.drops.get(), 1);
         article0.discard();
-        assert_eq!(blog.drops.get(), 2_usize);
+        assert_eq!(blog.drops.get(), 2);
 
         assert!(blog.is_dropped(pid), "{} should have been dropped", pid);
         assert!(blog.is_dropped(pid0), "{} should have been dropped", pid0);
@@ -62,33 +32,26 @@ mod tests {
 
         article1.discard();
         article2.discard();
-        assert_eq!(blog.drops.get(), 4_usize);
+        assert_eq!(blog.drops.get(), 4);
     }
 
     #[test]
     fn test_using_rc() {
-        // will create a new reference to the article
-        // this will test the following
-        // if we drop the cloned value the RC will decrease
-        // but the article will not be dropped!
         let blog = Blog::new();
         let (_, article) = blog.new_article(String::from("Xorg"));
         let article = Rc::new(article);
-        let article_clone = article.clone();
+        let article_clone = Rc::clone(&article);
 
         assert_eq!(Rc::strong_count(&article), 2);
-
         drop(article_clone);
-
         assert_eq!(Rc::strong_count(&article), 1);
     }
 
     #[test]
-    #[should_panic(expected = "0 is already dropped")]
+    #[should_panic]
     fn test_drop_same_article() {
-        // test if we drop the same article after it was already been dropped
         let blog = Blog::new();
-        let (_pid, article) = blog.new_article(String::from("gsd-rfkill"));
+        let (_, article) = blog.new_article(String::from("gsd-rfkill"));
         let article_clone = article.clone();
         article.discard();
         article_clone.discard();
diff --git a/tests/flat_tree_test/Cargo.toml b/tests/flat_tree_test/Cargo.toml
index d8978ce7..3017a9aa 100644
--- a/tests/flat_tree_test/Cargo.toml
+++ b/tests/flat_tree_test/Cargo.toml
@@ -2,9 +2,9 @@
 name = "flat_tree_test"
 version = "0.1.0"
 authors = ["Augusto <aug.ornelas@gmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-flat_tree = { path = "../../solutions/flat_tree" }
\ No newline at end of file
+flat_tree = { path = "../../solutions/flat_tree" }
diff --git a/tests/flat_tree_test/src/lib.rs b/tests/flat_tree_test/src/lib.rs
new file mode 100644
index 00000000..ba47bde5
--- /dev/null
+++ b/tests/flat_tree_test/src/lib.rs
@@ -0,0 +1,18 @@
+#[cfg(test)]
+mod tests {
+    use flat_tree::*;
+    use std::collections::BTreeSet;
+
+    #[test]
+    fn it_works() {
+        assert_eq!(flatten_tree(&BTreeSet::from([3, 0, 9, 10])), [0, 3, 9, 10]);
+    }
+
+    #[test]
+    fn test_with_str() {
+        assert_eq!(
+            flatten_tree(&BTreeSet::from(["Slow", "kill", "will", "Horses"])),
+            ["Horses", "Slow", "kill", "will"]
+        );
+    }
+}
diff --git a/tests/flat_tree_test/src/main.rs b/tests/flat_tree_test/src/main.rs
deleted file mode 100644
index 5e15ad9d..00000000
--- a/tests/flat_tree_test/src/main.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-// convert a binary search tree into a sorted array
-
-use flat_tree::*;
-use std::collections::BTreeSet;
-
-fn main() {
-    let mut tree = BTreeSet::new();
-    tree.insert(34);
-    tree.insert(0);
-    tree.insert(9);
-    tree.insert(30);
-    println!("{:?}", flatten_tree(&tree));
-
-    let mut tree = BTreeSet::new();
-    tree.insert("Slow");
-    tree.insert("kill");
-    tree.insert("will");
-    tree.insert("Horses");
-    println!("{:?}", flatten_tree(&tree));
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let mut tree = BTreeSet::new();
-        tree.insert(3);
-        tree.insert(0);
-        tree.insert(9);
-        tree.insert(10);
-        assert_eq!(flatten_tree(&tree), &[0, 3, 9, 10]);
-    }
-
-    #[test]
-    fn test_with_str() {
-        let mut tree = BTreeSet::new();
-        tree.insert("Slow");
-        tree.insert("kill");
-        tree.insert("will");
-        tree.insert("Horses");
-        assert_eq!(flatten_tree(&tree), &["Horses", "Slow", "kill", "will"]);
-    }
-}
diff --git a/tests/insertion_sort_test/Cargo.toml b/tests/insertion_sort_test/Cargo.toml
index 8d2dd28c..3af0c2b2 100644
--- a/tests/insertion_sort_test/Cargo.toml
+++ b/tests/insertion_sort_test/Cargo.toml
@@ -2,9 +2,9 @@
 name = "insertion_sort_test"
 version = "0.1.0"
 authors = ["Augusto <aug.ornelas@gmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-insertion_sort = {path = "../../solutions/insertion_sort"}
\ No newline at end of file
+insertion_sort = {path = "../../solutions/insertion_sort"}
diff --git a/tests/insertion_sort_test/src/lib.rs b/tests/insertion_sort_test/src/lib.rs
new file mode 100644
index 00000000..ba2413a1
--- /dev/null
+++ b/tests/insertion_sort_test/src/lib.rs
@@ -0,0 +1,26 @@
+#[cfg(test)]
+mod tests {
+    use insertion_sort::*;
+
+    #[test]
+    fn it_works() {
+        let mut target = [5, 3, 7, 2, 1, 6, 8, 4];
+        let len = target.len();
+        insertion_sort(&mut target, len - 1);
+        assert_eq!(&[1, 2, 3, 4, 5, 6, 7, 8], &target);
+    }
+
+    #[test]
+    fn test_first_step() {
+        let mut target = [5, 3, 7, 2, 1, 6, 8, 4];
+        insertion_sort(&mut target, 1);
+        assert_eq!(&[3, 5, 7, 2, 1, 6, 8, 4], &target);
+    }
+
+    #[test]
+    fn test_second_step() {
+        let mut target = [5, 3, 7, 2, 1, 6, 8, 4];
+        insertion_sort(&mut target, 2);
+        assert_eq!(&[3, 5, 7, 2, 1, 6, 8, 4], &target);
+    }
+}
diff --git a/tests/insertion_sort_test/src/main.rs b/tests/insertion_sort_test/src/main.rs
deleted file mode 100644
index 000f05ed..00000000
--- a/tests/insertion_sort_test/src/main.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// How to avoid that students use sort without creating a program to
-// restrict functions in the code??
-// Just use a grep?
-// Implement the insertion sort algorithm but implement it in a step
-// by step so we can test that each step is corresponding with the algorithm
-
-// Insertion sort algorithmAlgorithm
-
-// To sort an array of size n in ascending order:
-
-// 1: Iterate from arr[1] to arr[n] over the array.
-
-// 2: Compare the current element (key) to its predecessor.
-
-// 3: If the key element is smaller than its predecessor, compare it
-// to the elements before. Move the greater elements one position up
-// to make space for the swapped element.
-
-use insertion_sort::*;
-
-fn main() {
-    let mut target = [5, 3, 7, 2, 1, 6, 8, 4];
-    insertion_sort(&mut target, 1);
-    println!("{:?}", target);
-
-    let mut target = [5, 3, 7, 2, 1, 6, 8, 4];
-    let len = target.len();
-    insertion_sort(&mut target, len - 1);
-    println!("{:?}", target);
-}
-
-#[cfg(test)]
-mod tests {
-    use insertion_sort::*;
-
-    #[test]
-    fn it_works() {
-        let mut target = [5, 3, 7, 2, 1, 6, 8, 4];
-        let len = target.len();
-        insertion_sort(&mut target, len - 1);
-        assert_eq!(&[1, 2, 3, 4, 5, 6, 7, 8], &target);
-    }
-
-    #[test]
-    fn test_first_step() {
-        let mut target = [5, 3, 7, 2, 1, 6, 8, 4];
-        insertion_sort(&mut target, 1);
-        assert_eq!(&[3, 5, 7, 2, 1, 6, 8, 4], &target);
-    }
-
-    #[test]
-    fn test_second_step() {
-        let mut target = [5, 3, 7, 2, 1, 6, 8, 4];
-        insertion_sort(&mut target, 2);
-        assert_eq!(&[3, 5, 7, 2, 1, 6, 8, 4], &target);
-    }
-}
diff --git a/tests/inv_pyramid_test/Cargo.toml b/tests/inv_pyramid_test/Cargo.toml
index e83b8a5f..f9ab89c3 100644
--- a/tests/inv_pyramid_test/Cargo.toml
+++ b/tests/inv_pyramid_test/Cargo.toml
@@ -2,7 +2,7 @@
 name = "inv_pyramid_test"
 version = "0.1.0"
 authors = ["lee <lee-dasilva@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/tests/inv_pyramid_test/src/lib.rs b/tests/inv_pyramid_test/src/lib.rs
new file mode 100644
index 00000000..4b29857c
--- /dev/null
+++ b/tests/inv_pyramid_test/src/lib.rs
@@ -0,0 +1,45 @@
+#[cfg(test)]
+mod tests {
+    use inv_pyramid::*;
+
+    #[test]
+    fn it_works() {
+        assert_eq!(inv_pyramid(String::from("#"), 0), [] as [&str; _]);
+        assert_eq!(inv_pyramid(String::from("#"), 1), [" #"]);
+        assert_eq!(inv_pyramid(String::from("a"), 2), [" a", "  aa", " a"]);
+        assert_eq!(
+            inv_pyramid(String::from(">"), 5),
+            vec![
+                " >",
+                "  >>",
+                "   >>>",
+                "    >>>>",
+                "     >>>>>",
+                "    >>>>",
+                "   >>>",
+                "  >>",
+                " >",
+            ]
+        );
+        assert_eq!(
+            inv_pyramid(String::from("&"), 8),
+            [
+                " &",
+                "  &&",
+                "   &&&",
+                "    &&&&",
+                "     &&&&&",
+                "      &&&&&&",
+                "       &&&&&&&",
+                "        &&&&&&&&",
+                "       &&&&&&&",
+                "      &&&&&&",
+                "     &&&&&",
+                "    &&&&",
+                "   &&&",
+                "  &&",
+                " &",
+            ]
+        );
+    }
+}
diff --git a/tests/inv_pyramid_test/src/main.rs b/tests/inv_pyramid_test/src/main.rs
deleted file mode 100644
index 3ef3b5e7..00000000
--- a/tests/inv_pyramid_test/src/main.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-use inv_pyramid::*;
-
-fn main() {
-    println!("{:?}", inv_pyramid(String::from("&"), 8));
-}
-
-#[test]
-fn it_works() {
-    let data_sets = vec![
-        vec![],
-        vec![" #"],
-        vec![" a", "  aa", " a"],
-        vec![
-            " >",
-            "  >>",
-            "   >>>",
-            "    >>>>",
-            "     >>>>>",
-            "    >>>>",
-            "   >>>",
-            "  >>",
-            " >",
-        ],
-        vec![
-            " &",
-            "  &&",
-            "   &&&",
-            "    &&&&",
-            "     &&&&&",
-            "      &&&&&&",
-            "       &&&&&&&",
-            "        &&&&&&&&",
-            "       &&&&&&&",
-            "      &&&&&&",
-            "     &&&&&",
-            "    &&&&",
-            "   &&&",
-            "  &&",
-            " &",
-        ],
-    ];
-    assert_eq!(inv_pyramid(String::from("#"), 0), data_sets[0]);
-    assert_eq!(inv_pyramid(String::from("#"), 1), data_sets[1]);
-    assert_eq!(inv_pyramid(String::from("a"), 2), data_sets[2]);
-    assert_eq!(inv_pyramid(String::from(">"), 5), data_sets[3]);
-    assert_eq!(inv_pyramid(String::from("&"), 8), data_sets[4]);
-}
diff --git a/tests/nextprime_test/Cargo.toml b/tests/nextprime_test/Cargo.toml
index 9277fd97..0f18edcb 100644
--- a/tests/nextprime_test/Cargo.toml
+++ b/tests/nextprime_test/Cargo.toml
@@ -2,9 +2,9 @@
 name = "nextprime_test"
 version = "0.1.0"
 authors = ["OGordoo <marcosafonso8@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-nextprime = {path = "../../solutions/nextprime"}
\ No newline at end of file
+nextprime = {path = "../../solutions/nextprime"}
diff --git a/tests/nextprime_test/src/main.rs b/tests/nextprime_test/src/lib.rs
similarity index 60%
rename from tests/nextprime_test/src/main.rs
rename to tests/nextprime_test/src/lib.rs
index ab2bc515..e35d41df 100644
--- a/tests/nextprime_test/src/main.rs
+++ b/tests/nextprime_test/src/lib.rs
@@ -1,13 +1,6 @@
-use nextprime::*;
-
-fn main() {
-    println!("The next prime after 4 is: {}", next_prime(4));
-    println!("The next prime after 11 is: {}", next_prime(11));
-}
-
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use nextprime::*;
 
     #[test]
     fn simple_tests() {
diff --git a/tests/order_books_test/Cargo.toml b/tests/order_books_test/Cargo.toml
index 8023ba63..15e069ce 100644
--- a/tests/order_books_test/Cargo.toml
+++ b/tests/order_books_test/Cargo.toml
@@ -2,9 +2,9 @@
 name = "order_books_test"
 version = "0.1.0"
 authors = ["OGordoo <marcosafonso8@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-order_books = {path = "../../solutions/order_books"}
\ No newline at end of file
+order_books = {path = "../../solutions/order_books"}
diff --git a/tests/order_books_test/src/main.rs b/tests/order_books_test/src/lib.rs
similarity index 60%
rename from tests/order_books_test/src/main.rs
rename to tests/order_books_test/src/lib.rs
index 9d8740a7..90972505 100644
--- a/tests/order_books_test/src/main.rs
+++ b/tests/order_books_test/src/lib.rs
@@ -1,69 +1,30 @@
-use order_books::{
-    library::{books::Book, writers::Writer},
-    order_books,
-};
-
-fn main() {
-    let mut writer_a = Writer {
-        first_name: "William".to_string(),
-        last_name: "Shakespeare".to_string(),
-        books: vec![
-            Book {
-                title: "Hamlet".to_string(),
-                year: 1600,
-            },
-            Book {
-                title: "Othelo".to_string(),
-                year: 1603,
-            },
-            Book {
-                title: "Romeo and Juliet".to_string(),
-                year: 1593,
-            },
-            Book {
-                title: "MacBeth".to_string(),
-                year: 1605,
-            },
-        ],
-    };
-
-    println!("Before ordering");
-    for b in &writer_a.books {
-        println!("{:?}", b.title);
-    }
-
-    order_books(&mut writer_a);
-
-    println!("\nAfter ordering");
-    for b in writer_a.books {
-        println!("{:?}", b.title);
-    }
-}
-
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use order_books::{
+        library::{books::Book, writers::Writer},
+        order_books,
+    };
 
     #[test]
     fn w_shakespeare() {
         let mut writer = Writer {
-            first_name: "William".to_string(),
-            last_name: "Shakespeare".to_string(),
+            first_name: "William".to_owned(),
+            last_name: "Shakespeare".to_owned(),
             books: vec![
                 Book {
-                    title: "Hamlet".to_string(),
+                    title: "Hamlet".to_owned(),
                     year: 1600,
                 },
                 Book {
-                    title: "Othelo".to_string(),
+                    title: "Othelo".to_owned(),
                     year: 1603,
                 },
                 Book {
-                    title: "Romeo and Juliet".to_string(),
+                    title: "Romeo and Juliet".to_owned(),
                     year: 1593,
                 },
                 Book {
-                    title: "MacBeth".to_string(),
+                    title: "MacBeth".to_owned(),
                     year: 1605,
                 },
             ],
@@ -76,30 +37,31 @@ mod tests {
         assert_eq!("Othelo", writer.books[2].title);
         assert_eq!("Romeo and Juliet", writer.books[3].title);
     }
+
     #[test]
     fn j_k_rowling() {
         let mut writer = Writer {
-            first_name: "William".to_string(),
-            last_name: "Shakespeare".to_string(),
+            first_name: "Joanne".to_owned(),
+            last_name: "Rowling".to_owned(),
             books: vec![
                 Book {
-                    title: "Harry Potter and the Philosopher's Stone".to_string(),
+                    title: "Harry Potter and the Philosopher's Stone".to_owned(),
                     year: 1997,
                 },
                 Book {
-                    title: "Harry Potter and the Prisoner of Azkaban".to_string(),
+                    title: "Harry Potter and the Prisoner of Azkaban".to_owned(),
                     year: 1999,
                 },
                 Book {
-                    title: "Harry Potter and the Order of the Phoenix".to_string(),
+                    title: "Harry Potter and the Order of the Phoenix".to_owned(),
                     year: 2003,
                 },
                 Book {
-                    title: "Harry Potter and the Chamber of Secrets".to_string(),
+                    title: "Harry Potter and the Chamber of Secrets".to_owned(),
                     year: 1998,
                 },
                 Book {
-                    title: "Harry Potter and the Deathly Hallows".to_string(),
+                    title: "Harry Potter and the Deathly Hallows".to_owned(),
                     year: 2007,
                 },
             ],
diff --git a/tests/organize_garage_test/Cargo.toml b/tests/organize_garage_test/Cargo.toml
index e832cbb4..eb89b513 100644
--- a/tests/organize_garage_test/Cargo.toml
+++ b/tests/organize_garage_test/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "organize_garage_test"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/tests/organize_garage_test/src/main.rs b/tests/organize_garage_test/src/lib.rs
similarity index 85%
rename from tests/organize_garage_test/src/main.rs
rename to tests/organize_garage_test/src/lib.rs
index 52f0ffaa..496a08ff 100644
--- a/tests/organize_garage_test/src/main.rs
+++ b/tests/organize_garage_test/src/lib.rs
@@ -1,21 +1,6 @@
-use organize_garage::*;
-
-fn main() {
-    let mut garage = Garage {
-        left: Some(5),
-        right: Some(2),
-    };
-
-    println!("{:?}", garage);
-    garage.move_to_right();
-    println!("{:?}", garage);
-    garage.move_to_left();
-    println!("{:?}", garage);
-}
-
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use organize_garage::*;
 
     #[test]
     fn test_move_to_right() {
diff --git a/tests/own_and_return_test/Cargo.toml b/tests/own_and_return_test/Cargo.toml
index 0017ad15..bd19bdad 100644
--- a/tests/own_and_return_test/Cargo.toml
+++ b/tests/own_and_return_test/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "own_and_return_test"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/tests/own_and_return_test/src/lib.rs b/tests/own_and_return_test/src/lib.rs
new file mode 100644
index 00000000..a25228a1
--- /dev/null
+++ b/tests/own_and_return_test/src/lib.rs
@@ -0,0 +1,24 @@
+#[cfg(test)]
+mod tests {
+    use own_and_return::*;
+
+    #[test]
+    fn test_consume() {
+        assert_eq!(
+            take_film_name(Film {
+                name: "Matrix".to_owned()
+            }),
+            "Matrix"
+        );
+    }
+
+    #[test]
+    fn test_reference() {
+        assert_eq!(
+            read_film_name(&Film {
+                name: "Matrix".to_owned()
+            }),
+            "Matrix"
+        );
+    }
+}
diff --git a/tests/own_and_return_test/src/main.rs b/tests/own_and_return_test/src/main.rs
deleted file mode 100644
index 5e1aa451..00000000
--- a/tests/own_and_return_test/src/main.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-use own_and_return::*;
-
-fn main() {
-    let my_film = Film {
-        name: "Terminator".to_string(),
-    };
-    // println!("{}", take_film_name(my_film));
-    // uncomment the previous line to check that the value is consumed
-    println!("{}", read_film_name(&my_film));
-    println!("{}", take_film_name(my_film));
-    // you can test this function by commenting out the first print statement, you should see the expected output without errors in this case
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_consume() {
-        assert_eq!(
-            take_film_name(Film {
-                name: "Matrix".to_string()
-            }),
-            "Matrix".to_string()
-        );
-    }
-    #[test]
-    fn test_only_print() {
-        assert_eq!(
-            read_film_name(&Film {
-                name: "Matrix".to_string()
-            }),
-            "Matrix".to_string()
-        )
-    }
-}
diff --git a/tests/prime_checker_test/Cargo.toml b/tests/prime_checker_test/Cargo.toml
index 7c9658a5..5f16212f 100644
--- a/tests/prime_checker_test/Cargo.toml
+++ b/tests/prime_checker_test/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "prime_checker_test"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/tests/prime_checker_test/src/main.rs b/tests/prime_checker_test/src/lib.rs
similarity index 83%
rename from tests/prime_checker_test/src/main.rs
rename to tests/prime_checker_test/src/lib.rs
index a023a496..e9197006 100644
--- a/tests/prime_checker_test/src/main.rs
+++ b/tests/prime_checker_test/src/lib.rs
@@ -1,14 +1,6 @@
-use prime_checker::*;
-
-fn main() {
-    println!("Is {} prime? {:?}", 2, prime_checker(2));
-    println!("Is {} prime? {:?}", 14, prime_checker(14));
-    println!("Is {} prime? {:?}", 2147483647, prime_checker(2147483647));
-}
-
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use prime_checker::*;
 
     #[test]
     fn prime_checker_prime() {
@@ -18,23 +10,27 @@ mod tests {
         assert_eq!(Some(Ok(23)), prime_checker(23));
         assert_eq!(Some(Ok(7919)), prime_checker(7919));
     }
+
     #[test]
     fn prime_checker_even() {
         assert_eq!(Some(Err(PrimeErr::Even)), prime_checker(4));
         assert_eq!(Some(Err(PrimeErr::Even)), prime_checker(6));
         assert_eq!(Some(Err(PrimeErr::Even)), prime_checker(1234));
     }
+
     #[test]
     fn prime_checker_not_prime() {
         assert_eq!(Some(Err(PrimeErr::Divider(3))), prime_checker(9));
         assert_eq!(Some(Err(PrimeErr::Divider(5))), prime_checker(25));
         assert_eq!(Some(Err(PrimeErr::Divider(11))), prime_checker(121));
     }
+
     #[test]
     fn prime_checker_small() {
         assert_eq!(None, prime_checker(0));
         assert_eq!(None, prime_checker(1));
     }
+
     #[test]
     fn prime_check_big() {
         assert_eq!(Some(Err(PrimeErr::Divider(7993))), prime_checker(63888049));
diff --git a/tests/queens_test/Cargo.toml b/tests/queens_test/Cargo.toml
index b5c847cb..3394f150 100644
--- a/tests/queens_test/Cargo.toml
+++ b/tests/queens_test/Cargo.toml
@@ -2,7 +2,7 @@
 name = "queens_test"
 version = "0.1.0"
 authors = ["MSilva95 <miguel-silva98@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/tests/queens_test/src/lib.rs b/tests/queens_test/src/lib.rs
new file mode 100644
index 00000000..862535cf
--- /dev/null
+++ b/tests/queens_test/src/lib.rs
@@ -0,0 +1,100 @@
+#[cfg(test)]
+mod tests {
+    use queens::*;
+
+    #[test]
+    fn test_position_is_valid() {
+        assert!(ChessPosition::new(2, 4).is_some());
+        assert!(ChessPosition::new(8, 2).is_none());
+        assert!(ChessPosition::new(5, 8).is_none());
+    }
+
+    #[test]
+    fn test_queen_valid_position() {
+        Queen::new(ChessPosition::new(2, 4).unwrap());
+    }
+
+    #[test]
+    fn test_can_not_attack() {
+        [
+            (2, 4),
+            (6, 6),
+            (1, 2),
+            (0, 4),
+            (5, 3),
+            (0, 6),
+            (3, 7),
+            (2, 0),
+        ]
+        .map(|pos| Queen::new(ChessPosition::new(pos.0, pos.1).unwrap()))
+        .as_chunks() // use array_chunks when stabilised
+        .0
+        .iter()
+        .for_each(|&[w, b]| {
+            assert!(!w.can_attack(b));
+        });
+    }
+
+    #[test]
+    fn test_same_rank() {
+        [
+            (2, 4),
+            (2, 6),
+            (1, 2),
+            (1, 6),
+            (4, 7),
+            (4, 3),
+            (5, 3),
+            (5, 1),
+        ]
+        .map(|pos| Queen::new(ChessPosition::new(pos.0, pos.1).unwrap()))
+        .as_chunks()
+        .0
+        .iter()
+        .for_each(|&[w, b]| {
+            assert!(w.can_attack(b));
+        });
+    }
+
+    #[test]
+    fn test_same_file() {
+        [
+            (4, 5),
+            (3, 5),
+            (2, 2),
+            (3, 2),
+            (2, 6),
+            (1, 6),
+            (2, 7),
+            (5, 7),
+        ]
+        .map(|pos| Queen::new(ChessPosition::new(pos.0, pos.1).unwrap()))
+        .as_chunks()
+        .0
+        .iter()
+        .for_each(|&[w, b]| {
+            assert!(w.can_attack(b));
+        });
+    }
+
+    #[test]
+    fn test_same_diagonal() {
+        [
+            (2, 2),
+            (0, 4),
+            (2, 2),
+            (3, 1),
+            (2, 2),
+            (1, 1),
+            (2, 2),
+            (5, 5),
+        ]
+        .map(|pos| Queen::new(ChessPosition::new(pos.0, pos.1).unwrap()))
+        .as_chunks()
+        .0
+        .iter()
+        .for_each(|&[w, b]| {
+            assert!(w.can_attack(b));
+        });
+    }
+}
diff --git a/tests/queens_test/src/main.rs b/tests/queens_test/src/main.rs
deleted file mode 100644
index aceb8593..00000000
--- a/tests/queens_test/src/main.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
-## queens
-
-### Instructions
-
-In a chess game, a queen can attack pieces which are on the same row,
-column, or diagonal.
-
-Your purpose in this exercise is to find out if two queens can attack
-each other using the same rules.
-
-The chess board will be represented as a 8 by 8 array.
-
-So, given the position of the two queens on a chess board, you will have to
-implement the function `can_attack` in the given struct `Queen` with
-the purpose of finding out if the two queens can attack each other or not.
-For this to be possible, you will also have to implement the struct `ChessPosition`
-with the function `new` that will allow you to verify if the position is
-valid or not. If the position is valid it will return that position and invalid it will return `None`.
-
-So if you are told that the white queen is at (2, 3) and the black queen is at (5, 6),
-then you would know you have got a set-up like so:
-
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ W _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ B _
-_ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _
-
-In this case, the two queens can attack each other because both pieces share a diagonal.
-
-
-
-### Expected Function
-
-```rust
-#[derive(Debug)]
-pub struct ChessPosition {
-    rank: i32,
-    file: i32,
-}
-
-#[derive(Debug)]
-pub struct Queen {
-    position: ChessPosition,
-}
-
-impl ChessPosition {
-    pub fn new(rank: i32, file: i32) -> Option<Self> {}
-}
-
-impl Queen {
-    pub fn can_attack(&self, other: &Queen) -> bool {}
-}
-```
-
-### Usage
-
-Here is a possible program to test your function :
-
-```rust
-use queens::queens;
-
-fn main() {
-    let white_queen = Queen::new(ChessPosition::new(2, 2).unwrap());
-    let black_queen = Queen::new(ChessPosition::new(0, 4).unwrap());
-
-    println!(
-        "Is it possible for the queens to attack each other? => {}",
-        white_queen.can_attack(&black_queen)
-    );
-
-    let white_queen = Queen::new(ChessPosition::new(1, 2).unwrap());
-    let black_queen = Queen::new(ChessPosition::new(0, 4).unwrap());
-
-    println!(
-        "Is it possible for the queens to attack each other? => {}",
-        white_queen.can_attack(&black_queen)
-    );
-}
-```
-
-And its output:
-
-```console
-student@ubuntu:~/[[ROOT]]/test$ cargo run
-Is it possible for the queens to attack each other? => true
-Is it possible for the queens to attack each other? => false
-student@ubuntu:~/[[ROOT]]/test$
-```
-*/
-
-use queens::*;
-
-fn main() {
-    let white_queen = Queen::new(ChessPosition::new(2, 2).unwrap());
-    let black_queen = Queen::new(ChessPosition::new(0, 4).unwrap());
-
-    println!(
-        "Is it possible for the queens to attack each other? {}",
-        white_queen.can_attack(&black_queen)
-    );
-
-    let white_queen = Queen::new(ChessPosition::new(1, 2).unwrap());
-    let black_queen = Queen::new(ChessPosition::new(0, 4).unwrap());
-
-    println!(
-        "Is it possible for the queens to attack each other? {}",
-        white_queen.can_attack(&black_queen)
-    );
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_position_is_valid() {
-        assert!(ChessPosition::new(2, 4).is_some());
-        assert!(ChessPosition::new(-1, 2).is_none());
-        assert!(ChessPosition::new(8, 2).is_none());
-        assert!(ChessPosition::new(5, -1).is_none());
-        assert!(ChessPosition::new(5, 8).is_none());
-    }
-
-    #[test]
-    fn test_queen_valid_position() {
-        Queen::new(ChessPosition::new(2, 4).unwrap());
-    }
-
-    #[test]
-    fn test_can_not_attack() {
-        let white_queen = Queen::new(ChessPosition::new(2, 4).unwrap());
-        let black_queen = Queen::new(ChessPosition::new(6, 6).unwrap());
-        let white_queen2 = Queen::new(ChessPosition::new(1, 2).unwrap());
-        let black_queen2 = Queen::new(ChessPosition::new(0, 4).unwrap());
-        let white_queen3 = Queen::new(ChessPosition::new(5, 3).unwrap());
-        let black_queen3 = Queen::new(ChessPosition::new(0, 6).unwrap());
-        let white_queen4 = Queen::new(ChessPosition::new(3, 7).unwrap());
-        let black_queen4 = Queen::new(ChessPosition::new(2, 0).unwrap());
-
-        assert!(!white_queen.can_attack(&black_queen));
-        assert!(!white_queen2.can_attack(&black_queen2));
-        assert!(!white_queen3.can_attack(&black_queen3));
-        assert!(!white_queen4.can_attack(&black_queen4));
-    }
-
-    #[test]
-    fn test_same_rank() {
-        let white_queen = Queen::new(ChessPosition::new(2, 4).unwrap());
-        let black_queen = Queen::new(ChessPosition::new(2, 6).unwrap());
-        let white_queen2 = Queen::new(ChessPosition::new(1, 2).unwrap());
-        let black_queen2 = Queen::new(ChessPosition::new(1, 6).unwrap());
-        let white_queen3 = Queen::new(ChessPosition::new(4, 7).unwrap());
-        let black_queen3 = Queen::new(ChessPosition::new(4, 3).unwrap());
-        let white_queen4 = Queen::new(ChessPosition::new(5, 3).unwrap());
-        let black_queen4 = Queen::new(ChessPosition::new(5, 1).unwrap());
-
-        assert!(white_queen.can_attack(&black_queen));
-        assert!(white_queen2.can_attack(&black_queen2));
-        assert!(white_queen3.can_attack(&black_queen3));
-        assert!(white_queen4.can_attack(&black_queen4));
-    }
-
-    #[test]
-    fn test_same_file() {
-        let white_queen = Queen::new(ChessPosition::new(4, 5).unwrap());
-        let black_queen = Queen::new(ChessPosition::new(3, 5).unwrap());
-        let white_queen2 = Queen::new(ChessPosition::new(2, 2).unwrap());
-        let black_queen2 = Queen::new(ChessPosition::new(3, 2).unwrap());
-        let white_queen3 = Queen::new(ChessPosition::new(2, 6).unwrap());
-        let black_queen3 = Queen::new(ChessPosition::new(1, 6).unwrap());
-        let white_queen4 = Queen::new(ChessPosition::new(2, 7).unwrap());
-        let black_queen4 = Queen::new(ChessPosition::new(5, 7).unwrap());
-
-        assert!(white_queen.can_attack(&black_queen));
-        assert!(white_queen2.can_attack(&black_queen2));
-        assert!(white_queen3.can_attack(&black_queen3));
-        assert!(white_queen4.can_attack(&black_queen4));
-    }
-
-    #[test]
-    fn test_same_diagonal() {
-        let white_queen = Queen::new(ChessPosition::new(2, 2).unwrap());
-        let black_queen = Queen::new(ChessPosition::new(0, 4).unwrap());
-        let white_queen2 = Queen::new(ChessPosition::new(2, 2).unwrap());
-        let black_queen2 = Queen::new(ChessPosition::new(3, 1).unwrap());
-        let white_queen3 = Queen::new(ChessPosition::new(2, 2).unwrap());
-        let black_queen3 = Queen::new(ChessPosition::new(1, 1).unwrap());
-        let white_queen4 = Queen::new(ChessPosition::new(2, 2).unwrap());
-        let black_queen4 = Queen::new(ChessPosition::new(5, 5).unwrap());
-
-        assert!(white_queen.can_attack(&black_queen));
-        assert!(white_queen2.can_attack(&black_queen2));
-        assert!(white_queen3.can_attack(&black_queen3));
-        assert!(white_queen4.can_attack(&black_queen4));
-    }
-}
diff --git a/tests/rpn_test/Cargo.toml b/tests/rpn_test/Cargo.toml
index b0ff97d4..1eb7a8de 100644
--- a/tests/rpn_test/Cargo.toml
+++ b/tests/rpn_test/Cargo.toml
@@ -2,7 +2,7 @@
 name = "rpn_test"
 version = "0.1.0"
 authors = ["OGordoo <marcosafonso8@hotmail.com>"]
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/tests/rpn_test/src/main.rs b/tests/rpn_test/src/lib.rs
similarity index 64%
rename from tests/rpn_test/src/main.rs
rename to tests/rpn_test/src/lib.rs
index 844ea0e9..c94f677a 100644
--- a/tests/rpn_test/src/main.rs
+++ b/tests/rpn_test/src/lib.rs
@@ -1,23 +1,34 @@
-fn main() {}
-
 #[cfg(test)]
 mod tests {
     use std::process::Command;
 
     const MANIFEST_PATH: &str = "../../solutions/rpn/Cargo.toml";
 
-    fn run(s: &str) -> String {
-        let output = Command::new("cargo")
+    fn run_args(f: impl FnOnce(&mut Command) -> &mut Command) -> String {
+        let output = f(&mut Command::new("cargo")
             .arg("run")
             .arg("--manifest-path")
-            .arg(MANIFEST_PATH)
-            .arg(s)
-            .output()
-            .expect("Failed to execute command");
+            .arg(MANIFEST_PATH))
+        .output()
+        .expect("Failed to execute command");
 
         String::from_utf8(output.stdout).unwrap()
     }
 
+    #[inline]
+    fn run(s: &str) -> String {
+        run_args(|c| c.arg(s))
+    }
+
+    #[test]
+    fn incorrect_args_tests() {
+        assert_eq!("Error\n", run_args(|c| c.arg("")));
+        assert_eq!("Error\n", run_args(|c| c.arg("test")));
+        assert_eq!("Error\n", run_args(|c| c));
+        assert_eq!("Error\n", run_args(|c| c.arg("2").arg("4")));
+        assert_eq!("Error\n", run_args(|c| c.arg("2").arg("4").arg("-")));
+    }
+
     #[test]
     fn error_tests() {
         assert_eq!("Error\n", run("21 3 2 % 2 3 2 *"));
diff --git a/tests/scytale_decoder_test/Cargo.toml b/tests/scytale_decoder_test/Cargo.toml
index 55f5b5e4..c91fe4c6 100644
--- a/tests/scytale_decoder_test/Cargo.toml
+++ b/tests/scytale_decoder_test/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "scytale_decoder_test"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
diff --git a/tests/scytale_decoder_test/src/lib.rs b/tests/scytale_decoder_test/src/lib.rs
new file mode 100644
index 00000000..8cf91358
--- /dev/null
+++ b/tests/scytale_decoder_test/src/lib.rs
@@ -0,0 +1,46 @@
+#[cfg(test)]
+mod tests {
+    use scytale_decoder::*;
+
+    #[test]
+    fn test_empty_args() {
+        assert_eq!(scytale_decoder("".to_owned(), 5), None);
+        assert_eq!(scytale_decoder("empty test".to_owned(), 0), None);
+        assert_eq!(scytale_decoder("".to_owned(), 0), None);
+    }
+
+    #[test]
+    fn test_short_nb_letters() {
+        assert_eq!(
+            scytale_decoder("This is already decoded".to_owned(), 100),
+            Some("This is already decoded".to_owned())
+        );
+    }
+
+    #[test]
+    fn test_short_sentence() {
+        assert_eq!(
+            scytale_decoder("aebfcgd".to_owned(), 2),
+            Some("abcdefg".to_owned())
+        );
+    }
+
+    #[test]
+    fn test_medium_sentence() {
+        assert_eq!(
+            scytale_decoder("oenset  daa yt hirne et hfea lflosr".to_owned(), 2),
+            Some("one day in the forest a three falls".to_owned())
+        );
+    }
+
+    #[test]
+    fn test_long_sentence() {
+        assert_eq!(
+            scytale_decoder(
+                "dbtheouoevyigleolepnudtmmwhheaaoegnnurigtsavoteneeosdss".to_owned(),
+                5
+            ),
+            Some("doyouwanttobuildhousestogetherandhelpmegivesevenmangoes".to_owned())
+        );
+    }
+}
diff --git a/tests/scytale_decoder_test/src/main.rs b/tests/scytale_decoder_test/src/main.rs
deleted file mode 100644
index 3fedc6cd..00000000
--- a/tests/scytale_decoder_test/src/main.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use scytale_decoder::*;
-
-fn main() {
-    println!(
-        "\"sec yCtoadle\" size=2 -> {:?}",
-        scytale_decoder("sec yCtoadle".to_string(), 2)
-    );
-
-    println!(
-        "\"steoca dylCe\" size=4 -> {:?}",
-        scytale_decoder("steoca dylCe".to_string(), 4)
-    );
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_empty_args() {
-        assert_eq!(scytale_decoder("".to_string(), 5), None);
-        assert_eq!(scytale_decoder("empty test".to_string(), 0), None);
-        assert_eq!(scytale_decoder("".to_string(), 0), None);
-    }
-
-    #[test]
-    fn test_short_nb_letters() {
-        assert_eq!(
-            scytale_decoder("This is already decoded".to_string(), 100),
-            Some("This is already decoded".to_string())
-        );
-    }
-
-    #[test]
-    fn test_short_sentence() {
-        assert_eq!(
-            scytale_decoder("aebfcgd".to_string(), 2),
-            Some("abcdefg".to_string())
-        );
-    }
-
-    #[test]
-    fn test_medium_sentence() {
-        assert_eq!(
-            scytale_decoder("oenset  daa yt hirne et hfea lflosr".to_string(), 2),
-            Some("one day in the forest a three falls".to_string())
-        );
-    }
-
-    #[test]
-    fn test_long_sentence() {
-        assert_eq!(
-            scytale_decoder(
-                "dbtheouoevyigleolepnudtmmwhheaaoegnnurigtsavoteneeosdss".to_string(),
-                5
-            ),
-            Some("doyouwanttobuildhousestogetherandhelpmegivesevenmangoes".to_string())
-        );
-    }
-}