PSeitz
diff --git a/‎src/is_hiragana.rs
Lines changed: 10 additions & 10 deletions b/‎src/is_hiragana.rs
Lines changed: 10 additions & 10 deletions
diff --git a/‎src/is_kana.rs
Lines changed: 7 additions & 7 deletions b/‎src/is_kana.rs
Lines changed: 7 additions & 7 deletions
diff --git a/‎src/is_kanji.rs
Lines changed: 15 additions & 15 deletions b/‎src/is_kanji.rs
Lines changed: 15 additions & 15 deletions
diff --git a/‎src/is_katakana.rs
Lines changed: 7 additions & 7 deletions b/‎src/is_katakana.rs
Lines changed: 7 additions & 7 deletions
diff --git a/‎src/is_mixed.rs
Lines changed: 12 additions & 12 deletions b/‎src/is_mixed.rs
Lines changed: 12 additions & 12 deletions
diff --git a/‎src/is_romaji.rs
Lines changed: 16 additions & 16 deletions b/‎src/is_romaji.rs
Lines changed: 16 additions & 16 deletions
diff --git a/‎src/to_kana_node_tree.rs
Lines changed: 1 addition & 1 deletion b/‎src/to_kana_node_tree.rs
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/to_romaji_node_tree.rs
Lines changed: 1 addition & 1 deletion b/‎src/to_romaji_node_tree.rs
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/utils/is_char_consonant.rs
Lines changed: 4 additions & 4 deletions b/‎src/utils/is_char_consonant.rs
Lines changed: 4 additions & 4 deletions
diff --git a/‎src/utils/is_char_hiragana.rs
Lines changed: 4 additions & 4 deletions b/‎src/utils/is_char_hiragana.rs
Lines changed: 4 additions & 4 deletions
diff --git a/‎src/utils/is_char_in_range.rs
Lines changed: 2 additions & 2 deletions b/‎src/utils/is_char_in_range.rs
Lines changed: 2 additions & 2 deletions
@@ -10,9 +10,9 @@ pub fn is_hiragana(input: &str) -> bool {
 
 #[test]
 fn check_is_hiragana() {
-    assert_eq!(is_hiragana("げーむ"), true);
-    assert_eq!(is_hiragana("A"), false);
-    assert_eq!(is_hiragana("あア"), false);
+    assert!(is_hiragana("げーむ"));
+    assert!(!is_hiragana("A"));
+    assert!(!is_hiragana("あア"));
 }
 
 #[cfg(test)]
@@ -21,30 +21,30 @@ mod tests {
 
     #[test]
     fn sane_defaults() {
-        assert_eq!(is_hiragana(""), false);
+        assert!(!is_hiragana(""));
     }
     #[test]
     fn あ_is_hiragana() {
-        assert_eq!(is_hiragana("あ"), true);
+        assert!(is_hiragana("あ"));
     }
     #[test]
     fn ああ_is_hiragana() {
-        assert_eq!(is_hiragana("ああ"), true);
+        assert!(is_hiragana("ああ"));
     }
     #[test]
     fn ア_is_not_hiragana() {
-        assert_eq!(is_hiragana("ア"), false);
+        assert!(!is_hiragana("ア"));
     }
     #[test]
     fn a_is_not_hiragana() {
-        assert_eq!(is_hiragana("A"), false);
+        assert!(!is_hiragana("A"));
     }
     #[test]
     fn あア_is_not_hiragana() {
-        assert_eq!(is_hiragana("あア"), false);
+        assert!(!is_hiragana("あア"));
     }
     #[test]
     fn ignores_long_dash_in_hiragana() {
-        assert_eq!(is_hiragana("げーむ"), true);
+        assert!(is_hiragana("げーむ"));
     }
 }
@@ -14,30 +14,30 @@ mod tests {
 
     #[test]
     fn sane_defaults() {
-        assert_eq!(is_kana(""), false);
+        assert!(!is_kana(""));
     }
     #[test]
     fn あ_is_kana() {
-        assert_eq!(is_kana("あ"), true);
+        assert!(is_kana("あ"));
     }
     #[test]
     fn ア_is_kana() {
-        assert_eq!(is_kana("ア"), true);
+        assert!(is_kana("ア"));
     }
     #[test]
     fn あア_is_kana() {
-        assert_eq!(is_kana("あア"), true);
+        assert!(is_kana("あア"));
     }
     #[test]
     fn a_is_not_kana() {
-        assert_eq!(is_kana("A"), false);
+        assert!(!is_kana("A"));
     }
     #[test]
     fn あaア_is_not_kana() {
-        assert_eq!(is_kana("あAア"), false);
+        assert!(!is_kana("あAア"));
     }
     #[test]
     fn ignores_long_dash_in_mixed_kana() {
-        assert_eq!(is_kana("アーあ"), true);
+        assert!(is_kana("アーあ"));
     }
 }
@@ -24,60 +24,60 @@ mod tests {
 
     #[test]
     fn sane_defaults() {
-        assert_eq!(is_kanji(""), false);
-        assert_eq!(contains_kanji(""), false);
+        assert!(!is_kanji(""));
+        assert!(!contains_kanji(""));
     }
 
     #[test]
     fn 勢い_contains_kanji() {
-        assert_eq!(contains_kanji("勢い"), true);
+        assert!(contains_kanji("勢い"));
     }
     #[test]
     fn hello_contains_not_kanji() {
-        assert_eq!(contains_kanji("hello"), false);
+        assert!(!contains_kanji("hello"));
     }
     #[test]
     fn 切腹_is_kanji() {
-        assert_eq!(is_kanji("切腹"), true);
+        assert!(is_kanji("切腹"));
     }
     #[test]
     fn 刀_is_kanji() {
-        assert_eq!(is_kanji("刀"), true);
+        assert!(is_kanji("刀"));
     }
     #[test]
     fn emoji_are_not_kanji() {
-        assert_eq!(is_kanji("🐸"), false);
+        assert!(!is_kanji("🐸"));
     }
     #[test]
     fn あ_is_not_kanji() {
-        assert_eq!(is_kanji("あ"), false);
+        assert!(!is_kanji("あ"));
     }
     #[test]
     fn ア_is_not_kanji() {
-        assert_eq!(is_kanji("ア"), false);
+        assert!(!is_kanji("ア"));
     }
     #[test]
     fn あア_is_not_kanji() {
-        assert_eq!(is_kanji("あア"), false);
+        assert!(!is_kanji("あア"));
     }
     #[test]
     fn a_is_not_kanji() {
-        assert_eq!(is_kanji("A"), false);
+        assert!(!is_kanji("A"));
     }
     #[test]
     fn あaア_is_not_kanji() {
-        assert_eq!(is_kanji("あAア"), false);
+        assert!(!is_kanji("あAア"));
     }
     #[test]
     fn number_with_kanj_is_not_kanji1() {
-        assert_eq!(is_kanji("１２隻"), false);
+        assert!(!is_kanji("１２隻"));
     }
     #[test]
     fn number_with_kanj_is_not_kanji2() {
-        assert_eq!(is_kanji("12隻"), false);
+        assert!(!is_kanji("12隻"));
     }
     #[test]
     fn kanji_with_dot_is_not_kanji() {
-        assert_eq!(is_kanji("隻。"), false);
+        assert!(!is_kanji("隻。"));
     }
 }
@@ -14,30 +14,30 @@ mod tests {
 
     #[test]
     fn sane_defaults() {
-        assert_eq!(is_katakana(""), false);
+        assert!(!is_katakana(""));
     }
     #[test]
     fn アア_is_katakana() {
-        assert_eq!(is_katakana("アア"), true);
+        assert!(is_katakana("アア"));
     }
     #[test]
     fn ア_is_katakana() {
-        assert_eq!(is_katakana("ア"), true);
+        assert!(is_katakana("ア"));
     }
     #[test]
     fn あ_is_not_katakana() {
-        assert_eq!(is_katakana("あ"), false);
+        assert!(!is_katakana("あ"));
     }
     #[test]
     fn a_is_not_katakana() {
-        assert_eq!(is_katakana("A"), false);
+        assert!(!is_katakana("A"));
     }
     #[test]
     fn あア_is_not_katakana() {
-        assert_eq!(is_katakana("あア"), false);
+        assert!(!is_katakana("あア"));
     }
     #[test]
     fn ignores_long_dash_in_katakana() {
-        assert_eq!(is_katakana("ゲーム"), true);
+        assert!(is_katakana("ゲーム"));
     }
 }
@@ -28,50 +28,50 @@ mod tests {
 
     #[test]
     fn sane_defaults() {
-        assert_eq!(is_mixed(""), false);
+        assert!(!is_mixed(""));
     }
     #[test]
     fn aア_is_mixed() {
-        assert_eq!(is_mixed("Aア"), true);
+        assert!(is_mixed("Aア"));
     }
     #[test]
     fn aあ_is_mixed() {
-        assert_eq!(is_mixed("Aあ"), true);
+        assert!(is_mixed("Aあ"));
     }
     #[test]
     fn aあア_is_mixed() {
-        assert_eq!(is_mixed("Aあア"), true);
+        assert!(is_mixed("Aあア"));
     }
     #[test]
     fn number_2あア_is_not_mixed() {
-        assert_eq!(is_mixed("２あア"), false);
+        assert!(!is_mixed("２あア"));
     }
     #[test]
     fn お腹a_is_mixed() {
-        assert_eq!(is_mixed("お腹A"), true);
+        assert!(is_mixed("お腹A"));
     }
     #[test]
     fn お腹a_is_not_mixed_when_pass_kanji_false() {
-        assert_eq!(is_mixed_pass_kanji("お腹A", false), false);
+        assert!(!is_mixed_pass_kanji("お腹A", false));
     }
     #[test]
     fn お腹_is_not_mixed() {
-        assert_eq!(is_mixed("お腹"), false);
+        assert!(!is_mixed("お腹"));
     }
     #[test]
     fn 腹_is_not_mixed() {
-        assert_eq!(is_mixed("腹"), false);
+        assert!(!is_mixed("腹"));
     }
     #[test]
     fn a_is_not_mixed() {
-        assert_eq!(is_mixed("A"), false);
+        assert!(!is_mixed("A"));
     }
     #[test]
     fn あ_is_not_mixed() {
-        assert_eq!(is_mixed("あ"), false);
+        assert!(!is_mixed("あ"));
     }
     #[test]
     fn ア_is_not_mixed() {
-        assert_eq!(is_mixed("ア"), false);
+        assert!(!is_mixed("ア"));
     }
 }
@@ -31,11 +31,11 @@ pub fn is_romaji_with_whitelist(input: &str, allowed: Option<&Regex>) -> bool {
 
 #[test]
 fn check_is_romaji() {
-    assert_eq!(is_romaji("Tōkyō and Ōsaka"), true);
-    assert_eq!(is_romaji("12a*b&c-d"), true);
-    assert_eq!(is_romaji("あアA"), false);
-    assert_eq!(is_romaji("お願い"), false);
-    assert_eq!(is_romaji("a！b&cーd"), false);
+    assert!(is_romaji("Tōkyō and Ōsaka"));
+    assert!(is_romaji("12a*b&c-d"));
+    assert!(!is_romaji("あアA"));
+    assert!(!is_romaji("お願い"));
+    assert!(!is_romaji("a！b&cーd"));
 }
 
 #[cfg(test)]
@@ -44,50 +44,50 @@ mod tests {
 
     #[test]
     fn sane_defaults() {
-        assert_eq!(is_romaji(""), false);
+        assert!(!is_romaji(""));
 
         #[cfg(feature = "enable_regex")]
         assert_eq!(is_romaji_with_whitelist("", None), false);
     }
     #[test]
     fn a_is_romaji() {
-        assert_eq!(is_romaji("A"), true);
+        assert!(is_romaji("A"));
     }
     #[test]
     fn x_yz_is_romaji() {
-        assert_eq!(is_romaji("xYz"), true);
+        assert!(is_romaji("xYz"));
     }
     #[test]
     fn tōkyō_and_ōsaka_is_romaji() {
-        assert_eq!(is_romaji("Tōkyō and Ōsaka"), true);
+        assert!(is_romaji("Tōkyō and Ōsaka"));
     }
     #[test]
     fn あアa_is_not_romaji() {
-        assert_eq!(is_romaji("あアA"), false);
+        assert!(!is_romaji("あアA"));
     }
     #[test]
     fn お願い_is_not_romaji() {
-        assert_eq!(is_romaji("お願い"), false);
+        assert!(!is_romaji("お願い"));
     }
     #[test]
     fn 熟成_is_not_romaji() {
-        assert_eq!(is_romaji("熟成"), false);
+        assert!(!is_romaji("熟成"));
     }
     #[test]
     fn passes_latin_punctuation() {
-        assert_eq!(is_romaji("a*b&c-d"), true);
+        assert!(is_romaji("a*b&c-d"));
     }
     #[test]
     fn passes_latin_numbers() {
-        assert_eq!(is_romaji("0123456789"), true);
+        assert!(is_romaji("0123456789"));
     }
     #[test]
     fn fails_zenkaku_punctuation() {
-        assert_eq!(is_romaji("a！b&cーd"), false);
+        assert!(!is_romaji("a！b&cーd"));
     }
     #[test]
     fn fails_zenkaku_latin() {
-        assert_eq!(is_romaji("ｈｅｌｌｏ"), false);
+        assert!(!is_romaji("ｈｅｌｌｏ"));
     }
 
     #[cfg(feature = "enable_regex")]
 
@@ -5,7 +5,7 @@ pub(crate) struct Node {
 }
 
 impl Node {
-    pub(crate) fn get<'a>(&self, chars: &'a [char]) -> (Option<&'static str>, usize) {
+    pub(crate) fn get(&self, chars: &[char]) -> (Option<&'static str>, usize) {
         let mut i = 0;
         let mut curr_node = self;
         for char in chars.iter() {
 
@@ -5,7 +5,7 @@ pub(crate) struct Node {
 }
 
 impl Node {
-    pub(crate) fn get<'a>(&self, chars: &'a [char]) -> (&'static str, usize) {
+    pub(crate) fn get(&self, chars: &[char]) -> (&'static str, usize) {
         let mut i = 0;
         let mut curr_node = self;
         for char in chars.iter() {
 
@@ -14,8 +14,8 @@ pub fn is_char_consonant(char: char, include_y: bool) -> bool {
 
 #[test]
 fn is_char_consonant_test() {
-    assert_eq!(is_char_consonant('y', false), false);
-    assert_eq!(is_char_consonant('y', true), true);
-    assert_eq!(is_char_consonant('a', true), false);
-    assert_eq!(is_char_consonant('!', true), false);
+    assert!(!is_char_consonant('y', false));
+    assert!(is_char_consonant('y', true));
+    assert!(!is_char_consonant('a', true));
+    assert!(!is_char_consonant('!', true));
 }
@@ -12,8 +12,8 @@ pub fn is_char_hiragana(char: char) -> bool {
 
 #[test]
 fn is_char_hiragana_test() {
-    assert_eq!(is_char_hiragana('な'), true);
-    assert_eq!(is_char_hiragana('ナ'), false);
-    assert_eq!(is_char_hiragana('n'), false);
-    assert_eq!(is_char_hiragana('!'), false);
+    assert!(is_char_hiragana('な'));
+    assert!(!is_char_hiragana('ナ'));
+    assert!(!is_char_hiragana('n'));
+    assert!(!is_char_hiragana('!'));
 }
@@ -14,6 +14,6 @@ pub fn is_char_in_range(char: char, start: u32, end: u32) -> bool {
 #[test]
 fn is_char_in_range_test() {
     use crate::constants::{HIRAGANA_END, HIRAGANA_START};
-    assert_eq!(is_char_in_range('は', HIRAGANA_START, HIRAGANA_END), true);
-    assert_eq!(is_char_in_range('d', HIRAGANA_START, HIRAGANA_END), false);
+    assert!(is_char_in_range('は', HIRAGANA_START, HIRAGANA_END));
+    assert!(!is_char_in_range('d', HIRAGANA_START, HIRAGANA_END));
 }
Original file line number	Diff line number	Diff line change
`@@ -10,9 +10,9 @@ pub fn is_hiragana(input: &str) -> bool {`
`10`	`10`
`11`	`11`	`#[test]`
`12`	`12`	`fn check_is_hiragana() {`
`13`		`- assert_eq!(is_hiragana("げーむ"), true);`
`14`		`- assert_eq!(is_hiragana("A"), false);`
`15`		`- assert_eq!(is_hiragana("あア"), false);`
	`13`	`+ assert!(is_hiragana("げーむ"));`
	`14`	`+ assert!(!is_hiragana("A"));`
	`15`	`+ assert!(!is_hiragana("あア"));`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`#[cfg(test)]`
`@@ -21,30 +21,30 @@ mod tests {`
`21`	`21`
`22`	`22`	`#[test]`
`23`	`23`	`fn sane_defaults() {`
`24`		`- assert_eq!(is_hiragana(""), false);`
	`24`	`+ assert!(!is_hiragana(""));`
`25`	`25`	`}`
`26`	`26`	`#[test]`
`27`	`27`	`fn あ_is_hiragana() {`
`28`		`- assert_eq!(is_hiragana("あ"), true);`
	`28`	`+ assert!(is_hiragana("あ"));`
`29`	`29`	`}`
`30`	`30`	`#[test]`
`31`	`31`	`fn ああ_is_hiragana() {`
`32`		`- assert_eq!(is_hiragana("ああ"), true);`
	`32`	`+ assert!(is_hiragana("ああ"));`
`33`	`33`	`}`
`34`	`34`	`#[test]`
`35`	`35`	`fn ア_is_not_hiragana() {`
`36`		`- assert_eq!(is_hiragana("ア"), false);`
	`36`	`+ assert!(!is_hiragana("ア"));`
`37`	`37`	`}`
`38`	`38`	`#[test]`
`39`	`39`	`fn a_is_not_hiragana() {`
`40`		`- assert_eq!(is_hiragana("A"), false);`
	`40`	`+ assert!(!is_hiragana("A"));`
`41`	`41`	`}`
`42`	`42`	`#[test]`
`43`	`43`	`fn あア_is_not_hiragana() {`
`44`		`- assert_eq!(is_hiragana("あア"), false);`
	`44`	`+ assert!(!is_hiragana("あア"));`
`45`	`45`	`}`
`46`	`46`	`#[test]`
`47`	`47`	`fn ignores_long_dash_in_hiragana() {`
`48`		`- assert_eq!(is_hiragana("げーむ"), true);`
	`48`	`+ assert!(is_hiragana("げーむ"));`
`49`	`49`	`}`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,30 +14,30 @@ mod tests {`
`14`	`14`
`15`	`15`	`#[test]`
`16`	`16`	`fn sane_defaults() {`
`17`		`- assert_eq!(is_kana(""), false);`
	`17`	`+ assert!(!is_kana(""));`
`18`	`18`	`}`
`19`	`19`	`#[test]`
`20`	`20`	`fn あ_is_kana() {`
`21`		`- assert_eq!(is_kana("あ"), true);`
	`21`	`+ assert!(is_kana("あ"));`
`22`	`22`	`}`
`23`	`23`	`#[test]`
`24`	`24`	`fn ア_is_kana() {`
`25`		`- assert_eq!(is_kana("ア"), true);`
	`25`	`+ assert!(is_kana("ア"));`
`26`	`26`	`}`
`27`	`27`	`#[test]`
`28`	`28`	`fn あア_is_kana() {`
`29`		`- assert_eq!(is_kana("あア"), true);`
	`29`	`+ assert!(is_kana("あア"));`
`30`	`30`	`}`
`31`	`31`	`#[test]`
`32`	`32`	`fn a_is_not_kana() {`
`33`		`- assert_eq!(is_kana("A"), false);`
	`33`	`+ assert!(!is_kana("A"));`
`34`	`34`	`}`
`35`	`35`	`#[test]`
`36`	`36`	`fn あaア_is_not_kana() {`
`37`		`- assert_eq!(is_kana("あAア"), false);`
	`37`	`+ assert!(!is_kana("あAア"));`
`38`	`38`	`}`
`39`	`39`	`#[test]`
`40`	`40`	`fn ignores_long_dash_in_mixed_kana() {`
`41`		`- assert_eq!(is_kana("アーあ"), true);`
	`41`	`+ assert!(is_kana("アーあ"));`
`42`	`42`	`}`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,60 +24,60 @@ mod tests {`
`24`	`24`
`25`	`25`	`#[test]`
`26`	`26`	`fn sane_defaults() {`
`27`		`- assert_eq!(is_kanji(""), false);`
`28`		`- assert_eq!(contains_kanji(""), false);`
	`27`	`+ assert!(!is_kanji(""));`
	`28`	`+ assert!(!contains_kanji(""));`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`#[test]`
`32`	`32`	`fn 勢い_contains_kanji() {`
`33`		`- assert_eq!(contains_kanji("勢い"), true);`
	`33`	`+ assert!(contains_kanji("勢い"));`
`34`	`34`	`}`
`35`	`35`	`#[test]`
`36`	`36`	`fn hello_contains_not_kanji() {`
`37`		`- assert_eq!(contains_kanji("hello"), false);`
	`37`	`+ assert!(!contains_kanji("hello"));`
`38`	`38`	`}`
`39`	`39`	`#[test]`
`40`	`40`	`fn 切腹_is_kanji() {`
`41`		`- assert_eq!(is_kanji("切腹"), true);`
	`41`	`+ assert!(is_kanji("切腹"));`
`42`	`42`	`}`
`43`	`43`	`#[test]`
`44`	`44`	`fn 刀_is_kanji() {`
`45`		`- assert_eq!(is_kanji("刀"), true);`
	`45`	`+ assert!(is_kanji("刀"));`
`46`	`46`	`}`
`47`	`47`	`#[test]`
`48`	`48`	`fn emoji_are_not_kanji() {`
`49`		`- assert_eq!(is_kanji("🐸"), false);`
	`49`	`+ assert!(!is_kanji("🐸"));`
`50`	`50`	`}`
`51`	`51`	`#[test]`
`52`	`52`	`fn あ_is_not_kanji() {`
`53`		`- assert_eq!(is_kanji("あ"), false);`
	`53`	`+ assert!(!is_kanji("あ"));`
`54`	`54`	`}`
`55`	`55`	`#[test]`
`56`	`56`	`fn ア_is_not_kanji() {`
`57`		`- assert_eq!(is_kanji("ア"), false);`
	`57`	`+ assert!(!is_kanji("ア"));`
`58`	`58`	`}`
`59`	`59`	`#[test]`
`60`	`60`	`fn あア_is_not_kanji() {`
`61`		`- assert_eq!(is_kanji("あア"), false);`
	`61`	`+ assert!(!is_kanji("あア"));`
`62`	`62`	`}`
`63`	`63`	`#[test]`
`64`	`64`	`fn a_is_not_kanji() {`
`65`		`- assert_eq!(is_kanji("A"), false);`
	`65`	`+ assert!(!is_kanji("A"));`
`66`	`66`	`}`
`67`	`67`	`#[test]`
`68`	`68`	`fn あaア_is_not_kanji() {`
`69`		`- assert_eq!(is_kanji("あAア"), false);`
	`69`	`+ assert!(!is_kanji("あAア"));`
`70`	`70`	`}`
`71`	`71`	`#[test]`
`72`	`72`	`fn number_with_kanj_is_not_kanji1() {`
`73`		`- assert_eq!(is_kanji("１２隻"), false);`
	`73`	`+ assert!(!is_kanji("１２隻"));`
`74`	`74`	`}`
`75`	`75`	`#[test]`
`76`	`76`	`fn number_with_kanj_is_not_kanji2() {`
`77`		`- assert_eq!(is_kanji("12隻"), false);`
	`77`	`+ assert!(!is_kanji("12隻"));`
`78`	`78`	`}`
`79`	`79`	`#[test]`
`80`	`80`	`fn kanji_with_dot_is_not_kanji() {`
`81`		`- assert_eq!(is_kanji("隻。"), false);`
	`81`	`+ assert!(!is_kanji("隻。"));`
`82`	`82`	`}`
`83`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,50 +28,50 @@ mod tests {`
`28`	`28`
`29`	`29`	`#[test]`
`30`	`30`	`fn sane_defaults() {`
`31`		`- assert_eq!(is_mixed(""), false);`
	`31`	`+ assert!(!is_mixed(""));`
`32`	`32`	`}`
`33`	`33`	`#[test]`
`34`	`34`	`fn aア_is_mixed() {`
`35`		`- assert_eq!(is_mixed("Aア"), true);`
	`35`	`+ assert!(is_mixed("Aア"));`
`36`	`36`	`}`
`37`	`37`	`#[test]`
`38`	`38`	`fn aあ_is_mixed() {`
`39`		`- assert_eq!(is_mixed("Aあ"), true);`
	`39`	`+ assert!(is_mixed("Aあ"));`
`40`	`40`	`}`
`41`	`41`	`#[test]`
`42`	`42`	`fn aあア_is_mixed() {`
`43`		`- assert_eq!(is_mixed("Aあア"), true);`
	`43`	`+ assert!(is_mixed("Aあア"));`
`44`	`44`	`}`
`45`	`45`	`#[test]`
`46`	`46`	`fn number_2あア_is_not_mixed() {`
`47`		`- assert_eq!(is_mixed("２あア"), false);`
	`47`	`+ assert!(!is_mixed("２あア"));`
`48`	`48`	`}`
`49`	`49`	`#[test]`
`50`	`50`	`fn お腹a_is_mixed() {`
`51`		`- assert_eq!(is_mixed("お腹A"), true);`
	`51`	`+ assert!(is_mixed("お腹A"));`
`52`	`52`	`}`
`53`	`53`	`#[test]`
`54`	`54`	`fn お腹a_is_not_mixed_when_pass_kanji_false() {`
`55`		`- assert_eq!(is_mixed_pass_kanji("お腹A", false), false);`
	`55`	`+ assert!(!is_mixed_pass_kanji("お腹A", false));`
`56`	`56`	`}`
`57`	`57`	`#[test]`
`58`	`58`	`fn お腹_is_not_mixed() {`
`59`		`- assert_eq!(is_mixed("お腹"), false);`
	`59`	`+ assert!(!is_mixed("お腹"));`
`60`	`60`	`}`
`61`	`61`	`#[test]`
`62`	`62`	`fn 腹_is_not_mixed() {`
`63`		`- assert_eq!(is_mixed("腹"), false);`
	`63`	`+ assert!(!is_mixed("腹"));`
`64`	`64`	`}`
`65`	`65`	`#[test]`
`66`	`66`	`fn a_is_not_mixed() {`
`67`		`- assert_eq!(is_mixed("A"), false);`
	`67`	`+ assert!(!is_mixed("A"));`
`68`	`68`	`}`
`69`	`69`	`#[test]`
`70`	`70`	`fn あ_is_not_mixed() {`
`71`		`- assert_eq!(is_mixed("あ"), false);`
	`71`	`+ assert!(!is_mixed("あ"));`
`72`	`72`	`}`
`73`	`73`	`#[test]`
`74`	`74`	`fn ア_is_not_mixed() {`
`75`		`- assert_eq!(is_mixed("ア"), false);`
	`75`	`+ assert!(!is_mixed("ア"));`
`76`	`76`	`}`
`77`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ pub(crate) struct Node {`
`5`	`5`	`}`
`6`	`6`
`7`	`7`	`impl Node {`
`8`		`- pub(crate) fn get<'a>(&self, chars: &'a [char]) -> (Option<&'static str>, usize) {`
	`8`	`+ pub(crate) fn get(&self, chars: &[char]) -> (Option<&'static str>, usize) {`
`9`	`9`	`let mut i = 0;`
`10`	`10`	`let mut curr_node = self;`
`11`	`11`	`for char in chars.iter() {`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,6 @@ pub fn is_char_in_range(char: char, start: u32, end: u32) -> bool {`
`14`	`14`	`#[test]`
`15`	`15`	`fn is_char_in_range_test() {`
`16`	`16`	`use crate::constants::{HIRAGANA_END, HIRAGANA_START};`
`17`		`- assert_eq!(is_char_in_range('は', HIRAGANA_START, HIRAGANA_END), true);`
`18`		`- assert_eq!(is_char_in_range('d', HIRAGANA_START, HIRAGANA_END), false);`
	`17`	`+ assert!(is_char_in_range('は', HIRAGANA_START, HIRAGANA_END));`
	`18`	`+ assert!(!is_char_in_range('d', HIRAGANA_START, HIRAGANA_END));`
`19`	`19`	`}`