Prime factors of a number

prime_factors.rs

#![crate_id = "dojo"]
#![crate_type = "lib"]

use std::iter::range_step_inclusive;

fn prime_number_list(number: uint) -> Vec<uint> {
    let mut prime_list:Vec<uint> = vec!(2);

    for i in range_step_inclusive(3, number, 2) {
        if !prime_list.iter().any(|x| i % *x == 0) {
            prime_list.push(i);
        }


    }
    prime_list
}

fn prime_factors(x: uint) -> Vec<uint> {
    let mut number = x;

    let primes_vector = prime_number_list(number);

    let mut prime_list_result = vec!();

    let mut iter = primes_vector.iter();

    let mut partial_number = iter.next();

    loop {
        match partial_number {
            Some(&i) => {
                if number % i == 0 {
                    prime_list_result.push(i);
                    number /= i;
                } else {
                    partial_number = iter.next();
                }
            },
            None => {
                break;
            }
        }
    }

    prime_list_result

}

#[cfg(test)]
mod test {

    use super::{prime_factors, prime_number_list};

    #[test]
    fn test_prime_list_for_number_6() {
        let numbers = prime_factors(6);
        println!("{}",numbers);
        assert!(numbers==vec!(2, 3));
    }

    #[test]
    fn test_prime_list_for_number_5() {
        let numbers = prime_factors(5);
        println!("{}",numbers);
        assert!(numbers==vec!(5));
    }

    #[test]
    fn test_prime_list_for_number_100() {
        let numbers = prime_factors(100);
        assert!(numbers==vec!(2, 2, 5, 5));
    }

    #[test]
    fn test_prime_list_for_number_198() {
        let numbers = prime_factors(198);
        assert!(numbers==vec!(2, 3, 3, 11));
    }

    #[test]
    fn test_prime_list_for_number_276() {
        let numbers = prime_factors(276);
        assert!(numbers==vec!(2, 2, 3, 23));
    }

    #[test]
    fn test_prime_number_list_for_5() {
        assert_eq!(prime_number_list(5), vec!(2, 3, 5));
    }

    #[test]
    fn test_prime_number_list_for_10() {
        assert_eq!(prime_number_list(10), vec!(2, 3, 5, 7));
    }
}