triangle.rs

use std::f32;
use std::fmt;

fn main() {
    let (x, y, z) = (1., 2., 3.);
    let result: String = match triangle(x, y, z) {
        Some(x) => x.to_string(),
        _ => "insufficient".to_string(),
    };
    println!("{}", result);
}

#[derive(Debug, PartialEq)]
enum Triangle {
    EquilateralTriangle,
    IsoscelesTriangle,
    ScaleneTriangle,
}

impl fmt::Display for Triangle {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{:?}", self)
    }
}

fn triangle(x: f32, y: f32, z: f32) -> Option<Triangle> {
    if f32::MAX - x < 0. {
        return None;
    } else if f32::MAX - x - y < 0. {
        return None;
    } else if f32::MAX - x - y - z < 0. {
        return None;
    }

    if x <= 0. || y <= 0. || z <= 0. {
        return None;
    }

    if x + y <= z || y + z <= x || z + x <= y {
        return None;
    }

    if x == y {
        if y == z {
            return Some(Triangle::EquilateralTriangle);
        }
        return Some(Triangle::IsoscelesTriangle);
    }
    return Some(Triangle::ScaleneTriangle);
}

#[test]
fn equilateral_triangle() {
    let result = triangle(1., 1., 1.);
    assert_eq!(result, Some(Triangle::EquilateralTriangle));
}

#[test]
fn isosceles_triangle() {
    let result = triangle(3., 3., 4.);
    assert_eq!(result, Some(Triangle::IsoscelesTriangle));
}

#[test]
fn scalene_triangle() {
    let result = triangle(3., 4., 5.);
    assert_eq!(result, Some(Triangle::ScaleneTriangle));
}

#[test]
fn incomplete_triangle() {
    let result = triangle(1., 1., 10.);
    assert_eq!(result, None);
}

#[test]
fn negative_value_x_triangle() {
    let result = triangle(-1., 1., 1.);
    assert_eq!(result, None);
}

#[test]
fn negative_value_y_triangle() {
    let result = triangle(1., -1., 1.);
    assert_eq!(result, None);
}

#[test]
fn negative_value_z_triangle() {
    let result = triangle(1., 1., -1.);
    assert_eq!(result, None);
}

#[test]
fn zero_value_x_triangle() {
    let result = triangle(0., 1., 1.);
    assert_eq!(result, None);
}

#[test]
fn zero_value_y_triangle() {
    let result = triangle(1., 0., 1.);
    assert_eq!(result, None);
}

#[test]
fn zero_value_z_triangle() {
    let result = triangle(1., 1., 0.);
    assert_eq!(result, None);
}

#[test]
fn max_value_x_triangle() {
    let result = triangle(f32::MAX, 1., 1.);
    assert_eq!(result, None);
}

#[test]
fn max_value_y_triangle() {
    let result = triangle(f32::MAX, f32::MAX, 1.);
    assert_eq!(result, None);
}

#[test]
fn max_value_z_triangle() {
    let result = triangle(f32::MAX, f32::MAX, f32::MAX);
    assert_eq!(result, None);
}