moved operation tests to each operations corresponding file

src/operations/add.rs

@@ -28,3 +28,27 @@ pub fn op(lhs: &Data, rhs: &Data) -> Option<Data> {
         _ => None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::Type;
+
+    use super::super::Operation;
+
+    #[test]
+    fn add_numbers() {
+        let res_type = Operation::Add.typ(&Type::Number, &Type::Number);
+        assert_eq!(res_type, Ok(Type::Number));
+    }
+
+    #[test]
+    fn add_strings() {
+        let res_type = Operation::Add.typ(&Type::String, &Type::String);
+        assert_eq!(res_type, Ok(Type::String));
+    }
+
+    #[test]
+    fn cannot_add_different() {
+        assert!(Operation::Add.typ(&Type::String, &Type::Number).is_err())
+    }
+}

src/operations/div.rs

@@ -20,3 +20,21 @@ pub fn op(lhs: &Data, rhs: &Data) -> Option<Data> {
         _ => None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::Type;
+
+    use super::super::Operation;
+
+    #[test]
+    fn div_numbers() {
+        let res_type = Operation::Div.typ(&Type::Number, &Type::Number);
+        assert_eq!(res_type, Ok(Type::Number));
+    }
+
+    #[test]
+    fn cannot_div_different() {
+        assert!(Operation::Div.typ(&Type::String, &Type::Number).is_err())
+    }
+}

src/operations/eq.rs

@@ -28,3 +28,27 @@ pub fn op(lhs: &Data, rhs: &Data) -> Option<Data> {
         _ => None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::Type;
+
+    use super::super::Operation;
+
+    #[test]
+    fn eq_numbers() {
+        let res_type = Operation::Eq.typ(&Type::Number, &Type::Number);
+        assert_eq!(res_type, Ok(Type::Bool));
+    }
+
+    #[test]
+    fn eq_strings() {
+        let res_type = Operation::Eq.typ(&Type::String, &Type::String);
+        assert_eq!(res_type, Ok(Type::Bool));
+    }
+
+    #[test]
+    fn cannot_eq_different() {
+        assert!(Operation::Eq.typ(&Type::String, &Type::Number).is_err())
+    }
+}

src/operations/gt.rs

@@ -20,3 +20,21 @@ pub fn op(lhs: &Data, rhs: &Data) -> Option<Data> {
         _ => None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::Type;
+
+    use super::super::Operation;
+
+    #[test]
+    fn gt_numbers() {
+        let res_type = Operation::Gt.typ(&Type::Number, &Type::Number);
+        assert_eq!(res_type, Ok(Type::Bool));
+    }
+
+    #[test]
+    fn cannot_gt_different() {
+        assert!(Operation::Gt.typ(&Type::String, &Type::Number).is_err())
+    }
+}

src/operations/gte.rs

@@ -20,3 +20,21 @@ pub fn op(lhs: &Data, rhs: &Data) -> Option<Data> {
         _ => None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::Type;
+
+    use super::super::Operation;
+
+    #[test]
+    fn gte_numbers() {
+        let res_type = Operation::Gte.typ(&Type::Number, &Type::Number);
+        assert_eq!(res_type, Ok(Type::Bool));
+    }
+
+    #[test]
+    fn cannot_gte_different() {
+        assert!(Operation::Gte.typ(&Type::String, &Type::Number).is_err())
+    }
+}

src/operations/lt.rs

@@ -20,3 +20,21 @@ pub fn op(lhs: &Data, rhs: &Data) -> Option<Data> {
         _ => None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::Type;
+
+    use super::super::Operation;
+
+    #[test]
+    fn lt_numbers() {
+        let res_type = Operation::Lt.typ(&Type::Number, &Type::Number);
+        assert_eq!(res_type, Ok(Type::Bool));
+    }
+
+    #[test]
+    fn cannot_lt_different() {
+        assert!(Operation::Lt.typ(&Type::String, &Type::Number).is_err())
+    }
+}

src/operations/lte.rs

@@ -20,3 +20,21 @@ pub fn op(lhs: &Data, rhs: &Data) -> Option<Data> {
         _ => None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::Type;
+
+    use super::super::Operation;
+
+    #[test]
+    fn lte_numbers() {
+        let res_type = Operation::Lte.typ(&Type::Number, &Type::Number);
+        assert_eq!(res_type, Ok(Type::Bool));
+    }
+
+    #[test]
+    fn cannot_lte_different() {
+        assert!(Operation::Lte.typ(&Type::String, &Type::Number).is_err())
+    }
+}

src/operations/mod.rs

@@ -62,6 +62,3 @@ impl Operation {
         res.expect("invalid operation slipped through to the interpreter after a valid operation check")
     }
 }
-
-#[cfg(test)]
-mod tests;

src/operations/mul.rs

@@ -20,3 +20,21 @@ pub fn op(lhs: &Data, rhs: &Data) -> Option<Data> {
         _ => None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::Type;
+
+    use super::super::Operation;
+
+    #[test]
+    fn mul_numbers() {
+        let res_type = Operation::Mul.typ(&Type::Number, &Type::Number);
+        assert_eq!(res_type, Ok(Type::Number));
+    }
+
+    #[test]
+    fn cannot_mul_different() {
+        assert!(Operation::Mul.typ(&Type::String, &Type::Number).is_err())
+    }
+}

src/operations/rem.rs

@@ -20,3 +20,21 @@ pub fn op(lhs: &Data, rhs: &Data) -> Option<Data> {
         _ => None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::Type;
+
+    use super::super::Operation;
+
+    #[test]
+    fn rem_numbers() {
+        let res_type = Operation::Rem.typ(&Type::Number, &Type::Number);
+        assert_eq!(res_type, Ok(Type::Number));
+    }
+
+    #[test]
+    fn cannot_rem_different() {
+        assert!(Operation::Rem.typ(&Type::String, &Type::Number).is_err())
+    }
+}

src/operations/sub.rs

@@ -20,3 +20,21 @@ pub fn op(lhs: &Data, rhs: &Data) -> Option<Data> {
         _ => None
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::types::Type;
+
+    use super::super::Operation;
+
+    #[test]
+    fn sub_numbers() {
+        let res_type = Operation::Sub.typ(&Type::Number, &Type::Number);
+        assert_eq!(res_type, Ok(Type::Number));
+    }
+
+    #[test]
+    fn cannot_sub_different() {
+        assert!(Operation::Sub.typ(&Type::String, &Type::Number).is_err())
+    }
+}