arabic_script/core/
arabic_character.rs

1/**************************************************************************************************
2 * Copyright 2023 Tamer Elzein <tamer@tamerudition.com>                                           *
3 *                                                                                                *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file      *
5 * except in compliance with the License. You may obtain a copy of the License at                 *
6 *                                                                                                *
7 * http://www.apache.org/licenses/LICENSE-2.0                                                     *
8 *                                                                                                *
9 * Unless required by applicable law or agreed to in writing, software distributed under the      *
10 * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,      *
11 * either express or implied. See the License for the specific language governing permissions     *
12 * and limitations under the License.                                                             *
13 **************************************************************************************************/
14
15use std::fmt::{Debug, Display, Formatter};
16
17use crate::core::UnicodeCharacter;
18use crate::ArabicDamma;
19use crate::ArabicDammatan;
20use crate::ArabicFatha;
21use crate::ArabicFathatan;
22use crate::ArabicKasra;
23use crate::ArabicKasratan;
24use crate::ArabicLetterAin;
25use crate::ArabicLetterAlef;
26use crate::ArabicLetterAlefMaksura;
27use crate::ArabicLetterAlefWithHamzaAbove;
28use crate::ArabicLetterAlefWithHamzaBelow;
29use crate::ArabicLetterAlefWithMaddaAbove;
30use crate::ArabicLetterBeh;
31use crate::ArabicLetterDad;
32use crate::ArabicLetterDal;
33use crate::ArabicLetterFeh;
34use crate::ArabicLetterGhain;
35use crate::ArabicLetterHah;
36use crate::ArabicLetterHamza;
37use crate::ArabicLetterHeh;
38use crate::ArabicLetterJeem;
39use crate::ArabicLetterKaf;
40use crate::ArabicLetterKhah;
41use crate::ArabicLetterLam;
42use crate::ArabicLetterMeem;
43use crate::ArabicLetterNoon;
44use crate::ArabicLetterQaf;
45use crate::ArabicLetterReh;
46use crate::ArabicLetterSad;
47use crate::ArabicLetterSeen;
48use crate::ArabicLetterSheen;
49use crate::ArabicLetterTah;
50use crate::ArabicLetterTeh;
51use crate::ArabicLetterTehMarbuta;
52use crate::ArabicLetterThal;
53use crate::ArabicLetterTheh;
54use crate::ArabicLetterWaw;
55use crate::ArabicLetterWawWithHamzaAbove;
56use crate::ArabicLetterYeh;
57use crate::ArabicLetterYehWithHamzaAbove;
58use crate::ArabicLetterZah;
59use crate::ArabicLetterZain;
60use crate::ArabicShadda;
61use crate::ArabicSukun;
62use crate::ArabicTatweel;
63
64/// Represents a character of the Arabic script.
65///
66/// An Arabic character can be instantiated directly by specifying one of its variants by name:
67///
68/// ```
69/// let character = arabic_script::ArabicLetterDad;
70/// ```
71///
72/// Alternatively, it can be instantiated from a [`char`]...
73///
74/// ```
75/// let character = arabic_script::ArabicCharacter::try_from('ض').unwrap();
76/// ```
77///
78/// Note that the [`ArabicCharacter::try_from()`] method will return an [Error][`Err`] for any
79/// character that does not belong to the Arabic script.
80pub enum ArabicCharacter {
81    ArabicLetterHamza,
82    ArabicLetterAlefWithMaddaAbove,
83    ArabicLetterAlefWithHamzaAbove,
84    ArabicLetterAlefWithHamzaBelow,
85    ArabicLetterWawWithHamzaAbove,
86    ArabicLetterYehWithHamzaAbove,
87    ArabicLetterAlef,
88    ArabicLetterBeh,
89    ArabicLetterTehMarbuta,
90    ArabicLetterTeh,
91    ArabicLetterTheh,
92    ArabicLetterJeem,
93    ArabicLetterHah,
94    ArabicLetterKhah,
95    ArabicLetterDal,
96    ArabicLetterThal,
97    ArabicLetterReh,
98    ArabicLetterZain,
99    ArabicLetterSeen,
100    ArabicLetterSheen,
101    ArabicLetterSad,
102    ArabicLetterDad,
103    ArabicLetterTah,
104    ArabicLetterZah,
105    ArabicLetterAin,
106    ArabicLetterGhain,
107    ArabicTatweel,
108    ArabicLetterFeh,
109    ArabicLetterQaf,
110    ArabicLetterKaf,
111    ArabicLetterLam,
112    ArabicLetterMeem,
113    ArabicLetterNoon,
114    ArabicLetterHeh,
115    ArabicLetterWaw,
116    ArabicLetterAlefMaksura,
117    ArabicLetterYeh,
118    ArabicFathatan,
119    ArabicDammatan,
120    ArabicKasratan,
121    ArabicFatha,
122    ArabicDamma,
123    ArabicKasra,
124    ArabicShadda,
125    ArabicSukun,
126}
127
128impl ArabicCharacter {
129    /// Returns the underlying Unicode character.
130    fn character(&self) -> Box<dyn UnicodeCharacter> {
131        match self {
132            ArabicLetterHamza => Box::new(crate::core::characters::ArabicLetterHamza::new()),
133            ArabicLetterAlefWithMaddaAbove => {
134                Box::new(crate::core::characters::ArabicLetterAlefWithMaddaAbove::new())
135            }
136            ArabicLetterAlefWithHamzaAbove => {
137                Box::new(crate::core::characters::ArabicLetterAlefWithHamzaAbove::new())
138            }
139            ArabicLetterWawWithHamzaAbove => {
140                Box::new(crate::core::characters::ArabicLetterWawWithHamzaAbove::new())
141            }
142            ArabicLetterAlefWithHamzaBelow => {
143                Box::new(crate::core::characters::ArabicLetterAlefWithHamzaBelow::new())
144            }
145            ArabicLetterYehWithHamzaAbove => {
146                Box::new(crate::core::characters::ArabicLetterYehWithHamzaAbove::new())
147            }
148            ArabicLetterAlef => Box::new(crate::core::characters::ArabicLetterAlef::new()),
149            ArabicLetterBeh => Box::new(crate::core::characters::ArabicLetterBeh::new()),
150            ArabicLetterTehMarbuta => {
151                Box::new(crate::core::characters::ArabicLetterTehMarbuta::new())
152            }
153            ArabicLetterTeh => Box::new(crate::core::characters::ArabicLetterTeh::new()),
154            ArabicLetterTheh => Box::new(crate::core::characters::ArabicLetterTheh::new()),
155            ArabicLetterJeem => Box::new(crate::core::characters::ArabicLetterJeem::new()),
156            ArabicLetterHah => Box::new(crate::core::characters::ArabicLetterHah::new()),
157            ArabicLetterKhah => Box::new(crate::core::characters::ArabicLetterKhah::new()),
158            ArabicLetterDal => Box::new(crate::core::characters::ArabicLetterDal::new()),
159            ArabicLetterThal => Box::new(crate::core::characters::ArabicLetterThal::new()),
160            ArabicLetterReh => Box::new(crate::core::characters::ArabicLetterReh::new()),
161            ArabicLetterZain => Box::new(crate::core::characters::ArabicLetterZain::new()),
162            ArabicLetterSeen => Box::new(crate::core::characters::ArabicLetterSeen::new()),
163            ArabicLetterSheen => Box::new(crate::core::characters::ArabicLetterSheen::new()),
164            ArabicLetterSad => Box::new(crate::core::characters::ArabicLetterSad::new()),
165            ArabicLetterDad => Box::new(crate::core::characters::ArabicLetterDad::new()),
166            ArabicLetterTah => Box::new(crate::core::characters::ArabicLetterTah::new()),
167            ArabicLetterZah => Box::new(crate::core::characters::ArabicLetterZah::new()),
168            ArabicLetterAin => Box::new(crate::core::characters::ArabicLetterAin::new()),
169            ArabicLetterGhain => Box::new(crate::core::characters::ArabicLetterGhain::new()),
170            ArabicTatweel => Box::new(crate::core::characters::ArabicTatweel::new()),
171            ArabicLetterFeh => Box::new(crate::core::characters::ArabicLetterFeh::new()),
172            ArabicLetterQaf => Box::new(crate::core::characters::ArabicLetterQaf::new()),
173            ArabicLetterKaf => Box::new(crate::core::characters::ArabicLetterKaf::new()),
174            ArabicLetterLam => Box::new(crate::core::characters::ArabicLetterLam::new()),
175            ArabicLetterMeem => Box::new(crate::core::characters::ArabicLetterMeem::new()),
176            ArabicLetterNoon => Box::new(crate::core::characters::ArabicLetterNoon::new()),
177            ArabicLetterHeh => Box::new(crate::core::characters::ArabicLetterHeh::new()),
178            ArabicLetterWaw => Box::new(crate::core::characters::ArabicLetterWaw::new()),
179            ArabicLetterAlefMaksura => {
180                Box::new(crate::core::characters::ArabicLetterAlefMaksura::new())
181            }
182            ArabicLetterYeh => Box::new(crate::core::characters::ArabicLetterYeh::new()),
183            ArabicFathatan => Box::new(crate::core::characters::ArabicFathatan::new()),
184            ArabicDammatan => Box::new(crate::core::characters::ArabicDammatan::new()),
185            ArabicKasratan => Box::new(crate::core::characters::ArabicKasratan::new()),
186            ArabicFatha => Box::new(crate::core::characters::ArabicFatha::new()),
187            ArabicDamma => Box::new(crate::core::characters::ArabicDamma::new()),
188            ArabicKasra => Box::new(crate::core::characters::ArabicKasra::new()),
189            ArabicShadda => Box::new(crate::core::characters::ArabicShadda::new()),
190            ArabicSukun => Box::new(crate::core::characters::ArabicSukun::new()),
191        }
192    }
193}
194
195impl UnicodeCharacter for ArabicCharacter {
196    fn block(&self) -> &'static str {
197        self.character().block()
198    }
199
200    fn name(&self) -> &'static str {
201        self.character().name()
202    }
203
204    fn scalar_value(&self) -> char {
205        self.character().scalar_value()
206    }
207}
208
209/**************************************************************************************************
210 * Standard Library Implementations.                                                              *
211 **************************************************************************************************/
212
213impl Debug for ArabicCharacter {
214    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
215        write!(f, "{} {{ {} }}", self.name(), self.scalar_value())
216    }
217}
218
219impl Display for ArabicCharacter {
220    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
221        write!(f, "{}", self.scalar_value())
222    }
223}
224
225impl PartialEq for ArabicCharacter {
226    fn eq(&self, other: &Self) -> bool {
227        self.block() == other.block()
228            && self.name() == other.name()
229            && self.scalar_value() == other.scalar_value()
230    }
231}
232
233impl PartialEq<char> for ArabicCharacter {
234    fn eq(&self, other: &char) -> bool {
235        &self.scalar_value() == other
236    }
237}
238
239impl PartialEq<&str> for ArabicCharacter {
240    fn eq(&self, other: &&str) -> bool {
241        &self.scalar_value().to_string() == other
242    }
243}
244
245impl PartialEq<String> for ArabicCharacter {
246    fn eq(&self, other: &String) -> bool {
247        &self.scalar_value().to_string() == other
248    }
249}
250
251impl TryFrom<char> for ArabicCharacter {
252    type Error = ();
253
254    fn try_from(value: char) -> Result<Self, Self::Error> {
255        match value {
256            '\u{0621}' => Ok(ArabicLetterHamza),
257            '\u{0622}' => Ok(ArabicLetterAlefWithMaddaAbove),
258            '\u{0623}' => Ok(ArabicLetterAlefWithHamzaAbove),
259            '\u{0624}' => Ok(ArabicLetterWawWithHamzaAbove),
260            '\u{0625}' => Ok(ArabicLetterAlefWithHamzaBelow),
261            '\u{0626}' => Ok(ArabicLetterYehWithHamzaAbove),
262            '\u{0627}' => Ok(ArabicLetterAlef),
263            '\u{0628}' => Ok(ArabicLetterBeh),
264            '\u{0629}' => Ok(ArabicLetterTehMarbuta),
265            '\u{062A}' => Ok(ArabicLetterTeh),
266            '\u{062B}' => Ok(ArabicLetterTheh),
267            '\u{062C}' => Ok(ArabicLetterJeem),
268            '\u{062D}' => Ok(ArabicLetterHah),
269            '\u{062E}' => Ok(ArabicLetterKhah),
270            '\u{062F}' => Ok(ArabicLetterDal),
271            '\u{0630}' => Ok(ArabicLetterThal),
272            '\u{0631}' => Ok(ArabicLetterReh),
273            '\u{0632}' => Ok(ArabicLetterZain),
274            '\u{0633}' => Ok(ArabicLetterSeen),
275            '\u{0634}' => Ok(ArabicLetterSheen),
276            '\u{0635}' => Ok(ArabicLetterSad),
277            '\u{0636}' => Ok(ArabicLetterDad),
278            '\u{0637}' => Ok(ArabicLetterTah),
279            '\u{0638}' => Ok(ArabicLetterZah),
280            '\u{0639}' => Ok(ArabicLetterAin),
281            '\u{063A}' => Ok(ArabicLetterGhain),
282            '\u{0640}' => Ok(ArabicTatweel),
283            '\u{0641}' => Ok(ArabicLetterFeh),
284            '\u{0642}' => Ok(ArabicLetterQaf),
285            '\u{0643}' => Ok(ArabicLetterKaf),
286            '\u{0644}' => Ok(ArabicLetterLam),
287            '\u{0645}' => Ok(ArabicLetterMeem),
288            '\u{0646}' => Ok(ArabicLetterNoon),
289            '\u{0647}' => Ok(ArabicLetterHeh),
290            '\u{0648}' => Ok(ArabicLetterWaw),
291            '\u{0649}' => Ok(ArabicLetterAlefMaksura),
292            '\u{064A}' => Ok(ArabicLetterYeh),
293            '\u{064B}' => Ok(ArabicFathatan),
294            '\u{064C}' => Ok(ArabicDammatan),
295            '\u{064D}' => Ok(ArabicKasratan),
296            '\u{064E}' => Ok(ArabicFatha),
297            '\u{064F}' => Ok(ArabicDamma),
298            '\u{0650}' => Ok(ArabicKasra),
299            '\u{0651}' => Ok(ArabicShadda),
300            '\u{0652}' => Ok(ArabicSukun),
301            _ => Err(()),
302        }
303    }
304}
305
306/**************************************************************************************************
307 * Tests.                                                                                         *
308 **************************************************************************************************/
309
310#[cfg(test)]
311mod tests {
312    use crate::core::UnicodeCharacter;
313    use crate::ArabicCharacter;
314
315    use super::ArabicDamma;
316    use super::ArabicDammatan;
317    use super::ArabicFatha;
318    use super::ArabicFathatan;
319    use super::ArabicKasra;
320    use super::ArabicKasratan;
321    use super::ArabicLetterAin;
322    use super::ArabicLetterAlef;
323    use super::ArabicLetterAlefMaksura;
324    use super::ArabicLetterAlefWithHamzaAbove;
325    use super::ArabicLetterAlefWithHamzaBelow;
326    use super::ArabicLetterAlefWithMaddaAbove;
327    use super::ArabicLetterBeh;
328    use super::ArabicLetterDad;
329    use super::ArabicLetterDal;
330    use super::ArabicLetterFeh;
331    use super::ArabicLetterGhain;
332    use super::ArabicLetterHah;
333    use super::ArabicLetterHamza;
334    use super::ArabicLetterHeh;
335    use super::ArabicLetterJeem;
336    use super::ArabicLetterKaf;
337    use super::ArabicLetterKhah;
338    use super::ArabicLetterLam;
339    use super::ArabicLetterMeem;
340    use super::ArabicLetterNoon;
341    use super::ArabicLetterQaf;
342    use super::ArabicLetterReh;
343    use super::ArabicLetterSad;
344    use super::ArabicLetterSeen;
345    use super::ArabicLetterSheen;
346    use super::ArabicLetterTah;
347    use super::ArabicLetterTeh;
348    use super::ArabicLetterTehMarbuta;
349    use super::ArabicLetterThal;
350    use super::ArabicLetterTheh;
351    use super::ArabicLetterWaw;
352    use super::ArabicLetterWawWithHamzaAbove;
353    use super::ArabicLetterYeh;
354    use super::ArabicLetterYehWithHamzaAbove;
355    use super::ArabicLetterZah;
356    use super::ArabicLetterZain;
357    use super::ArabicShadda;
358    use super::ArabicSukun;
359    use super::ArabicTatweel;
360
361    #[test]
362    #[should_panic]
363    fn accepts_only_arabic_script_characters() {
364        ArabicCharacter::try_from('a').unwrap();
365    }
366
367    #[test]
368    fn arabic_letter_hamza() {
369        assert_eq!(ArabicLetterHamza.block(), "Arabic");
370        assert_eq!(ArabicLetterHamza.name(), "Arabic Letter Hamza");
371        assert_eq!(ArabicLetterHamza.scalar_value(), '\u{0621}');
372
373        assert_eq!(
374            format!("{:?}", ArabicLetterHamza),
375            "Arabic Letter Hamza { \u{0621} }"
376        );
377        assert_eq!(format!("{}", ArabicLetterHamza), "\u{0621}");
378        assert_eq!(ArabicLetterHamza, ArabicLetterHamza);
379        assert_eq!(ArabicLetterHamza, '\u{0621}');
380        assert_eq!(ArabicLetterHamza, "\u{0621}");
381        assert_eq!(ArabicLetterHamza, "\u{0621}".to_string());
382        assert_eq!(
383            ArabicLetterHamza,
384            ArabicCharacter::try_from('\u{0621}').unwrap()
385        );
386    }
387
388    #[test]
389    fn arabic_letter_alef_with_madda_above() {
390        assert_eq!(ArabicLetterAlefWithMaddaAbove.block(), "Arabic");
391        assert_eq!(
392            ArabicLetterAlefWithMaddaAbove.name(),
393            "Arabic Letter Alef With Madda Above"
394        );
395        assert_eq!(ArabicLetterAlefWithMaddaAbove.scalar_value(), '\u{0622}');
396
397        assert_eq!(
398            format!("{:?}", ArabicLetterAlefWithMaddaAbove),
399            "Arabic Letter Alef With Madda Above { \u{0622} }"
400        );
401        assert_eq!(format!("{}", ArabicLetterAlefWithMaddaAbove), "\u{0622}");
402        assert_eq!(
403            ArabicLetterAlefWithMaddaAbove,
404            ArabicLetterAlefWithMaddaAbove
405        );
406        assert_eq!(ArabicLetterAlefWithMaddaAbove, '\u{0622}');
407        assert_eq!(ArabicLetterAlefWithMaddaAbove, "\u{0622}");
408        assert_eq!(ArabicLetterAlefWithMaddaAbove, "\u{0622}".to_string());
409        assert_eq!(
410            ArabicLetterAlefWithMaddaAbove,
411            ArabicCharacter::try_from('\u{0622}').unwrap()
412        );
413    }
414
415    #[test]
416    fn arabic_letter_alef_with_hamza_above() {
417        assert_eq!(ArabicLetterAlefWithHamzaAbove.block(), "Arabic");
418        assert_eq!(
419            ArabicLetterAlefWithHamzaAbove.name(),
420            "Arabic Letter Alef With Hamza Above"
421        );
422        assert_eq!(ArabicLetterAlefWithHamzaAbove.scalar_value(), '\u{0623}');
423
424        assert_eq!(
425            format!("{:?}", ArabicLetterAlefWithHamzaAbove),
426            "Arabic Letter Alef With Hamza Above { \u{0623} }"
427        );
428        assert_eq!(format!("{}", ArabicLetterAlefWithHamzaAbove), "\u{0623}");
429        assert_eq!(
430            ArabicLetterAlefWithHamzaAbove,
431            ArabicLetterAlefWithHamzaAbove
432        );
433        assert_eq!(ArabicLetterAlefWithHamzaAbove, '\u{0623}');
434        assert_eq!(ArabicLetterAlefWithHamzaAbove, "\u{0623}");
435        assert_eq!(ArabicLetterAlefWithHamzaAbove, "\u{0623}".to_string());
436        assert_eq!(
437            ArabicLetterAlefWithHamzaAbove,
438            ArabicCharacter::try_from('\u{0623}').unwrap()
439        );
440    }
441
442    #[test]
443    fn arabic_letter_waw_with_hamza_above() {
444        assert_eq!(ArabicLetterWawWithHamzaAbove.block(), "Arabic");
445        assert_eq!(
446            ArabicLetterWawWithHamzaAbove.name(),
447            "Arabic Letter Waw With Hamza Above"
448        );
449        assert_eq!(ArabicLetterWawWithHamzaAbove.scalar_value(), '\u{0624}');
450
451        assert_eq!(
452            format!("{:?}", ArabicLetterWawWithHamzaAbove),
453            "Arabic Letter Waw With Hamza Above { \u{0624} }"
454        );
455        assert_eq!(format!("{}", ArabicLetterWawWithHamzaAbove), "\u{0624}");
456        assert_eq!(ArabicLetterWawWithHamzaAbove, ArabicLetterWawWithHamzaAbove);
457        assert_eq!(ArabicLetterWawWithHamzaAbove, '\u{0624}');
458        assert_eq!(ArabicLetterWawWithHamzaAbove, "\u{0624}");
459        assert_eq!(ArabicLetterWawWithHamzaAbove, "\u{0624}".to_string());
460        assert_eq!(
461            ArabicLetterWawWithHamzaAbove,
462            ArabicCharacter::try_from('\u{0624}').unwrap()
463        );
464    }
465
466    #[test]
467    fn arabic_letter_alef_with_hamza_below() {
468        assert_eq!(ArabicLetterAlefWithHamzaBelow.block(), "Arabic");
469        assert_eq!(
470            ArabicLetterAlefWithHamzaBelow.name(),
471            "Arabic Letter Alef With Hamza Below"
472        );
473        assert_eq!(ArabicLetterAlefWithHamzaBelow.scalar_value(), '\u{0625}');
474
475        assert_eq!(
476            format!("{:?}", ArabicLetterAlefWithHamzaBelow),
477            "Arabic Letter Alef With Hamza Below { \u{0625} }"
478        );
479        assert_eq!(format!("{}", ArabicLetterAlefWithHamzaBelow), "\u{0625}");
480        assert_eq!(
481            ArabicLetterAlefWithHamzaBelow,
482            ArabicLetterAlefWithHamzaBelow
483        );
484        assert_eq!(ArabicLetterAlefWithHamzaBelow, '\u{0625}');
485        assert_eq!(ArabicLetterAlefWithHamzaBelow, "\u{0625}");
486        assert_eq!(ArabicLetterAlefWithHamzaBelow, "\u{0625}".to_string());
487        assert_eq!(
488            ArabicLetterAlefWithHamzaBelow,
489            ArabicCharacter::try_from('\u{0625}').unwrap()
490        );
491    }
492
493    #[test]
494    fn arabic_letter_yeh_with_hamza_above() {
495        assert_eq!(ArabicLetterYehWithHamzaAbove.block(), "Arabic");
496        assert_eq!(
497            ArabicLetterYehWithHamzaAbove.name(),
498            "Arabic Letter Yeh With Hamza Above"
499        );
500        assert_eq!(ArabicLetterYehWithHamzaAbove.scalar_value(), '\u{0626}');
501
502        assert_eq!(
503            format!("{:?}", ArabicLetterYehWithHamzaAbove),
504            "Arabic Letter Yeh With Hamza Above { \u{0626} }"
505        );
506        assert_eq!(format!("{}", ArabicLetterYehWithHamzaAbove), "\u{0626}");
507        assert_eq!(ArabicLetterYehWithHamzaAbove, ArabicLetterYehWithHamzaAbove);
508        assert_eq!(ArabicLetterYehWithHamzaAbove, '\u{0626}');
509        assert_eq!(ArabicLetterYehWithHamzaAbove, "\u{0626}");
510        assert_eq!(ArabicLetterYehWithHamzaAbove, "\u{0626}".to_string());
511        assert_eq!(
512            ArabicLetterYehWithHamzaAbove,
513            ArabicCharacter::try_from('\u{0626}').unwrap()
514        );
515    }
516
517    #[test]
518    fn arabic_letter_alef() {
519        assert_eq!(ArabicLetterAlef.block(), "Arabic");
520        assert_eq!(ArabicLetterAlef.name(), "Arabic Letter Alef");
521        assert_eq!(ArabicLetterAlef.scalar_value(), '\u{0627}');
522
523        assert_eq!(
524            format!("{:?}", ArabicLetterAlef),
525            "Arabic Letter Alef { \u{0627} }"
526        );
527        assert_eq!(format!("{}", ArabicLetterAlef), "\u{0627}");
528        assert_eq!(ArabicLetterAlef, ArabicLetterAlef);
529        assert_eq!(ArabicLetterAlef, '\u{0627}');
530        assert_eq!(ArabicLetterAlef, "\u{0627}");
531        assert_eq!(ArabicLetterAlef, "\u{0627}".to_string());
532        assert_eq!(
533            ArabicLetterAlef,
534            ArabicCharacter::try_from('\u{0627}').unwrap()
535        );
536    }
537
538    #[test]
539    fn arabic_letter_beh() {
540        assert_eq!(ArabicLetterBeh.block(), "Arabic");
541        assert_eq!(ArabicLetterBeh.name(), "Arabic Letter Beh");
542        assert_eq!(ArabicLetterBeh.scalar_value(), '\u{0628}');
543
544        assert_eq!(
545            format!("{:?}", ArabicLetterBeh),
546            "Arabic Letter Beh { \u{0628} }"
547        );
548        assert_eq!(format!("{}", ArabicLetterBeh), "\u{0628}");
549        assert_eq!(ArabicLetterBeh, ArabicLetterBeh);
550        assert_eq!(ArabicLetterBeh, '\u{0628}');
551        assert_eq!(ArabicLetterBeh, "\u{0628}");
552        assert_eq!(ArabicLetterBeh, "\u{0628}".to_string());
553        assert_eq!(
554            ArabicLetterBeh,
555            ArabicCharacter::try_from('\u{0628}').unwrap()
556        );
557    }
558
559    #[test]
560    fn arabic_letter_teh_marbuta() {
561        assert_eq!(ArabicLetterTehMarbuta.block(), "Arabic");
562        assert_eq!(ArabicLetterTehMarbuta.name(), "Arabic Letter Teh Marbuta");
563        assert_eq!(ArabicLetterTehMarbuta.scalar_value(), '\u{0629}');
564
565        assert_eq!(
566            format!("{:?}", ArabicLetterTehMarbuta),
567            "Arabic Letter Teh Marbuta { \u{0629} }"
568        );
569        assert_eq!(format!("{}", ArabicLetterTehMarbuta), "\u{0629}");
570        assert_eq!(ArabicLetterTehMarbuta, ArabicLetterTehMarbuta);
571        assert_eq!(ArabicLetterTehMarbuta, '\u{0629}');
572        assert_eq!(ArabicLetterTehMarbuta, "\u{0629}");
573        assert_eq!(ArabicLetterTehMarbuta, "\u{0629}".to_string());
574        assert_eq!(
575            ArabicLetterTehMarbuta,
576            ArabicCharacter::try_from('\u{0629}').unwrap()
577        );
578    }
579
580    #[test]
581    fn arabic_letter_teh() {
582        assert_eq!(ArabicLetterTeh.block(), "Arabic");
583        assert_eq!(ArabicLetterTeh.name(), "Arabic Letter Teh");
584        assert_eq!(ArabicLetterTeh.scalar_value(), '\u{062A}');
585
586        assert_eq!(
587            format!("{:?}", ArabicLetterTeh),
588            "Arabic Letter Teh { \u{062A} }"
589        );
590        assert_eq!(format!("{}", ArabicLetterTeh), "\u{062A}");
591        assert_eq!(ArabicLetterTeh, ArabicLetterTeh);
592        assert_eq!(ArabicLetterTeh, '\u{062A}');
593        assert_eq!(ArabicLetterTeh, "\u{062A}");
594        assert_eq!(ArabicLetterTeh, "\u{062A}".to_string());
595        assert_eq!(
596            ArabicLetterTeh,
597            ArabicCharacter::try_from('\u{062A}').unwrap()
598        );
599    }
600
601    #[test]
602    fn arabic_letter_theh() {
603        assert_eq!(ArabicLetterTheh.block(), "Arabic");
604        assert_eq!(ArabicLetterTheh.name(), "Arabic Letter Theh");
605        assert_eq!(ArabicLetterTheh.scalar_value(), '\u{062B}');
606
607        assert_eq!(
608            format!("{:?}", ArabicLetterTheh),
609            "Arabic Letter Theh { \u{062B} }"
610        );
611        assert_eq!(format!("{}", ArabicLetterTheh), "\u{062B}");
612        assert_eq!(ArabicLetterTheh, ArabicLetterTheh);
613        assert_eq!(ArabicLetterTheh, '\u{062B}');
614        assert_eq!(ArabicLetterTheh, "\u{062B}");
615        assert_eq!(ArabicLetterTheh, "\u{062B}".to_string());
616        assert_eq!(
617            ArabicLetterTheh,
618            ArabicCharacter::try_from('\u{062B}').unwrap()
619        );
620    }
621
622    #[test]
623    fn arabic_letter_jeem() {
624        assert_eq!(ArabicLetterJeem.block(), "Arabic");
625        assert_eq!(ArabicLetterJeem.name(), "Arabic Letter Jeem");
626        assert_eq!(ArabicLetterJeem.scalar_value(), '\u{062C}');
627
628        assert_eq!(
629            format!("{:?}", ArabicLetterJeem),
630            "Arabic Letter Jeem { \u{062C} }"
631        );
632        assert_eq!(format!("{}", ArabicLetterJeem), "\u{062C}");
633        assert_eq!(ArabicLetterJeem, ArabicLetterJeem);
634        assert_eq!(ArabicLetterJeem, '\u{062C}');
635        assert_eq!(ArabicLetterJeem, "\u{062C}");
636        assert_eq!(ArabicLetterJeem, "\u{062C}".to_string());
637        assert_eq!(
638            ArabicLetterJeem,
639            ArabicCharacter::try_from('\u{062C}').unwrap()
640        );
641    }
642
643    #[test]
644    fn arabic_letter_hah() {
645        assert_eq!(ArabicLetterHah.block(), "Arabic");
646        assert_eq!(ArabicLetterHah.name(), "Arabic Letter Hah");
647        assert_eq!(ArabicLetterHah.scalar_value(), '\u{062D}');
648
649        assert_eq!(
650            format!("{:?}", ArabicLetterHah),
651            "Arabic Letter Hah { \u{062D} }"
652        );
653        assert_eq!(format!("{}", ArabicLetterHah), "\u{062D}");
654        assert_eq!(ArabicLetterHah, ArabicLetterHah);
655        assert_eq!(ArabicLetterHah, '\u{062D}');
656        assert_eq!(ArabicLetterHah, "\u{062D}");
657        assert_eq!(ArabicLetterHah, "\u{062D}".to_string());
658        assert_eq!(
659            ArabicLetterHah,
660            ArabicCharacter::try_from('\u{062D}').unwrap()
661        );
662    }
663
664    #[test]
665    fn arabic_letter_khah() {
666        assert_eq!(ArabicLetterKhah.block(), "Arabic");
667        assert_eq!(ArabicLetterKhah.name(), "Arabic Letter Khah");
668        assert_eq!(ArabicLetterKhah.scalar_value(), '\u{062E}');
669
670        assert_eq!(
671            format!("{:?}", ArabicLetterKhah),
672            "Arabic Letter Khah { \u{062E} }"
673        );
674        assert_eq!(format!("{}", ArabicLetterKhah), "\u{062E}");
675        assert_eq!(ArabicLetterKhah, ArabicLetterKhah);
676        assert_eq!(ArabicLetterKhah, '\u{062E}');
677        assert_eq!(ArabicLetterKhah, "\u{062E}");
678        assert_eq!(ArabicLetterKhah, "\u{062E}".to_string());
679        assert_eq!(
680            ArabicLetterKhah,
681            ArabicCharacter::try_from('\u{062E}').unwrap()
682        );
683    }
684
685    #[test]
686    fn arabic_letter_dal() {
687        assert_eq!(ArabicLetterDal.block(), "Arabic");
688        assert_eq!(ArabicLetterDal.name(), "Arabic Letter Dal");
689        assert_eq!(ArabicLetterDal.scalar_value(), '\u{062F}');
690
691        assert_eq!(
692            format!("{:?}", ArabicLetterDal),
693            "Arabic Letter Dal { \u{062F} }"
694        );
695        assert_eq!(format!("{}", ArabicLetterDal), "\u{062F}");
696        assert_eq!(ArabicLetterDal, ArabicLetterDal);
697        assert_eq!(ArabicLetterDal, '\u{062F}');
698        assert_eq!(ArabicLetterDal, "\u{062F}");
699        assert_eq!(ArabicLetterDal, "\u{062F}".to_string());
700        assert_eq!(
701            ArabicLetterDal,
702            ArabicCharacter::try_from('\u{062F}').unwrap()
703        );
704    }
705
706    #[test]
707    fn arabic_letter_thal() {
708        assert_eq!(ArabicLetterThal.block(), "Arabic");
709        assert_eq!(ArabicLetterThal.name(), "Arabic Letter Thal");
710        assert_eq!(ArabicLetterThal.scalar_value(), '\u{0630}');
711
712        assert_eq!(
713            format!("{:?}", ArabicLetterThal),
714            "Arabic Letter Thal { \u{0630} }"
715        );
716        assert_eq!(format!("{}", ArabicLetterThal), "\u{0630}");
717        assert_eq!(ArabicLetterThal, ArabicLetterThal);
718        assert_eq!(ArabicLetterThal, '\u{0630}');
719        assert_eq!(ArabicLetterThal, "\u{0630}");
720        assert_eq!(ArabicLetterThal, "\u{0630}".to_string());
721        assert_eq!(
722            ArabicLetterThal,
723            ArabicCharacter::try_from('\u{0630}').unwrap()
724        );
725    }
726
727    #[test]
728    fn arabic_letter_reh() {
729        assert_eq!(ArabicLetterReh.block(), "Arabic");
730        assert_eq!(ArabicLetterReh.name(), "Arabic Letter Reh");
731        assert_eq!(ArabicLetterReh.scalar_value(), '\u{0631}');
732
733        assert_eq!(
734            format!("{:?}", ArabicLetterReh),
735            "Arabic Letter Reh { \u{0631} }"
736        );
737        assert_eq!(format!("{}", ArabicLetterReh), "\u{0631}");
738        assert_eq!(ArabicLetterReh, ArabicLetterReh);
739        assert_eq!(ArabicLetterReh, '\u{0631}');
740        assert_eq!(ArabicLetterReh, "\u{0631}");
741        assert_eq!(ArabicLetterReh, "\u{0631}".to_string());
742        assert_eq!(
743            ArabicLetterReh,
744            ArabicCharacter::try_from('\u{0631}').unwrap()
745        );
746    }
747
748    #[test]
749    fn arabic_letter_zain() {
750        assert_eq!(ArabicLetterZain.block(), "Arabic");
751        assert_eq!(ArabicLetterZain.name(), "Arabic Letter Zain");
752        assert_eq!(ArabicLetterZain.scalar_value(), '\u{0632}');
753
754        assert_eq!(
755            format!("{:?}", ArabicLetterZain),
756            "Arabic Letter Zain { \u{0632} }"
757        );
758        assert_eq!(format!("{}", ArabicLetterZain), "\u{0632}");
759        assert_eq!(ArabicLetterZain, ArabicLetterZain);
760        assert_eq!(ArabicLetterZain, '\u{0632}');
761        assert_eq!(ArabicLetterZain, "\u{0632}");
762        assert_eq!(ArabicLetterZain, "\u{0632}".to_string());
763        assert_eq!(
764            ArabicLetterZain,
765            ArabicCharacter::try_from('\u{0632}').unwrap()
766        );
767    }
768
769    #[test]
770    fn arabic_letter_seen() {
771        assert_eq!(ArabicLetterSeen.block(), "Arabic");
772        assert_eq!(ArabicLetterSeen.name(), "Arabic Letter Seen");
773        assert_eq!(ArabicLetterSeen.scalar_value(), '\u{0633}');
774
775        assert_eq!(
776            format!("{:?}", ArabicLetterSeen),
777            "Arabic Letter Seen { \u{0633} }"
778        );
779        assert_eq!(format!("{}", ArabicLetterSeen), "\u{0633}");
780        assert_eq!(ArabicLetterSeen, ArabicLetterSeen);
781        assert_eq!(ArabicLetterSeen, '\u{0633}');
782        assert_eq!(ArabicLetterSeen, "\u{0633}");
783        assert_eq!(ArabicLetterSeen, "\u{0633}".to_string());
784        assert_eq!(
785            ArabicLetterSeen,
786            ArabicCharacter::try_from('\u{0633}').unwrap()
787        );
788    }
789
790    #[test]
791    fn arabic_letter_sheen() {
792        assert_eq!(ArabicLetterSheen.block(), "Arabic");
793        assert_eq!(ArabicLetterSheen.name(), "Arabic Letter Sheen");
794        assert_eq!(ArabicLetterSheen.scalar_value(), '\u{0634}');
795
796        assert_eq!(
797            format!("{:?}", ArabicLetterSheen),
798            "Arabic Letter Sheen { \u{0634} }"
799        );
800        assert_eq!(format!("{}", ArabicLetterSheen), "\u{0634}");
801        assert_eq!(ArabicLetterSheen, ArabicLetterSheen);
802        assert_eq!(ArabicLetterSheen, '\u{0634}');
803        assert_eq!(ArabicLetterSheen, "\u{0634}");
804        assert_eq!(ArabicLetterSheen, "\u{0634}".to_string());
805        assert_eq!(
806            ArabicLetterSheen,
807            ArabicCharacter::try_from('\u{0634}').unwrap()
808        );
809    }
810
811    #[test]
812    fn arabic_letter_sad() {
813        assert_eq!(ArabicLetterSad.block(), "Arabic");
814        assert_eq!(ArabicLetterSad.name(), "Arabic Letter Sad");
815        assert_eq!(ArabicLetterSad.scalar_value(), '\u{0635}');
816
817        assert_eq!(
818            format!("{:?}", ArabicLetterSad),
819            "Arabic Letter Sad { \u{0635} }"
820        );
821        assert_eq!(format!("{}", ArabicLetterSad), "\u{0635}");
822        assert_eq!(ArabicLetterSad, ArabicLetterSad);
823        assert_eq!(ArabicLetterSad, '\u{0635}');
824        assert_eq!(ArabicLetterSad, "\u{0635}");
825        assert_eq!(ArabicLetterSad, "\u{0635}".to_string());
826        assert_eq!(
827            ArabicLetterSad,
828            ArabicCharacter::try_from('\u{0635}').unwrap()
829        );
830    }
831
832    #[test]
833    fn arabic_letter_dad() {
834        assert_eq!(ArabicLetterDad.block(), "Arabic");
835        assert_eq!(ArabicLetterDad.name(), "Arabic Letter Dad");
836        assert_eq!(ArabicLetterDad.scalar_value(), '\u{0636}');
837
838        assert_eq!(
839            format!("{:?}", ArabicLetterDad),
840            "Arabic Letter Dad { \u{0636} }"
841        );
842        assert_eq!(format!("{}", ArabicLetterDad), "\u{0636}");
843        assert_eq!(ArabicLetterDad, ArabicLetterDad);
844        assert_eq!(ArabicLetterDad, '\u{0636}');
845        assert_eq!(ArabicLetterDad, "\u{0636}");
846        assert_eq!(ArabicLetterDad, "\u{0636}".to_string());
847        assert_eq!(
848            ArabicLetterDad,
849            ArabicCharacter::try_from('\u{0636}').unwrap()
850        );
851    }
852
853    #[test]
854    fn arabic_letter_tah() {
855        assert_eq!(ArabicLetterTah.block(), "Arabic");
856        assert_eq!(ArabicLetterTah.name(), "Arabic Letter Tah");
857        assert_eq!(ArabicLetterTah.scalar_value(), '\u{0637}');
858
859        assert_eq!(
860            format!("{:?}", ArabicLetterTah),
861            "Arabic Letter Tah { \u{0637} }"
862        );
863        assert_eq!(format!("{}", ArabicLetterTah), "\u{0637}");
864        assert_eq!(ArabicLetterTah, ArabicLetterTah);
865        assert_eq!(ArabicLetterTah, '\u{0637}');
866        assert_eq!(ArabicLetterTah, "\u{0637}");
867        assert_eq!(ArabicLetterTah, "\u{0637}".to_string());
868        assert_eq!(
869            ArabicLetterTah,
870            ArabicCharacter::try_from('\u{0637}').unwrap()
871        );
872    }
873
874    #[test]
875    fn arabic_letter_zah() {
876        assert_eq!(ArabicLetterZah.block(), "Arabic");
877        assert_eq!(ArabicLetterZah.name(), "Arabic Letter Zah");
878        assert_eq!(ArabicLetterZah.scalar_value(), '\u{0638}');
879
880        assert_eq!(
881            format!("{:?}", ArabicLetterZah),
882            "Arabic Letter Zah { \u{0638} }"
883        );
884        assert_eq!(format!("{}", ArabicLetterZah), "\u{0638}");
885        assert_eq!(ArabicLetterZah, ArabicLetterZah);
886        assert_eq!(ArabicLetterZah, '\u{0638}');
887        assert_eq!(ArabicLetterZah, "\u{0638}");
888        assert_eq!(ArabicLetterZah, "\u{0638}".to_string());
889        assert_eq!(
890            ArabicLetterZah,
891            ArabicCharacter::try_from('\u{0638}').unwrap()
892        );
893    }
894
895    #[test]
896    fn arabic_letter_ain() {
897        assert_eq!(ArabicLetterAin.block(), "Arabic");
898        assert_eq!(ArabicLetterAin.name(), "Arabic Letter Ain");
899        assert_eq!(ArabicLetterAin.scalar_value(), '\u{0639}');
900
901        assert_eq!(
902            format!("{:?}", ArabicLetterAin),
903            "Arabic Letter Ain { \u{0639} }"
904        );
905        assert_eq!(format!("{}", ArabicLetterAin), "\u{0639}");
906        assert_eq!(ArabicLetterAin, ArabicLetterAin);
907        assert_eq!(ArabicLetterAin, '\u{0639}');
908        assert_eq!(ArabicLetterAin, "\u{0639}");
909        assert_eq!(ArabicLetterAin, "\u{0639}".to_string());
910        assert_eq!(
911            ArabicLetterAin,
912            ArabicCharacter::try_from('\u{0639}').unwrap()
913        );
914    }
915
916    #[test]
917    fn arabic_letter_ghain() {
918        assert_eq!(ArabicLetterGhain.block(), "Arabic");
919        assert_eq!(ArabicLetterGhain.name(), "Arabic Letter Ghain");
920        assert_eq!(ArabicLetterGhain.scalar_value(), '\u{063A}');
921
922        assert_eq!(
923            format!("{:?}", ArabicLetterGhain),
924            "Arabic Letter Ghain { \u{063A} }"
925        );
926        assert_eq!(format!("{}", ArabicLetterGhain), "\u{063A}");
927        assert_eq!(ArabicLetterGhain, ArabicLetterGhain);
928        assert_eq!(ArabicLetterGhain, '\u{063A}');
929        assert_eq!(ArabicLetterGhain, "\u{063A}");
930        assert_eq!(ArabicLetterGhain, "\u{063A}".to_string());
931        assert_eq!(
932            ArabicLetterGhain,
933            ArabicCharacter::try_from('\u{063A}').unwrap()
934        );
935    }
936
937    #[test]
938    fn arabic_tatweel() {
939        assert_eq!(ArabicTatweel.block(), "Arabic");
940        assert_eq!(ArabicTatweel.name(), "Arabic Tatweel");
941        assert_eq!(ArabicTatweel.scalar_value(), '\u{0640}');
942
943        assert_eq!(
944            format!("{:?}", ArabicTatweel),
945            "Arabic Tatweel { \u{0640} }"
946        );
947        assert_eq!(format!("{}", ArabicTatweel), "\u{0640}");
948        assert_eq!(ArabicTatweel, ArabicTatweel);
949        assert_eq!(ArabicTatweel, '\u{0640}');
950        assert_eq!(ArabicTatweel, "\u{0640}");
951        assert_eq!(ArabicTatweel, "\u{0640}".to_string());
952        assert_eq!(
953            ArabicTatweel,
954            ArabicCharacter::try_from('\u{0640}').unwrap()
955        );
956    }
957
958    #[test]
959    fn arabic_letter_feh() {
960        assert_eq!(ArabicLetterFeh.block(), "Arabic");
961        assert_eq!(ArabicLetterFeh.name(), "Arabic Letter Feh");
962        assert_eq!(ArabicLetterFeh.scalar_value(), '\u{0641}');
963
964        assert_eq!(
965            format!("{:?}", ArabicLetterFeh),
966            "Arabic Letter Feh { \u{0641} }"
967        );
968        assert_eq!(format!("{}", ArabicLetterFeh), "\u{0641}");
969        assert_eq!(ArabicLetterFeh, ArabicLetterFeh);
970        assert_eq!(ArabicLetterFeh, '\u{0641}');
971        assert_eq!(ArabicLetterFeh, "\u{0641}");
972        assert_eq!(ArabicLetterFeh, "\u{0641}".to_string());
973        assert_eq!(
974            ArabicLetterFeh,
975            ArabicCharacter::try_from('\u{0641}').unwrap()
976        );
977    }
978
979    #[test]
980    fn arabic_letter_qaf() {
981        assert_eq!(ArabicLetterQaf.block(), "Arabic");
982        assert_eq!(ArabicLetterQaf.name(), "Arabic Letter Qaf");
983        assert_eq!(ArabicLetterQaf.scalar_value(), '\u{0642}');
984
985        assert_eq!(
986            format!("{:?}", ArabicLetterQaf),
987            "Arabic Letter Qaf { \u{0642} }"
988        );
989        assert_eq!(format!("{}", ArabicLetterQaf), "\u{0642}");
990        assert_eq!(ArabicLetterQaf, ArabicLetterQaf);
991        assert_eq!(ArabicLetterQaf, '\u{0642}');
992        assert_eq!(ArabicLetterQaf, "\u{0642}");
993        assert_eq!(ArabicLetterQaf, "\u{0642}".to_string());
994        assert_eq!(
995            ArabicLetterQaf,
996            ArabicCharacter::try_from('\u{0642}').unwrap()
997        );
998    }
999
1000    #[test]
1001    fn arabic_letter_kaf() {
1002        assert_eq!(ArabicLetterKaf.block(), "Arabic");
1003        assert_eq!(ArabicLetterKaf.name(), "Arabic Letter Kaf");
1004        assert_eq!(ArabicLetterKaf.scalar_value(), '\u{0643}');
1005
1006        assert_eq!(
1007            format!("{:?}", ArabicLetterKaf),
1008            "Arabic Letter Kaf { \u{0643} }"
1009        );
1010        assert_eq!(format!("{}", ArabicLetterKaf), "\u{0643}");
1011        assert_eq!(ArabicLetterKaf, ArabicLetterKaf);
1012        assert_eq!(ArabicLetterKaf, '\u{0643}');
1013        assert_eq!(ArabicLetterKaf, "\u{0643}");
1014        assert_eq!(ArabicLetterKaf, "\u{0643}".to_string());
1015        assert_eq!(
1016            ArabicLetterKaf,
1017            ArabicCharacter::try_from('\u{0643}').unwrap()
1018        );
1019    }
1020
1021    #[test]
1022    fn arabic_letter_lam() {
1023        assert_eq!(ArabicLetterLam.block(), "Arabic");
1024        assert_eq!(ArabicLetterLam.name(), "Arabic Letter Lam");
1025        assert_eq!(ArabicLetterLam.scalar_value(), '\u{0644}');
1026
1027        assert_eq!(
1028            format!("{:?}", ArabicLetterLam),
1029            "Arabic Letter Lam { \u{0644} }"
1030        );
1031        assert_eq!(format!("{}", ArabicLetterLam), "\u{0644}");
1032        assert_eq!(ArabicLetterLam, ArabicLetterLam);
1033        assert_eq!(ArabicLetterLam, '\u{0644}');
1034        assert_eq!(ArabicLetterLam, "\u{0644}");
1035        assert_eq!(ArabicLetterLam, "\u{0644}".to_string());
1036        assert_eq!(
1037            ArabicLetterLam,
1038            ArabicCharacter::try_from('\u{0644}').unwrap()
1039        );
1040    }
1041
1042    #[test]
1043    fn arabic_letter_meem() {
1044        assert_eq!(ArabicLetterMeem.block(), "Arabic");
1045        assert_eq!(ArabicLetterMeem.name(), "Arabic Letter Meem");
1046        assert_eq!(ArabicLetterMeem.scalar_value(), '\u{0645}');
1047
1048        assert_eq!(
1049            format!("{:?}", ArabicLetterMeem),
1050            "Arabic Letter Meem { \u{0645} }"
1051        );
1052        assert_eq!(format!("{}", ArabicLetterMeem), "\u{0645}");
1053        assert_eq!(ArabicLetterMeem, ArabicLetterMeem);
1054        assert_eq!(ArabicLetterMeem, '\u{0645}');
1055        assert_eq!(ArabicLetterMeem, "\u{0645}");
1056        assert_eq!(ArabicLetterMeem, "\u{0645}".to_string());
1057        assert_eq!(
1058            ArabicLetterMeem,
1059            ArabicCharacter::try_from('\u{0645}').unwrap()
1060        );
1061    }
1062
1063    #[test]
1064    fn arabic_letter_noon() {
1065        assert_eq!(ArabicLetterNoon.block(), "Arabic");
1066        assert_eq!(ArabicLetterNoon.name(), "Arabic Letter Noon");
1067        assert_eq!(ArabicLetterNoon.scalar_value(), '\u{0646}');
1068
1069        assert_eq!(
1070            format!("{:?}", ArabicLetterNoon),
1071            "Arabic Letter Noon { \u{0646} }"
1072        );
1073        assert_eq!(format!("{}", ArabicLetterNoon), "\u{0646}");
1074        assert_eq!(ArabicLetterNoon, ArabicLetterNoon);
1075        assert_eq!(ArabicLetterNoon, '\u{0646}');
1076        assert_eq!(ArabicLetterNoon, "\u{0646}");
1077        assert_eq!(ArabicLetterNoon, "\u{0646}".to_string());
1078        assert_eq!(
1079            ArabicLetterNoon,
1080            ArabicCharacter::try_from('\u{0646}').unwrap()
1081        );
1082    }
1083
1084    #[test]
1085    fn arabic_letter_heh() {
1086        assert_eq!(ArabicLetterHeh.block(), "Arabic");
1087        assert_eq!(ArabicLetterHeh.name(), "Arabic Letter Heh");
1088        assert_eq!(ArabicLetterHeh.scalar_value(), '\u{0647}');
1089
1090        assert_eq!(
1091            format!("{:?}", ArabicLetterHeh),
1092            "Arabic Letter Heh { \u{0647} }"
1093        );
1094        assert_eq!(format!("{}", ArabicLetterHeh), "\u{0647}");
1095        assert_eq!(ArabicLetterHeh, ArabicLetterHeh);
1096        assert_eq!(ArabicLetterHeh, '\u{0647}');
1097        assert_eq!(ArabicLetterHeh, "\u{0647}");
1098        assert_eq!(ArabicLetterHeh, "\u{0647}".to_string());
1099        assert_eq!(
1100            ArabicLetterHeh,
1101            ArabicCharacter::try_from('\u{0647}').unwrap()
1102        );
1103    }
1104
1105    #[test]
1106    fn arabic_letter_waw() {
1107        assert_eq!(ArabicLetterWaw.block(), "Arabic");
1108        assert_eq!(ArabicLetterWaw.name(), "Arabic Letter Waw");
1109        assert_eq!(ArabicLetterWaw.scalar_value(), '\u{0648}');
1110
1111        assert_eq!(
1112            format!("{:?}", ArabicLetterWaw),
1113            "Arabic Letter Waw { \u{0648} }"
1114        );
1115        assert_eq!(format!("{}", ArabicLetterWaw), "\u{0648}");
1116        assert_eq!(ArabicLetterWaw, ArabicLetterWaw);
1117        assert_eq!(ArabicLetterWaw, '\u{0648}');
1118        assert_eq!(ArabicLetterWaw, "\u{0648}");
1119        assert_eq!(ArabicLetterWaw, "\u{0648}".to_string());
1120        assert_eq!(
1121            ArabicLetterWaw,
1122            ArabicCharacter::try_from('\u{0648}').unwrap()
1123        );
1124    }
1125
1126    #[test]
1127    fn arabic_letter_alef_maksura() {
1128        assert_eq!(ArabicLetterAlefMaksura.block(), "Arabic");
1129        assert_eq!(ArabicLetterAlefMaksura.name(), "Arabic Letter Alef Maksura");
1130        assert_eq!(ArabicLetterAlefMaksura.scalar_value(), '\u{0649}');
1131
1132        assert_eq!(
1133            format!("{:?}", ArabicLetterAlefMaksura),
1134            "Arabic Letter Alef Maksura { \u{0649} }"
1135        );
1136        assert_eq!(format!("{}", ArabicLetterAlefMaksura), "\u{0649}");
1137        assert_eq!(ArabicLetterAlefMaksura, ArabicLetterAlefMaksura);
1138        assert_eq!(ArabicLetterAlefMaksura, '\u{0649}');
1139        assert_eq!(ArabicLetterAlefMaksura, "\u{0649}");
1140        assert_eq!(ArabicLetterAlefMaksura, "\u{0649}".to_string());
1141        assert_eq!(
1142            ArabicLetterAlefMaksura,
1143            ArabicCharacter::try_from('\u{0649}').unwrap()
1144        );
1145    }
1146
1147    #[test]
1148    fn arabic_letter_yeh() {
1149        assert_eq!(ArabicLetterYeh.block(), "Arabic");
1150        assert_eq!(ArabicLetterYeh.name(), "Arabic Letter Yeh");
1151        assert_eq!(ArabicLetterYeh.scalar_value(), '\u{064A}');
1152
1153        assert_eq!(
1154            format!("{:?}", ArabicLetterYeh),
1155            "Arabic Letter Yeh { \u{064A} }"
1156        );
1157        assert_eq!(format!("{}", ArabicLetterYeh), "\u{064A}");
1158        assert_eq!(ArabicLetterYeh, ArabicLetterYeh);
1159        assert_eq!(ArabicLetterYeh, '\u{064A}');
1160        assert_eq!(ArabicLetterYeh, "\u{064A}");
1161        assert_eq!(ArabicLetterYeh, "\u{064A}".to_string());
1162        assert_eq!(
1163            ArabicLetterYeh,
1164            ArabicCharacter::try_from('\u{064A}').unwrap()
1165        );
1166    }
1167
1168    #[test]
1169    fn arabic_fathatan() {
1170        assert_eq!(ArabicFathatan.block(), "Arabic");
1171        assert_eq!(ArabicFathatan.name(), "Arabic Fathatan");
1172        assert_eq!(ArabicFathatan.scalar_value(), '\u{064B}');
1173
1174        assert_eq!(
1175            format!("{:?}", ArabicFathatan),
1176            "Arabic Fathatan { \u{064B} }"
1177        );
1178        assert_eq!(format!("{}", ArabicFathatan), "\u{064B}");
1179        assert_eq!(ArabicFathatan, ArabicFathatan);
1180        assert_eq!(ArabicFathatan, '\u{064B}');
1181        assert_eq!(ArabicFathatan, "\u{064B}");
1182        assert_eq!(ArabicFathatan, "\u{064B}".to_string());
1183        assert_eq!(
1184            ArabicFathatan,
1185            ArabicCharacter::try_from('\u{064B}').unwrap()
1186        );
1187    }
1188
1189    #[test]
1190    fn arabic_dammatan() {
1191        assert_eq!(ArabicDammatan.block(), "Arabic");
1192        assert_eq!(ArabicDammatan.name(), "Arabic Dammatan");
1193        assert_eq!(ArabicDammatan.scalar_value(), '\u{064C}');
1194
1195        assert_eq!(
1196            format!("{:?}", ArabicDammatan),
1197            "Arabic Dammatan { \u{064C} }"
1198        );
1199        assert_eq!(format!("{}", ArabicDammatan), "\u{064C}");
1200        assert_eq!(ArabicDammatan, ArabicDammatan);
1201        assert_eq!(ArabicDammatan, '\u{064C}');
1202        assert_eq!(ArabicDammatan, "\u{064C}");
1203        assert_eq!(ArabicDammatan, "\u{064C}".to_string());
1204        assert_eq!(
1205            ArabicDammatan,
1206            ArabicCharacter::try_from('\u{064C}').unwrap()
1207        );
1208    }
1209
1210    #[test]
1211    fn arabic_kasratan() {
1212        assert_eq!(ArabicKasratan.block(), "Arabic");
1213        assert_eq!(ArabicKasratan.name(), "Arabic Kasratan");
1214        assert_eq!(ArabicKasratan.scalar_value(), '\u{064D}');
1215
1216        assert_eq!(
1217            format!("{:?}", ArabicKasratan),
1218            "Arabic Kasratan { \u{064D} }"
1219        );
1220        assert_eq!(format!("{}", ArabicKasratan), "\u{064D}");
1221        assert_eq!(ArabicKasratan, ArabicKasratan);
1222        assert_eq!(ArabicKasratan, '\u{064D}');
1223        assert_eq!(ArabicKasratan, "\u{064D}");
1224        assert_eq!(ArabicKasratan, "\u{064D}".to_string());
1225        assert_eq!(
1226            ArabicKasratan,
1227            ArabicCharacter::try_from('\u{064D}').unwrap()
1228        );
1229    }
1230
1231    #[test]
1232    fn arabic_fatha() {
1233        assert_eq!(ArabicFatha.block(), "Arabic");
1234        assert_eq!(ArabicFatha.name(), "Arabic Fatha");
1235        assert_eq!(ArabicFatha.scalar_value(), '\u{064E}');
1236
1237        assert_eq!(format!("{:?}", ArabicFatha), "Arabic Fatha { \u{064E} }");
1238        assert_eq!(format!("{}", ArabicFatha), "\u{064E}");
1239        assert_eq!(ArabicFatha, ArabicFatha);
1240        assert_eq!(ArabicFatha, '\u{064E}');
1241        assert_eq!(ArabicFatha, "\u{064E}");
1242        assert_eq!(ArabicFatha, "\u{064E}".to_string());
1243        assert_eq!(ArabicFatha, ArabicCharacter::try_from('\u{064E}').unwrap());
1244    }
1245
1246    #[test]
1247    fn arabic_damma() {
1248        assert_eq!(ArabicDamma.block(), "Arabic");
1249        assert_eq!(ArabicDamma.name(), "Arabic Damma");
1250        assert_eq!(ArabicDamma.scalar_value(), '\u{064F}');
1251
1252        assert_eq!(format!("{:?}", ArabicDamma), "Arabic Damma { \u{064F} }");
1253        assert_eq!(format!("{}", ArabicDamma), "\u{064F}");
1254        assert_eq!(ArabicDamma, ArabicDamma);
1255        assert_eq!(ArabicDamma, '\u{064F}');
1256        assert_eq!(ArabicDamma, "\u{064F}");
1257        assert_eq!(ArabicDamma, "\u{064F}".to_string());
1258        assert_eq!(ArabicDamma, ArabicCharacter::try_from('\u{064F}').unwrap());
1259    }
1260
1261    #[test]
1262    fn arabic_kasra() {
1263        assert_eq!(ArabicKasra.block(), "Arabic");
1264        assert_eq!(ArabicKasra.name(), "Arabic Kasra");
1265        assert_eq!(ArabicKasra.scalar_value(), '\u{0650}');
1266
1267        assert_eq!(format!("{:?}", ArabicKasra), "Arabic Kasra { \u{0650} }");
1268        assert_eq!(format!("{}", ArabicKasra), "\u{0650}");
1269        assert_eq!(ArabicKasra, ArabicKasra);
1270        assert_eq!(ArabicKasra, '\u{0650}');
1271        assert_eq!(ArabicKasra, "\u{0650}");
1272        assert_eq!(ArabicKasra, "\u{0650}".to_string());
1273        assert_eq!(ArabicKasra, ArabicCharacter::try_from('\u{0650}').unwrap());
1274    }
1275
1276    #[test]
1277    fn arabic_shadda() {
1278        assert_eq!(ArabicShadda.block(), "Arabic");
1279        assert_eq!(ArabicShadda.name(), "Arabic Shadda");
1280        assert_eq!(ArabicShadda.scalar_value(), '\u{0651}');
1281
1282        assert_eq!(format!("{:?}", ArabicShadda), "Arabic Shadda { \u{0651} }");
1283        assert_eq!(format!("{}", ArabicShadda), "\u{0651}");
1284        assert_eq!(ArabicShadda, ArabicShadda);
1285        assert_eq!(ArabicShadda, '\u{0651}');
1286        assert_eq!(ArabicShadda, "\u{0651}");
1287        assert_eq!(ArabicShadda, "\u{0651}".to_string());
1288        assert_eq!(ArabicShadda, ArabicCharacter::try_from('\u{0651}').unwrap());
1289    }
1290
1291    #[test]
1292    fn arabic_sukun() {
1293        assert_eq!(ArabicSukun.block(), "Arabic");
1294        assert_eq!(ArabicSukun.name(), "Arabic Sukun");
1295        assert_eq!(ArabicSukun.scalar_value(), '\u{0652}');
1296
1297        assert_eq!(format!("{:?}", ArabicSukun), "Arabic Sukun { \u{0652} }");
1298        assert_eq!(format!("{}", ArabicSukun), "\u{0652}");
1299        assert_eq!(ArabicSukun, ArabicSukun);
1300        assert_eq!(ArabicSukun, '\u{0652}');
1301        assert_eq!(ArabicSukun, "\u{0652}");
1302        assert_eq!(ArabicSukun, "\u{0652}".to_string());
1303        assert_eq!(ArabicSukun, ArabicCharacter::try_from('\u{0652}').unwrap());
1304    }
1305}
arabic_script/core/arabic_character.rs

arabic_script/core/
arabic_character.rs
