diff --git a/tests/test_regexp.rs b/tests/test_regexp.rs
--- a/tests/test_regexp.rs
+++ b/tests/test_regexp.rs
@@ -1,9 +1,9 @@
-use regexp::Regexp;
+use regexp::RegexpNFA;
 use regexp::ParsingError;
 
 #[test]
 fn test_eval_basic_nfa() {
-	let r = Regexp::new(&String::from("abc")).unwrap();
+	let r = RegexpNFA::new(&String::from("abc")).unwrap();
 	assert!(r.eval(String::from("abc")));
 	assert!(!r.eval(String::from("ab")));
 	assert!(!r.eval(String::from("abcd")));
@@ -11,7 +11,7 @@ fn test_eval_basic_nfa() {
 
 #[test]
 fn test_eval_basic_dfa() {
-	let r = Regexp::new(&String::from("abc")).unwrap().determinize().reduce().normalize();
+	let r = RegexpNFA::new(&String::from("abc")).unwrap().determinize().reduce().normalize();
 	assert!(r.eval(String::from("abc")));
 	assert!(!r.eval(String::from("ab")));
 	assert!(!r.eval(String::from("abcd")));
@@ -19,22 +19,22 @@ fn test_eval_basic_dfa() {
 
 #[test]
 fn test_eval_empty_nfa() {
-	assert!(Regexp::new(&String::from("a*")).unwrap().eval(String::from("")));
-	assert!(Regexp::new(&String::from("")).unwrap().eval(String::from("")));
-	assert!(!Regexp::new(&String::from("")).unwrap().eval(String::from("a")));
-	assert!(!Regexp::new(&String::from("a")).unwrap().eval(String::from("")));
+	assert!(RegexpNFA::new(&String::from("a*")).unwrap().eval(String::from("")));
+	assert!(RegexpNFA::new(&String::from("")).unwrap().eval(String::from("")));
+	assert!(!RegexpNFA::new(&String::from("")).unwrap().eval(String::from("a")));
+	assert!(!RegexpNFA::new(&String::from("a")).unwrap().eval(String::from("")));
 }
 
 #[test]
 fn test_eval_empty_dfa() {
-	assert!(Regexp::new(&String::from("a*")).unwrap().determinize().reduce().normalize().eval(String::from("")));
-	assert!(Regexp::new(&String::from("")).unwrap().determinize().reduce().normalize().eval(String::from("")));
-	assert!(!Regexp::new(&String::from("")).unwrap().determinize().reduce().normalize().eval(String::from("a")));
+	assert!(RegexpNFA::new(&String::from("a*")).unwrap().determinize().reduce().normalize().eval(String::from("")));
+	assert!(RegexpNFA::new(&String::from("")).unwrap().determinize().reduce().normalize().eval(String::from("")));
+	assert!(!RegexpNFA::new(&String::from("")).unwrap().determinize().reduce().normalize().eval(String::from("a")));
 }
 
 #[test]
 fn test_eval_asterisk_nfa() {
-	let r = Regexp::new(&String::from("a*b*")).unwrap();
+	let r = RegexpNFA::new(&String::from("a*b*")).unwrap();
 	assert!(r.eval(String::from("a")));
 	assert!(r.eval(String::from("ab")));
 	assert!(r.eval(String::from("aabb")));
@@ -43,7 +43,7 @@ fn test_eval_asterisk_nfa() {
 
 #[test]
 fn test_eval_asterisk_dfa() {
-	let r = Regexp::new(&String::from("a*b*")).unwrap().determinize().normalize().reduce();
+	let r = RegexpNFA::new(&String::from("a*b*")).unwrap().determinize().normalize().reduce();
 	assert!(r.eval(String::from("a")));
 	assert!(r.eval(String::from("ab")));
 	assert!(r.eval(String::from("aabb")));
@@ -52,7 +52,7 @@ fn test_eval_asterisk_dfa() {
 
 #[test]
 fn test_eval_alternative_nfa() {
-	let r = Regexp::new(&String::from("a|b|c")).unwrap();
+	let r = RegexpNFA::new(&String::from("a|b|c")).unwrap();
 	assert!(r.eval(String::from("a")));
 	assert!(r.eval(String::from("b")));
 	assert!(r.eval(String::from("c")));
@@ -62,7 +62,7 @@ fn test_eval_alternative_nfa() {
 
 #[test]
 fn test_eval_alternative_dfa() {
-	let r = Regexp::new(&String::from("a|b|c")).unwrap().determinize().reduce().normalize();
+	let r = RegexpNFA::new(&String::from("a|b|c")).unwrap().determinize().reduce().normalize();
 	assert!(r.eval(String::from("a")));
 	assert!(r.eval(String::from("b")));
 	assert!(r.eval(String::from("c")));
@@ -72,12 +72,12 @@ fn test_eval_alternative_dfa() {
 
 #[test]
 fn test_eval_lambda_nfa() {
-	let r = Regexp::new(&String::from("a_")).unwrap();
+	let r = RegexpNFA::new(&String::from("a_")).unwrap();
 	assert!(r.eval(String::from("a")));
 	assert!(!r.eval(String::from("")));
 	assert!(!r.eval(String::from("ab")));
 
-	let r = Regexp::new(&String::from("a|_")).unwrap();
+	let r = RegexpNFA::new(&String::from("a|_")).unwrap();
 	assert!(r.eval(String::from("a")));
 	assert!(r.eval(String::from("")));
 	assert!(!r.eval(String::from("b")));
@@ -85,12 +85,12 @@ fn test_eval_lambda_nfa() {
 
 #[test]
 fn test_eval_lambda_dfa() {
-	let r = Regexp::new(&String::from("a_")).unwrap().determinize().reduce().normalize();
+	let r = RegexpNFA::new(&String::from("a_")).unwrap().determinize().reduce().normalize();
 	assert!(r.eval(String::from("a")));
 	assert!(!r.eval(String::from("")));
 	assert!(!r.eval(String::from("ab")));
 
-	let r = Regexp::new(&String::from("a|_")).unwrap().determinize().reduce().normalize();
+	let r = RegexpNFA::new(&String::from("a|_")).unwrap().determinize().reduce().normalize();
 	assert!(r.eval(String::from("a")));
 	assert!(r.eval(String::from("")));
 	assert!(!r.eval(String::from("b")));
@@ -98,36 +98,36 @@ fn test_eval_lambda_dfa() {
 
 #[test]
 fn test_invalid_asterisk() {
-	let x = Regexp::new(&String::from("*"));
+	let x = RegexpNFA::new(&String::from("*"));
 	assert!(matches!(x, Err(ParsingError::Asterisk{s: _, pos: 0})));
 }
 
 #[test]
 fn test_invalid_closing_parenthesis() {
-	let x = Regexp::new(&String::from("(a"));
+	let x = RegexpNFA::new(&String::from("(a"));
 	assert!(matches!(x, Err(ParsingError::ClosingParenthesis{s: _, pos: 0})));
 }
 
 #[test]
 fn test_invalid_opening_parenthesis() {
-	let x = Regexp::new(&String::from("a)"));
+	let x = RegexpNFA::new(&String::from("a)"));
 	assert!(matches!(x, Err(ParsingError::OpeningParenthesis{s: _, pos: 1})));
 }
 
 #[test]
 fn test_invalid_empty_variant_start() {
-	let x = Regexp::new(&String::from("a(|b)"));
+	let x = RegexpNFA::new(&String::from("a(|b)"));
 	assert!(matches!(x, Err(ParsingError::EmptyAlternativeVariant)));
 }
 
 #[test]
 fn test_invalid_empty_variant_end() {
-	let x = Regexp::new(&String::from("a|"));
+	let x = RegexpNFA::new(&String::from("a|"));
 	assert!(matches!(x, Err(ParsingError::EmptyAlternativeVariant)));
 }
 
 #[test]
 fn test_invalid_empty_variant_middle() {
-	let x = Regexp::new(&String::from("a||b"));
+	let x = RegexpNFA::new(&String::from("a||b"));
 	assert!(matches!(x, Err(ParsingError::EmptyAlternativeVariant)));
 }