devnagari 0.1.0

#[cfg(test)]
mod संस्कृत_परीक्षण {
    use crate::prelude::*;

    #[test]
    fn संस्कृत_कर्म_यदि() {
        // Sanskrit keywords: कर्म (fn), नियत (let), चेत् (if), अन्यथा (else)
        देव! {
            कर्म विभाजित_है(न: अङ्क) -> bool {
                चेत् न % द्वि == नल { सत्य } अन्यथा { असत्य }
            }
        }
        निश्चय!(विभाजित_है(चतुर));
        निश्चय!(!विभाजित_है(सप्त));
    }

    #[test]
    fn संस्कृत_यावत्_विराम() {
        // यावत् (while), विराम (break), अङ्क, Sanskrit numbers
        देव! {
            कर्म गणना_तक(सीमा: अङ्क) -> अङ्क {
                नियत परिवर्तनीय i: अङ्क = नल;
                यावत् i < सीमा {
                    i += एक;
                }
                i
            }
        }
        समत्व_निश्चय!(गणना_तक(दश), दश);
    }

    #[test]
    fn संस्कृत_रचना_लक्षण() {
        // रचना (struct), लक्षण (trait), साधन (impl), आत्म (self)
        देव! {
            लक्षण क्षेत्रफल {
                कर्म क्षेत्रफल(&आत्म) -> राशि;
            }

            रचना वृत्त {
                त्रिज्या: राशि,
            }

            साधन क्षेत्रफल कृते वृत्त {
                कर्म क्षेत्रफल(&आत्म) -> राशि {
                    पाई * आत्म.त्रिज्या * आत्म.त्रिज्या
                }
            }
        }
        let व = वृत्त { त्रिज्या: 1.0 };
        समत्व_निश्चय!(व.क्षेत्रफल(), पाई);
    }

    #[test]
    fn संस्कृत_संख्याएँ() {
        // Sanskrit number constants
        समत्व_निश्चय!(एक + द्वि, त्रि);
        समत्व_निश्चय!(पञ्च * द्वि, दश);
        समत्व_निश्चय!(शत / दश, दश);
        समत्व_निश्चय!(सहस्र, शत * दश);
    }

    #[test]
    fn संस्कृत_सूत्र_वर्ण() {
        // Sanskrit type aliases: सूत्र (String), वर्ण (char), श्रेणी (Vec)
        let सूत्र_मान: सूत्र = "नमस्ते".to_string();
        निश्चय!(!सूत्र_मान.रिक्त_है());

        let वर्ण_मान: वर्ण = 'अ';
        निश्चय!(वर्ण_मान.is_alphabetic());

        let श्रेणी_मान: श्रेणी<अङ्क> = vec![एक, द्वि, त्रि];
        समत्व_निश्चय!(श्रेणी_मान.लम्बाई(), त्रि as usize);
    }

    #[test]
    fn संस्कृत_परिणाम_सम्भव() {
        // परिणाम (Result), सम्भव (Option), सिद्ध (Ok), दोष (Err), विद्यमान (Some), अविद्यमान (None)
        let प: परिणाम<अङ्क, &str> = सिद्ध(दश);
        निश्चय!(प.ठीक_है());

        let द: परिणाम<अङ्क, &str> = दोष("अशुद्ध");
        निश्चय!(द.त्रुटि_है());

        let स: सम्भव<अङ्क> = विद्यमान(पञ्च);
        निश्चय!(स.कुछ_है());

        let अ: सम्भव<अङ्क> = अविद्यमान;
        निश्चय!(अ.रिक्त_है());
    }

    #[test]
    fn संस्कृत_ध्रुव_शाश्वत() {
        // ध्रुव (const), शाश्वत (static)
        देव! {
            ध्रुव अधिकतम_अङ्क: अङ्क = शत;
            शाश्वत संस्था_नाम: &str = "आर्यभट";
        }
        समत्व_निश्चय!(अधिकतम_अङ्क, शत);
        समत्व_निश्चय!(संस्था_नाम, "आर्यभट");
    }

    #[test]
    fn संस्कृत_आवर्तन_अनुवर्तन() {
        // आवर्तन (loop), विराम (break), अनुवर्तन (continue)
        देव! {
            कर्म प्रथम_विषम(सीमा: अङ्क) -> अङ्क {
                नियत परिवर्तनीय i: अङ्क = नल;
                आवर्तन {
                    i += एक;
                    चेत् i % द्वि == नल { अनुवर्तन; }
                    चेत् i >= सीमा { विराम; }
                }
                i
            }
        }
        समत्व_निश्चय!(प्रथम_विषम(दश), एकादश);
    }

    #[test]
    fn संस्कृत_निघण्टु() {
        // निघण्टु (HashMap / glossary)
        let mut शब्दकोश: निघण्टु<&str, अङ्क> = निघण्टु::new();
        शब्दकोश.insert("एक", एक);
        शब्दकोश.insert("दश", दश);
        समत्व_निश्चय!(शब्दकोश["एक"], एक);
    }

    #[test]
    fn संस्कृत_मैक्रो() {
        // Sanskrit macros: रचय (format!), निश्चय (assert!), समत्व_निश्चय (assert_eq!)
        let वाक्य = रचय!("{}  +  {} = {}", एक, द्वि, त्रि);
        निश्चय!(वाक्य.समाविष्ट("3"));
    }
}

#[cfg(test)]
mod परीक्षण {
    use crate::prelude::*;

    #[test]
    fn पूर्णांक_जोड़() {
        देव! {
            कार्य जोड़(क: पूर्णांक, ख: पूर्णांक) -> पूर्णांक {
                क + ख
            }
        }
        समता_दावा!(जोड़(3, 4), 7);
    }

    #[test]
    fn यदि_अन्यथा() {
        देव! {
            कार्य पूर्ण_है(न: पूर्णांक) -> bool {
                यदि न % 2 == 0 { सत्य } अन्यथा { असत्य }
            }
        }
        दावा!(पूर्ण_है(4));
        दावा!(!पूर्ण_है(7));
    }

    #[test]
    fn सूची_चक्र() {
        देव! {
            कार्य गुणनफल(सूची: &[पूर्णांक]) -> पूर्णांक {
                मान परिवर्तनीय फल = 1;
                प्रत्येक &न में सूची {
                    फल *= न;
                }
                फल
            }
        }
        समता_दावा!(गुणनफल(&[1, 2, 3, 4, 5]), 120);
    }

    #[test]
    fn मिलान_परीक्षण() {
        देव! {
            कार्य श्रेणी(अंक: पूर्णांक) -> &'static str {
                मिलान अंक {
                    90..=100 => "उत्कृष्ट",
                    75..=89  => "अच्छा",
                    50..=74  => "सामान्य",
                    _        => "अनुत्तीर्ण",
                }
            }
        }
        समता_दावा!(श्रेणी(95), "उत्कृष्ट");
        समता_दावा!(श्रेणी(80), "अच्छा");
        समता_दावा!(श्रेणी(30), "अनुत्तीर्ण");
    }

    #[test]
    fn पाठ_विस्तार() {
        let वाक्य = "नमस्ते";
        दावा!(!वाक्य.रिक्त_है());
        समता_दावा!(वाक्य.अक्षर_संख्या(), 6);
    }

    #[test]
    fn विकल्प_विस्तार() {
        let मान: Option<पूर्णांक> = कुछ(10);
        दावा!(मान.कुछ_है());
        समता_दावा!(मान.या(0), 10);

        let रिक्त_मान: Option<पूर्णांक> = रिक्त;
        दावा!(रिक्त_मान.रिक्त_है());
        समता_दावा!(रिक्त_मान.या(99), 99);
    }

    #[test]
    fn फल_विस्तार() {
        let सफल: Result<पूर्णांक, &str> = ठीक(42);
        दावा!(सफल.ठीक_है());

        let विफल: Result<पूर्णांक, &str> = त्रुटि("कुछ गलत हुआ");
        दावा!(विफल.त्रुटि_है());
    }

    #[test]
    fn स्वरूप_मैक्रो() {
        let नाम = "अर्जुन";
        let वाक्य = स्वरूप!("नमस्ते, {}!", नाम);
        समता_दावा!(वाक्य, "नमस्ते, अर्जुन!");
    }

    #[test]
    fn संरचना_परीक्षण() {
        देव! {
            संरचना बिंदु {
                x: दशमलव,
                y: दशमलव,
            }

            क्रियान्वयन बिंदु {
                कार्य दूरी(&स्व, अन्य: &स्वप्रकार) -> दशमलव {
                    मान dx = स्व.x - अन्य.x;
                    मान dy = स्व.y - अन्य.y;
                    (dx * dx + dy * dy).sqrt()
                }
            }
        }

        let मूल = बिंदु { x: 0.0, y: 0.0 };
        let बिंदु_क = बिंदु { x: 3.0, y: 4.0 };
        समता_दावा!(मूल.दूरी(&बिंदु_क), 5.0);
    }
}