diff --git a/Rules/Languages/pl/ClearSpeak_Rules.yaml b/Rules/Languages/pl/ClearSpeak_Rules.yaml index dfcea2e0..5e6cca14 100644 --- a/Rules/Languages/pl/ClearSpeak_Rules.yaml +++ b/Rules/Languages/pl/ClearSpeak_Rules.yaml @@ -631,36 +631,59 @@ - LineCount: "count(*[not(contains(@data-intent-property, ':continued-row:'))])" - NextLineIsContinuedRow: "false()" # default value - IsColumnSilent: true() + # Polish plural declension category of $LineCount: singular (1), paucal (2-4 + # except 12-14 -> nominative plural), otherwise genitive plural. + - Paucal: "($LineCount mod 10 = 2 or $LineCount mod 10 = 3 or $LineCount mod 10 = 4) and not($LineCount mod 100 = 12 or $LineCount mod 100 = 13 or $LineCount mod 100 = 14)" + - IsCase: "($ClearSpeak_MultiLineLabel = 'Auto' and self::m:piecewise) or $ClearSpeak_MultiLineLabel = 'Case'" + - IsLine: "not($IsCase) and ($ClearSpeak_MultiLineLabel = 'Auto' or $ClearSpeak_MultiLineLabel = 'Line' or $ClearSpeak_MultiLineLabel = 'None')" replace: - test: - if: "$ClearSpeak_MultiLineOverview = 'Auto'" then: - x: "$LineCount" - test: - - if: "$LineCount != 1 and (($ClearSpeak_MultiLineLabel = 'Auto' and self::m:piecewise) or $ClearSpeak_MultiLineLabel = 'Case')" - then: [t: "przypadki"] # phrase(this is the first 'case' of three cases) - - else_if: "$LineCount != 1 and ($ClearSpeak_MultiLineLabel = 'Auto' or $ClearSpeak_MultiLineLabel = 'Line' or $ClearSpeak_MultiLineLabel = 'None')" - then: [t: "linie"] # phrase(this is the first 'line' of three lines) - - else_if: "$LineCount != 1 and $ClearSpeak_MultiLineLabel = 'Constraint'" - then: [t: "warunki"] # phrase(this is the first 'constraint' of three constraints) - - else_if: "$LineCount != 1 and $ClearSpeak_MultiLineLabel = 'Equation'" - then: [t: "równania"] # phrase(this is the first 'equation' of three equations) - - else_if: "$LineCount != 1 and $ClearSpeak_MultiLineLabel = 'Row'" - then: [T: "wiersze"] # phrase(this is the first 'row' of three rows) - - else_if: "$LineCount != 1 and $ClearSpeak_MultiLineLabel = 'Step'" - then: [t: "kroki"] # phrase(this is the first 'step' of three steps) - - else_if: "($ClearSpeak_MultiLineLabel = 'Auto' and self::m:piecewise) or $ClearSpeak_MultiLineLabel = 'Case'" - then: [t: "przypadek"] # phrase(this is the first 'case' of three cases) - - else_if: "$ClearSpeak_MultiLineLabel = 'Auto' or $ClearSpeak_MultiLineLabel = 'Line' or $ClearSpeak_MultiLineLabel = 'None'" # already dealt with Auto/Case - then: [t: "linia"] # phrase(this is the first 'line' of three lines) + - if: "$IsCase" + then_test: + - if: "$LineCount = 1" + then: [t: "przypadek"] # phrase(this is the first 'case' of three cases) + - else_if: "$Paucal" + then: [t: "przypadki"] # phrase(there are 'two cases' to consider) + else: [t: "przypadków"] # phrase(there are 'five cases' to consider) + - else_if: "$IsLine" + then_test: + - if: "$LineCount = 1" + then: [t: "linia"] # phrase(this is the first 'line' of three lines) + - else_if: "$Paucal" + then: [t: "linie"] # phrase(there are 'two lines' shown) + else: [t: "linii"] # phrase(there are 'five lines' shown) - else_if: "$ClearSpeak_MultiLineLabel = 'Constraint'" - then: [t: "warunek"] # phrase(this is the first 'constraint' of three constraints) + then_test: + - if: "$LineCount = 1" + then: [t: "warunek"] # phrase(this is the first 'constraint' of three constraints) + - else_if: "$Paucal" + then: [t: "warunki"] # phrase(there are 'two constraints' to satisfy) + else: [t: "warunków"] # phrase(there are 'five constraints' to satisfy) - else_if: "$ClearSpeak_MultiLineLabel = 'Equation'" - then: [t: "równanie"] # phrase(this is the first 'equation' of three equations) + then_test: + - if: "$LineCount = 1" + then: [t: "równanie"] # phrase(this is the first 'equation' of three equations) + - else_if: "$Paucal" + then: [t: "równania"] # phrase(there are 'two equations' to solve) + else: [t: "równań"] # phrase(there are 'five equations' to solve) - else_if: "$ClearSpeak_MultiLineLabel = 'Row'" - then: [T: "wiersz"] # phrase(this is the first 'row' of three rows) + then_test: + - if: "$LineCount = 1" + then: [T: "wiersz"] # phrase(this is the first 'row' of three rows) + - else_if: "$Paucal" + then: [T: "wiersze"] # phrase(there are 'two rows' shown) + else: [T: "wierszy"] # phrase(there are 'five rows' shown) - else_if: "$ClearSpeak_MultiLineLabel = 'Step'" - then: [t: "krok"] # phrase(this is the first 'step' of three steps) + then_test: + - if: "$LineCount = 1" + then: [t: "krok"] # phrase(this is the first 'step' of three steps) + - else_if: "$Paucal" + then: [t: "kroki"] # phrase(there are 'two steps' to follow) + else: [t: "kroków"] # phrase(there are 'five steps' to follow) # else 'None -- don't say anything' - pause: short - x: "*" diff --git a/Rules/Languages/pl/SharedRules/general.yaml b/Rules/Languages/pl/SharedRules/general.yaml index d1a2d103..40e996f4 100644 --- a/Rules/Languages/pl/SharedRules/general.yaml +++ b/Rules/Languages/pl/SharedRules/general.yaml @@ -544,15 +544,32 @@ - IsColumnSilent: true() replace: - x: "$LineCount" + # Polish plural declension of the counted noun: 1 -> singular; 2-4 (but not + # 12-14) -> paucal; otherwise genitive plural. Applied per row-type. - test: - - if: "self::m:piecewise" - then: [t: "przypadek"] # phrase(this is the first 'case' of three cases) - - else_if: "self::m:system-of-equations" - then: [t: "równanie"] # phrase(this is the first 'equation' of three equations) - else: [t: "linia"] # phrase(this is the first 'line' of three lines) - - test: - - if: "$LineCount != 1" - then: [ct: "s"] # plural + - if: "$LineCount = 1" + then: + - test: + - if: "self::m:piecewise" + then: [t: "przypadek"] # phrase(this is the first 'case' of three cases) + - else_if: "self::m:system-of-equations" + then: [t: "równanie"] # phrase(this is the first 'equation' of three equations) + else: [t: "linia"] # phrase(this is the first 'line' of three lines) + - else_if: "($LineCount mod 10 = 2 or $LineCount mod 10 = 3 or $LineCount mod 10 = 4) and not($LineCount mod 100 = 12 or $LineCount mod 100 = 13 or $LineCount mod 100 = 14)" + then: + - test: + - if: "self::m:piecewise" + then: [t: "przypadki"] # phrase(there are 'two cases' to consider) + - else_if: "self::m:system-of-equations" + then: [t: "równania"] # phrase(there are 'two equations' to solve) + else: [t: "linie"] # phrase(there are 'two lines' shown) + - else: + - test: + - if: "self::m:piecewise" + then: [t: "przypadków"] # phrase(there are 'five cases' to consider) + - else_if: "self::m:system-of-equations" + then: [t: "równań"] # phrase(there are 'five equations' to solve) + else: [t: "linii"] # phrase(there are 'five lines' shown) - pause: short - x: "*" - pause: long diff --git a/tests/Languages/pl.rs b/tests/Languages/pl.rs index 677d4dc2..44016ff5 100644 --- a/tests/Languages/pl.rs +++ b/tests/Languages/pl.rs @@ -1,3 +1,35 @@ #![allow(non_snake_case)] -mod pl; \ No newline at end of file +// Existing hand-written Polish tests (norms, degrees, relations, etc.) +mod pl; + +// Tests mirrored from the English suite, with expected speech localized to Polish. +mod ClearSpeak { + mod functions; + mod large_ops; + mod menclose; + mod mfrac; + mod mroot; + mod msup; + mod sets; + mod symbols_and_adornments; + mod multiline; +} + +mod SimpleSpeak { + mod functions; + mod large_ops; + mod mfrac; + mod msup; + mod sets; + mod geometry; + mod linear_algebra; + mod multiline; + mod subscripts; +} +mod shared; +mod units; +mod chemistry; +mod alphabets; +mod definitions; +mod mtable; diff --git a/tests/Languages/pl/ClearSpeak/functions.rs b/tests/Languages/pl/ClearSpeak/functions.rs new file mode 100644 index 00000000..66216dfb --- /dev/null +++ b/tests/Languages/pl/ClearSpeak/functions.rs @@ -0,0 +1,569 @@ +/// Tests for: +/// * functions including trig functions, logs, and functions to powers +/// * implied times/functional call and explicit times/function call +/// * parens +/// These are all intertwined, so they are in one file +use crate::common::*; +use anyhow::Result; + +#[test] +fn trig_names() -> Result<()> { + let expr = " + sinx+ + cosy+ + tanz+ + secα+ + cscϕ+ + cotφ + "; + test("pl", "ClearSpeak", expr, "sinus x plus cosinus y plus tangens z plus sekans alfa, plus kosekans fi, plus cotangens fi")?; + return Ok(()); + +} + +#[test] +fn hyperbolic_trig_names() -> Result<()> { + let expr = " + sinhx+ + coshy+ + tanhz+ + sechα+ + cschϕ+ + cothφ + "; + test("pl", "ClearSpeak", expr, "sinus hiperboliczny z x, plus cosinus hiperboliczny z y, plus tangens hiperboliczny z z, plus sekans hiperboliczny z alfa, plus kosekans hiperboliczny z fi, plus cotangens hiperboliczny z fi")?; + return Ok(()); + +} + + +#[test] +fn inverse_trig() -> Result<()> { + let expr = "sin-1x"; + test("pl", "ClearSpeak", expr, "odwrotność sinus z x")?; + return Ok(()); + +} + +#[test] +fn inverse_trig_trig_inverse() -> Result<()> { + let expr = "tan-1x"; + test_ClearSpeak("pl", "ClearSpeak_Trig", "TrigInverse",expr, + "tangens odwrotność z x")?; + return Ok(()); + +} + +#[test] +fn inverse_trig_arc() -> Result<()> { + let expr = "cosh-1x"; + test_ClearSpeak("pl", "ClearSpeak_Trig", "ArcTrig",expr, + "łuk cosinus hiperboliczny z x")?; + return Ok(()); + +} + +#[test] +fn trig_squared() -> Result<()> { + let expr = "sin2x"; + test("pl", "ClearSpeak", expr, "sinus do kwadratu z x")?; + return Ok(()); + +} + +#[test] +fn trig_cubed() -> Result<()> { + let expr = "tan3x"; + test("pl", "ClearSpeak", expr, "tangens do sześcianu z x")?; + return Ok(()); + +} + +#[test] +fn trig_fourth() -> Result<()> { + let expr = "sec4x"; + test("pl", "ClearSpeak", expr, "sekans do potęgi czwartej, z x")?; + return Ok(()); + +} + + +#[test] +fn trig_power_other() -> Result<()> { + let expr = "sinh>n-1x"; + test("pl", "ClearSpeak", expr, "sinus hiperboliczny do potęgi n minus 1, z x")?; + return Ok(()); + +} + +#[test] +fn simple_log() -> Result<()> { + let expr = " logx "; + test("pl", "ClearSpeak", expr, "logarytm x")?; + return Ok(()); + +} + +#[test] +fn principal_value_log() -> Result<()> { + let expr = "Logz"; + test("pl", "ClearSpeak", expr, "Log z z")?; + return Ok(()); + +} + +#[test] +fn normal_log() -> Result<()> { + let expr = "log(x+y)"; + test("pl", "ClearSpeak", expr, "logarytm z, nawias otwierający, x plus y, nawias zamykający")?; + return Ok(()); + +} + +#[test] +fn simple_log_with_base() -> Result<()> { + let expr = " logbx "; + test("pl", "ClearSpeak", expr, "logarytm o podstawie b, z x")?; + return Ok(()); + +} + +#[test] +fn normal_log_with_base() -> Result<()> { + let expr = "logb(x+y)"; + test("pl", "ClearSpeak", expr, "logarytm o podstawie b, z, nawias otwierający, x plus y, nawias zamykający")?; + return Ok(()); + +} + +#[test] +fn simple_ln() -> Result<()> { + let expr = " lnx "; + test("pl", "ClearSpeak", expr, "l n x")?; + return Ok(()); + +} + +#[test] +fn normal_ln() -> Result<()> { + let expr = "ln(x+y)"; + test("pl", "ClearSpeak", expr, "l n z, nawias otwierający, x plus y, nawias zamykający")?; + return Ok(()); + +} + + +#[test] +fn simple_natural_log() -> Result<()> { + let expr = " lnx "; + test_ClearSpeak("pl", "ClearSpeak_Log", "LnAsNaturalLog",expr, + "logarytm naturalny x")?; + return Ok(()); + +} + + +#[test] +fn natural_log() -> Result<()> { + let expr = "ln(x+y)"; + test_ClearSpeak("pl", "ClearSpeak_Log", "LnAsNaturalLog",expr, + "logarytm naturalny z, nawias otwierający, x plus y, nawias zamykający")?; + return Ok(()); + +} + + +#[test] +fn explicit_function_call_with_parens() -> Result<()> { + let expr = "t⁡(x)"; + test("pl", "ClearSpeak", expr, "t z x")?; + return Ok(()); + +} + + +#[test] +fn explicit_times_with_parens() -> Result<()> { + let expr = "t⁢(x)"; + test("pl", "ClearSpeak", expr, "t razy x")?; + return Ok(()); + +} + +#[test] +fn explicit_function_call() -> Result<()> { + let expr = "t⁡x"; + test("pl", "ClearSpeak", expr, "t z x")?; + return Ok(()); + +} + +#[test] +fn explicit_times() -> Result<()> { + let expr = "t⁢x"; + test("pl", "ClearSpeak", expr, "t x")?; + return Ok(()); + +} + + +#[test] +fn test_functions_none_pref() -> Result<()> { + let expr = " + log⁡(x+y) + + + f⁡(x+y) + "; + test_ClearSpeak("pl", "ClearSpeak_Functions", "None",expr, + "logarytm z, nawias otwierający, x plus y, nawias zamykający; plus; f razy, nawias otwierający, x plus y, nawias zamykający")?; + return Ok(()); + +} + +#[test] +fn test_functions_none_pref_multiple_args() -> Result<()> { + let expr = " + B ( 2,6 ) + "; + test_ClearSpeak("pl", "ClearSpeak_Functions", "None",expr, + "wielka b razy, nawias otwierający, 2 przecinek, 6, nawias zamykający")?; + return Ok(()); + +} + + +/* + * Tests for times + */ +#[test] +fn no_times_binomial() -> Result<()> { + let expr = "x ⁢ y"; + test("pl", "ClearSpeak", expr, "x y")?; + return Ok(()); + +} + +#[test] +fn times_following_paren() -> Result<()> { + let expr = " + 2 + ( 3 ) + "; + test("pl", "ClearSpeak", expr, "2 razy 3")?; + return Ok(()); + +} + +#[test] +fn times_preceding_paren() -> Result<()> { + let expr = " + ( 2 ) + 3 + "; + test("pl", "ClearSpeak", expr, "2 razy 3")?; + return Ok(()); + +} + +#[test] +fn times_sqrt() -> Result<()> { + let expr = " + a + b + = + ab + "; + test("pl", "ClearSpeak", expr, "pierwiastek kwadratowy z a; razy pierwiastek kwadratowy z b; równa się, pierwiastek kwadratowy z a b")?; + return Ok(()); + +} + +#[test] +fn more_implied_times() -> Result<()> { + let expr = " + + + + ( + 2x + ) + 2 + + + "; + test_ClearSpeak("pl", "ClearSpeak_ImpliedTimes", "MoreImpliedTimes",expr, + "nawias otwierający, 2 razy x, nawias zamykający do kwadratu")?; + return Ok(()); + +} + +#[test] +fn explicit_times_more_implied_times() -> Result<()> { + let expr = "t⁢x"; + test_ClearSpeak("pl", "ClearSpeak_ImpliedTimes", "MoreImpliedTimes",expr, "t razy x")?; + return Ok(()); + +} + +#[test] +fn explicit_times_none_simple_right() -> Result<()> { + let expr = "2[3 ]"; + test_ClearSpeak("pl", "ClearSpeak_ImpliedTimes", "None", + expr, "2, nawias kwadratowy otwierający 3 nawias kwadratowy zamykający")?; + return Ok(()); + +} + +#[test] +fn explicit_times_none_simple_left() -> Result<()> { + let expr = "(2−1)x"; + test_ClearSpeak("pl", "ClearSpeak_ImpliedTimes", "None", + expr, "nawias otwierający, 2 minus 1, nawias zamykający; x")?; + return Ok(()); + +} + +#[test] +fn explicit_times_none_superscript() -> Result<()> { + let expr = " + f(x)= +x +2 + +( + +x+1 +) + "; + test_ClearSpeak_prefs("pl", + vec![("ClearSpeak_ImpliedTimes", "None"), ("ClearSpeak_Functions", "None")], + expr, "f, nawias otwierający x nawias zamykający; równa się; x do kwadratu, nawias otwierający, x plus 1, nawias zamykający")?; + return Ok(()); + +} + +/* + * Tests for parens + */ + #[test] + fn no_parens_number() -> Result<()> { + let expr = " + ( + 25 + ) + x + "; + test("pl", "ClearSpeak", expr, "25 razy x")?; + return Ok(()); + + } + + #[test] + fn no_parens_monomial() -> Result<()> { + let expr = " + b + ( + xy + ) + "; + test("pl", "ClearSpeak", expr, "b, nawias otwierający, x y nawias zamykający")?; + return Ok(()); + + } + + #[test] + fn no_parens_negative_number() -> Result<()> { + let expr = " + 2+ + ( + −2 + ) + "; + test("pl", "ClearSpeak", expr, "2 plus minus 2")?; + return Ok(()); + + } + + + #[test] + fn no_parens_negative_number_with_var() -> Result<()> { + let expr = " + ( + −2x + ) + + +1 + "; + test("pl", "ClearSpeak", expr, "minus 2 x plus 1")?; + return Ok(()); + + } + + #[test] + fn parens_superscript() -> Result<()> { + let expr = " + + + + ( + 2x + ) + 2 + + + "; + test("pl", "ClearSpeak", expr, "nawias otwierający, 2 x nawias zamykający do kwadratu")?; + return Ok(()); + + } + + #[test] + fn no_parens_fraction() -> Result<()> { + let expr = " + 2 + + + + ( + 12 + ) + "; + test("pl", "ClearSpeak", expr, "2 plus jedna druga")?; + return Ok(()); + + } + + + // Tests for the ten types of intervals in ClearSpeak + #[test] + fn parens_interval_open_open() -> Result<()> { + let expr = " + ( + c,d + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Paren", "Interval",expr, + "przedział otwarty od c do d")?; + return Ok(()); + +} + +#[test] + fn parens_interval_closed_open() -> Result<()> { + let expr = " + [ + c,d + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Paren", "Interval ",expr, + "przedział lewostronnie domknięty prawostronnie otwarty od c do d")?; + return Ok(()); + +} + + +#[test] +fn parens_interval_open_closed() -> Result<()> { + let expr = " + ( + c,d + ] + "; + test_ClearSpeak("pl", "ClearSpeak_Paren", "Interval ",expr, + "przedział lewostronnie otwarty prawostronnie domknięty od c do d")?; + return Ok(()); + +} + + +#[test] +fn parens_interval_closed_closed() -> Result<()> { + let expr = " + [ + c,d + ] +"; +test_ClearSpeak("pl", "ClearSpeak_Paren", "Interval ",expr, +"przedział domknięty od c do d")?; +return Ok(()); + +} + + #[test] + fn parens_interval_neg_infinity_open_open() -> Result<()> { + let expr = " + ( + - ∞,d + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Paren", "Interval ",expr, + "przedział otwarty od minus nieskończoność do d")?; + return Ok(()); + +} + + #[test] + fn parens_interval_neg_infinity_closed_open() -> Result<()> { + let expr = " + ( + - ∞,d + ] + "; + test_ClearSpeak("pl", "ClearSpeak_Paren", "Interval ",expr, + "przedział lewostronnie otwarty prawostronnie domknięty od minus nieskończoność do d")?; + return Ok(()); + +} + + +#[test] +fn parens_interval_open_open_infinity() -> Result<()> { + let expr = " + ( + c,∞ + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Paren", "Interval ",expr, + "przedział otwarty od c do nieskończoność")?; + return Ok(()); + +} + + +#[test] +fn parens_interval_closed_open_infinity() -> Result<()> { + let expr = " + [ + c,∞ + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Paren", "Interval ",expr, +"przedział lewostronnie domknięty prawostronnie otwarty od c do nieskończoność")?; +return Ok(()); + +} + +#[test] +fn parens_interval_neg_infinity_to_infinity() -> Result<()> { + let expr = " + ( + - ∞,∞ + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Paren", "Interval ",expr, + "przedział otwarty od minus nieskończoność do nieskończoność")?; + return Ok(()); + +} + +#[test] +fn parens_interval_neg_infinity_to_pos_infinity() -> Result<()> { + let expr = " + ( + - ∞,+∞ + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Paren", "Interval ",expr, + "przedział otwarty od minus nieskończoność do plus nieskończoność")?; + return Ok(()); + +} diff --git a/tests/Languages/pl/ClearSpeak/large_ops.rs b/tests/Languages/pl/ClearSpeak/large_ops.rs new file mode 100644 index 00000000..edc0bbb7 --- /dev/null +++ b/tests/Languages/pl/ClearSpeak/large_ops.rs @@ -0,0 +1,235 @@ +use crate::common::*; +use anyhow::Result; + +#[test] +fn sum_both() -> Result<()> { + let expr = " + + ∑ + n=1 + 10 + + n + "; + test("pl", "ClearSpeak", expr, "suma od n równa się 1, do 10; n")?; + return Ok(()); + +} + +#[test] +fn sum_under() -> Result<()> { + let expr = " + + ∑ + S + + i + "; + test("pl", "ClearSpeak", expr, "suma przez wielka s z i")?; + return Ok(()); + +} +#[test] +fn sum_both_msubsup() -> Result<()> { + let expr = " + + ∑ + n=1 + 10 + + n + "; + test("pl", "ClearSpeak", expr, "suma od n równa się 1, do 10; n")?; + return Ok(()); + +} + +#[test] +fn sum_sub() -> Result<()> { + let expr = " + + ∑ + S + + i + "; + test("pl", "ClearSpeak", expr, "suma przez wielka s z i")?; + return Ok(()); + +} + +#[test] +fn sum() -> Result<()> { + let expr = " + ∑ + ai + "; + test("pl", "ClearSpeak", expr, "suma, a indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn product_both() -> Result<()> { + let expr = " + + ∏ + n=1 + 10 + + n + "; + test("pl", "ClearSpeak", expr, "iloczyn od n równa się 1, do 10; n")?; + return Ok(()); + +} + +#[test] +fn product_under() -> Result<()> { + let expr = " + + ∏ + S + + i + "; + test("pl", "ClearSpeak", expr, "iloczyn przez wielka s z i")?; + return Ok(()); + +} + +#[test] +fn product() -> Result<()> { + let expr = " + ∏ + ai + "; + test("pl", "ClearSpeak", expr, "iloczyn, a indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn intersection_both() -> Result<()> { + let expr = " + + ⋂ + i=1 + 10 + + Si + "; + test("pl", "ClearSpeak", expr, "przecięcie od i równa się 1, do 10; wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn intersection_under() -> Result<()> { + let expr = " + + ⋂ + C + + Si + "; + test("pl", "ClearSpeak", expr, "przecięcie przez wielka c z, wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn intersection() -> Result<()> { + let expr = " + ⋂ + Si + "; + test("pl", "ClearSpeak", expr, "przecięcie, wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn union_both() -> Result<()> { + let expr = " + + ⋃ + i=1 + 10 + + Si + "; + test("pl", "ClearSpeak", expr, "suma zbiorów od i równa się 1, do 10; wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn union_under() -> Result<()> { + let expr = " + + ⋃ + C + + Si + "; + test("pl", "ClearSpeak", expr, "suma zbiorów przez wielka c z, wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn union() -> Result<()> { + let expr = " + ⋃ + Si + "; + test("pl", "ClearSpeak", expr, "suma zbiorów, wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn integral_both() -> Result<()> { + let expr = " + + + ∫ + 0 + 1 + + f(x ) + +  dx + "; + test("pl", "ClearSpeak", expr, "całka od 0, do 1; f z x; d x")?; + return Ok(()); + +} + +#[test] +fn integral_under() -> Result<()> { + let expr = " + + ∫ + ℝ + + f(x ) + dx + "; + test("pl", "ClearSpeak", expr, "całka przez liczby rzeczywiste z; f z x d x")?; + return Ok(()); + +} + +#[test] +fn integral() -> Result<()> { + let expr = " + ∫ + f(x ) + dx + "; + test("pl", "ClearSpeak", expr, "całka, f z x d x")?; + return Ok(()); + +} \ No newline at end of file diff --git a/tests/Languages/pl/ClearSpeak/menclose.rs b/tests/Languages/pl/ClearSpeak/menclose.rs new file mode 100644 index 00000000..7c676217 --- /dev/null +++ b/tests/Languages/pl/ClearSpeak/menclose.rs @@ -0,0 +1,242 @@ +use crate::common::*; +use anyhow::Result; + +#[test] +fn menclose_actuarial() -> Result<()> { + let expr = " + 3+2i + "; + test("pl", "ClearSpeak", expr, "symbol aktuarialny, obejmujący 3 plus 2 i koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_box() -> Result<()> { + let expr = " + 3+2i + "; + test("pl", "ClearSpeak", expr, "ramka, okrąg, obejmujący 3 plus 2 i koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_left() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "linia na lewo, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_right() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "linia na prawo, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_top_bottom() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "linia na góra, dół, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_updiagonalstrike() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "ukośnie w górę, krzyż na zewnątrz, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_downdiagonalstrike() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "ukośnie w dół, krzyż na zewnątrz, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_cross_out() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "x, krzyż na zewnątrz, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_vertical_horizontal_strike() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "pionowy, poziomy, krzyż na zewnątrz, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_leftarrow() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "strzałka w lewo, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_right_up_down_arrow() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "strzałka w górę, strzałka w dół, strzałka w prawo, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_northeastarrow() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "strzałka na północny wschód, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_other_single_arrows() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "strzałka na południowy wschód, strzałka na południowy zachód, strzałka na północny zachód, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_northwestsoutheastarrow() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "strzałka dwukierunkowa ukośna w dół, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_other_double_arrows() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "strzałka dwukierunkowa pionowa, strzałka dwukierunkowa pozioma, strzałka dwukierunkowa ukośna w górę, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_madrub() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "arabski symbol silni, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_phasorangle() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "kąt fazowy, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_circle_phasorangle() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "okrąg, kąt fazowy, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_longdiv() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "znak dzielenia pisemnego, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_longdiv_default() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "znak dzielenia pisemnego, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_longdiv_empty_string() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "znak dzielenia pisemnego, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_longdiv_whitespace_string() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "znak dzielenia pisemnego, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn menclose_radical() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "pierwiastek kwadratowy, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} + +#[test] +fn simple_speak_menclose_top_bottom() -> Result<()> { + let expr = " + 32 + "; + test("pl", "SimpleSpeak", expr, "linia na góra, dół, obejmujący 3 drugie koniec obramowania")?; + return Ok(()); + +} diff --git a/tests/Languages/pl/ClearSpeak/mfrac.rs b/tests/Languages/pl/ClearSpeak/mfrac.rs new file mode 100644 index 00000000..f7197bcb --- /dev/null +++ b/tests/Languages/pl/ClearSpeak/mfrac.rs @@ -0,0 +1,313 @@ +/// Tests for fractions +/// includes simple fractions and more complex fractions +/// also tests mixed fractions (implicit and explicit) +use crate::common::*; +use anyhow::Result; + +#[test] +fn common_fraction_half() -> Result<()> { + let expr = " + 1 2 + "; + test("pl", "ClearSpeak", expr, "jedna druga")?; + return Ok(()); + +} + +#[test] +fn common_fraction_thirds() -> Result<()> { + let expr = " + 2 3 + "; + test("pl", "ClearSpeak", expr, "dwie trzecie")?; + return Ok(()); + +} + +#[test] +fn common_fraction_tenths() -> Result<()> { + let expr = " + 17 10 + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "Auto")], expr, "17 dziesiąte")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "Ordinal")], expr, "17 dziesiąte")?; + return Ok(()); + +} + +#[test] +#[allow(non_snake_case)] +fn not_ClearSpeak_common_fraction_tenths() -> Result<()> { + let expr = " + 89 10 + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "Auto")], expr, "89 przez 10")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "Ordinal")], expr, "89 dziesiąte")?; + return Ok(()); + +} + +#[test] +fn non_simple_fraction() -> Result<()> { + let expr = " + + + + + x+y + + x-y + + + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "Auto")], expr, "ułamek z licznikiem; x plus y; i mianownikiem x minus y")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "Ordinal")], expr, "ułamek z licznikiem; x plus y; i mianownikiem x minus y")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "Over")], expr, "x plus y przez x minus y")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "FracOver")], expr, "ułamek x plus y przez x minus y")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "General")], expr, "ułamek z licznikiem; x plus y; i mianownikiem x minus y")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "EndFrac")], expr, "ułamek z licznikiem; x plus y; i mianownikiem x minus y; koniec ułamka")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "GeneralEndFrac")], expr, "ułamek z licznikiem; x plus y; i mianownikiem x minus y; koniec ułamka")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "OverEndFrac")], expr, "x plus y przez x minus y, koniec ułamka")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "Per")], expr, "x plus y na x minus y")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Verbose"),("ClearSpeak_Fractions", "Auto")], expr, "ułamek z licznikiem; x plus y; i mianownikiem x minus y; koniec ułamka")?; + return Ok(()); + +} + +#[test] +fn frac_with_units() -> Result<()> { + let expr = " + + + 62 + + mi + hr + + + "; + test("pl", "ClearSpeak", expr, "62 milas na godzina")?; + return Ok(()); + +} + + +#[test] +fn mixed_number() -> Result<()> { + let expr = " + 3 + 1 2 + "; + test("pl", "ClearSpeak", expr, "3 i jedna druga")?; + return Ok(()); + +} + +#[test] +fn explicit_mixed_number() -> Result<()> { + let expr = " + 3 + ⁤ + 1 8 + "; + test("pl", "ClearSpeak", expr, "3 i jedna ósma")?; + return Ok(()); + +} + +#[test] +fn mixed_number_big() -> Result<()> { + let expr = " + 3 + 7 83 + "; + test("pl", "ClearSpeak", expr, "3 i 7 przez 83")?; + return Ok(()); + +} + +#[test] +fn simple_text() -> Result<()> { + let expr = " + rise run + "; + test("pl", "ClearSpeak", expr, "rise przez run")?; + return Ok(()); + +} + +#[test] +fn number_and_text() -> Result<()> { + let expr = " + + + 2miles + + 3gallons + + "; + test("pl", "ClearSpeak", expr, "2 miles przez 3 gallons")?; + return Ok(()); + +} + + +#[test] +fn nested_simple_fractions() -> Result<()> { + let expr = " + + + + + 1 + 2 + + + + + 2 + 3 + + + + + "; + test_prefs("pl", "ClearSpeak", vec![("ClearSpeak_Fractions", "Auto")], expr, "jedna druga przez dwie trzecie")?; + test_prefs("pl", "ClearSpeak", vec![("ClearSpeak_Fractions", "Ordinal")], expr, "jedna druga przez dwie trzecie")?; + test_prefs("pl", "ClearSpeak", vec![("ClearSpeak_Fractions", "Over")], expr, "1 przez 2 przez 2 przez 3")?; + test_prefs("pl", "ClearSpeak", vec![("ClearSpeak_Fractions", "FracOver")], expr, + "ułamek ułamek 1 przez 2 przez ułamek 2 przez 3")?; + test_prefs("pl", "ClearSpeak", vec![("ClearSpeak_Fractions", "General")], expr, + "ułamek z licznikiem ułamek z licznikiem 1; i mianownikiem 2; i mianownikiem ułamek z licznikiem 2; i mianownikiem 3")?; + test_prefs("pl", "ClearSpeak", vec![("ClearSpeak_Fractions", "EndFrac")], expr, "jedna druga przez dwie trzecie")?; + test_prefs("pl", "ClearSpeak", vec![("ClearSpeak_Fractions", "GeneralEndFrac")], expr, + "ułamek z licznikiem ułamek z licznikiem 1; i mianownikiem 2; koniec ułamka; i mianownikiem ułamek z licznikiem 2; i mianownikiem 3; koniec ułamka; koniec ułamka")?; + test_prefs("pl", "ClearSpeak", vec![("ClearSpeak_Fractions", "OverEndFrac")], expr, + "1 przez 2, koniec ułamka, przez 2 przez 3, koniec ułamka; koniec ułamka")?; + return Ok(()); + +} + + +#[test] +fn semi_nested_fraction() -> Result<()> { + let expr = " + + + + + 2 + 3 + + x + + 6 + + + "; + test("pl", "ClearSpeak", expr, "dwie trzecie x przez 6")?; + return Ok(()); + +} + +#[test] +fn general_nested_fraction() -> Result<()> { + let expr = " + + + + + + 10 + n + + + + + 2 + n + + + + + + "; + test("pl", "ClearSpeak", expr, "ułamek z licznikiem; 10 przez n; i mianownikiem 2 przez n")?; + return Ok(()); + +} + +#[test] +fn complex_nested_fraction() -> Result<()> { + let expr = " + + + + + + n + 10 + n + + + + + 2 + n + + + + + + "; + test("pl", "ClearSpeak", expr, "ułamek z licznikiem; ułamek z licznikiem; n plus 10; i mianownikiem n; i mianownikiem 2 przez n")?; + return Ok(()); + +} + +#[test] +fn simple_function() -> Result<()> { + let expr = "f(x)2"; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "Auto")], expr, "f z x przez 2")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Verbose"), ("ClearSpeak_Fractions", "Auto")], expr, "f z x przez 2, koniec ułamka")?; + return Ok(()); + +} + +#[test] +fn function_over_function() -> Result<()> { + let expr = " + f(x) + g(x) + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "Auto")], expr, "f z x przez g z x")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Verbose"), ("ClearSpeak_Fractions", "Auto")], expr, "f z x przez g z x, koniec ułamka")?; + return Ok(()); + +} + +#[test] +fn non_simple_function_over_function() -> Result<()> { + let expr = " + f(x+1) + g(x) + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Fractions", "Auto")], expr, + "ułamek z licznikiem; f z, nawias otwierający, x plus 1, nawias zamykający; i mianownikiem g z x")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Verbose"), ("ClearSpeak_Fractions", "Auto")], expr, + "ułamek z licznikiem; f z, nawias otwierający, x plus 1, nawias zamykający; i mianownikiem g z x; koniec ułamka")?; + return Ok(()); + +} + +#[test] +fn binomial() -> Result<()> { + let expr = " + 2 + ( + 7 3 + ) + "; + test("pl", "ClearSpeak", expr, "2 razy 7 po 3")?; + return Ok(()); + +} diff --git a/tests/Languages/pl/ClearSpeak/mroot.rs b/tests/Languages/pl/ClearSpeak/mroot.rs new file mode 100644 index 00000000..88292f51 --- /dev/null +++ b/tests/Languages/pl/ClearSpeak/mroot.rs @@ -0,0 +1,171 @@ +use crate::common::*; +use anyhow::Result; + +#[test] +fn msqrt_simple() -> Result<()> { + let expr = " + x + "; + test("pl", "ClearSpeak", expr, "pierwiastek kwadratowy z x")?; + return Ok(()); + +} + +#[test] +fn msqrt_simple_end_root() -> Result<()> { + let expr = " + x + "; + test_ClearSpeak("pl", "ClearSpeak_Roots", "RootEnd", expr, "pierwiastek kwadratowy z x, koniec pierwiastka")?; + return Ok(()); + +} + +#[test] +fn msqrt_simple_positive() -> Result<()> { + let expr = " + x + "; + test_ClearSpeak("pl", "ClearSpeak_Roots", "PosNegSqRoot", expr, "plus pierwiastek kwadratowy z x")?; + return Ok(()); + +} + +#[test] +fn msqrt_simple_pos_end_root() -> Result<()> { + let expr = " + x + "; + test_ClearSpeak("pl", "ClearSpeak_Roots", "PosNegSqRootEnd", expr, "plus pierwiastek kwadratowy z x, koniec pierwiastka")?; + return Ok(()); + +} + +#[test] +fn msqrt_simple_pos_end_with_neg_root() -> Result<()> { + let expr = " + - x + - x 3 + "; + test_ClearSpeak("pl", "ClearSpeak_Roots", "PosNegSqRootEnd", expr, + "minus pierwiastek kwadratowy z x, koniec pierwiastka; minus, plus pierwiastek sześcienny z x, koniec pierwiastka")?; + return Ok(()); + +} + +#[test] +fn mroot_simple_pos_end_with_neg_root() -> Result<()> { + let expr = " + - x 3 + - x + + "; + test_ClearSpeak("pl", "ClearSpeak_Roots", "PosNegSqRoot", expr, + "minus pierwiastek sześcienny z x; minus plus pierwiastek kwadratowy z x")?; + return Ok(()); + +} + +#[test] +fn neg_without_root() -> Result<()> { + let expr = " + - x - y + "; + test("pl", "ClearSpeak", expr, "minus x minus y")?; + return Ok(()); + +} + +#[test] +fn msqrt() -> Result<()> { + let expr = " + + x + y + + "; + test("pl", "ClearSpeak", expr, "pierwiastek kwadratowy z x plus y")?; + return Ok(()); + +} + +#[test] +fn mroot_as_square_root() -> Result<()> { + let expr = " + x 2 + "; + test("pl", "ClearSpeak", expr, "pierwiastek kwadratowy z x")?; + return Ok(()); + +} + +#[test] +fn cube_root() -> Result<()> { + let expr = " + x 3 + "; + test("pl", "ClearSpeak", expr, "pierwiastek sześcienny z x")?; + return Ok(()); + +} + +#[test] +fn ordinal_root() -> Result<()> { + let expr = " + x 9 + "; + test("pl", "ClearSpeak", expr, "dziewiątej pierwiastek z x")?; + return Ok(()); + +} + +#[test] +fn simple_mi_root() -> Result<()> { + let expr = " + x n + "; + test("pl", "ClearSpeak", expr, "n pierwiastek z x")?; + return Ok(()); + +} + +#[test] +fn mroot_simple_pos_end_root() -> Result<()> { + let expr = " + x t + "; + test_ClearSpeak("pl", "ClearSpeak_Roots", "PosNegSqRootEnd", expr, "plus t pierwiastek z x, koniec pierwiastka")?; + return Ok(()); + +} + +#[test] +fn mroot_simple_end_root() -> Result<()> { + let expr = " + x + y + 21 + "; + test_ClearSpeak("pl", "ClearSpeak_Roots", "RootEnd", expr, "dwadzieścia pierwszej pierwiastek z x plus y, koniec pierwiastka")?; + return Ok(()); + +} + +#[test] +fn simple_fraction_power() -> Result<()> { + let expr = " + + x + 13 + + "; + test("pl", "ClearSpeak", expr, "jedna trzecia pierwiastek z x")?; + return Ok(()); + +} + +#[test] +fn no_double_the_532() -> Result<()> { + let expr = "423"; + test("pl", "ClearSpeak", expr, "pierwiastek sześcienny z pierwiastek kwadratowy z 42")?; + return Ok(()); + +} diff --git a/tests/Languages/pl/ClearSpeak/msup.rs b/tests/Languages/pl/ClearSpeak/msup.rs new file mode 100644 index 00000000..fc20a27b --- /dev/null +++ b/tests/Languages/pl/ClearSpeak/msup.rs @@ -0,0 +1,382 @@ +/// Tests for superscripts +/// simple superscripts +/// complex/nested superscripts +use crate::common::*; +use anyhow::Result; + +#[test] +fn squared() -> Result<()> { + let expr = " + x 2 + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "x do kwadratu")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "x do potęgi drugiej")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "x do potęgi drugiej")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "x do potęgi 2")?; + + return Ok(()); + +} + +#[test] +fn cubed() -> Result<()> { + let expr = " + x 3 + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "x do sześcianu")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "x do potęgi trzeciej")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "x do potęgi trzeciej")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "x do potęgi 3")?; + return Ok(()); + +} + +#[test] +fn ordinal_power() -> Result<()> { + let expr = " + 3 5 + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "3 do potęgi piątej")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "3 do potęgi piątej")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "3 do potęgi piątej")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "3 do potęgi 5")?; + return Ok(()); + +} + + +#[test] +fn zero_power() -> Result<()> { + let expr = " + 3 0 + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "3 do potęgi 0")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "3 do potęgi 0")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "3 do potęgi 0")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "3 do potęgi 0")?; + return Ok(()); + +} + +#[test] +fn simple_mi_power() -> Result<()> { + let expr = " + 4 x + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "4 do potęgi x")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "4 do potęgi x")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "4 do potęgi x")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "4 do potęgi x")?; + return Ok(()); + +} + +#[test] +fn decimal_power() -> Result<()> { + let expr = " + 3 5.0 + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "3 do potęgi 50")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "3 do potęgi 50")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "3 do potęgi 50")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "3 do potęgi 50")?; + return Ok(()); + +} + +#[test] +fn non_simple_power() -> Result<()> { + let expr = " + 3 y+2 + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "3 do potęgi y plus 2")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "3 do potęgi y plus 2")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "3 do potęgi y plus 2")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "3 do potęgi y plus 2")?; + return Ok(()); + +} + +#[test] +fn negative_power() -> Result<()> { + let expr = " + 3 - 2 + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "3 do potęgi minus 2")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "3 do potęgi minus 2")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "3 do potęgi minus 2")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "3 do potęgi minus 2")?; + return Ok(()); + +} + +#[test] +fn simple_fraction_power() -> Result<()> { + let expr = " + + x + 13 + + "; + test("pl", "ClearSpeak", expr, "x do potęgi jedna trzecia")?; + return Ok(()); + +} + +#[test] +fn nested_squared_power_with_coef() -> Result<()> { + let expr = " + + + 3 + + 2 + + x + 2 + + + + + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "3 do potęgi 2 x do kwadratu")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "3 do wykładnika, 2 x do potęgi drugiej, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "3 do wykładnika, 2 x do potęgi drugiej, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "3 do wykładnika, 2 x do potęgi 2; koniec wykładnika")?; + + return Ok(()); + +} + +#[test] +fn nested_squared_power_with_neg_coef() -> Result<()> { + let expr = " + + + 3 + + - + 2 + + x + 2 + + + + + "; + test("pl", "ClearSpeak", expr, "3 do potęgi minus 2 x do kwadratu")?; + return Ok(()); + +} + + +#[test] +fn nested_cubed_power() -> Result<()> { + let expr = " + + y + + 45 + 3 + + + "; + test("pl", "ClearSpeak", expr, "y do potęgi 4 piąte do sześcianu")?; + return Ok(()); + +} + +#[test] +fn nested_cubed_power_with_neg_base() -> Result<()> { + let expr = " + + y + + - + + 45 + 3 + + + + "; + test("pl", "ClearSpeak", expr, "y do potęgi minus 4 piąte do sześcianu")?; + return Ok(()); + +} + +#[test] +fn nested_number_times_squared() -> Result<()> { + let expr = " + + + e + + + 1 + 2 + + + x + 2 + + + + + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "e do potęgi jedna druga x do kwadratu")?; + return Ok(()); + +} + +#[test] +fn nested_negative_number_times_squared() -> Result<()> { + let expr = " + + + e + + − + 1 + 2 + + + x + 2 + + + + + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "e do potęgi minus jedna druga x do kwadratu")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "e do wykładnika, minus jedna druga x do potęgi drugiej, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "e do wykładnika, minus jedna druga x do potęgi drugiej, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "e do wykładnika, minus jedna druga x do potęgi 2; koniec wykładnika")?; + return Ok(()); + +} + +#[test] +fn nested_expr_to_tenth() -> Result<()> { + let expr = " + + + 3 + + + 3 + + 10 + + + + + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "3 do wykładnika, 3 do potęgi dziesiątej, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "3 do wykładnika, 3 do potęgi dziesiątej, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "3 do wykładnika, 3 do potęgi dziesiątej, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "3 do wykładnika, 3 do potęgi 10; koniec wykładnika")?; + + return Ok(()); + +} + +#[test] +fn nested_non_simple_squared_exp() -> Result<()> { + let expr = " + + + 3 + + + + ( + + x+1 + ) + 2 + + + + + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, "3 do wykładnika, nawias otwierający, x plus 1, nawias zamykający do kwadratu, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, "3 do wykładnika, nawias otwierający, x plus 1, nawias zamykający do potęgi drugiej, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, "3 do wykładnika, nawias otwierający, x plus 1, nawias zamykający do potęgi drugiej, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, "3 do wykładnika, nawias otwierający, x plus 1, nawias zamykający do potęgi 2; koniec wykładnika")?; + return Ok(()); + +} + +#[test] +fn nested_default_power() -> Result<()> { + let expr = " + + t + + 45 + n + + +"; + test("pl", "ClearSpeak", expr, "t do wykładnika, 4 piąte do potęgi n, koniec wykładnika")?; + return Ok(()); + +} + +#[test] +fn nested_complex_power() -> Result<()> { + let expr = " + + + e + + − + 1 + 2 + + + + ( + + + + x−μ + σ + + + ) + 2 + + + + + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Auto")], expr, + "e do wykładnika, minus jedna druga razy; nawias otwierający; ułamek z licznikiem; x minus mi; i mianownikiem sigma; nawias zamykający do kwadratu, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "Ordinal")], expr, + "e do wykładnika, minus jedna druga razy; nawias otwierający; ułamek z licznikiem; x minus mi; i mianownikiem sigma; nawias zamykający do potęgi drugiej, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "OrdinalPower")], expr, + "e do wykładnika, minus jedna druga razy; nawias otwierający; ułamek z licznikiem; x minus mi; i mianownikiem sigma; nawias zamykający do potęgi drugiej, koniec wykładnika")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_Exponents", "AfterPower")], expr, + "e do wykładnika, minus jedna druga razy; nawias otwierający; ułamek z licznikiem; x minus mi; i mianownikiem sigma; nawias zamykający do potęgi 2; koniec wykładnika")?; + return Ok(()); + +} + +#[test] +fn default_power() -> Result<()> { + let expr = " + + t + + b+1 + 3 + + + "; + test("pl", "ClearSpeak", expr, "t do potęgi ułamek z licznikiem; b plus 1; i mianownikiem 3")?; + return Ok(()); + +} diff --git a/tests/Languages/pl/ClearSpeak/multiline.rs b/tests/Languages/pl/ClearSpeak/multiline.rs new file mode 100644 index 00000000..b57c8c6b --- /dev/null +++ b/tests/Languages/pl/ClearSpeak/multiline.rs @@ -0,0 +1,173 @@ +use crate::common::*; +use anyhow::Result; + + +#[test] +fn case_1() -> Result<()> { + let expr = " + f + + ( + x + ) + + = + + { + + -1ifx<0 + 0ifx=0 + 1ifx>0 + + + + "; + test_ClearSpeak("pl", "ClearSpeak_MultiLineLabel", "Auto", expr, + "f z x równa się; 3 przypadki; przypadek 1; minus 1 if x jest mniejsze niż 0; przypadek 2; 0 if x równa się 0; przypadek 3; 1 if x jest większe niż 0" + )?; + return Ok(()); +} + +#[test] +fn equation_auto() -> Result<()> { + let expr = " + + + x+y = 7 + 2x+3y = 17 + + + "; + test_ClearSpeak("pl", "ClearSpeak_MultiLineLabel", "Auto", expr, + "2 linie; linia 1; x plus y, równa się 7; linia 2; 2 x plus 3 y; równa się 17")?; + return Ok(()); +} + + +#[test] +fn equation_plus_at_start() -> Result<()> { + let expr = " + + + x+y = 7 + 2x+3y = 17 + + + "; + test_ClearSpeak("pl", "ClearSpeak_MultiLineLabel", "Auto", expr, "2 linie; linia 1; x plus y równa się 7; linia 2; 2 x, plus 3 y, równa się 17")?; + return Ok(()); +} + +#[test] +fn equation_case() -> Result<()> { + let expr = " + + + x+y = 7 + 2x+3y = 17 + + + "; + test_ClearSpeak("pl", "ClearSpeak_MultiLineLabel", "Case", expr, + "2 przypadki; przypadek 1; x plus y, równa się 7; przypadek 2; 2 x plus 3 y; równa się 17")?; + return Ok(()); +} + +#[test] +fn equation_constraint() -> Result<()> { + let expr = " + + + x+y = 7 + 2x+3y = 17 + + + "; + test_ClearSpeak("pl", "ClearSpeak_MultiLineLabel", "Constraint", expr, "2 warunki; warunek 1; x plus y, równa się 7; warunek 2; 2 x plus 3 y; równa się 17")?; + return Ok(()); +} + +#[test] +fn equation_equation() -> Result<()> { + let expr = " + + + x+y = 7 + 2x+3y = 17 + + + "; + test_ClearSpeak("pl", "ClearSpeak_MultiLineLabel", "Equation", expr, "2 równania; równanie 1; x plus y, równa się 7; równanie 2; 2 x plus 3 y; równa się 17")?; + return Ok(()); +} + +#[test] +fn equation_line() -> Result<()> { + let expr = " + + + x+y = 7 + 2x+3y = 17 + + + "; + test_ClearSpeak("pl", "ClearSpeak_MultiLineLabel", "Line", expr, "2 linie; linia 1; x plus y, równa się 7; linia 2; 2 x plus 3 y; równa się 17")?; + return Ok(()); +} + +#[test] +fn equation_none() -> Result<()> { + let expr = " + + + x+y = 7 + 2x+3y = 17 + + + "; + test_ClearSpeak("pl", "ClearSpeak_MultiLineLabel", "None", expr, + "2 linie; x plus y, równa się 7; 2 x plus 3 y; równa się 17")?; + return Ok(()); +} + +#[test] +fn equation_row() -> Result<()> { + let expr = " + + + x+y = 7 + 2x+3y = 17 + + + "; + test_ClearSpeak("pl", "ClearSpeak_MultiLineLabel", "Row", expr, "2 wiersze; wiersz 1; x plus y, równa się 7; wiersz 2; 2 x plus 3 y; równa się 17")?; + return Ok(()); +} + +#[test] +fn equation_step() -> Result<()> { + let expr = " + + + x+y = 7 + 2x+3y = 17 + + + "; + test_ClearSpeak("pl", "ClearSpeak_MultiLineLabel", "Step", expr, "2 kroki; krok 1; x plus y, równa się 7; krok 2; 2 x plus 3 y; równa się 17")?; + return Ok(()); +} + +#[test] +fn continued_row() -> Result<()> { + let expr = " + + x=y + +1 + y=1 + +"; +test("pl", "SimpleSpeak", expr, + "2 równania; równanie 1; x równa się y plus 1; równanie 2; y równa się 1")?; + return Ok(()); +} diff --git a/tests/Languages/pl/ClearSpeak/sets.rs b/tests/Languages/pl/ClearSpeak/sets.rs new file mode 100644 index 00000000..93a3dd77 --- /dev/null +++ b/tests/Languages/pl/ClearSpeak/sets.rs @@ -0,0 +1,531 @@ +use crate::common::*; +use anyhow::Result; + +#[test] +fn complex() -> Result<()> { + let expr = " + ℂ + "; + test("pl", "ClearSpeak", expr, "liczby zespolone")?; + return Ok(()); + +} + +#[test] +fn natural() -> Result<()> { + let expr = " + ℕ + "; + test("pl", "ClearSpeak", expr, "liczby naturalne")?; + return Ok(()); + +} + +#[test] +fn rationals() -> Result<()> { + let expr = " + ℚ + "; + test("pl", "ClearSpeak", expr, "liczby wymierne")?; + return Ok(()); + +} + +#[test] +fn reals() -> Result<()> { + let expr = " + ℝ + "; + test("pl", "ClearSpeak", expr, "liczby rzeczywiste")?; + return Ok(()); + +} + +#[test] +fn integers() -> Result<()> { + let expr = " + ℤ + "; + test("pl", "ClearSpeak", expr, "liczby całkowite")?; + return Ok(()); + +} + + + +#[test] +fn msup_complex() -> Result<()> { + let expr = " + + ℂ + 2 + + "; + test("pl", "ClearSpeak", expr, "C 2")?; + return Ok(()); + +} + +#[test] +fn msup_natural() -> Result<()> { + let expr = " + + ℕ + 2 + + "; + test("pl", "ClearSpeak", expr, "N 2")?; + return Ok(()); + +} + +#[test] +fn msup_rationals() -> Result<()> { + let expr = " + + ℚ + 2 + + "; + test("pl", "ClearSpeak", expr, "Q 2")?; + return Ok(()); + +} + +#[test] +fn msup_reals() -> Result<()> { + let expr = " + + ℝ + 3 + + "; + test("pl", "ClearSpeak", expr, "R 3")?; + return Ok(()); + +} + +#[test] +fn msup_integers() -> Result<()> { + let expr = " + + ℤ + 4 + + "; + test("pl", "ClearSpeak", expr, "Z 4")?; + return Ok(()); + +} + +#[test] +fn msup_positive_integers() -> Result<()> { + let expr = " + + ℤ + + + + "; + test("pl", "ClearSpeak", expr, "plus liczby całkowite")?; + return Ok(()); + +} + +#[test] +fn msup_negative_integers() -> Result<()> { + let expr = " + + ℤ + - + + "; + test("pl", "ClearSpeak", expr, "minus liczby całkowite")?; + return Ok(()); + +} + +#[test] +fn msup_positive_rationals() -> Result<()> { + let expr = " + + ℚ + + + + "; + test("pl", "ClearSpeak", expr, "plus liczby wymierne")?; + return Ok(()); + +} + +#[test] +fn msup_negative_rationals() -> Result<()> { + let expr = " + + ℚ + - + + "; + test("pl", "ClearSpeak", expr, "minus liczby wymierne")?; + return Ok(()); + +} + +#[test] +fn empty_set() -> Result<()> { + let expr = " + { } + "; + test("pl", "ClearSpeak", expr, "zbiór pusty")?; + return Ok(()); + +} + +#[test] +fn single_element_set() -> Result<()> { + let expr = " + { 12} + "; + test("pl", "ClearSpeak", expr, "zbiór 12")?; + return Ok(()); + +} + +#[test] +fn multiple_element_set() -> Result<()> { + let expr = " + { 5 , 10 , 15 } + "; + test("pl", "ClearSpeak", expr, "zbiór 5 przecinek, 10 przecinek, 15")?; + return Ok(()); + +} + +#[test] +fn set_with_colon() -> Result<()> { + let expr = " + { x:x>2 } + "; + test("pl", "ClearSpeak", expr, "zbiór wszystkie x takich że x jest większe niż 2")?; + return Ok(()); + +} + +#[test] +fn set_with_bar() -> Result<()> { + let expr = " + { x|x>2 } + "; + test("pl", "ClearSpeak", expr, "zbiór wszystkie x takich że x jest większe niż 2")?; + return Ok(()); + +} + +#[test] +fn element_alone() -> Result<()> { + let expr = " + 3+2i∉ℝ + "; + test("pl", "ClearSpeak", expr, "3 plus 2 i, nie jest elementem zbioru, liczby rzeczywiste")?; + return Ok(()); + +} + +#[test] +fn element_under_sum() -> Result<()> { + let expr = " + + ∑ + i ∈ ℤ + + + 1 + i 2 + + "; + test("pl", "ClearSpeak", expr, + "suma przez i jest elementem zbioru, liczby całkowite z; ułamek z licznikiem 1; i mianownikiem i do kwadratu")?; + return Ok(()); + +} + +#[test] +fn complicated_set_with_colon() -> Result<()> { + let expr = " + { + x + ∈ + ℤ + : + 2 + < + x + < + 7 + } + "; + test("pl", "ClearSpeak", expr, "zbiór wszystkie x do liczby całkowite takich że 2 jest mniejsze niż x jest mniejsze niż 7")?; + return Ok(()); + +} + +#[test] +fn complicated_set_with_mtext() -> Result<()> { + // as of 8/5/21, parsing of "|" is problematic in the example, so are needed for this test + let expr = " + { + x∈ℕ + | + x is an even number + } + "; + test("pl", "ClearSpeak", expr, + "zbiór wszystkie x do liczby naturalne takich że x is an even number")?; + return Ok(()); + +} + + +#[test] +fn set_with_bar_member() -> Result<()> { + let expr = " + { + x + ∈ + ℤ + : + x + > + 5 + } + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "Member", + expr, "zbiór wszystkie x element zbioru liczby całkowite takich że x jest większe niż 5")?; + return Ok(()); + +} + +#[test] +fn element_alone_member() -> Result<()> { + let expr = " + 3+2i∉ℝ + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "Member", + expr, "3 plus 2 i, nie jest elementem zbioru, liczby rzeczywiste")?; + return Ok(()); + +} + +#[test] +fn element_under_sum_member() -> Result<()> { + let expr = " + + ∑ + i ∈ ℤ + + + 1 + i 2 + + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "Member", + expr, "suma przez i jest elementem zbioru, liczby całkowite z; ułamek z licznikiem 1; i mianownikiem i do kwadratu")?; + return Ok(()); + +} + + +#[test] +fn set_with_bar_element() -> Result<()> { + let expr = " + { + x + ∈ + ℤ + : + x + > + 5 + } + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "Element", + expr, "zbiór wszystkie x należy do liczby całkowite takich że x jest większe niż 5")?; + return Ok(()); + +} + +#[test] +fn element_alone_element() -> Result<()> { + let expr = " + 3+2i∉ℝ + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "Element", + expr, "3 plus 2 i, nie jest elementem zbioru, liczby rzeczywiste")?; + return Ok(()); + +} + +#[test] +fn element_under_sum_element() -> Result<()> { + let expr = " + + ∑ + i ∈ ℤ + + + 1 + i 2 + + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "Element", + expr, "suma przez i jest elementem zbioru, liczby całkowite z; ułamek z licznikiem 1; i mianownikiem i do kwadratu")?; + return Ok(()); + +} + +#[test] +fn set_with_bar_in() -> Result<()> { + let expr = " + { + x + ∈ + ℤ + : + x + > + 5 + } + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "In", + expr, "zbiór wszystkie x do liczby całkowite takich że x jest większe niż 5")?; + return Ok(()); + +} + +#[test] +fn element_alone_in() -> Result<()> { + let expr = " + 3+2i∉ℝ + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "In", + expr, "3 plus 2 i, nie należy do liczby rzeczywiste")?; + return Ok(()); + +} + +#[test] +fn element_under_sum_in() -> Result<()> { + let expr = " + + ∑ + i ∈ ℤ + + + 1 + i 2 + + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "In", + expr, "suma przez i należy do liczby całkowite z; ułamek z licznikiem 1; i mianownikiem i do kwadratu")?; + return Ok(()); + +} + +#[test] +fn set_with_bar_belongs() -> Result<()> { + let expr = " + { + x + ∈ + ℤ + : + x + > + 5 + } + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "Belongs", + expr, "zbiór wszystkie x należące do liczby całkowite takich że x jest większe niż 5")?; + return Ok(()); + +} + +#[test] +fn element_alone_belongs() -> Result<()> { + let expr = " + 3+2i∉ℝ + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "Belongs", + expr, "3 plus 2 i, nie należy do liczby rzeczywiste")?; + return Ok(()); + +} + +#[test] +fn element_under_sum_belongs() -> Result<()> { + let expr = " + + ∑ + i ∈ ℤ + + + 1 + i 2 + + "; + test_ClearSpeak("pl", "ClearSpeak_SetMemberSymbol", "Belongs", + expr, "suma przez i należy do liczby całkowite z; ułamek z licznikiem 1; i mianownikiem i do kwadratu")?; + return Ok(()); + +} + + +#[test] +fn set_member_woall() -> Result<()> { + let expr = " + { + x + ∈ + ℤ + : + x + > + 5 + } + "; + test_ClearSpeak_prefs("pl", vec![("ClearSpeak_SetMemberSymbol", "Member"), ("ClearSpeak_Sets", "woAll")], + expr, "zbiór x element zbioru liczby całkowite takich że x jest większe niż 5")?; + return Ok(()); + +} + +#[test] +fn multiple_element_set_woall() -> Result<()> { + let expr = " + { 5 , 10 , 15 } + "; + test_ClearSpeak("pl", "ClearSpeak_Sets", "woAll", expr, "zbiór 5 przecinek, 10 przecinek, 15")?; + return Ok(()); + +} + +#[test] +fn multiple_element_set_silent_bracket() -> Result<()> { + let expr = " + { 5 , 10 , 15 } + "; + test_ClearSpeak("pl", "ClearSpeak_Sets", "SilentBracket", expr, "5 przecinek, 10 przecinek, 15")?; + return Ok(()); + + } + +#[test] +fn silent_bracket() -> Result<()> { + let expr = " + {x|x>2} + "; + test_ClearSpeak("pl", "ClearSpeak_Sets", "SilentBracket", expr, + "zbiór wszystkie x takich że x jest większe niż 2")?; + return Ok(()); + + } + diff --git a/tests/Languages/pl/ClearSpeak/symbols_and_adornments.rs b/tests/Languages/pl/ClearSpeak/symbols_and_adornments.rs new file mode 100644 index 00000000..160e0fec --- /dev/null +++ b/tests/Languages/pl/ClearSpeak/symbols_and_adornments.rs @@ -0,0 +1,377 @@ +use crate::common::*; +use anyhow::Result; + +#[test] +fn multiplication() -> Result<()> { + let expr = " + 2×3 + "; + test("pl", "ClearSpeak", expr, "2 razy 3")?; + return Ok(()); + +} + +#[test] +fn multiplication_by() -> Result<()> { + let expr = " + 2×3 + "; + test_ClearSpeak("pl", "ClearSpeak_MultSymbolX", "By", expr, "2 na 3")?; + return Ok(()); + +} + +#[test] +fn multiplication_cross() -> Result<()> { + let expr = " + u×v + "; + test_ClearSpeak("pl", "ClearSpeak_MultSymbolX", "Cross", expr, "u krzyż v")?; + return Ok(()); + +} + +#[test] +fn ellipses_auto_start() -> Result<()> { + let expr = " + …, + -2,-1,0 + "; + test("pl", "ClearSpeak", expr, "trzy kropki przecinek, minus 2 przecinek, minus 1 przecinek, 0")?; + return Ok(()); + +} + +#[test] +fn ellipses_auto_end() -> Result<()> { + let expr = " + 1 + , + 2 + , + 3 + , + … + "; + test_ClearSpeak("pl", "ClearSpeak_Ellipses", "Auto", expr, "1 przecinek, 2 przecinek, 3 przecinek, trzy kropki")?; + return Ok(()); + +} + +#[test] +fn ellipses_auto_middle() -> Result<()> { + let expr = " + + 1 + , + 2 + , + 3 + , + … + , + 20 + + "; + test_ClearSpeak("pl", "ClearSpeak_Ellipses", "Auto", expr, + "1 przecinek, 2 przecinek, 3 przecinek, trzy kropki przecinek, 20")?; + return Ok(()); + +} + +#[test] +fn ellipses_auto_both() -> Result<()> { + let expr = " + …, + -2,-1,0,1,2 + ,… + "; + test_ClearSpeak("pl", "ClearSpeak_Ellipses", "Auto", expr, + "trzy kropki przecinek, minus 2 przecinek, minus 1 przecinek, 0 przecinek, 1 przecinek, 2 przecinek, trzy kropki")?; + return Ok(()); + +} + +#[test] +fn ellipses_and_so_on_start() -> Result<()> { + let expr = " + …, + -2,-1,0 + "; + test_ClearSpeak("pl", "ClearSpeak_Ellipses", "AndSoOn", expr, "trzy kropki przecinek, minus 2 przecinek, minus 1 przecinek, 0")?; + return Ok(()); + +} + +#[test] +fn ellipses_and_so_on_end() -> Result<()> { + let expr = " + 1 + , + 2 + , + 3 + , + … + "; + test_ClearSpeak("pl", "ClearSpeak_Ellipses", "AndSoOn", expr, "1 przecinek, 2 przecinek, 3 i tak dalej")?; + return Ok(()); + +} + +#[test] +fn ellipses_and_so_on_middle() -> Result<()> { + let expr = " + + 1 + , + 2 + , + 3 + , + … + , + 20 + + "; + test_ClearSpeak("pl", "ClearSpeak_Ellipses", "AndSoOn", expr, + "1 przecinek, 2 przecinek, 3 i tak dalej aż do 20")?; + return Ok(()); + +} + +#[test] +fn ellipses_and_so_on_both() -> Result<()> { + let expr = " + …, + -2,-1,0,1,2 + ,… + "; + test_ClearSpeak("pl", "ClearSpeak_Ellipses", "AndSoOn", expr, + "trzy kropki przecinek, minus 2 przecinek, minus 1 przecinek, 0 przecinek, 1 przecinek, 2 przecinek, trzy kropki")?; + return Ok(()); + +} + +#[test] +fn vertical_line_auto() -> Result<()> { + let expr = " + 3|6 + "; + test_ClearSpeak("pl", "ClearSpeak_VerticalLine", "Auto", expr, + "3 dzieli 6")?; + return Ok(()); + +} + +#[test] +fn vertical_line_divides() -> Result<()> { + let expr = " + 3|6 + "; + test_ClearSpeak("pl", "ClearSpeak_VerticalLine", "Divides", expr, + "3 dzieli 6")?; + return Ok(()); + +} + + #[test] + fn vertical_line_given() -> Result<()> { + let expr = " + 3|6 + "; + test_ClearSpeak("pl", "ClearSpeak_VerticalLine", "Given", expr, + "3 pod warunkiem 6")?; + return Ok(()); + + } + + #[test] + fn vertical_line_probability_given() -> Result<()> { + let expr = " + P + + ( + + A + | + B + + ) + + "; + test_ClearSpeak_prefs("pl", vec![("ClearSpeak_VerticalLine", "Given"), ("ClearSpeak_ImpliedTimes", "None")] + , expr, "wielka p; nawias otwierający, wielka a pod warunkiem wielka b; nawias zamykający")?; + return Ok(()); + } + +#[test] +fn vertical_line_set() -> Result<()> { + let expr = " + { + + x + | + x + > + 0 + + } + "; + test_ClearSpeak("pl", "ClearSpeak_VerticalLine", "Auto", expr, + "zbiór wszystkie x takich że x jest większe niż 0")?; + return Ok(()); + +} + + +#[test] +fn vertical_line_set_such_that() -> Result<()> { + let expr = " + { + + x + | + x + > + 0 + + } + "; + test_ClearSpeak("pl", "ClearSpeak_VerticalLine", "SuchThat", expr, + "zbiór wszystkie x takich że x jest większe niż 0")?; + return Ok(()); + +} + +#[test] +fn vertical_line_set_given() -> Result<()> { + let expr = " + { + + x + | + x + > + 0 + + } + "; + // the rules for set will override all the options -- ClearSpeak spec should be clarified + test_ClearSpeak("pl", "ClearSpeak_VerticalLine", "Given", expr, + "zbiór wszystkie x takich że x jest większe niż 0")?; + return Ok(()); + +} + +#[test] +fn vertical_line_set_and_abs() -> Result<()> { + let expr = " + { + + x + | + + | + x + | + + > + 2 + + } + "; + test_ClearSpeak("pl", "ClearSpeak_VerticalLine", "Auto", expr, + "zbiór wszystkie x takich że wartość bezwzględna z x; jest większe niż 2")?; + return Ok(()); + +} + +#[test] +fn vertical_line_evaluated_at() -> Result<()> { + let expr = " + f + + ( + x + ) + + + | + + x + = + 5 + + + "; + test_ClearSpeak("pl", "ClearSpeak_VerticalLine", "Auto", expr, + "f z x obliczone w, x równa się 5")?; + return Ok(()); + +} + +#[test] +fn vertical_line_evaluated_at_both() -> Result<()> { + let expr = " + + x + 2 + + + + x + + | + 0 + 1 + + "; + test_ClearSpeak("pl", "ClearSpeak_VerticalLine", "Auto", expr, + "x do kwadratu plus x, obliczone w 1 minus to samo wyrażenie obliczone w 0")?; + return Ok(()); + +} +#[test] +fn vertical_line_evaluated_at_divides() -> Result<()> { + let expr = " + f + + ( + x + ) + + + | + + x + = + 5 + + + "; + test_ClearSpeak("pl", "ClearSpeak_VerticalLine", "Divides", expr, + "f z x obliczone w, x równa się 5")?; + return Ok(()); + +} + +#[test] +fn vertical_line_evaluated_at_both_given() -> Result<()> { + let expr = " + + x + 2 + + + + x + + | + 0 + 1 + + "; + test_ClearSpeak("pl", "ClearSpeak_VerticalLine", "Given", expr, + "x do kwadratu plus x, obliczone w 1 minus to samo wyrażenie obliczone w 0")?; + return Ok(()); + +} \ No newline at end of file diff --git a/tests/Languages/pl/SimpleSpeak/functions.rs b/tests/Languages/pl/SimpleSpeak/functions.rs new file mode 100644 index 00000000..d7e6f53c --- /dev/null +++ b/tests/Languages/pl/SimpleSpeak/functions.rs @@ -0,0 +1,412 @@ +/// Tests for: +/// * functions including trig functions, logs, and functions to powers +/// * implied times/functional call and explicit times/function call +/// * parens +/// These are all intertwined, so they are in one file +use crate::common::*; +use anyhow::Result; + +#[test] +fn trig_names() -> Result<()> { + let expr = " + sinx+ + cosy+ + tanz+ + secα+ + cscϕ+ + cotφ + "; + test("pl", "SimpleSpeak", expr, "sinus z x plus cosinus z y plus tangens z z plus sekans z alfa, plus kosekans z fi plus cotangens z fi")?; + return Ok(()); + +} + +#[test] +fn hyperbolic_trig_names() -> Result<()> { + let expr = " + sinhx+ + coshy+ + tanhz+ + sechα+ + cschϕ+ + cothφ + "; + test("pl", "SimpleSpeak", expr, "sinus hiperboliczny z x, plus cosinus hiperboliczny z y, plus tangens hiperboliczny z z, plus sekans hiperboliczny z alfa, plus kosekans hiperboliczny z fi, plus cotangens hiperboliczny z fi")?; + return Ok(()); + +} + + +#[test] +fn inverse_trig() -> Result<()> { + let expr = "sin-1x"; + test("pl", "SimpleSpeak", expr, "odwrotność sinus z x")?; + return Ok(()); + +} + +#[test] +fn trig_squared() -> Result<()> { + let expr = "sin2x"; + test("pl", "SimpleSpeak", expr, "sinus do kwadratu z x")?; + return Ok(()); + +} + +#[test] +fn trig_cubed() -> Result<()> { + let expr = "tan3x"; + test("pl", "SimpleSpeak", expr, "tangens do sześcianu z x")?; + return Ok(()); + +} + +#[test] +fn trig_fourth() -> Result<()> { + let expr = "sec4x"; + test("pl", "SimpleSpeak", expr, "sekans do potęgi czwartej, z x")?; + return Ok(()); + +} + + +#[test] +fn trig_power_other() -> Result<()> { + let expr = "sinh>n-1x"; + test("pl", "SimpleSpeak", expr, "sinus hiperboliczny do potęgi n minus 1, z x")?; + return Ok(()); + +} + +#[test] +fn simple_log() -> Result<()> { + let expr = " logx "; + test("pl", "SimpleSpeak", expr, "logarytm z x")?; + return Ok(()); + +} + +#[test] +fn principal_value_log() -> Result<()> { + let expr = "Logz"; + test("pl", "SimpleSpeak", expr, "Log z z")?; + return Ok(()); + +} + +#[test] +fn normal_log() -> Result<()> { + let expr = "log(x+y)"; + test("pl", "SimpleSpeak", expr, "logarytm z, nawias otwierający, x plus y, nawias zamykający")?; + return Ok(()); + +} + +#[test] +fn simple_log_with_base() -> Result<()> { + let expr = " logbx "; + test("pl", "SimpleSpeak", expr, "logarytm o podstawie b, z x")?; + return Ok(()); + +} + +#[test] +fn normal_log_with_base() -> Result<()> { + let expr = "logb(x+y)"; + test("pl", "SimpleSpeak", expr, "logarytm o podstawie b, z, nawias otwierający, x plus y, nawias zamykający")?; + return Ok(()); + +} + +#[test] +fn normal_ln() -> Result<()> { + let expr = "ln(x+y)"; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "l n, otwórz x plus y zamknij")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Medium")], + expr, "logarytm naturalny z, nawias otwierający, x plus y, nawias zamykający")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], + expr, "logarytm naturalny z, nawias otwierający, x plus y, nawias zamykający")?; + return Ok(()); + +} + +#[test] +fn simple_ln() -> Result<()> { + let expr = " lnx "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "l n x")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Medium")], + expr, "logarytm naturalny z x")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], + expr, "logarytm naturalny z x")?; + return Ok(()); + +} + +#[test] +fn other_names() -> Result<()> { + let expr = " Covx "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "kowariancja x")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Medium")], + expr, "kowariancja x")?; + let expr = " exp(x) "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "eksponenta x")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Medium")], + expr, "funkcja wykładnicza z x")?; + return Ok(()); + +} + +#[test] +fn explicit_function_call_with_parens() -> Result<()> { + let expr = "t⁡(x)"; + test("pl", "SimpleSpeak", expr, "t z x")?; + return Ok(()); + +} + + +#[test] +fn explicit_times_with_parens() -> Result<()> { + let expr = "t⁢(x)"; + test("pl", "SimpleSpeak", expr, "t razy x")?; + return Ok(()); + +} + +#[test] +fn explicit_function_call() -> Result<()> { + let expr = "t⁡x"; + test("pl", "SimpleSpeak", expr, "t z x")?; + return Ok(()); + +} + +#[test] +fn explicit_times() -> Result<()> { + let expr = "t⁢x"; + test("pl", "SimpleSpeak", expr, "t x")?; + return Ok(()); + +} + + +/* + * Tests for times + */ +#[test] +fn no_times_binomial() -> Result<()> { + let expr = "x ⁢ y"; + test("pl", "SimpleSpeak", expr, "x y")?; + return Ok(()); + +} + +#[test] +fn times_following_paren() -> Result<()> { + let expr = " + 2 + ( 3 ) + "; + test("pl", "SimpleSpeak", expr, "2 razy 3")?; + return Ok(()); + +} + +#[test] +fn times_preceding_paren() -> Result<()> { + let expr = " + ( 2 ) + 3 + "; + test("pl", "SimpleSpeak", expr, "2 razy 3")?; + return Ok(()); + +} + +#[test] +fn no_times_sqrt() -> Result<()> { + let expr = " + a + b + = + ab + "; + test("pl", "SimpleSpeak", expr, + "pierwiastek kwadratowy z a; razy pierwiastek kwadratowy z b; równa się, pierwiastek kwadratowy z a b, koniec pierwiastka")?; + test_prefs("pl", "SimpleSpeak", vec![("Impairment", "LearningDisability")], expr, + "pierwiastek kwadratowy z a; razy pierwiastek kwadratowy z b; równa się, pierwiastek kwadratowy z a b")?; + return Ok(()); + +} + +/* + * Tests for parens + */ + #[test] + fn no_parens_number() -> Result<()> { + let expr = " + ( + 25 + ) + x + "; + test("pl", "SimpleSpeak", expr, "25 razy x")?; + return Ok(()); + + } + + #[test] + fn no_parens_monomial() -> Result<()> { + let expr = " + b + ( + xy + ) + "; + test("pl", "SimpleSpeak", expr, "b, nawias otwierający, x y nawias zamykający")?; + return Ok(()); + + } + + #[test] + fn no_parens_negative_number() -> Result<()> { + let expr = " + 2+ + ( + −2 + ) + "; + test("pl", "SimpleSpeak", expr, "2 plus minus 2")?; + return Ok(()); + + } + + + #[test] + fn no_parens_negative_number_with_var() -> Result<()> { + let expr = " + ( + −2x + ) + +1 + "; + test("pl", "SimpleSpeak", expr, "minus 2 x, plus 1")?; + return Ok(()); + + } + + #[test] + fn parens_superscript() -> Result<()> { + let expr = " + + + + ( + 2x + ) + 2 + + + "; + test("pl", "SimpleSpeak", expr, "nawias otwierający, 2 x nawias zamykający do kwadratu")?; + return Ok(()); + + } + + #[test] + fn no_parens_fraction() -> Result<()> { + let expr = " + 2 + + + + ( + 12 + ) + "; + test("pl", "SimpleSpeak", expr, "2 plus jedna druga")?; + return Ok(()); + + } + + + // Tests for the four types of intervals in SimpleSpeak + #[test] + fn parens_interval_open_open() -> Result<()> { + let expr = " + ( + (c,d) + ) + "; + test("pl", "SimpleSpeak",expr, "przedział otwarty od c do d")?; + return Ok(()); + +} + +#[test] + fn parens_interval_closed_open() -> Result<()> { + let expr = " + [ + [(]c,d) + ) + "; + test("pl", "SimpleSpeak",expr, "przedział lewostronnie domknięty prawostronnie otwarty od c do d")?; + return Ok(()); + +} + + +#[test] +fn parens_interval_open_closed() -> Result<()> { + let expr = " + ( + (c,d] + ] + "; + test("pl", "SimpleSpeak",expr,"przedział lewostronnie otwarty prawostronnie domknięty od c do d")?; + return Ok(()); + +} + + +#[test] +fn parens_interval_closed_closed() -> Result<()> { + let expr = " + [ + [(]c,d] + ] + "; + test("pl", "SimpleSpeak",expr, "przedział domknięty od c do d")?; + return Ok(()); + +} + + #[test] + fn parens_interval_neg_infinity_open_open() -> Result<()> { + let expr = " + ( + - ∞,d) + ) + "; + test("pl", "SimpleSpeak",expr, + "przedział otwarty od minus nieskończoność do d")?; + return Ok(()); + +} + + #[test] + fn parens_interval_neg_infinity_open_closed() -> Result<()> { + let expr = " + ( + - ∞,d] + ] + "; + test("pl", "SimpleSpeak",expr, + "przedział lewostronnie otwarty prawostronnie domknięty od minus nieskończoność do d")?; + return Ok(()); + +} + diff --git a/tests/Languages/pl/SimpleSpeak/geometry.rs b/tests/Languages/pl/SimpleSpeak/geometry.rs new file mode 100644 index 00000000..c4059be0 --- /dev/null +++ b/tests/Languages/pl/SimpleSpeak/geometry.rs @@ -0,0 +1,36 @@ +/// Tests for geometry listed in intent +/// ABC as mtext and as separated letters +use crate::common::*; +use anyhow::Result; + +#[test] +fn arc() -> Result<()> { + let expr = " BC⌒ "; + test("pl", "SimpleSpeak", expr, "łuk wielka b wielka c")?; + return Ok(()); + +} + +#[test] +fn ray() -> Result<()> { + let expr = " XY¯ "; + test("pl", "SimpleSpeak", expr, "odcinek wielka x wielka y")?; + return Ok(()); + +} + +#[test] +fn arc_mtext() -> Result<()> { + let expr = " BC⌒ "; + test("pl", "SimpleSpeak", expr, "łuk wielka b wielka c")?; + return Ok(()); + +} + +#[test] +fn ray_mtext() -> Result<()> { + let expr = " XY→ "; + test("pl", "SimpleSpeak", expr, "półprosta wielka x wielka y")?; + return Ok(()); + +} diff --git a/tests/Languages/pl/SimpleSpeak/large_ops.rs b/tests/Languages/pl/SimpleSpeak/large_ops.rs new file mode 100644 index 00000000..337a9304 --- /dev/null +++ b/tests/Languages/pl/SimpleSpeak/large_ops.rs @@ -0,0 +1,235 @@ +use crate::common::*; +use anyhow::Result; + +#[test] +fn sum_both() -> Result<()> { + let expr = " + + ∑ + n=1 + 10 + + n + "; + test("pl", "SimpleSpeak", expr, "suma od n równa się 1, do 10; n")?; + return Ok(()); + +} + +#[test] +fn sum_under() -> Result<()> { + let expr = " + + ∑ + S + + i + "; + test("pl", "SimpleSpeak", expr, "suma przez wielka s z i")?; + return Ok(()); + +} +#[test] +fn sum_both_msubsup() -> Result<()> { + let expr = " + + ∑ + n=1 + 10 + + n + "; + test("pl", "SimpleSpeak", expr, "suma od n równa się 1, do 10; n")?; + return Ok(()); + +} + +#[test] +fn sum_sub() -> Result<()> { + let expr = " + + ∑ + S + + i + "; + test("pl", "SimpleSpeak", expr, "suma przez wielka s z i")?; + return Ok(()); + +} + +#[test] +fn sum() -> Result<()> { + let expr = " + ∑ + ai + "; + test("pl", "SimpleSpeak", expr, "suma, a indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn product_both() -> Result<()> { + let expr = " + + ∏ + n=1 + 10 + + n + "; + test("pl", "SimpleSpeak", expr, "iloczyn od n równa się 1, do 10; n")?; + return Ok(()); + +} + +#[test] +fn product_under() -> Result<()> { + let expr = " + + ∏ + S + + i + "; + test("pl", "SimpleSpeak", expr, "iloczyn przez wielka s z i")?; + return Ok(()); + +} + +#[test] +fn product() -> Result<()> { + let expr = " + ∏ + ai + "; + test("pl", "SimpleSpeak", expr, "iloczyn, a indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn intersection_both() -> Result<()> { + let expr = " + + ⋂ + i=1 + 10 + + Si + "; + test("pl", "SimpleSpeak", expr, "przecięcie od i równa się 1, do 10; wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn intersection_under() -> Result<()> { + let expr = " + + ⋂ + C + + Si + "; + test("pl", "SimpleSpeak", expr, "przecięcie przez wielka c z, wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn intersection() -> Result<()> { + let expr = " + ⋂ + Si + "; + test("pl", "SimpleSpeak", expr, "przecięcie, wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn union_both() -> Result<()> { + let expr = " + + ⋃ + i=1 + 10 + + Si + "; + test("pl", "SimpleSpeak", expr, "suma zbiorów od i równa się 1, do 10; wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn union_under() -> Result<()> { + let expr = " + + ⋃ + C + + Si + "; + test("pl", "SimpleSpeak", expr, "suma zbiorów przez wielka c z, wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn union() -> Result<()> { + let expr = " + ⋃ + Si + "; + test("pl", "SimpleSpeak", expr, "suma zbiorów, wielka s indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn integral_both() -> Result<()> { + let expr = " + + + ∫ + 0 + 1 + + f(x ) + +  dx + "; + test("pl", "SimpleSpeak", expr, "całka od 0, do 1; f z x; d x")?; + return Ok(()); + +} + +#[test] +fn integral_under() -> Result<()> { + let expr = " + + ∫ + ℝ + + f(x ) + dx + "; + test("pl", "SimpleSpeak", expr, "całka przez liczby rzeczywiste z; f z x d x")?; + return Ok(()); + +} + +#[test] +fn integral() -> Result<()> { + let expr = " + ∫ + f(x ) + dx + "; + test("pl", "SimpleSpeak", expr, "całka, f z x d x")?; + return Ok(()); + +} \ No newline at end of file diff --git a/tests/Languages/pl/SimpleSpeak/linear_algebra.rs b/tests/Languages/pl/SimpleSpeak/linear_algebra.rs new file mode 100644 index 00000000..d090856d --- /dev/null +++ b/tests/Languages/pl/SimpleSpeak/linear_algebra.rs @@ -0,0 +1,111 @@ +use crate::common::*; +use anyhow::Result; + +#[test] +fn transpose() -> Result<()> { + let expr = " MT "; + test("pl", "SimpleSpeak", expr, "wielka m transponowane")?; + return Ok(()); + +} + +#[test] +fn trace() -> Result<()> { + let expr = " TrM "; + test("pl", "SimpleSpeak", expr, "ślad z wielka m")?; + return Ok(()); + +} + +#[test] +fn dimension() -> Result<()> { + let expr = " DimM "; + test("pl", "SimpleSpeak", expr, "wymiar z wielka m")?; + return Ok(()); + +} + +#[test] +fn homomorphism() -> Result<()> { + let expr = " Hom(M) "; + test("pl", "SimpleSpeak", expr, "homomorfizm z wielka m")?; + return Ok(()); + +} + +#[test] +fn kernel() -> Result<()> { + let expr = " ker(L) "; + test("pl", "SimpleSpeak", expr, "jądro z wielka l")?; + return Ok(()); + +} + +#[test] +fn norm() -> Result<()> { + let expr = " + + ∥ + f + ∥ + + +"; + test("pl", "SimpleSpeak", expr, "norma z f")?; + return Ok(()); + +} + +#[test] +fn norm_non_simple() -> Result<()> { + let expr = " + + ∥ + x + + + y + ∥ + + +"; + test("pl", "SimpleSpeak", expr, "norma z x plus y koniec normy")?; + return Ok(()); + +} + +#[test] +fn norm_subscripted() -> Result<()> { + let expr = " + + + ∥ + f + ∥ + + p + + +"; + test("pl", "SimpleSpeak", expr, "norma p z f")?; + return Ok(()); + +} + +#[test] +fn not_gradient() -> Result<()> { + // the nabla is at the end, so it can't be gradient because it doesn't operate on anything + let expr = r#" + ( + b + ⋅ + + ∇ + + ) + a + +"#; + test("pl", "SimpleSpeak", expr, "nawias otwierający, b razy nabla, nawias zamykający; razy a")?; + return Ok(()); + +} \ No newline at end of file diff --git a/tests/Languages/pl/SimpleSpeak/mfrac.rs b/tests/Languages/pl/SimpleSpeak/mfrac.rs new file mode 100644 index 00000000..2e84dc98 --- /dev/null +++ b/tests/Languages/pl/SimpleSpeak/mfrac.rs @@ -0,0 +1,356 @@ +/// Tests for fractions +/// includes simple fractions and more complex fractions +/// also tests mixed fractions (implicit and explicit) +use crate::common::*; +use anyhow::Result; + +#[test] +fn common_fraction_half() -> Result<()> { + let expr = " + 1 2 + "; + test("pl", "SimpleSpeak", expr, "jedna druga")?; + return Ok(()); + +} + +#[test] +fn common_fraction_thirds() -> Result<()> { + let expr = " + 2 3 + "; + test("pl", "SimpleSpeak", expr, "dwie trzecie")?; + return Ok(()); + +} + +#[test] +fn common_fraction_tenths() -> Result<()> { + let expr = " + 17 10 + "; + test("pl", "SimpleSpeak", expr, "17 dziesiąte")?; + return Ok(()); + +} + +#[test] +#[allow(non_snake_case)] +fn not_SimpleSpeak_common_fraction_tenths() -> Result<()> { + let expr = " + 89 10 + "; + test("pl", "SimpleSpeak", expr, "89 przez 10")?; + return Ok(()); + +} + +#[test] +fn non_simple_fraction() -> Result<()> { + let expr = " + + + + x+y + + x-y + + + + "; + test("pl", "SimpleSpeak", expr, "ułamek, x plus y, przez, x minus y, koniec ułamka")?; + return Ok(()); + +} + +#[test] +fn nested_fraction() -> Result<()> { + let expr = " + + + + x+ 1y + + x-y + + + + "; + test("pl", "SimpleSpeak", expr, "ułamek, x plus, ułamek, 1 przez y, koniec ułamka; przez, x minus y, koniec ułamka")?; + return Ok(()); + +} + + +#[test] +fn deeply_nested_fraction_msqrt() -> Result<()> { + let expr = " + + + + x+ 1y + + x-y + + + + "; + test("pl", "SimpleSpeak", expr, "ułamek, x plus, pierwiastek kwadratowy z 1 przez y; koniec pierwiastka; przez, x minus y, koniec ułamka")?; + return Ok(()); + +} + +#[test] +fn deeply_nested_fraction_mrow_msqrt() -> Result<()> { + let expr = " + + + + x+ 2+1y + + x-y + + + + "; + test("pl", "SimpleSpeak", expr, "ułamek, x plus; pierwiastek kwadratowy z 2 plus 1 przez y; koniec pierwiastka; przez, x minus y, koniec ułamka")?; + return Ok(()); + +} + +#[test] +fn numerator_simple_fraction() -> Result<()> { + let expr = " + + + + x + + x-y + + + + "; + test("pl", "SimpleSpeak", expr, "ułamek, x przez, x minus y, koniec ułamka")?; + return Ok(()); + +} + +#[test] +fn denominator_simple_fraction() -> Result<()> { + let expr = " + + + x-y + x + + + "; + test("pl", "SimpleSpeak", expr, "ułamek, x minus y, przez x, koniec ułamka")?; + return Ok(()); + +} + + +#[test] +fn frac_with_units() -> Result<()> { + let expr = " + + + 62 + + mi + hr + + + "; + test("pl", "SimpleSpeak", expr, "62 milas na godzina")?; + return Ok(()); + +} + +#[test] +fn singular_frac_with_units() -> Result<()> { + let expr = " + + + 1 + + gal + mi + + + "; + test("pl", "SimpleSpeak", expr, "1 galon na mila")?; + return Ok(()); + +} + +#[test] +fn number_in_numerator_with_units() -> Result<()> { + let expr = " + + + + 3 + gal + + mi + + "; + test("pl", "SimpleSpeak", expr, "3 galons na mila")?; + return Ok(()); + +} + +#[test] +fn units_with_powers() -> Result<()> { + let expr = " + + + 3 m + s2 + + "; + test("pl", "SimpleSpeak", expr, "3 metrs na sekunda do kwadratu")?; + return Ok(()); + +} + + +#[test] +fn mixed_number() -> Result<()> { + let expr = " + 3 + 1 2 + "; + test("pl", "SimpleSpeak", expr, "3 i jedna druga")?; + return Ok(()); + +} + +#[test] +fn explicit_mixed_number() -> Result<()> { + let expr = " + 3 + ⁤ + 1 8 + "; + test("pl", "SimpleSpeak", expr, "3 i jedna ósma")?; + return Ok(()); + +} + +#[test] +fn mixed_number_big() -> Result<()> { + let expr = " + 3 + 7 83 + "; + test("pl", "SimpleSpeak", expr, "3 i 7 osiemdziesiąt trzecich")?; + return Ok(()); + +} + +#[test] +fn simple_text() -> Result<()> { + let expr = " + rise run + "; + test("pl", "SimpleSpeak", expr, "rise przez run")?; + return Ok(()); + +} + +#[test] +fn number_and_text() -> Result<()> { + let expr = " + + + 2miles + + 3gallons + + "; + test("pl", "SimpleSpeak", expr, "ułamek, 2 miles, przez, 3 gallons, koniec ułamka")?; + return Ok(()); + +} + + +#[test] +fn nested_simple_fractions() -> Result<()> { + let expr = " + + + + + 1 + 2 + + + + + 2 + 3 + + + + + "; + test("pl", "SimpleSpeak", expr, "ułamek, jedna druga, przez, dwie trzecie, koniec ułamka")?; + return Ok(()); + +} + +#[test] +fn binomial() -> Result<()> { + let expr = " + 2 + ( + 7 3 + ) + "; + test("pl", "SimpleSpeak", expr, "2 razy 7 po 3")?; + return Ok(()); + +} + +#[test] +fn binomial_non_simple_top() -> Result<()> { + let expr = " + 2 + ( + n+7 3 + ) + "; + test("pl", "SimpleSpeak", expr, "2 razy, symbol newtona n plus 7 po 3")?; + return Ok(()); + +} + +#[test] +fn binomial_non_simple_bottom() -> Result<()> { + let expr = " + 2 + ( + 7 k+3 + ) + "; + test("pl", "SimpleSpeak", expr, "2 razy, 7 po k plus 3 koniec symbolu newtona")?; + return Ok(()); + +} + +#[test] +fn binomial_non_simple_top_and_bottom() -> Result<()> { + let expr = " + 2 + ( + n+7 k+3 + ) + "; + test("pl", "SimpleSpeak", expr, "2 razy; symbol newtona n plus 7 po k plus 3 koniec symbolu newtona")?; + return Ok(()); + +} diff --git a/tests/Languages/pl/SimpleSpeak/msup.rs b/tests/Languages/pl/SimpleSpeak/msup.rs new file mode 100644 index 00000000..4fdb0644 --- /dev/null +++ b/tests/Languages/pl/SimpleSpeak/msup.rs @@ -0,0 +1,379 @@ +/// Tests for superscripts +/// simple superscripts +/// complex/nested superscripts +use crate::common::*; +use anyhow::Result; + +#[test] +fn squared() -> Result<()> { + let expr = " + x 2 + "; + test("pl", "SimpleSpeak", expr, "x do kwadratu")?; + return Ok(()); + +} + +#[test] +fn cubed() -> Result<()> { + let expr = " + x 3 + "; + test("pl", "SimpleSpeak", expr, "x do sześcianu")?; + return Ok(()); + +} + +#[test] + fn ordinal_power() -> Result<()> { + let expr = " + x 4 + "; + test("pl", "SimpleSpeak", expr, "x do potęgi czwartej")?; + return Ok(()); + + } + +#[test] +fn simple_mi_power() -> Result<()> { + let expr = " + x n + "; + test("pl", "SimpleSpeak", expr, "x do potęgi n")?; + return Ok(()); + +} + +#[test] +fn zero_power() -> Result<()> { + let expr = " + x 0 + "; + test("pl", "SimpleSpeak", expr, "x do potęgi 0")?; + return Ok(()); + +} + + +#[test] +fn decimal_power() -> Result<()> { + let expr = " + x 2,0 + "; + test("pl", "SimpleSpeak", expr, "x do potęgi 2,0")?; + return Ok(()); + +} + +#[test] +fn non_simple_power() -> Result<()> { + let expr = " + + + 3 + + y+2 + + + "; + test("pl", "SimpleSpeak", expr, "3 do potęgi y plus 2")?; + return Ok(()); + +} + +#[test] +fn negative_power() -> Result<()> { + let expr = " + + x + - 2 + + "; + test("pl", "SimpleSpeak", expr, "x do potęgi minus 2")?; + return Ok(()); + +} + +#[test] +fn simple_fraction_power() -> Result<()> { + let expr = " + + x + 13 + + "; + test("pl", "SimpleSpeak", expr, "x do potęgi jedna trzecia")?; + return Ok(()); + +} + +#[test] +fn nested_squared_power_with_coef() -> Result<()> { + let expr = " + + + 3 + + 2 + + x + 2 + + + + + "; + test("pl", "SimpleSpeak", expr, "3 do potęgi 2 x do kwadratu")?; + return Ok(()); + +} + +#[test] +fn nested_squared_power_with_neg_coef() -> Result<()> { + let expr = " + + + 3 + + - + 2 + + x + 2 + + + + + "; + test("pl", "SimpleSpeak", expr, "3 do potęgi minus 2 x do kwadratu")?; + return Ok(()); + +} + + +#[test] +fn nested_cubed_power() -> Result<()> { + let expr = " + + y + + 45 + 3 + + + "; + test("pl", "SimpleSpeak", expr, "y do potęgi 4 piąte do sześcianu")?; + return Ok(()); + +} + +#[test] +fn nested_cubed_power_with_neg_base() -> Result<()> { + let expr = " + + y + + - + + 45 + 3 + + + + "; + test("pl", "SimpleSpeak", expr, "y do potęgi minus 4 piąte do sześcianu")?; + return Ok(()); + +} + +#[test] +fn nested_number_times_squared() -> Result<()> { + let expr = " + + + e + + + 1 + 2 + + + x + 2 + + + + + "; + test("pl", "SimpleSpeak", expr, "e do potęgi jedna druga x do kwadratu")?; + return Ok(()); + +} + +#[test] +fn nested_negative_number_times_squared() -> Result<()> { + let expr = " + + + e + + − + 1 + 2 + + + x + 2 + + + + + "; + test("pl", "SimpleSpeak", expr, "e do potęgi minus jedna druga, x do kwadratu")?; + return Ok(()); + +} + +#[test] +fn nested_expr_to_tenth() -> Result<()> { + let expr = " + + + 3 + + + 3 + + 10 + + + + + "; + test("pl", "SimpleSpeak", expr, "3 do potęgi 3 do potęgi dziesiątej")?; + return Ok(()); + +} + +#[test] +fn nested_non_simple_squared_exp() -> Result<()> { + let expr = " + + + 3 + + + + ( + + x+1 + ) + 2 + + + + + "; + test("pl", "SimpleSpeak", expr, "3 do potęgi nawias otwierający, x plus 1, nawias zamykający do kwadratu")?; + return Ok(()); + +} + +#[test] +fn nested_simple_power() -> Result<()> { + let expr = " + + t + + 45 + n + + + "; + test("pl", "SimpleSpeak", expr, "t do potęgi 4 piąte do potęgi n")?; + return Ok(()); + +} + +#[test] +fn nested_end_exponent_power() -> Result<()> { + let expr = " + + t + + 45 + n+1 + + + "; + test("pl", "SimpleSpeak", expr, "t do potęgi 4 piąte do potęgi n plus 1; koniec wykładnika")?; + test_prefs("pl", "SimpleSpeak", vec![("Impairment", "LearningDisability")], expr, + "t do potęgi 4 piąte do potęgi n plus 1")?; + return Ok(()); + +} + +#[test] +fn nested_end_exponent_neg_power() -> Result<()> { + let expr = " + + t + + 45 + -3 + + + "; + test("pl", "SimpleSpeak", expr, "t do potęgi 4 piąte do potęgi minus 3, koniec wykładnika")?; + return Ok(()); + +} + +#[test] +fn nested_complex_power() -> Result<()> { + let expr = " + + + e + + − + 1 + 2 + + + + ( + + + + x−μ + σ + + + ) + 2 + + + + + "; + test("pl", "SimpleSpeak", expr, "e do potęgi minus jedna druga razy; nawias otwierający; ułamek, x minus mi, przez sigma, koniec ułamka; nawias zamykający do kwadratu")?; + return Ok(()); + +} + +#[test] +fn default_power() -> Result<()> { + let expr = " + + t + + b+1 + 3 + + + "; + test("pl", "SimpleSpeak", expr, "t do potęgi ułamek, b plus 1, przez 3, koniec ułamka")?; + return Ok(()); + +} diff --git a/tests/Languages/pl/SimpleSpeak/multiline.rs b/tests/Languages/pl/SimpleSpeak/multiline.rs new file mode 100644 index 00000000..f2551e17 --- /dev/null +++ b/tests/Languages/pl/SimpleSpeak/multiline.rs @@ -0,0 +1,73 @@ +use crate::common::*; +use anyhow::Result; + +#[test] +fn case_1() -> Result<()> { + let expr = " + + f( + x + )={ + + + + + −1 if x<0 + + + + + + 0 if x=0 + + + + + + 1 if x>0 + + + + + "; + test("pl", "SimpleSpeak", expr, "f z x równa się; 3 przypadki; przypadek 1; minus 1 if x; jest mniejsze niż 0; przypadek 2; 0 if x, równa się 0; przypadek 3; 1 if x, jest większe niż 0")?; + return Ok(()); +} + +#[test] +fn equation_1() -> Result<()> { + let expr = " + + + + + + x+y + + + = + + + 7 + + + + + + 2x+3y + + + = + + + + 17 + + + + + + "; + test("pl", "SimpleSpeak", expr, "2 równania; równanie 1; x plus y, równa się 7; równanie 2; 2 x plus 3 y; równa się 17")?; + return Ok(()); +} diff --git a/tests/Languages/pl/SimpleSpeak/sets.rs b/tests/Languages/pl/SimpleSpeak/sets.rs new file mode 100644 index 00000000..43fe91db --- /dev/null +++ b/tests/Languages/pl/SimpleSpeak/sets.rs @@ -0,0 +1,285 @@ +use crate::common::*; +use anyhow::Result; + +#[test] +fn complex() -> Result<()> { + let expr = " + ℂ + "; + test("pl", "SimpleSpeak", expr, "liczby zespolone")?; + return Ok(()); + +} + +#[test] +fn natural() -> Result<()> { + let expr = " + ℕ + "; + test("pl", "SimpleSpeak", expr, "liczby naturalne")?; + return Ok(()); + +} + +#[test] +fn rationals() -> Result<()> { + let expr = " + ℚ + "; + test("pl", "SimpleSpeak", expr, "liczby wymierne")?; + return Ok(()); + +} + +#[test] +fn reals() -> Result<()> { + let expr = " + ℝ + "; + test("pl", "SimpleSpeak", expr, "liczby rzeczywiste")?; + return Ok(()); + +} + +#[test] +fn integers() -> Result<()> { + let expr = " + ℤ + "; + test("pl", "SimpleSpeak", expr, "liczby całkowite")?; + return Ok(()); + +} + + + +#[test] +fn msup_complex() -> Result<()> { + let expr = " + + ℂ + 2 + + "; + test("pl", "SimpleSpeak", expr, "C 2")?; + return Ok(()); + +} + +#[test] +fn msup_natural() -> Result<()> { + let expr = " + + ℕ + 2 + + "; + test("pl", "SimpleSpeak", expr, "N 2")?; + return Ok(()); + +} + +#[test] +fn msup_rationals() -> Result<()> { + let expr = " + + ℚ + 2 + + "; + test("pl", "SimpleSpeak", expr, "Q 2")?; + return Ok(()); + +} + +#[test] +fn msup_reals() -> Result<()> { + let expr = " + + ℝ + 3 + + "; + test("pl", "SimpleSpeak", expr, "R 3")?; + return Ok(()); + +} + +#[test] +fn msup_integers() -> Result<()> { + let expr = " + + ℤ + 4 + + "; + test("pl", "SimpleSpeak", expr, "Z 4")?; + return Ok(()); + +} + +#[test] +fn msup_positive_integers() -> Result<()> { + let expr = " + + ℤ + + + + "; + test("pl", "SimpleSpeak", expr, "plus liczby całkowite")?; + return Ok(()); + +} + +#[test] +fn msup_negative_integers() -> Result<()> { + let expr = " + + ℤ + - + + "; + test("pl", "SimpleSpeak", expr, "minus liczby całkowite")?; + return Ok(()); + +} + +#[test] +fn msup_positive_rationals() -> Result<()> { + let expr = " + + ℚ + + + + "; + test("pl", "SimpleSpeak", expr, "plus liczby wymierne")?; + return Ok(()); + +} + +#[test] +fn msup_negative_rationals() -> Result<()> { + let expr = " + + ℚ + - + + "; + test("pl", "SimpleSpeak", expr, "minus liczby wymierne")?; + return Ok(()); + +} + +#[test] +fn empty_set() -> Result<()> { + let expr = " + { } + "; + test("pl", "SimpleSpeak", expr, "zbiór pusty")?; + return Ok(()); + +} + +#[test] +fn single_element_set() -> Result<()> { + let expr = " + { 12} + "; + test("pl", "SimpleSpeak", expr, "zbiór 12")?; + return Ok(()); + +} + +#[test] +fn multiple_element_set() -> Result<()> { + let expr = " + { 5 , 10 , 15 } + "; + test("pl", "SimpleSpeak", expr, "zbiór 5 przecinek, 10 przecinek, 15")?; + return Ok(()); + +} + +#[test] +fn set_with_colon() -> Result<()> { + let expr = " + { x:x>2 } + "; + test("pl", "SimpleSpeak", expr, "zbiór wszystkich x takich że x jest większe niż 2")?; + return Ok(()); + +} + +#[test] +fn set_with_bar() -> Result<()> { + let expr = " + { x|x>2 } + "; + test("pl", "SimpleSpeak", expr, "zbiór wszystkich x takich że x jest większe niż 2")?; + return Ok(()); + +} + +#[test] +fn element_alone() -> Result<()> { + let expr = " + 3+2i∉ℝ + "; + test("pl", "SimpleSpeak", expr, "3 plus 2 i, nie jest elementem zbioru, liczby rzeczywiste")?; + return Ok(()); + +} + +#[test] +fn element_under_sum() -> Result<()> { + let expr = " + + ∑ + i ∈ ℤ + + + 1 + i 2 + + "; + test("pl", "SimpleSpeak", expr, + "suma przez i jest elementem zbioru, liczby całkowite z; ułamek, 1 przez, i do kwadratu, koniec ułamka")?; + return Ok(()); + +} + +#[test] +fn complicated_set_with_colon() -> Result<()> { + let expr = " + { + x + ∈ + ℤ + : + 2 + < + x + < + 7 + } + "; + test("pl", "SimpleSpeak", expr, "zbiór wszystkich x elementem zbioru, liczby całkowite takich że 2 jest mniejsze niż x jest mniejsze niż 7")?; + return Ok(()); + +} + +#[test] +fn complicated_set_with_mtext() -> Result<()> { + // as of 8/5/21, parsing of "|" is problematic an element of the example, so are needed for this test + let expr = " + { + x∈ℕ + | + x  is an even number + } + "; + test("pl", "SimpleSpeak", expr, + "zbiór wszystkich x elementem zbioru, liczby naturalne takich że x is an even number")?; + return Ok(()); + +} diff --git a/tests/Languages/pl/SimpleSpeak/subscripts.rs b/tests/Languages/pl/SimpleSpeak/subscripts.rs new file mode 100644 index 00000000..709861d5 --- /dev/null +++ b/tests/Languages/pl/SimpleSpeak/subscripts.rs @@ -0,0 +1,64 @@ +use crate::common::*; +use anyhow::Result; + +#[test] +fn msub_simple() -> Result<()> { + let expr = " x 1 "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "x 1")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Medium")], expr, "x indeks dolny 1")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, "x indeks dolny 1")?; + return Ok(()); + + } + +#[test] +fn msub_not_simple() -> Result<()> { + let expr = " x 1.2 "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "x indeks dolny 12")?; + return Ok(()); + + } + +#[test] +fn msubsup_not_simple() -> Result<()> { + let expr = " x 1.2 3 "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "x indeks dolny 12, do sześcianu")?; + return Ok(()); + + } + +#[test] +fn msub_simple_mi() -> Result<()> { + let expr = " x i "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "x indeks dolny i")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, "x indeks dolny i")?; + return Ok(()); + +} + +#[test] +fn msub_simple_number_follows() -> Result<()> { + let expr = " x 1 102 "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "x 1, 10 do kwadratu")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, "x indeks dolny 1; 10 do kwadratu")?; + return Ok(()); + +} + +#[test] +fn msub_simple_non_number_follows() -> Result<()> { + let expr = " x 1 2 "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "x 1, do kwadratu")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, "x indeks dolny 1, do kwadratu")?; + return Ok(()); + +} + +#[test] +fn msubsup_simple() -> Result<()> { + let expr = " x 1 x,2 "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "x 1, x do kwadratu")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, "x indeks dolny 1; x do kwadratu")?; + return Ok(()); + +} \ No newline at end of file diff --git a/tests/Languages/pl/alphabets.rs b/tests/Languages/pl/alphabets.rs new file mode 100644 index 00000000..5c2aef97 --- /dev/null +++ b/tests/Languages/pl/alphabets.rs @@ -0,0 +1,415 @@ +/// Tests for rules shared between various speech styles: +/// * this has tests focused on the various alphabets +use crate::common::*; +use anyhow::Result; + + +#[test] +fn special_alphabet_chars() -> Result<()> { + let expr = " ℌ,ℭ"; + test("pl", "SimpleSpeak", expr, "fraktura wielka h, przecinek, fraktura wielka c")?; + let expr = " ℍ,ℿ"; + test("pl", "SimpleSpeak", expr, "dwukreskowe wielka h, przecinek; dwukreskowe wielka pi")?; + let expr = " ℐ,ℳ"; + test("pl", "SimpleSpeak", expr, "pisane wielka i przecinek, pisane wielka m")?; + return Ok(()); + +} + +#[test] +fn greek() -> Result<()> { + let expr = " Α,Ω"; + test("pl", "SimpleSpeak", expr, "wielka alfa przecinek, wielka omega")?; + let expr = " α,ω"; + test("pl", "SimpleSpeak", expr, "alfa przecinek, omega")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "dwukreskowe wielka delta, przecinek; dwukreskowe wielka ypsilon")?; + let expr = " α,ω"; + test("pl", "SimpleSpeak", expr, "alfa przecinek, omega")?; + return Ok(()); + +} + +#[test] +fn cap_cyrillic() -> Result<()> { + let expr = " А,Я"; + test("pl", "SimpleSpeak", expr, "wielka a przecinek, wielka ja")?; + return Ok(()); + +} + +#[test] +fn parenthesized() -> Result<()> { + let expr = " ⒜,⒵"; + test("pl", "SimpleSpeak", expr, "w nawiasie a przecinek, w nawiasie z")?; + return Ok(()); + +} + +#[test] +fn circled() -> Result<()> { + let expr = " Ⓐ,Ⓩ"; + test("pl", "SimpleSpeak", expr, "w kółku wielka a, przecinek, w kółku wielka z")?; + let expr = " 🅐,🅩"; + test("pl", "SimpleSpeak", expr, "czarny w kółku wielka a, przecinek; czarny w kółku wielka z")?; + let expr = " ⓐ,ⓩ"; + test("pl", "SimpleSpeak", expr, "w kółku a przecinek, w kółku z")?; + return Ok(()); + +} + +#[test] +fn fraktur() -> Result<()> { + let expr = " 𝔄,𝔜"; + test("pl", "SimpleSpeak", expr, "fraktura wielka a, przecinek, fraktura wielka y")?; + let expr = " 𝔞,𝔷"; + test("pl", "SimpleSpeak", expr, "fraktura a przecinek, fraktura z")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "fraktura wielka a, przecinek, fraktura wielka y")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "fraktura a przecinek, fraktura z")?; + return Ok(()); + +} + +#[test] +fn bold_fraktur() -> Result<()> { + let expr = " 𝕬,𝖅"; + test("pl", "SimpleSpeak", expr, "fraktura pogrubione wielka a, przecinek; fraktura pogrubione wielka z")?; + let expr = " 𝖆,𝖟"; + test("pl", "SimpleSpeak", expr, "fraktura pogrubione a, przecinek; fraktura pogrubione z")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "fraktura pogrubione wielka a, przecinek; fraktura pogrubione wielka z")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "fraktura pogrubione a, przecinek; fraktura pogrubione z")?; + return Ok(()); + +} + +#[test] +fn double_struck() -> Result<()> { + let expr = " 𝔸,𝕐"; + test("pl", "SimpleSpeak", expr, "dwukreskowe wielka a, przecinek; dwukreskowe wielka y")?; + let expr = " 𝕒,𝕫"; + test("pl", "SimpleSpeak", expr, "dwukreskowe a przecinek, dwukreskowe z")?; + let expr = " 𝟘,𝟡"; + test("pl", "SimpleSpeak", expr, "dwukreskowe 0 przecinek, dwukreskowe 9")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "dwukreskowe wielka a, przecinek; dwukreskowe wielka y")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "dwukreskowe a przecinek, dwukreskowe z")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "dwukreskowe 0 przecinek, dwukreskowe 9")?; + return Ok(()); + +} + +#[test] +fn script() -> Result<()> { + let expr = " 𝒜,𝒵"; + test("pl", "SimpleSpeak", expr, "pisane wielka a przecinek, pisane wielka z")?; + let expr = " 𝒶,𝓏"; + test("pl", "SimpleSpeak", expr, "pisane a przecinek, pisane z")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pisane wielka a przecinek, pisane wielka z")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pisane a przecinek, pisane z")?; + return Ok(()); + +} + +#[test] +fn bold_script() -> Result<()> { + let expr = " 𝓐,𝓩"; + test("pl", "SimpleSpeak", expr, "pisane pogrubione wielka a, przecinek; pisane pogrubione wielka z")?; + let expr = " 𝓪,𝔃"; + test("pl", "SimpleSpeak", expr, "pisane pogrubione a, przecinek, pisane pogrubione z")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pisane pogrubione wielka a, przecinek; pisane pogrubione wielka z")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pisane pogrubione a, przecinek, pisane pogrubione z")?; + return Ok(()); + +} + +#[test] +fn bold() -> Result<()> { + let expr = " 𝐀,𝐙"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka a, przecinek; pogrubione wielka z")?; + let expr = " 𝐚,𝐳"; + test("pl", "SimpleSpeak", expr, "pogrubione a przecinek, pogrubione z")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka a, przecinek; pogrubione wielka z")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione a przecinek, pogrubione z")?; + return Ok(()); + +} + +#[test] +fn italic() -> Result<()> { + let expr = " 𝐴,𝑍"; + test("pl", "SimpleSpeak", expr, "wielka a przecinek, wielka z")?; + let expr = " 𝑎,𝑧"; + test("pl", "SimpleSpeak", expr, "a przecinek, z")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "wielka a przecinek, wielka z")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "a przecinek, z")?; + return Ok(()); + +} + +#[test] +fn sans_serif() -> Result<()> { + let expr = " 𝖠,𝖹"; + test("pl", "SimpleSpeak", expr, "wielka a przecinek, wielka z")?; + let expr = " 𝖺,𝗓"; + test("pl", "SimpleSpeak", expr, "a przecinek, z")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "wielka a przecinek, wielka z")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "a przecinek, z")?; + return Ok(()); + +} + +#[test] +fn sans_serif_bold() -> Result<()> { + let expr = " 𝗔,𝗭"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka a, przecinek; pogrubione wielka z")?; + let expr = " 𝗮,𝘇"; + test("pl", "SimpleSpeak", expr, "pogrubione a przecinek, pogrubione z")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka a, przecinek; pogrubione wielka z")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione a przecinek, pogrubione z")?; + return Ok(()); + +} + +#[test] +fn sans_serif_italic() -> Result<()> { + let expr = " 𝘈,𝘡"; + test("pl", "SimpleSpeak", expr, "wielka a przecinek, wielka z")?; + let expr = " 𝘢,𝘻"; + test("pl", "SimpleSpeak", expr, "a przecinek, z")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "wielka a przecinek, wielka z")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "a przecinek, z")?; + return Ok(()); + +} + +#[test] +fn sans_serif_bold_italic() -> Result<()> { + let expr = " 𝘼,𝙕"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka a, przecinek; pogrubione wielka z")?; + let expr = " 𝙖,𝙯"; + test("pl", "SimpleSpeak", expr, "pogrubione a przecinek, pogrubione z")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka a, przecinek; pogrubione wielka z")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione a przecinek, pogrubione z")?; + return Ok(()); + +} + +#[test] +fn monospace() -> Result<()> { + let expr = " 𝙰,𝚉"; + test("pl", "SimpleSpeak", expr, "wielka a przecinek, wielka z")?; + let expr = " 𝚊,𝚣"; + test("pl", "SimpleSpeak", expr, "a przecinek, z")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "wielka a przecinek, wielka z")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "a przecinek, z")?; + return Ok(()); + +} + + +#[test] +fn bold_greek() -> Result<()> { + let expr = " 𝚨,𝛀"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka alfa, przecinek; pogrubione wielka omega")?; + let expr = " 𝛂,𝛚"; + test("pl", "SimpleSpeak", expr, "pogrubione alfa przecinek, pogrubione omega")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka alfa, przecinek; pogrubione wielka omega")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione alfa przecinek, pogrubione omega")?; + return Ok(()); + +} + +#[test] +fn bold_greek_others() -> Result<()> { + let expr = " 𝛛,𝛡"; + test("pl", "SimpleSpeak", expr, "pogrubione pochodna cząstkowa, przecinek, pogrubione pi")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione pochodna cząstkowa, przecinek, pogrubione pi")?; + return Ok(()); + +} + + +#[test] +fn italic_greek() -> Result<()> { + let expr = " 𝛢,𝛺"; + test("pl", "SimpleSpeak", expr, "wielka alfa przecinek, wielka omega")?; + let expr = " 𝛼,𝜔"; + test("pl", "SimpleSpeak", expr, "alfa przecinek, omega")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "wielka alfa przecinek, wielka omega")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "alfa przecinek, omega")?; + return Ok(()); + +} + +#[test] +fn italic_greek_others() -> Result<()> { + let expr = " 𝜕,𝜛"; + test("pl", "SimpleSpeak", expr, "pochodna cząstkowa, przecinek, pi")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pochodna cząstkowa, przecinek, pi")?; + return Ok(()); + +} + +#[test] +fn bold_italic_greek() -> Result<()> { + let expr = " 𝜜,𝜴"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka alfa, przecinek; pogrubione wielka omega")?; + let expr = " 𝜶,𝝎"; + test("pl", "SimpleSpeak", expr, "pogrubione alfa przecinek, pogrubione omega")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka alfa, przecinek; pogrubione wielka omega")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione alfa przecinek, pogrubione omega")?; + return Ok(()); + +} + +#[test] +fn bold_italic_greek_others() -> Result<()> { + let expr = " 𝝏,𝝕"; + test("pl", "SimpleSpeak", expr, "pogrubione pochodna cząstkowa, przecinek, pogrubione pi")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione pochodna cząstkowa, przecinek, pogrubione pi")?; + return Ok(()); + +} + +#[test] +fn sans_serif_bold_greek() -> Result<()> { + let expr = " 𝝖,𝝮"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka alfa, przecinek; pogrubione wielka omega")?; + let expr = " 𝝰,𝞈"; + test("pl", "SimpleSpeak", expr, "pogrubione alfa przecinek, pogrubione omega")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka alfa, przecinek; pogrubione wielka omega")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione alfa przecinek, pogrubione omega")?; + return Ok(()); + +} + +#[test] +fn sans_serif_bold_greek_others() -> Result<()> { + let expr = " 𝞉,𝞏"; + test("pl", "SimpleSpeak", expr, "pogrubione pochodna cząstkowa, przecinek, pogrubione pi")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione pochodna cząstkowa, przecinek, pogrubione pi")?; + return Ok(()); + +} + +#[test] +fn sans_serif_bold_italic_greek() -> Result<()> { + let expr = " 𝞐,𝞨"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka alfa, przecinek; pogrubione wielka omega")?; + let expr = " 𝞪,𝟂"; + test("pl", "SimpleSpeak", expr, "pogrubione alfa przecinek, pogrubione omega")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione wielka alfa, przecinek; pogrubione wielka omega")?; + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione alfa przecinek, pogrubione omega")?; + return Ok(()); + +} + +#[test] +fn sans_serif_bold_italic_greek_others() -> Result<()> { + let expr = " 𝟃,𝟉"; + test("pl", "SimpleSpeak", expr, "pogrubione pochodna cząstkowa, przecinek, pogrubione pi")?; + // MathType private space versions + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "pogrubione pochodna cząstkowa, przecinek, pogrubione pi")?; + return Ok(()); + +} + +#[test] +fn pua_regular() -> Result<()> { + let expr = " ,"; + test("pl", "SimpleSpeak", expr, "wielka a przecinek, wielka z")?; + return Ok(()); + +} + +#[test] +fn turned() -> Result<()> { + let expr = " Ⅎ,⅄"; + test("pl", "SimpleSpeak", expr, "odwrócone wielka f, przecinek; odwrócony bezszeryfowe wielka y")?; + return Ok(()); + + } + +#[test] +fn unicode_typo_regressions() -> Result<()> { + test("pl", "SimpleSpeak", "ⁱ", "do potęgi i")?; + test("pl", "SimpleSpeak", "☌", "koniunkcja")?; + Ok(()) +} + +#[test] +fn enclosed_numbers() -> Result<()> { + let expr = " ①,⑨"; + test("pl", "SimpleSpeak", expr, "w kółku 1 przecinek, w kółku 9")?; + let expr = " ❶,㊿"; + test("pl", "SimpleSpeak", expr, "czarny w kółku jeden, przecinek; w kółku numer pięćdziesiąt")?; + let expr = " ⑴,⑼"; + test("pl", "SimpleSpeak", expr, "w nawiasie 1 przecinek, w nawiasie 9")?; + let expr = " ⒈,⒐"; + test("pl", "SimpleSpeak", expr, "1 z kropką przecinek, 9 z kropką")?; + let expr = " ⓵,⓽"; + test("pl", "SimpleSpeak", expr, "podwójny w kółku 1, przecinek; podwójny w kółku 9")?; + return Ok(()); + +} diff --git a/tests/Languages/pl/chemistry.rs b/tests/Languages/pl/chemistry.rs new file mode 100644 index 00000000..cda36182 --- /dev/null +++ b/tests/Languages/pl/chemistry.rs @@ -0,0 +1,766 @@ +/// Tests for rules shared between various speech styles: +/// * modified var +use crate::common::*; +use anyhow::Result; + +#[test] +fn salt() -> Result<()> { + let expr = "NaCl"; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "wielka n a, wielka c l")?; + return Ok(()); + +} + +#[test] +fn water() -> Result<()> { + let expr = "H2O"; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Terse")], expr, "wielka h, 2 wielka o")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium")], expr, "wielka h, indeks dolny 2, wielka o")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Verbose")], expr, "wielka h, indeks dolny 2, wielka o")?; + return Ok(()); + +} + +#[test] +fn carbon() -> Result<()> { + let expr = "C"; // not enough to trigger recognition + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "wielka c")?; + return Ok(()); + +} + +#[test] +fn sulfate() -> Result<()> { + let expr = " + [SO4] + 2− + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium")], expr, "nawias kwadratowy otwierający; wielka s, wielka o, indeks dolny 4; nawias kwadratowy zamykający indeks górny 2 minus")?; + return Ok(()); + +} + +#[test] +fn aluminum_sulfate() -> Result<()> { + let expr = "Al2 + (SO4)3"; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Terse")], expr, "wielka a l, 2, otwórz, wielka s, wielka o, 4; zamknij 3")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium")], expr, "wielka a l, indeks dolny 2; nawias otwierający; wielka s, wielka o, indeks dolny 4; nawias zamykający indeks dolny 3")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Verbose")], expr, "wielka a l, indeks dolny 2; nawias otwierający; wielka s, wielka o, indeks dolny 4; nawias zamykający indeks dolny 3")?; + return Ok(()); + +} + +#[test] +fn ethanol_bonds() -> Result<()> { + let expr = " + + C + H 3 + − + C + H 2 + − + O + H + + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Terse")], expr, "wielka c, wielka h, 3, wiązanie pojedyncze, wielka c, wielka h, 2, wiązanie pojedyncze, wielka o, wielka h")?; + + return Ok(()); + +} + +#[test] +fn dichlorine_hexoxide() -> Result<()> { + let expr = " + + [ClO2] + + + + + [ClO4] + - + + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "nawias kwadratowy otwierający; wielka c l, wielka o, 2; nawias kwadratowy zamykający plus; nawias kwadratowy otwierający; wielka c l, wielka o, 4; nawias kwadratowy zamykający minus")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Medium")], + expr, "nawias kwadratowy otwierający; wielka c l, wielka o, indeks dolny 2; nawias kwadratowy zamykający indeks górny plus; nawias kwadratowy otwierający; wielka c l, wielka o, indeks dolny 4; nawias kwadratowy zamykający indeks górny minus")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], + expr, "nawias kwadratowy otwierający; wielka c l, wielka o, indeks dolny 2; nawias kwadratowy zamykający indeks górny plus; nawias kwadratowy otwierający; wielka c l, wielka o, indeks dolny 4; nawias kwadratowy zamykający indeks górny minus")?; + return Ok(()); + +} + + +#[test] +fn ethylene_with_bond() -> Result<()> { + let expr = " + H2C + = + CH2 + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "wielka h, 2 wielka c, wiązanie podwójne, wielka c, wielka h, 2")?; + return Ok(()); + +} + +#[test] +fn ferric_chloride_aq() -> Result<()> { + let expr = " + Fe + Cl3 + (aq) + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "wielka f e, wielka c l, 3 wodny")?; + return Ok(()); + + } + +#[test] +fn ethylene_with_colon_bond() -> Result<()> { + let expr = " + H2C + :: + CH2 + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "wielka h, 2 wielka c, wiązanie podwójne, wielka c, wielka h, 2")?; + return Ok(()); + +} + +#[test] +fn beta_decay() -> Result<()> { + let expr = " + + C + + 6 + 14 + + → + + N + + 7 + 14 + + + + + e + + + − + 1 + + 0 + + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Terse")], expr, + "14, 6, wielka c; tworzy, 14, 7, wielka n; plus 0, minus 1, e")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium")], expr, + "indeks górny 14, indeks dolny 6, wielka c; reaguje tworząc; indeks górny 14, indeks dolny 7, wielka n; plus, indeks górny 0, indeks dolny minus 1, e")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Verbose")], expr, + "indeks górny 14, indeks dolny 6, wielka c; reaguje tworząc; indeks górny 14, indeks dolny 7, wielka n; plus, indeks górny 0, indeks dolny minus 1, e")?; + return Ok(()); + +} + +#[test] +fn mhchem_beta_decay() -> Result<()> { + let expr = " + + + + + + + A + + + + + + + + + 6 + + + + + + + + + 14 + + + + + + + + + + + + A + + + + + + + + + 2 + + + + + + + + 6 + + + + + + + + + + + + 2 + + + + + + + + 14 + + + + + + C + + + + ⟶ + + + + + + + + A + + + + + + + + + 7 + + + + + + + + + 14 + + + + + + + + + + + + A + + + + + + + + + 2 + + + + + + + + 7 + + + + + + + + + + + + 2 + + + + + + + + 14 + + + + + + N + + + + + + + + + + + A + + + + + + + + + − + 1 + + + + + + + + + 0 + + + + + + + + + + + + A + + + + + + + + + 2 + + + + + + + + − + 1 + + + + + + + + + + + + 2 + + + + + + + + 0 + + + + + + e + + + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Terse")], expr, + "14, 6, wielka c; tworzy, 14, 7, wielka n; plus 0, minus 1, e")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium")], expr, + "indeks górny 14, indeks dolny 6, wielka c; reaguje tworząc; indeks górny 14, indeks dolny 7, wielka n; plus, indeks górny 0, indeks dolny minus 1, e")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Verbose")], expr, + "indeks górny 14, indeks dolny 6, wielka c; reaguje tworząc; indeks górny 14, indeks dolny 7, wielka n; plus, indeks górny 0, indeks dolny minus 1, e")?; + return Ok(()); + +} + +#[test] +fn hcl_na_yields() -> Result<()> { + let expr = " + 2HCl+2Na + → + 2NaCl+ + H 2 + + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, + "2, wielka h, wielka c l; plus 2 wielka n a; reaguje tworząc; 2, wielka n a, wielka c l; plus wielka h, indeks dolny 2")?; + return Ok(()); + +} + +#[test] +fn mhchem_so4_2plus() -> Result<()> { + let expr = " + + + SO + + + + + + + A + + + + + + + + 4 + + + + + + + + + + A + + + + + + 2 + + + + + + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "wielka s; wielka o, 4, 2 plus")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Medium")], expr, "wielka s; wielka o, indeks dolny 4, indeks górny 2 plus")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, "wielka s; wielka o, indeks dolny 4, indeks górny 2 plus")?; + return Ok(()); + +} + + +#[test] +fn mhchem_hcl_aq_etc() -> Result<()> { + let expr = " + + 2 + + + + + HCl + + + ( + + aq + + ) + + + + + 2 + + + + + Na + + + ( + + s + + ) + + + ⟶ + + + 2 + + + + + NaCl + + + ( + + aq + + ) + + + + + + H + + + + + + + A + + + + + + + + 2 + + + + + + ( + + g + + ) + + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "2, wielka h, wielka c l, wodny; plus, 2, wielka n a, ciało stałe; tworzy; 2, wielka n a, wielka c l, wodny; plus, wielka h, 2; gaz")?; + + return Ok(()); + +} + + +#[test] +fn mhchem_barbed_equilibrium() -> Result<()> { + let expr = " + + + + H + 2 + + + ⁣ + + ( + g + ) + + + + + + + + I + 2 + + + ⁣ + + ( + g + ) + + + ⁢ + + + ↽ + - + + + - + ⇀ + + + ⁢ + 2 + ⁢ + + H + ⁣ + I + ⁣ + + ( + g + ) + + + + + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "wielka h, 2; gaz; plus; wielka i, 2; gaz; jest w równowadze z, 2, wielka h, wielka i, gaz")?; + return Ok(()); + +} + + + +#[test] +fn mhchem_roman_in_superscript() -> Result<()> { + let expr = " + + + Fe + + II + + ⁣ + + Fe + + III + + ⁣ + + O + 4 + + + + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "wielka f e, 2; wielka f e, 3; wielka o, 4")?; + return Ok(()); + +} + + +#[test] +fn dropped_msubsup_bug_358() -> Result<()> { + let expr = r#" + + + 2 + + + SO + + 2 + + + + + + + + + O + + 2 + + + + + + + + + + + + ↽ + + + + + − + + + + + + + + − + + + + + ⇀ + + + + + + 2 + + + SO + + 3 + + + + + + + + "#; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "2, wielka s, wielka o, 2; plus; wielka o, 2 jest w równowadze z, 2, wielka s, wielka o, 3")?; + return Ok(()); + +} + + diff --git a/tests/Languages/pl/definitions.rs b/tests/Languages/pl/definitions.rs new file mode 100644 index 00000000..9115608b --- /dev/null +++ b/tests/Languages/pl/definitions.rs @@ -0,0 +1,1032 @@ +/// Tests for rules in definitions: +/// * modified var +use crate::common::*; +use anyhow::Result; + +#[test] +fn tuple_basic() -> Result<()> { + // function + let expr = r#" + + + x + y + + + "#; + + test("pl", "ClearSpeak", expr, "krotka z x przecinek, y")?; + test("pl", "SimpleSpeak", expr, "krotka z x przecinek, y")?; + + return Ok(()); +} + +#[test] +fn my_set_basic() -> Result<()> { + let expr = r#" + + + x + y + + + "#; + + test("pl", "ClearSpeak", expr, "zbiór pusty")?; + + Ok(()) +} + +#[test] +fn fixed_test() -> Result<()> { + let expr = r#" + + R + + + "#; + + // Bez jawnej fixity silnik oddaje surową nazwę intentu (zachowanie rdzenia, + // identyczne w EN i PL). Poprawne tłumaczenie "zbiór liczb rzeczywistych" + // pojawia się przy intencie z ":nofix" (patrz nofix_set_tests). + test("pl", "ClearSpeak", expr, "set of reals")?; + Ok(()) +} + +#[test] +fn i_test() -> Result<()> { + let expr = r#" + + i + + + "#; + + // Bez jawnej fixity: surowa nazwa intentu (rdzeń, jak w EN). + test("pl", "ClearSpeak", expr, "imaginary i")?; + Ok(()) +} + + +#[test] +fn floor_basic() -> Result<()> { + let expr = r#" + + + x + + + "#; + + test("pl", "ClearSpeak", expr, "podłoga z x")?; + + Ok(()) +} + +#[test] +fn set_difference_basic() -> Result<()> { + let expr = r#" + + + A + ∖ + B + + + "#; + + test("pl", "ClearSpeak", expr, "i z wielka a przecinek, wielka b")?; + + Ok(()) +} + +#[test] +fn postfix_test() -> Result<()> { + let tests = [ + ( + "transpose", + r#" + + x + T + + "#, + "transpozycja z x", + ), + ( + "highlight", + r#" + + x + + "#, + "x podświetlone", + ), + ]; + + // Loop through all test cases, name _, body, and expected result + for (_, body, expected) in tests { + let expr = format!( + r#" + + {} + + "#, + body + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn prefix_test() -> Result<()> { + // Prefix test limit, unit-vector, line-segment + // Directed-line-segment, line, ray, arc + let tests = [ + ( + "limit", + r#" + + x + + "#, + "granica gdy x", + ), + ( + "unit-vector", + r#" + + x + ^ + + "#, + "wektor jednostkowy x", + ), + ( + "line-segment", + r#" + + x + ¯ + + "#, + "odcinek x", + ), + ]; + + for (_, body, expected) in tests { + let expr = format!( + r#" + + {} + + "#, + body + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + + +#[test] +fn functions_and_inverses_tests() -> Result<()> { + let tests = vec![ + //("closed-interval", "closed interval between x and y"), + //("closed-open-interval", "interval between x included and y"), + //("open-closed-interval", "interval between x and y included"), + //("open-interval", "open interval between x and y"), + + ("inverse", "odwrotność z x"), + ("domain", "dziedzina z x"), + ("codomain", "przeciwdziedzina z x"), + ("image", "obraz z x"), + + //("fraction", "fraction x over y end fraction"), + ("mixed-fraction", "x i y"), + ("quotient", "podzielone przez z x przecinek, y"), + ("evaluated-at", "x obliczone w y"), + ("remainder", "podzielone przez z x przecinek, y"), + + ("max", "maksimum z x przecinek, y przecinek, z"), + ("min", "minimum z x przecinek, y przecinek, z"), + + ("power", "x do potęgi y"), + + // ("root", ...) pominięte: intent 'root' bez indeksu rzuca błąd + // dopasowania reguły w RDZENIU silnika (identycznie w EN i PL), + // więc to nie jest luka polskiej lokalizacji. + + ("greatest-common-divisor", "największy wspólny dzielnik z x przecinek, y przecinek, z"), + ("least-common-multiple", "najmniejsza wspólna wielokrotność z x przecinek, y przecinek, z"), + + ("absolute-value", "wartość bezwzględna z x"), + + ("complex-conjugate", "sprzężenie zespolone z x"), + ("complex-arg", "arg z x"), + ("real-part", "część rzeczywista"), + ("imaginary-part", "część urojona"), + + ("polar-coordinate", "przecinek z x przecinek, y"), + ("spherical-coordinate", "przecinek z x przecinek, y przecinek, z"), + ("cartesian-coordinate", "przecinek z x przecinek, y przecinek, z"), + ("coordinate", "przecinek, x przecinek y przecinek z"), + + ("floor", "podłoga z x"), + ("ceiling", "sufit z x"), + ("round", "zaokrąglenie z x"), + ("fractional-part", "część ułamkowa z x"), + + + ]; + + for (intent, expected) in tests { + let expr = match intent { + + "max" + | "min" + | "greatest-common-divisor" + | "least-common-multiple" + | "spherical-coordinate" + | "cartesian-coordinate" + | "coordinate" => { + format!( + " + + x + y + z + + ", + intent + ) + } + + "power" + | "mixed-fraction" + | "quotient" + | "evaluated-at" + | "remainder" + | "closed-interval" + | "closed-open-interval" + | "open-closed-interval" + | "open-interval" + | "polar-coordinate" => { + format!( + " + + x + y + + ", + intent + ) + } + + _ => { + format!( + " + + x + + ", + intent + ) + } + }; + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + + +#[test] +fn calculus_tests() -> Result<()> { + let tests = vec![ + //("derivative", "the derivative of x with respect to x"), + //"definite-integral", "integral over x from x to x"), + + // prefix + ("limit", "granica gdy x"), + + // infix + ("tends-to", "x dąży do y"), + ("tends-to-from-above", "x dąży do z prawej y"), + ("tends-to-from-below", "x dąży do z lewej y"), + ]; + + for (intent, expected) in tests { + let expr = match intent { + "limit" => { + format!( + " + + x + + ", + intent + ) + } + + _ => { + // infix cases + format!( + " + + x + y + + ", + intent + ) + } + }; + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + + +#[test] +fn set_tests() -> Result<()> { + let tests = vec![ + ("set", "zbiór x"), + // ("set-difference", "set difference of x and y"), + ("complement", "dopełnienie z x"), + //("empty-set", "empty set"), + ("cardinality", "moc zbioru z x"), + ("list", "lista z x"), + ("tuple", "krotka z x"), + ]; + + for (intent, expected) in tests { + let expr = format!( + " + + x + + ", + intent + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + + +#[test] +fn sequence_and_series_intents() -> Result<()> { + let tests = [ + ( + "sum-1", + r#" + + ∑ + x + + "#, + "suma z x", + ), + ( + "sum-2", + r#" + + ∑ + i + x + + "#, + "suma z i przecinek, x", + ), + ( + "sum-3", + r#" + + ∑ + i + n + x + + "#, + "suma z i przecinek, n przecinek, x", + ), + ( + "product-1", + r#" + + ∏ + x + + "#, + "iloczyn z x", + ), + ( + "product-2", + r#" + + ∏ + i + x + + "#, + "iloczyn z i przecinek, x", + ), + ( + "product-3", + r#" + + ∏ + i + n + x + + "#, + "iloczyn z i przecinek, n przecinek, x", + ), + ]; + + for (_, body, expected) in tests { + let expr = format!( + r#" + + {} + + "#, + body + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn elementary_classical_tests() -> Result<()> { + let tests = vec![ + // Trig + ("sine", "sinus z x"), + ("cosine", "cosinus z x"), + ("tangent", "tangens z x"), + ("secant", "sekans z x"), + ("cosecant", "kosekans z x"), + ("cotangent", "cotangens z x"), + + // Inverse trig + ("arcsine", "arcus sinus z x"), + ("arccosine", "arcus cosinus z x"), + ("arctangent", "arcus tangens z x"), + ("arcsecant", "arcus sekans z x"), + ("arccosecant", "arcus kosekans z x"), + ("arccotangent", "arcus cotangens z x"), + + // Hyperbolic trig + ("hyperbolic-sine", "sinus hiperboliczny z x"), + ("hyperbolic-cosine", "cosinus hiperboliczny z x"), + ("hyperbolic-tangent", "tangens hiperboliczny z x"), + ("hyperbolic-secant", "sekans hiperboliczny z x"), + ("hyperbolic-cosecant", "kosekans hiperboliczny z x"), + ("hyperbolic-cotangent", "cotangens hiperboliczny z x"), + + // Inverse hyperbolic trig + ("arc-hyperbolic-sine", "arcus sinus hiperboliczny z x"), + ("arc-hyperbolic-cosine", "arcus cosinus hiperboliczny z x"), + ("arc-hyperbolic-tangent", "arcus tangens hiperboliczny z x"), + ("arc-hyperbolic-secant", "arcus sekans hiperboliczny z x"), + ("arc-hyperbolic-cosecant", "arcus kosekans hiperboliczny z x"), + ("arc-hyperbolic-cotangent", "arcus cotangens hiperboliczny z x"), + ]; + + for (intent, expected) in tests { + let expr = format!( + " + + x + + ", + intent + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn statistics_and_probability_tests() -> Result<()> { + let tests = vec![ + ("mean", "średnia z x"), + ("standard-deviation", "odchylenie standardowe z x"), + ("variance", "wariancja z x"), + ("median", "mediana z x"), + ("mode", "dominanta z x"), + + // conditional probability typically two arguments + // ("conditional-probability", "probability of x given y"), + ]; + + for (intent, expected) in tests { + let expr = match intent { + "conditional-probability" => format!( + " + + P + ( + + x + | + y + + ) + + ", + intent + ), + _ => format!( + " + + x + + ", + intent + ), + }; + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn linear_algebra_tests() -> Result<()> { + let tests = vec![ + ("vector", "wektor z x"), + // ("matrix", "matrix of x"), + ("determinant", "wyznacznik z x"), + ("adjugate", "macierz dopełnień algebraicznych z x"), + ("magnitude", "długość z x"), + ("norm", "norma z x"), + ("span", "powłoka liniowa z x"), + + // transpose supports both postfix and function; we test function explicitly + ("transpose", "transpozycja z x"), + + // dimensional product is infix + ("dimensional-product", "x na y"), + + // unit-vector is prefix + ("unit-vector", "wektor jednostkowy x") + ]; + + for (intent, expected) in tests { + let expr: String = match intent { + "dimensional-product" => { + " + + x + y + + " + .to_string() + } + _ => format!( + " + + x + + " + ), + }; + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn nofix_set_tests() -> Result<()> { + let tests = vec![ + ("set-of-integers", "ℤ", "zbiór liczb całkowitych"), + ("set-of-reals", "ℝ", "zbiór liczb rzeczywistych"), + ("set-of-rationals", "ℚ", "zbiór liczb wymiernych"), + ("set-of-natural-numbers", "ℕ", "zbiór liczb naturalnych"), + ("set-of-complex-numbers", "ℂ", "zbiór liczb zespolonych"), + ("set-of-primes", "ℙ", "zbiór liczb pierwszych"), + ]; + + for (intent, symbol, expected) in tests { + let expr = format!( + " + {} + ", + intent, + symbol + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn geometry_prefix_multi_value_tests() -> Result<()> { + let tests = vec![ + ("line-segment", "odcinek x y"), + ("directed-line-segment", "odcinek skierowany x y"), + ("line", "linia x y"), + ("ray", "półprosta x y"), + ("arc", "łuk x y"), + ("point", "punkt x y z"), + ]; + + for (intent, expected) in tests { + let expr = match intent{ + "point" => { + format!( + " + + x + y + z + + " + ) + } + + _ => { + format!( + " + + x + y + + " + ) + } + }; + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn geometry_prefix_tests() -> Result<()> { + let tests = vec![ + ("length", "długość z x"), + ("area", "pole z x"), + ("objętość", "objętość z x"), + ]; + + for (intent, expected) in tests { + let expr = format!( + " + + x + + " + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn separator_tests() -> Result<()> { + let expr = format!( + " + + x + y + + " + ); + + test("pl", "ClearSpeak", &expr, "x y")?; + Ok(()) +} + +#[test] +fn general_concepts_tests() -> Result<()> { + let tests = vec![ + // Unary structural + ("fenced-group", "grupa w nawiasach z x"), + ("highlight", "x podświetlone"), + ("least-common-denominator", "najmniejszy wspólny mianownik z x przecinek, y przecinek, z"), // add x, y , z ... + ("pochhammer", "symbol Pochhammera z x"), + ("permutation-cycle", "cykl permutacji z x"), + + // Binary structural / infix-style + // ("ordered-pair", "the pair of x and y"), + ("rate", "x na y"), + + ("binomial-coefficient", "x po y"), + ("embellished-name", "x z oznaczeniem y"), + ("indexed-by", "x indeks dolny y"), + // ("translation", "translation by x comma, y"), // Changes translation to comma + ("constraint", "x przy warunku y"), + ]; + + for (intent, expected) in tests { + let expr = match intent { + "ordered-pair" + | "rate" + | "constraint" + | "binomial-coefficient" + | "embellished-name" + | "translation" + | "indexed-by" => { + format!( + " + + x + y + + ", + intent + ) + } + "least-common-denominator" => { + format!( + " + + x + y + z + + ", + intent + ) + } + + // unary cases + _ => { + format!( + " + + x + + ", + intent + ) + } + }; + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn grouping_tests() -> Result<()> { + let tests = vec![ + ("annotation", "x czyli y"), + // ("braced-group", "grouped x end-grouped"), + // ("repeating-decimal", "repeating decimal of x"), + ]; + + for (intent, expected) in tests { + let expr = match intent { + "annotation" => { + format!( + " + + x + y + + ", + intent + ) + } + _ => { + format!( + " + + x + + ", + intent + ) + } + }; + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn function_default_fixity_tests() -> Result<()> { + let tests = vec![ + ("curl", "rotacja z x"), + ("divergence", "dywergencja z x"), + ("gradient", "gradient z x"), + ("laplacian", "laplasjan z x"), + ]; + + for (intent, expected) in tests { + let expr = format!( + " + + x + + ", + intent + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn prefix_default_fixity_tests() -> Result<()> { + let tests = vec![ + ("angle", "kąt x"), + ("angle-measure", "miara kąta x"), + ("change", "zmiana x"), + ("for-all", "dla każdego x"), + ("measured-angle", "kąt mierzony x"), + ("not", "nie x"), + ("number-of", "liczba x"), + ("partial-derivative", "cząstkowe x"), + ("right-angle", "kąt prosty x"), + ("square-root-of", "pierwiastek kwadratowy z x"), + ("there-does-not-exist", "nie istnieje x"), + ("there-exists", "istnieje x"), + ]; + + for (intent, expected) in tests { + let expr = format!( + " + + x + + ", + intent + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn infix_default_fixity_tests() -> Result<()> { + let tests = vec![ + ("and", "x i y"), + ("applied-to", "x zastosowane do y"), + ("approximately", "x w przybliżeniu y"), + ("congruent", "x przystające do y"), + ("cartesian-product", "x iloczyn kartezjański y"), + ("composed-with", "x złożone z y"), + ("cross-product", "x iloczyn wektorowy y"), + ("defined-as", "x zdefiniowane jako y"), + ("divided-by", "x podzielone przez y"), + ("divides", "x dzieli y"), + ("does-not-belong-to", "x nie należy do y"), + ("does-not-divide", "x nie dzieli y"), + ("dot-product", "x iloczyn skalarny y"), + ("downwards-diagonal-ellipsis", "x ukośny wielokropek w dół y"), + ("direct-product", "x iloczyn prosty y"), + ("element-of", "x należy do y"), + ("ellipsis", "x wielokropek y"), + ("equals", "x równa się y"), + ("equivalent-to", "x równoważne y"), + ("evaluates-to", "x ma wartość y"), + ("given", "x pod warunkiem y"), + ("greater-than", "x większe niż y"), + ("greater-than-or-equal-to", "x większe lub równe y"), + ("identically-equals", "x tożsamościowo równe y"), + ("if-and-only-if", "x wtedy i tylko wtedy gdy y"), + ("implies", "x implikuje y"), + ("inner-product", "x iloczyn wewnętrzny y"), + ("intersection", "x część wspólna y"), + ("less-than", "x mniejsze niż y"), + ("less-than-or-equal-to", "x mniejsze lub równe y"), + ("list-separator", "x przecinek y"), + ("maps-to", "x przekształca na y"), + ("member-of", "x element zbioru y"), + ("minus", "x minus y"), + ("minus-or-plus", "x minus lub plus y"), + ("not-subset", "x nie jest podzbiorem y"), + ("not-superset", "x nie jest nadzbiorem y"), + ("not-equal-to", "x nie równa się y"), + ("not-member-of", "x nie jest elementem zbioru y"), + ("not-parallel-to", "x nierównoległe do y"), + ("obtained-from", "x otrzymane z y"), + ("or", "x lub y"), + ("outer-product", "x iloczyn zewnętrzny y"), + ("parallel-to", "x równoległe do y"), + ("perpendicular", "x prostopadłe do y"), + ("plus", "x plus y"), + ("plus-or-minus", "x plus minus y"), + ("precedes", "x poprzedza y"), + ("proportional", "x proporcjonalne do y"), + ("range-separator", "x do y"), + ("ratio", "x stosunek y"), + ("similar", "x podobne do y"), + ("subset", "x podzbiór y"), + ("subset-or-equal", "x podzbiór lub równy y"), + ("succeeds", "x następuje po y"), + ("such-that", "x taki że y"), + ("superset", "x nadzbiór y"), + ("superset-or-equal", "x nadzbiór lub równy y"), + ("tilde", "x tylda y"), + ("times", "x razy y"), + ("union", "x suma zbiorów y"), + ("upwards-diagonal-ellipsis", "x ukośny wielokropek w górę y"), + ("vertical-ellipsis", "x wielokropek pionowy y"), + ("xor", "x albo y"), + ]; + + for (intent, expected) in tests { + let expr = format!( + " + + x + y + + ", + intent + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn postfix_default_fixity_tests() -> Result<()> { + let tests = vec![ + ("factorial", "x silnia"), + ("percent", "x procent"), + ]; + + for (intent, expected) in tests { + let expr = format!( + " + + x + + ", + intent + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} + +#[test] +fn nofix_default_fixity_tests() -> Result<()> { + let tests = vec![ + ("średnica", "d", "średnica"), + ("odległość", "D", "odległość"), + ("prawdopodobieństwo", "P", "prawdopodobieństwo"), + ("promień", "r", "promień"), + ("objętość", "V", "objętość"), + ("exponential-e", "e", "e"), + ("imaginary-i", "i", "i"), + ("differential-d", "d", "d"), + ("golden-ratio", "φ", "złota proporcja"), + ]; + + for (intent, symbol, expected) in tests { + let expr = format!( + " + {} + ", + intent, + symbol + ); + + test("pl", "ClearSpeak", &expr, expected)?; + } + + Ok(()) +} \ No newline at end of file diff --git a/tests/Languages/pl/mtable.rs b/tests/Languages/pl/mtable.rs new file mode 100644 index 00000000..8403eeae --- /dev/null +++ b/tests/Languages/pl/mtable.rs @@ -0,0 +1,1296 @@ +use crate::common::*; +use anyhow::Result; + +#[test] +fn matrix_1x1() -> Result<()> { + let expr = " + + + ( + + 3 + + ) + + "; + test("pl", "ClearSpeak", expr, "jeden na jeden macierz z elementem 3")?; + test("pl", "SimpleSpeak", expr, "jeden na jeden macierz z elementem 3")?; + return Ok(()); + +} + +#[test] +fn determinant_1x1() -> Result<()> { + let expr = " + + + | + + 3 + + | + + "; + test("pl", "ClearSpeak", expr, "jeden na jeden wyznacznik z elementem 3")?; + test("pl", "SimpleSpeak", expr, "jeden na jeden wyznacznik z elementem 3")?; + return Ok(()); + +} + + +#[test] +fn matrix_1x2() -> Result<()> { + let expr = " + + + ( + + + + 3 + + + 5 + + + + ) + + "; + test("pl", "ClearSpeak", expr, "jeden na 2 wiersz macierz; 3, 5")?; + test("pl", "SimpleSpeak", expr, "jeden na 2 wiersz macierz; 3, 5")?; + return Ok(()); + +} + + +#[test] +fn matrix_1x3() -> Result<()> { + let expr = " + + + ( + + + + -x + + + 5 + + + 12 + + + + ) + + "; + test("pl", "ClearSpeak", expr, "jeden na 3 wiersz macierz; minus x, 5, 12")?; + test("pl", "SimpleSpeak", expr, "jeden na 3 wiersz macierz; minus x, 5, 12")?; + return Ok(()); + +} + +#[test] +fn matrix_2x1_not_simple() -> Result<()> { + let expr = " + + + ( + + + + + x+1 + + + + + + + x-1 + + + + ) + + "; + test("pl", "ClearSpeak", expr, "2 na jedną kolumnę macierz; wiersz 1; x plus 1; wiersz 2; x minus 1")?; + test("pl", "SimpleSpeak", expr, "2 na jedną kolumnę macierz; wiersz 1; x plus 1; wiersz 2; x minus 1")?; + return Ok(()); + +} +#[test] +fn matrix_3x1_not_simple() -> Result<()> { + let expr = " + + + ( + + + + + x + + + + + + + a + + + + + + + x + + x+1 + + + + + + ) + "; + test("pl", "SimpleSpeak", expr, "3 na jedną kolumnę macierz; wiersz 1; x; wiersz 2; a; wiersz 3; ułamek, x przez, x plus 1, koniec ułamka")?; + test("pl", "ClearSpeak", expr, "3 na jedną kolumnę macierz; wiersz 1; x; wiersz 2; a; wiersz 3; ułamek z licznikiem x; i mianownikiem x plus 1")?; + return Ok(()); + +} + +#[test] +fn determinant_2x2() -> Result<()> { + let expr = " + + | + + + + 2 + + + 1 + + + + + 7 + + + 5 + + + + + | + "; + test("pl", "ClearSpeak", expr, "2 na 2 wyznacznik; wiersz 1; 2, 1; wiersz 2; 7, 5")?; + test("pl", "SimpleSpeak", expr, "2 na 2 wyznacznik; wiersz 1; 2, 1; wiersz 2; 7, 5")?; + return Ok(()); + +} + +#[test] +fn matrix_2x3() -> Result<()> { + let expr = " + + + [ + + + + 3 + + + 1 + + + 4 + + + + + 0 + + + 2 + + + 6 + + + + ] + + "; + test("pl", "ClearSpeak", expr, "2 na 3 macierz; wiersz 1; 3, 1, 4; wiersz 2; 0, 2, 6")?; + test("pl", "SimpleSpeak", expr, "2 na 3 macierz; wiersz 1; 3, 1, 4; wiersz 2; 0, 2, 6")?; + return Ok(()); + +} + +#[test] +fn augmented_matrix_2x3() -> Result<()> { + let expr = " + + + [ + + + + 3 + + + 1 + + + 4 + + + + + 0 + + + 2 + + + 6 + + + + ] + + "; + test("pl", "ClearSpeak", expr, "2 na 3 macierz rozszerzona; wiersz 1; 3, 1, 4; wiersz 2; 0, 2, 6")?; + test("pl", "SimpleSpeak", expr, "2 na 3 macierz rozszerzona; wiersz 1; 3, 1, 4; wiersz 2; 0, 2, 6")?; + Ok(()) +} + +#[test] +fn matrix_2x3_labeled() -> Result<()> { + let expr = " + + + [ + + + + (3.1) + + + 3 + + + 1 + + + 4 + + + + + 0 + + + 2 + + + 6 + + + + ] + + "; + test("pl", "ClearSpeak", expr, + "2 na 3 macierz; wiersz 1 z etykietą (3.1); kolumna 1; 3, kolumna 2; 1, kolumna 3; 4; wiersz 2; kolumna 1; 0, kolumna 2; 2, kolumna 3; 6")?; + test("pl", "SimpleSpeak", expr, + "2 na 3 macierz; wiersz 1 z etykietą (3.1); kolumna 1; 3, kolumna 2; 1, kolumna 3; 4; wiersz 2; kolumna 1; 0, kolumna 2; 2, kolumna 3; 6")?; + return Ok(()); + +} + +#[test] +fn matrix_3x1() -> Result<()> { + let expr = " + + + [ + + + + 1 + + + + + 2 + + + + + 3 + + + ] + + "; + test("pl", "ClearSpeak", expr, "3 na jedną kolumnę macierz; 1; 2; 3")?; + test("pl", "SimpleSpeak", expr, "3 na jedną kolumnę macierz; 1; 2; 3")?; + return Ok(()); + +} + +#[test] +fn matrix_4x1() -> Result<()> { + let expr = " + + + ( + + + + 3 + + + + + 6 + + + + + 1 + + + + + 2 + + + + ) + + "; + test("pl", "ClearSpeak", expr, "4 na jedną kolumnę macierz; wiersz 1; 3; wiersz 2; 6; wiersz 3; 1; wiersz 4; 2")?; + test("pl", "SimpleSpeak", expr, "4 na jedną kolumnę macierz; wiersz 1; 3; wiersz 2; 6; wiersz 3; 1; wiersz 4; 2")?; + return Ok(()); + +} + +#[test] +fn matrix_4x1_labeled() -> Result<()> { + let expr = " + + + ( + + + + 3 + + + + + 6 + + + + + 1 + + + + + (3.1) + + + 2 + + + + ) + + "; + test("pl", "ClearSpeak", expr, + "4 na jedną kolumnę macierz; wiersz 1; 3; wiersz 2; 6; wiersz 3; 1; wiersz 4 z etykietą (3.1); 2")?; + test("pl", "SimpleSpeak", expr, + "4 na jedną kolumnę macierz; wiersz 1; 3; wiersz 2; 6; wiersz 3; 1; wiersz 4 z etykietą (3.1); 2")?; + return Ok(()); + +} + +#[test] +fn matrix_1x4() -> Result<()> { + let expr = " + + + ( + + + + 3 + + + 6 + + + 1 + + + 2 + + + + ) + + "; + test("pl", "ClearSpeak", expr, "jeden na 4 wiersz macierz; kolumna 1; 3, kolumna 2; 6, kolumna 3; 1, kolumna 4; 2")?; + test("pl", "SimpleSpeak", expr, "jeden na 4 wiersz macierz; kolumna 1; 3, kolumna 2; 6, kolumna 3; 1, kolumna 4; 2")?; + return Ok(()); + +} + +#[test] +fn matrix_4x4() -> Result<()> { + let expr = " + + + ( + + + + 0 + + + 3 + + + 4 + + + 3 + + + + + 2 + + + 1 + + + 0 + + + 9 + + + + + 3 + + + 0 + + + 2 + + + 1 + + + + + 6 + + + 2 + + + 9 + + + 0 + + + + ) + + "; + test("pl", "ClearSpeak", expr, "4 na 4 macierz; wiersz 1; kolumna 1; 0, kolumna 2; 3, kolumna 3; 4, kolumna 4; 3; wiersz 2; kolumna 1; 2, kolumna 2; 1, kolumna 3; 0, kolumna 4; 9; wiersz 3; kolumna 1; 3, kolumna 2; 0, kolumna 3; 2, kolumna 4; 1; wiersz 4; kolumna 1; 6, kolumna 2; 2, kolumna 3; 9, kolumna 4; 0")?; + test("pl", "SimpleSpeak", expr, "4 na 4 macierz; wiersz 1; kolumna 1; 0, kolumna 2; 3, kolumna 3; 4, kolumna 4; 3; wiersz 2; kolumna 1; 2, kolumna 2; 1, kolumna 3; 0, kolumna 4; 9; wiersz 3; kolumna 1; 3, kolumna 2; 0, kolumna 3; 2, kolumna 4; 1; wiersz 4; kolumna 1; 6, kolumna 2; 2, kolumna 3; 9, kolumna 4; 0")?; + return Ok(()); +} + +#[test] +fn matrix_4x2() -> Result<()> { + let expr = " + + + ( + + + + 1 + + + 3 + + + + + 4 + + + 2 + + + + + 2 + + + 1 + + + + + 0 + + + 5 + + + + + ) + + "; + test("pl", "ClearSpeak", expr, "4 na 2 macierz; wiersz 1; kolumna 1; 1, kolumna 2; 3; wiersz 2; kolumna 1; 4, kolumna 2; 2; wiersz 3; kolumna 1; 2, kolumna 2; 1; wiersz 4; kolumna 1; 0, kolumna 2; 5")?; + test("pl", "SimpleSpeak", expr, "4 na 2 macierz; wiersz 1; kolumna 1; 1, kolumna 2; 3; wiersz 2; kolumna 1; 4, kolumna 2; 2; wiersz 3; kolumna 1; 2, kolumna 2; 1; wiersz 4; kolumna 1; 0, kolumna 2; 5")?; + return Ok(()); +} + +// put absolute value test here since it is related to determinate and is small for its own file +#[test] +fn simple_absolute_value() -> Result<()> { + let expr = " + | x | + "; + test("pl", "SimpleSpeak", expr, "wartość bezwzględna z x")?; + test("pl", "ClearSpeak", expr, "wartość bezwzględna z x")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Terse"), ("ClearSpeak_AbsoluteValue", "Auto")], expr, "wartość bezwzględna z x")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Verbose"), ("ClearSpeak_AbsoluteValue", "AbsEnd")], + expr, "wartość bezwzględna z x, koniec wartości bezwzględnej")?; + return Ok(()); +} + +#[test] +fn absolute_value_plus_1() -> Result<()> { +let expr = " + | + x+1 + | + "; + test("pl", "ClearSpeak", expr, "wartość bezwzględna z x plus 1")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Terse"), ("ClearSpeak_AbsoluteValue", "AbsEnd")], + expr, "wartość bezwzględna z x plus 1, koniec wartości bezwzględnej")?; + return Ok(()); +} + +#[test] +fn simple_cardinality_value() -> Result<()> { + let expr = " + | S | + "; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium"), ("ClearSpeak_AbsoluteValue", "Cardinality")], expr, + "moc z wielka s")?; + return Ok(()); +} + +// Test preferences +#[test] +fn simple_matrix_speak_col_num() -> Result<()> { +let expr = " + + ( + + + + 2 + 1 + + + 7 + 5 + + + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Matrix", "SpeakColNum", + expr, "2 na 2 macierz; wiersz 1; kolumna 1; 2, kolumna 2; 1; wiersz 2; kolumna 1; 7, kolumna 2; 5")?; + return Ok(()); +} + +#[test] +fn col_matrix_3x1_speak_col_num() -> Result<()> { +let expr = " + + ( + + + + 1 + + + 2 + + + 3 + + + ) + "; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "SpeakColNum", + expr, "3 na jedną kolumnę macierz; wiersz 1; 1; wiersz 2; 2; wiersz 3; 3")?; + return Ok(()); +} + +#[test] +fn row_matrix_1x2_speak_col_num() -> Result<()> { +let expr = " + + [ + + + + 1 2 + + + ] + "; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "SpeakColNum", + expr, "jeden na 2 wiersz macierz; kolumna 1; 1, kolumna 2; 2")?; + return Ok(()); +} + +#[test] +fn matrix_2x2_speak_col_num() -> Result<()> { +let expr = "( + + + b11 + b12 + + + b21 + b22 + + + )"; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "SpeakColNum", + expr, "2 na 2 macierz; wiersz 1; kolumna 1; b indeks dolny 1 1; kolumna 2; b indeks dolny 1 2; wiersz 2; kolumna 1; b indeks dolny 2 1; kolumna 2; b indeks dolny 2 2")?; + return Ok(()); +} + + +#[test] +fn simple_matrix_silent_col_num() -> Result<()> { +let expr = " + + ( + + + + 2 + 1 + + + 7 + 5 + + + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Matrix", "SilentColNum", + expr, "2 na 2 macierz; wiersz 1; 2, 1; wiersz 2; 7, 5")?; + return Ok(()); +} + +#[test] +fn col_matrix_3x1_silent_col_num() -> Result<()> { +let expr = " + + ( + + + + 1 + + + 2 + + + 3 + + + ) + "; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "SilentColNum", + expr, "3 na jedną kolumnę macierz; 1; 2; 3")?; + return Ok(()); +} + +#[test] +fn row_matrix_1x2_silent_col_num() -> Result<()> { +let expr = " + + [ + + + + 1 2 + + + ] + "; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "SilentColNum", + expr, "jeden na 2 wiersz macierz; 1, 2")?; + return Ok(()); +} + +#[test] +fn matrix_2x2_silent_col_num() -> Result<()> { +let expr = "( + + + b11 + b12 + + + b21 + b22 + + + )"; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "SilentColNum", + expr, "2 na 2 macierz; wiersz 1; b indeks dolny 1 1; b indeks dolny 1 2; wiersz 2; b indeks dolny 2 1; b indeks dolny 2 2")?; + return Ok(()); + } + + +#[test] +fn simple_matrix_end_matrix() -> Result<()> { +let expr = " + + ( + + + + 2 + 1 + + + 7 + 5 + + + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Matrix", "EndMatrix", + expr, "2 na 2 macierz; wiersz 1; 2, 1; wiersz 2; 7, 5; koniec macierzy")?; + return Ok(()); + } + +#[test] +fn col_matrix_3x1_end_matrix() -> Result<()> { +let expr = " + + ( + + + + 1 + + + 2 + + + 3 + + + ) + "; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "EndMatrix", + expr, "3 na jedną kolumnę macierz; 1; 2; 3; koniec macierzy")?; + return Ok(()); + } + +#[test] +fn row_matrix_1x2_end_matrix() -> Result<()> { +let expr = " + + [ + + + + 1 2 + + + ] + "; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "EndMatrix", + expr, "jeden na 2 wiersz macierz; 1, 2; koniec macierzy")?; + return Ok(()); + } + +#[test] +fn matrix_2x2_end_matrix() -> Result<()> { +let expr = "( + + + b11 + b12 + + + b21 + b22 + + + )"; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "EndMatrix", + expr, "2 na 2 macierz; wiersz 1; kolumna 1; b indeks dolny 1 1; kolumna 2; b indeks dolny 1 2; wiersz 2; kolumna 1; b indeks dolny 2 1; kolumna 2; b indeks dolny 2 2; koniec macierzy")?; + return Ok(()); + } + +#[test] +fn augmented_matrix_3x4_end_matrix() -> Result<()> { +let expr = " + + [ + + + 1 + 2 + -1 + 3 + + + -3 + 3 + -1 + 2 + + + 2 + 3 + 2 + -1 + + + ] + +"; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "EndMatrix", + expr, "3 na 4 macierz rozszerzona; wiersz 1; kolumna 1; 1, kolumna 2; 2, kolumna 3; minus 1, kolumna 4; 3; wiersz 2; kolumna 1; minus 3, kolumna 2; 3, kolumna 3; minus 1, kolumna 4; 2; wiersz 3; kolumna 1; 2, kolumna 2; 3, kolumna 3; 2, kolumna 4; minus 1; koniec macierzy")?; + test("pl", "SimpleSpeak", + expr, "3 na 4 macierz rozszerzona; wiersz 1; kolumna 1; 1, kolumna 2; 2, kolumna 3; minus 1, kolumna 4; 3; wiersz 2; kolumna 1; minus 3, kolumna 2; 3, kolumna 3; minus 1, kolumna 4; 2; wiersz 3; kolumna 1; 2, kolumna 2; 3, kolumna 3; 2, kolumna 4; minus 1; koniec macierzy")?; + Ok(()) + } + + +#[test] +fn simple_matrix_vector() -> Result<()> { +let expr = " + + ( + + + + 2 + 1 + + + 7 + 5 + + + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Matrix", "Vector", + expr, "2 na 2 macierz; wiersz 1; 2, 1; wiersz 2; 7, 5")?; + return Ok(()); + } + +#[test] +fn col_matrix_3x1_vector() -> Result<()> { +let expr = " + + ( + + + + 1 + + + 2 + + + 3 + + + ) + "; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "Vector", + expr, "3 na jedną kolumnę wektor; 1; 2; 3")?; + return Ok(()); + } + +#[test] +fn row_matrix_1x2_vector() -> Result<()> { +let expr = " + + [ + + + + 1 2 + + + ] + "; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "Vector", + expr, "jeden na 2 wiersz wektor; 1, 2")?; + return Ok(()); + } + +#[test] +fn matrix_2x2_vector() -> Result<()> { +let expr = "( + + + b11 + b12 + + + b21 + b22 + + + )"; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "Vector", + expr, "2 na 2 macierz; wiersz 1; kolumna 1; b indeks dolny 1 1; kolumna 2; b indeks dolny 1 2; wiersz 2; kolumna 1; b indeks dolny 2 1; kolumna 2; b indeks dolny 2 2")?; + return Ok(()); + } + + +#[test] +fn simple_matrix_end_vector() -> Result<()> { +let expr = " + + ( + + + + 2 + 1 + + + 7 + 5 + + + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Matrix", "EndVector", + expr, "2 na 2 macierz; wiersz 1; 2, 1; wiersz 2; 7, 5; koniec macierzy")?; + return Ok(()); + } + +#[test] +fn col_matrix_3x1_end_vector() -> Result<()> { +let expr = " + + ( + + + + 1 + + + 2 + + + 3 + + + ) + "; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "EndVector", + expr, "3 na jedną kolumnę wektor; 1; 2; 3; koniec wektora")?; + return Ok(()); + } + +#[test] +fn row_matrix_1x2_end_vector() -> Result<()> { +let expr = " + + [ + + + + 1 2 + + + ] + "; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "EndVector", + expr, "jeden na 2 wiersz wektor; 1, 2; koniec wektora")?; + return Ok(()); + } + +#[test] +fn matrix_2x2_end_vector() -> Result<()> { +let expr = "( + + + b11 + b12 + + + b21 + b22 + + + )"; +test_ClearSpeak("pl", "ClearSpeak_Matrix", "EndVector", + expr, "2 na 2 macierz; wiersz 1; kolumna 1; b indeks dolny 1 1; kolumna 2; b indeks dolny 1 2; wiersz 2; kolumna 1; b indeks dolny 2 1; kolumna 2; b indeks dolny 2 2; koniec macierzy")?; + return Ok(()); +} + + +#[test] +fn matrix_binomial() -> Result<()> { + let expr = " + ( + 32 + ) + "; + test_ClearSpeak("pl", "ClearSpeak_Matrix", "Combinatorics", expr, "3 po 2")?; + return Ok(()); +} + +#[test] +fn matrix_simple_table() -> Result<()> { + let expr = " + 32 + "; + test("pl", "ClearSpeak", expr, "tablica z; wiersz 1; kolumna 1; 3; przecinek; wiersz 2; kolumna 1; 2") +} + +#[test] +fn mtable_prefix_op() -> Result<()>{ + // When a table is prefixed with a non-blank operator, assume it is something besides array intent + for (op, expected) in [("(", "nawias otwierający, 2 linie; linia 1; 3; linia 2; 2"), + ("[", "nawias kwadratowy otwierający; 2 linie; linia 1; 3; linia 2; 2"), + ("|", "kreska pionowa, 2 linie; linia 1; 3; linia 2; 2"), + ("f", "f, 2 linie; linia 1; 3; linia 2; 2")] { + let expr = format!(" + {op}32 + "); + test("pl", "ClearSpeak", &expr, expected)?; + } + Ok(()) +} + +#[test] +fn mtable_blank_op() -> Result<()>{ + // When a table is prefixed with a blank operator, still assume array intent + let expr = " + \u{2062}32 + "; + test("pl", "ClearSpeak", expr, "; tablica z; wiersz 1; kolumna 1; 3; przecinek; wiersz 2; kolumna 1; 2") +} + + + +#[test] +fn mtable_colspan_table() -> Result<()>{ + let expr = " + 324 + "; + test("pl", "ClearSpeak", expr, "tablica z; wiersz 1; kolumna 1; 3; przecinek; wiersz 2; kolumna 1; 2, kolumna 2; 4") +} + +#[test] +fn bug_mtable_rowspan_colspan() -> Result<()>{ + // Currently, the code correctly computes the number of rows and + // columns, but it does not correctly compute the column number whnen + // colspans are involved. + let expr = " + + + a + b + c + + + de + + + "; + test("pl", "ClearSpeak", expr, + "tablica z; wiersz 1; kolumna 1; a, kolumna 2; b, kolumna 3; c; przecinek; wiersz 2; kolumna 1; d, kolumna 2; e") +} + + + +#[test] +fn matrix_times() { + let expr = " + 1234 + abcd + "; + let _ = test("pl", "SimpleSpeak", expr, + "2 na 2 macierz; wiersz 1; 1, 2; wiersz 2; 3, 4; razy, 2 na 2 macierz; wiersz 1; a, b; wiersz 2; c, d"); +} + +#[test] +fn unknown_mtable_property() -> Result<()> { + let expr = " + + + + a + + + = + + + + b + + + c + − + d + + + + + + + + + + e + − + f + + + + "; + test("pl", "ClearSpeak", expr, + "2 linie; linia 1; a równa się, b plus c minus d; linia 2; plus e minus f")?; + return Ok(()); + } + + +#[test] +fn zero_matrix() -> Result<()> { + let expr = " + [ + + 00 + 00 + + ] + "; + test("pl", "SimpleSpeak", expr, + "2 na 2 macierz zerowa")?; + return Ok(()); + } + +#[test] +fn identity_matrix() -> Result<()> { + let expr = " + ( + + 100 + 010 + 001 + + ) + "; + test("pl", "SimpleSpeak", expr, + "3 na 3 macierz jednostkowa")?; + return Ok(()); + } + +#[test] +fn identity_matrix_false_positive_negative_one() -> Result<()> { + let expr = " + [ + + 10 + 0-1 + + ] + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "2 na 2 macierz diagonalna; kolumna 1; 1; kolumna 2; minus 1")?; + Ok(()) +} + +#[test] +fn identity_matrix_false_positive_zero_diagonal() -> Result<()> { + let expr = " + [ + + 10 + 00 + + ] + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "2 na 2 macierz diagonalna; kolumna 1; 1")?; + Ok(()) +} + +#[test] +fn diagonal_matrix() -> Result<()> { + let expr = " + ( + + 200 + 010 + 00x2 + + ) + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "3 na 3 macierz diagonalna; kolumna 1; 2; kolumna 2; 1; kolumna 3; x do kwadratu")?; + // test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], + // expr, "the 3 by 3 diagonal matrix; row 1, column 1, 2; row 2, column 2, 1; row 3, column 3, x squared"); + return Ok(()); + } + +#[test] +fn single_line_with_label() -> Result<()> { + let expr = r#" + + + (2) + 𝑏 = 2 + + + "#; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Terse")], + expr, "1 linia, z etykietą 2; b równa się 2")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], + expr, "1 równanie, z etykietą 2; b równa się 2")?; + return Ok(()); + } diff --git a/tests/Languages/pl/pl.rs b/tests/Languages/pl/pl.rs index 7c250300..d8297b86 100644 --- a/tests/Languages/pl/pl.rs +++ b/tests/Languages/pl/pl.rs @@ -1255,3 +1255,88 @@ fn rownoleglosc_nie_jest_norma() -> Result<()> { test("pl", "ClearSpeak", expr, "a jest równoległe do b")?; Ok(()) } + +// --- Polska odmiana liczebnika w układach wielowierszowych ------------------- +// Cecha specyficzna dla polskiego: rzeczownik po liczbie odmienia się przez +// liczbę: 1 -> pojedyncza, 2-4 (oprócz 12-14) -> mianownik l.mn. (paucal), +// pozostałe -> dopełniacz l.mn. Zwykłe kopiowanie reguł z angielskiego (sufiks +// "s") dawało "2 równanies" / "5 równania" - te testy pilnują poprawnych form. + +// Buduje układ N równań (mtable z N wierszami "x = i"). +fn uklad_rownan(n: usize) -> String { + let mut wiersze = String::new(); + for i in 1..=n { + wiersze.push_str(&format!( + "x={i}" + )); + } + format!("{wiersze}") +} + +#[test] +fn simplespeak_uklad_dwa_rownania_paucal() -> Result<()> { + // 2 -> "równania" (mianownik l.mn.) + test("pl", "SimpleSpeak", &uklad_rownan(2), + "2 równania; równanie 1; x równa się 1; równanie 2; x równa się 2")?; + Ok(()) +} + +#[test] +fn simplespeak_uklad_piec_rownan_dopelniacz() -> Result<()> { + // 5 -> "równań" (dopełniacz l.mn.), NIE "równania" + let mowa = get_spoken_text_for(&uklad_rownan(5), "SimpleSpeak"); + assert!(mowa.starts_with("5 równań;"), "oczekiwano '5 równań;', było: {mowa}"); + Ok(()) +} + +#[test] +fn simplespeak_uklad_dwanascie_rownan_wyjatek() -> Result<()> { + // 12 -> dopełniacz "równań" (wyjątek 12-14, mimo końcówki 2) + let mowa = get_spoken_text_for(&uklad_rownan(12), "SimpleSpeak"); + assert!(mowa.starts_with("12 równań;"), "oczekiwano '12 równań;', było: {mowa}"); + Ok(()) +} + +#[test] +fn simplespeak_uklad_dwadziescia_dwa_rownania_paucal() -> Result<()> { + // 22 -> "równania" (końcówka 2, poza zakresem 12-14) + let mowa = get_spoken_text_for(&uklad_rownan(22), "SimpleSpeak"); + assert!(mowa.starts_with("22 równania;"), "oczekiwano '22 równania;', było: {mowa}"); + Ok(()) +} + +#[test] +fn clearspeak_uklad_przypadki_odmiana() -> Result<()> { + // ClearSpeak, etykieta Case: 5 -> "przypadków", 12 -> "przypadków" + for (n, forma) in [(5usize, "5 przypadków;"), (12, "12 przypadków;")] { + let mowa = get_spoken_text_cs(&uklad_rownan(n), "Case"); + assert!(mowa.starts_with(forma), "oczekiwano '{forma}', było: {mowa}"); + } + Ok(()) +} + +#[test] +fn clearspeak_uklad_linie_dopelniacz() -> Result<()> { + // ClearSpeak, etykieta Line: 5 -> "linii" (dopełniacz), NIE "linie" + let mowa = get_spoken_text_cs(&uklad_rownan(5), "Line"); + assert!(mowa.starts_with("5 linii;"), "oczekiwano '5 linii;', było: {mowa}"); + Ok(()) +} + +// Pomocnicze: zwróć wypowiedź dla danego MathML/stylu (spójne prefy testowe). +fn get_spoken_text_for(mathml: &str, style: &str) -> String { + set_rules_dir(abs_rules_dir_path()).unwrap(); + set_preference("Language", "pl").unwrap(); + set_preference("SpeechStyle", style).unwrap(); + set_mathml(mathml).unwrap(); + get_spoken_text().unwrap().split_whitespace().collect::>().join(" ") +} + +fn get_spoken_text_cs(mathml: &str, label: &str) -> String { + set_rules_dir(abs_rules_dir_path()).unwrap(); + set_preference("Language", "pl").unwrap(); + set_preference("SpeechStyle", "ClearSpeak").unwrap(); + set_preference("ClearSpeak_MultiLineLabel", label).unwrap(); + set_mathml(mathml).unwrap(); + get_spoken_text().unwrap().split_whitespace().collect::>().join(" ") +} diff --git a/tests/Languages/pl/shared.rs b/tests/Languages/pl/shared.rs new file mode 100644 index 00000000..8f42a8f5 --- /dev/null +++ b/tests/Languages/pl/shared.rs @@ -0,0 +1,609 @@ +/// Tests for rules shared between various speech styles: +/// * modified var +use crate::common::*; +use anyhow::Result; + +#[test] +fn modified_vars() -> Result<()> { + let expr = " + a ` + b ~ + c ̆ + b ̌ + c ` + + r ˇ + + x . + y ˙ + z ¨ + u ⃛ + v ⃜ + + x ^ + + t → + "; + test("pl", "SimpleSpeak", expr, + "a grawis, b tylda, c znak krótkości; b haczek, c grawis; plus r haczek plus; x kropka, y kropka, z diereza, u potrójny kropka; v poczwórny kropka; plus x daszek, plus wektor t")?; + return Ok(()); + +} + +#[test] +fn limit() -> Result<()> { + let expr = " + + lim + x → 0 + + + + sin ⁡ x + x + + + "; + test("pl", "SimpleSpeak", expr, "granica gdy x dąży do 0, z, ułamek, sinus z x, przez x, koniec ułamka")?; + test_prefs("pl", "SimpleSpeak", vec![("Impairment", "LearningDisability")], expr, + "granica gdy x dąży do 0, z, sinus z x, przez x")?; + return Ok(()); + +} + +#[test] +fn limit_from_below() -> Result<()> { + let expr = " + + lim + x ↗ 0 + + + sin ⁡ x + + "; + test("pl", "SimpleSpeak", expr, "granica gdy x dąży od dołu 0, z sinus z x")?; + return Ok(()); + +} + + +#[test] +fn binomial_mmultiscripts() -> Result<()> { + let expr = "Cmn"; + test("pl", "SimpleSpeak", expr, "n po m")?; + return Ok(()); + +} + +#[test] +fn binomial_mmultiscripts_other() -> Result<()> { + let expr = "Cmn"; + test("pl", "SimpleSpeak", expr, "n po m")?; + return Ok(()); + +} + +#[test] +fn binomial_subscript() -> Result<()> { // C_{n,k} + let expr = "Cn,m"; + test("pl", "SimpleSpeak", expr, "n po m")?; + return Ok(()); + +} + +#[test] +fn permutation_mmultiscripts() -> Result<()> { + let expr = "Pkn"; + test("pl", "SimpleSpeak", expr, "k permutacji z n")?; + return Ok(()); + +} + +#[test] +fn permutation_mmultiscripts_sup() -> Result<()> { + let expr = "Pkn"; + test("pl", "SimpleSpeak", expr, "k permutacji z n")?; + return Ok(()); + +} + +#[test] +fn permutation_msubsup() -> Result<()> { + let expr = "Pkn"; + test("pl", "SimpleSpeak", expr, "k permutacji z n")?; + return Ok(()); + +} + +#[test] +fn tensor_mmultiscripts() -> Result<()> { + let expr = " + R i j k l + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, + "wielka r z 4 prawe indeksy, indeks dolny i indeks górny j indeks dolny k indeks dolny l")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Medium")], expr, + "wielka r z 4 prawe indeksy, indeks dolny i indeks górny j indeks dolny k indeks dolny l")?; + return Ok(()); + +} + +#[test] +fn huge_num_mmultiscripts() -> Result<()> { + let expr = " + R i j k l m + I J K L + "; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, + "wielka r z 4 lewe indeksy, lewy indeks dolny wielka i, lewy indeks górny wielka j i kolejne lewe indeksy wielka k none wielka l none koniec lewych indeksów i z 5 prawe indeksy, indeks dolny i indeks górny j indeks dolny k indeks dolny l i kolejne indeksy m none koniec indeksów")?; + return Ok(()); + +} + +#[test] +fn prime() -> Result<()> { + let expr = " x′ "; + test("pl", "SimpleSpeak", expr, "x prim")?; + return Ok(()); + +} + +#[test] +fn given() -> Result<()> { + let expr = "P(A|B)"; + test("pl", "SimpleSpeak", expr, "wielka p; nawias otwierający, wielka a pod warunkiem wielka b; nawias zamykający")?; + test("pl", "ClearSpeak", expr, "wielka p; nawias otwierający, wielka a pod warunkiem wielka b; nawias zamykający")?; // not good, but follows the spec + return Ok(()); + +} + +#[test] +fn simple_msubsup() -> Result<()> { + let expr = " + + + x + + k + + + i + + + + "; + test("pl", "ClearSpeak", expr, "x indeks dolny k, do potęgi i")?; + return Ok(()); + +} + +#[test] +fn non_simple_msubsup() -> Result<()> { + let expr = "ij−2k"; + test("pl", "SimpleSpeak", expr, "i indeks dolny j minus 2 koniec indeksu dolnego, do potęgi k")?; + test("pl", "ClearSpeak", expr, "i indeks dolny j minus 2 koniec indeksu dolnego, do potęgi k")?; + test_prefs("pl", "SimpleSpeak", vec![("Impairment", "LearningDisability")], expr, + "i indeks dolny j minus 2, do potęgi k")?; + return Ok(()); + +} + +#[test] +fn presentation_mathml_in_semantics() -> Result<()> { + let expr = " + + {\\displaystyle x_k^i} + + + x + + k + + + i + + + + + "; + test("pl", "ClearSpeak", expr, "x indeks dolny k, do potęgi i")?; + return Ok(()); + +} + +#[test] +fn roman_like_superscript_identifier_is_not_chemistry() -> Result<()> { + // Regression test for https://github.com/daisy/MathCAT/issues/528 + let expr = " + I + = + − + b + r + + + + z + I + + "; + test("pl", "ClearSpeak", expr, "wielka i równa się, minus b r plus z do potęgi wielka i")?; + Ok(()) +} + +#[test] +fn roman_like_identifier_sequence_is_not_number() -> Result<()> { + // Regression test for https://github.com/daisy/MathCAT/issues/528 + let expr = " + C + + + I + + + X + "; + test("pl", "ClearSpeak", expr, "wielka c plus wielka i plus wielka x")?; + Ok(()) +} + + +#[test] +fn ignore_period() -> Result<()> { + // from https://en.wikipedia.org/wiki/Probability + let expr = " + + {\\displaystyle x_k^i} + + + + P + ( + A + + +  and  + + + B + ) + = + P + ( + A + ∩ + B + ) + = + P + ( + A + ) + P + ( + B + ) + . + + + + + "; + test("pl", "SimpleSpeak", expr, "wielka p; nawias otwierający, wielka a and wielka b; nawias zamykający; równa się; wielka p; nawias otwierający, wielka a przecięcie wielka b; nawias zamykający; równa się; wielka p z wielka a, wielka p z wielka b")?; + return Ok(()); + +} + +#[test] +fn ignore_mtext_period() -> Result<()> { + let expr = "{2}."; + test("pl", "SimpleSpeak", expr, "zbiór 2")?; + return Ok(()); + +} + +#[test] +fn ignore_comma() -> Result<()> { + // from https://en.wikipedia.org/wiki/Probability + let expr = " + + + ϕ + ( + x + ) + = + c + + e + + − + + h + + 2 + + + + x + + 2 + + + + + , + + +"; + test("pl", "SimpleSpeak", expr, "fi z x równa się; c razy, e do potęgi minus h do kwadratu, x do kwadratu")?; + return Ok(()); + +} + +#[test] +#[ignore] // issue #14 +fn ignore_period_and_space() -> Result<()> { + // from https://en.wikipedia.org/wiki/Probability + let expr = " + + + P + ( + A + ∣ + B + ) + = + + + + P + ( + A + ∩ + B + ) + + + P + ( + B + ) + + + + . + + + +"; + test("pl", "ClearSpeak", expr, "cap p, open paren, cap eigh divides cap b, close paren; is equal to; the fraction with numerator; cap p, open paren, cap eigh intersection cap b; close paren; and denominator cap p of cap b")?; + return Ok(()); + +} + + +#[test] +fn bug_199_2pi() -> Result<()> { + let expr = " + + [ + + 0 + + , + + 2 + π + + ) + + "; + test("pl", "SimpleSpeak",expr, "przedział lewostronnie domknięty prawostronnie otwarty od 0 do 2 pi")?; + return Ok(()); + +} + +#[test] +fn caret_and_hat() -> Result<()> { + let expr = "x^2+y^"; + test("pl", "SimpleSpeak",expr, "x daszek 2 plus y daszek")?; + return Ok(()); + +} + +#[test] +fn dots() -> Result<()> { + let expr = " + x.+ + x..+ + x... + "; + test("pl", "SimpleSpeak",expr, "x kropka, plus x .., plus x ...")?; + return Ok(()); +} + +#[test] +fn mn_with_space() -> Result<()> { + let expr = "1 234 567"; + test_prefs("pl", "SimpleSpeak", vec![("DecimalSeparators", "."), ("BlockSeparators", " ,")], expr, "1234567")?; + return Ok(()); + +} + +#[test] +fn ignore_bold() -> Result<()> { + let expr = r#" + x + = + 2 + + 𝒔𝒊𝒏 + ⁡ + t + + - + 1 + "#; + test_prefs("pl", "SimpleSpeak", vec![("IgnoreBold", "false")], + expr, "pogrubione x równa się, 2 sinus z pogrubione t; minus 1")?; + test_prefs("pl", "SimpleSpeak", vec![("IgnoreBold", "true")], + expr, "pogrubione x równa się, 2 sinus z pogrubione t; minus 1")?; + return Ok(()); + +} + +#[test] +fn mn_with_block_and_decimal_separators() -> Result<()> { + let expr = "1,234.56"; // may want to change this for another language + test_prefs("pl", "SimpleSpeak", vec![("DecimalSeparators", "."), ("BlockSeparators", " ,")], expr, "1234.56")?; + return Ok(()); + +} + +#[test] +fn divergence() -> Result<()> { + let expr = "∇·F"; // may want to change this for another language + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "dywergencja wielka f")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, "dywergencja z wielka f")?; + return Ok(()); + +} + +#[test] +fn curl() -> Result<()> { + let expr = "∇×F"; + // may want to change this for another language + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "rotacja wielka f")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, "rotacja z wielka f")?; + return Ok(()); + +} + +#[test] +fn gradient() -> Result<()> { + let expr = "∇F"; + // may want to change this for another language + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, "gradient wielka f")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, "gradient z wielka f")?; + return Ok(()); + +} + +#[test] +fn literal_speak_perpendicular() -> Result<()> { + let expr = r#" + + + A + → + + ⊥ + + B + → + + + "#; + test("pl", "LiteralSpeak", expr, "wielka a strzałka w prawo, perpendicular to, wielka b strzałka w prawo")?; + return Ok(()); + +} + +#[test] +fn literal_speak_chars() -> Result<()> { + let expr = r#" + + + x×y + · + z/2 + + + a∥b + + + x! + + + "#; + test("pl", "LiteralSpeak", expr, "kreska pionowa; x krzyż, y kropka z ukośnik 2; plus a; podwójna pionowa kreska, b plus x wykrzyknik; kreska pionowa")?; + return Ok(()); + +} + +#[test] +fn literal_speak_with_name() -> Result<()> { + let expr = r#" + + f + ⁡ + + ( + + x + ! + + ) + + + "#; + test("pl", "LiteralSpeak", expr, "forced f, lewy nawias x wykrzyknik, prawy nawias")?; + return Ok(()); + +} + +#[test] +fn literal_speak_with_property() -> Result<()> { + let expr = r#" + + f + ⁡ + + ( + + x + ! + + ) + + + "#; + test("pl", "LiteralSpeak", expr, "f, lewy nawias x wykrzyknik, prawy nawias")?; + return Ok(()); + +} + +#[test] +fn literal_intent_property() -> Result<()> { + let expr = r#" + + + A + → + + ⊥ + + B + → + + + "#; + test("pl", "SimpleSpeak", expr, "wielka a strzałka w prawo, perpendicular to, wielka b strzałka w prawo")?; + return Ok(()); + +} + +#[test] +fn literal_intent_property_with_name() -> Result<()> { + let expr = r#" + + f + ⁡ + + ( + + x + ! + + ) + + + "#; + test("pl", "SimpleSpeak", expr, "forced f, nawias otwierający, x wykrzyknik, nawias zamykający")?; + return Ok(()); + +} diff --git a/tests/Languages/pl/units.rs b/tests/Languages/pl/units.rs new file mode 100644 index 00000000..1676cf8a --- /dev/null +++ b/tests/Languages/pl/units.rs @@ -0,0 +1,382 @@ +/// Tests for rules shared between various speech styles: +/// * modified var +use crate::common::*; +use anyhow::Result; + +// The basic layout of the tests is: +// 1. Sweep through all the SI prefixes +// 2. Sweep through each group of SI units +// a) with both singular and plural without prefixes +// b) with both singular and plural with one prefix +// 3. Sweep through each group of units that don't take SI prefixes +// These are broken into chunks so it is easier to see errors, when there are errors + +#[test] +fn prefix_sweep() -> Result<()> { + let expr = r#" + Qg, + Rg, + Yg, + Zg, + Eg, + Pg, + Tg, + Gg, + Mg, + kg, + hg, + dag, + dg, + cg, + mg, + µg, + ng, + pg, + fg, + ag, + zg, + yg, + rg, + qg + "#; + test("pl", "SimpleSpeak", expr, + "kwetta-grams, przecinek; ronna-grams, przecinek; jotta-grams, przecinek; zetta-grams, przecinek; eksa-grams, przecinek; peta-grams, przecinek; tera-grams, przecinek; giga-grams, przecinek; mega-grams, przecinek; kilo-grams, przecinek; hekto-grams, przecinek; deka-grams, przecinek; decy-grams, przecinek; centy-grams, przecinek; mili-grams, przecinek; mikro-grams, przecinek; nano-grams, przecinek; piko-grams, przecinek; femto-grams, przecinek; atto-grams, przecinek; zepto-grams, przecinek; jokto-grams, przecinek; ronto-grams, przecinek; kwekto-grams")?; + return Ok(()); + +} + +#[test] +fn si_base() -> Result<()> { + let expr = r#" + 1A,2A, + 1cd,2cd, + 1K,2K, + 1K,2K, + 1g,2g, + 1m,2m, + 1mol,2mol, + 1s,2s, + 1″,2″, + 1",2", + 1sec,2sec + "#; + test("pl", "SimpleSpeak", expr, + "1 amper, przecinek; 2 ampers, przecinek; 1 kandela, przecinek; 2 kandelas, przecinek; 1 kelwin, przecinek; 2 kelwins, przecinek; 1 kelwin, przecinek; 2 kelwins, przecinek; 1 gram, przecinek; 2 grams, przecinek; 1 metr, przecinek; 2 metrs, przecinek, 1 mol, przecinek; 2 mols, przecinek; 1 sekunda, przecinek; 2 sekundas, przecinek; 1 sekunda, przecinek; 2 sekundas, przecinek; 1 sekunda, przecinek; 2 sekundas, przecinek; 1 sekunda, przecinek; 2 sekundas")?; + return Ok(()); + +} + +#[test] +fn si_base_with_prefixes() -> Result<()> { + let expr = r#" + 1QA,2RA, + 1Ycd,2Zcd, + 1EK,2PK, + 1TK,2GK, + 1Mg,2kg, + 1hm,2dam, + 1dmol,2cmol, + 1ms,2µs, + 1nsec,2psec + "#; + test("pl", "SimpleSpeak", expr, + "1 kwetta-amper, przecinek; 2 ronna-ampers, przecinek; 1 jotta-kandela, przecinek; 2 zetta-kandelas; przecinek; 1 eksa-kelwin, przecinek; 2 peta-kelwins, przecinek; 1 tera-kelwin, przecinek; 2 giga-kelwins, przecinek; 1 mega-gram, przecinek; 2 kilo-grams, przecinek; 1 hekto-metr, przecinek; 2 deka-metrs, przecinek; 1 decy-mol, przecinek; 2 centy-mols, przecinek; 1 mili-sekunda, przecinek; 2 mikro-sekundas; przecinek; 1 nano-sekunda, przecinek; 2 piko-sekundas")?; + return Ok(()); + +} + + +#[test] +fn si_derived_1() -> Result<()> { + let expr = r#" + 1Bq,2Bq, + 1C,2C, + 1°C,2°C, + 1℃,2℃, + 1F,2F, + 1Gy,2Gy, + 1H,2H, + 1Hz,2Hz, + 1J,2J, + 1kat,2kat, + 1lm,2lm, + 1lx,2lx + "#; + test("pl", "SimpleSpeak", expr, + "1 bekerel, przecinek; 2 bekerels, przecinek; 1 kulomb, przecinek; 2 kulombs, przecinek; 1 stopień Celsjusza, przecinek; 2 stopnie Celsjusza, przecinek; 1 stopień Celsjusza, przecinek; 2 stopnie Celsjusza, przecinek; 1 farad, przecinek; 2 farads, przecinek; 1 grej, przecinek; 2 grejs, przecinek; 1 henr, przecinek; 2 henry, przecinek; 1 herce, przecinek; 2 herces, przecinek; 1 dżul, przecinek; 2 dżuls, przecinek; 1 katal, przecinek; 2 katals, przecinek; 1 lumen, przecinek; 2 lumens, przecinek; 1 luks, przecinek; 2 luksy")?; + return Ok(()); + +} + +#[test] +fn si_derived_1_with_prefixes() -> Result<()> { + let expr = r#" + 1QBq,2RBq, + 1YC,2ZC, + 1EF,2PF, + 1TGy,2GGy, + 1MH,2kH, + 1daHz,2dHz, + 1cJ,2mJ, + 1µkat,2nkat, + 1plm,2flm, + 1alx,2zlx, + 1m°C,2µ°C, + 1p℃,2n℃ + "#; + test("pl", "SimpleSpeak", expr, + "1 kwetta-bekerel, przecinek; 2 ronna-bekerels; przecinek; 1 jotta-kulomb, przecinek; 2 zetta-kulombs; przecinek; 1 eksa-farad, przecinek; 2 peta-farads, przecinek; 1 tera-grej, przecinek; 2 giga-grejs, przecinek; 1 mega-henr, przecinek; 2 kilo-henry, przecinek; 1 deka-herce, przecinek; 2 decy-herces, przecinek; 1 centy-dżul, przecinek; 2 mili-dżuls, przecinek; 1 mikro-katal, przecinek; 2 nano-katals, przecinek; 1 piko-lumen, przecinek; 2 femto-lumens, przecinek; 1 atto-luks, przecinek; 2 zepto-luksy, przecinek; 1 mili-stopień Celsjusza; przecinek; 2 mikro-stopnie Celsjusza; przecinek; 1 piko-stopień Celsjusza; przecinek; 2 nano-stopnie Celsjusza")?; + return Ok(()); + +} + +#[test] +fn si_derived_2() -> Result<()> { + let expr = r#" + 1N,2N, + 1Ω,2Ω, + 1Ω,2Ω, + 1Pa,2Pa, + 1S,2S, + 1Sv,2Sv, + 1T,2T, + 1V,2V, + 1W,2W, + 1Wb,2Wb + "#; + test("pl", "SimpleSpeak", expr, + "1 niuton, przecinek; 2 niutons, przecinek, 1 om przecinek; 2 oms, przecinek, 1 om przecinek; 2 oms, przecinek; 1 paskal, przecinek; 2 paskals, przecinek; 1 siemens, przecinek; 2 siemens, przecinek; 1 siwert, przecinek; 2 siwerts, przecinek; 1 tesla, przecinek; 2 teslas, przecinek; 1 wolt, przecinek; 2 wolty, przecinek, 1 wat, przecinek; 2 waty, przecinek; 1 weber, przecinek; 2 webers")?; + return Ok(()); + +} + +#[test] +fn si_derived_2_with_prefixes() -> Result<()> { + let expr = r#" + 1qN,2rN, + 1yΩ,2zΩ, + 1aΩ,2fΩ, + 1pPa,2nPa, + 1µS,2mS, + 1cSv,2dSv, + 1daT,2hT, + 1kV,2MV, + 1GW,2TW, + 1PWb,2EWb + "#; + test("pl", "SimpleSpeak", expr, + "1 kwekto-niuton, przecinek; 2 ronto-niutons; przecinek; 1 jokto-om, przecinek; 2 zepto-oms, przecinek; 1 atto-om, przecinek; 2 femto-oms, przecinek; 1 piko-paskal, przecinek; 2 nano-paskals, przecinek; 1 mikro-siemens, przecinek; 2 mili-siemens, przecinek; 1 centy-siwert, przecinek; 2 decy-siwerts, przecinek; 1 deka-tesla, przecinek; 2 hekto-teslas, przecinek; 1 kilo-wolt, przecinek; 2 mega-wolty, przecinek; 1 giga-wat, przecinek; 2 tera-waty, przecinek; 1 peta-weber, przecinek; 2 eksa-webers")?; + return Ok(()); + +} + + +#[test] +fn si_accepted() -> Result<()> { + let expr = r#" + 1l,2l, + 1L,2L, + 1ℓ,2ℓ, + 1t,2t, + 1Da,2Da, + 1Np,2Np, + 1u,2u, + 1eV,2eV, + 1rad,2rad, + 1sr,2sr, + 1a,2a, + 1as,2as, + 1b,2b, + 1B,2B, + 1Bd,2Bd + "#; + test("pl", "SimpleSpeak", expr, + "1 litr, przecinek; 2 litrs, przecinek; 1 litr, przecinek; 2 litrs, przecinek; 1 litr, przecinek; 2 litrs, przecinek; 1 tona, przecinek; 2 tonas, przecinek; 1 dalton, przecinek; 2 daltons, przecinek; 1 neper, przecinek; 2 nepers, przecinek; 1 jednostka masy atomowej, przecinek; 2 jednostka masy atomowejs; przecinek; 1 elektronowolt, przecinek; 2 elektronowolts, przecinek; 1 radian, przecinek; 2 radians, przecinek; 1 steradian, przecinek; 2 steradians, przecinek, 1 rok, przecinek; 2 roks, przecinek; 1 sekunda łuku, przecinek; 2 sekunda łukus, przecinek, 1 bit, przecinek; 2 bits, przecinek; 1 bajt, przecinek; 2 bajts, przecinek, 1 bod, przecinek; 2 bods")?; + return Ok(()); + +} + +#[test] +fn si_accepted_with_prefixes() -> Result<()> { + let expr = r#" + 1Ql,2Rl, + 1YL,2ZL, + 1Eℓ,2Pℓ, + 1Tt,2Gt, + 1MDa,2kDa, + 1dNp,2cNp, + 1hu,2dau, + 1meV,2µeV, + 1nrad,2prad, + 1fsr,2asr, + 1Ga,2Ma, + 1zas,2yas, + 1kb,2Mb, + 1GB,2TB, + 1TBd,2EBd + "#; + test("pl", "SimpleSpeak", expr, + "1 kwetta-litr, przecinek; 2 ronna-litrs, przecinek; 1 jotta-litr, przecinek; 2 zetta-litrs, przecinek; 1 eksa-litr, przecinek; 2 peta-litrs, przecinek; 1 tera-tona, przecinek; 2 giga-tonas, przecinek; 1 mega-dalton, przecinek; 2 kilo-daltons, przecinek; 1 decy-neper, przecinek; 2 centy-nepers, przecinek; 1, hekto-jednostka masy atomowej; przecinek; 2, deka-jednostka masy atomowejs; przecinek; 1 mili-elektronowolt; przecinek; 2 mikro-elektronowolts; przecinek; 1 nano-radian, przecinek; 2 piko-radians, przecinek; 1 femto-steradian, przecinek; 2 atto-steradians; przecinek; 1 giga-rok, przecinek; 2 mega-roks, przecinek; 1 zepto-sekunda łuku; przecinek; 2 jokto-sekunda łukus; przecinek; 1 kilo-bit, przecinek; 2 mega-bits, przecinek; 1 giga-bajt, przecinek; 2 tera-bajts, przecinek; 1 tera-bod, przecinek; 2 eksa-bods")?; + return Ok(()); + +} + +#[test] +fn without_prefix_time() -> Result<()> { + let expr = r#" + 1″,2″, + 1",2", + 1′,2′, + 1',2', + 1min,2min, + 1h,2h, + 1hr,2hr, + 1Hr,2Hr, + 1d,2d, + 1dy,2dy, + 1w,2w, + 1wk,2wk, + 1y,2y, + 1yr,2yr + "#; + test("pl", "SimpleSpeak", expr, + "1 sekunda, przecinek; 2 sekundas, przecinek; 1 sekunda, przecinek; 2 sekundas, przecinek; 1 minuta, przecinek; 2 minutas, przecinek; 1 minuta, przecinek; 2 minutas, przecinek; 1 minuta, przecinek; 2 minutas, przecinek; 1 godzina, przecinek; 2 godzinas, przecinek; 1 godzina, przecinek; 2 godzinas, przecinek; 1 godzina, przecinek; 2 godzinas, przecinek; 1 dzień, przecinek; 2 dzieńs, przecinek; 1 dzień, przecinek; 2 dzieńs, przecinek; 1 tydzień, przecinek; 2 tydzieńs, przecinek; 1 tydzień, przecinek; 2 tydzieńs, przecinek, 1 rok, przecinek; 2 roks, przecinek, 1 rok, przecinek; 2 roks")?; + return Ok(()); + +} + +#[test] +fn without_prefix_angles() -> Result<()> { + let expr = r#" + 1°,2°, + 1deg,2deg, + 1arcmin,2arcmin, + 1amin,2amin, + 1am,2am, + 1MOA,2MOA, + 1arcsec,2arcsec, + 1asec,2asec + "#; + test("pl", "SimpleSpeak", expr, + "1 stopień, przecinek; 2 stopnie, przecinek; 1 stopień, przecinek; 2 stopnie, przecinek; 1 minuta łuku, przecinek; 2 minuta łukus, przecinek; 1 minuta łuku, przecinek; 2 minuta łukus, przecinek; 1 minuta łuku, przecinek; 2 minuta łukus, przecinek; 1 minuta łuku, przecinek; 2 minuta łukus, przecinek; 1 sekunda łuku, przecinek; 2 sekunda łukus, przecinek; 1 sekunda łuku, przecinek; 2 sekunda łukus")?; + return Ok(()); + +} + +#[test] +fn without_prefix_distance() -> Result<()> { + let expr = r#" + 1au,2au, + 1ltyr,2ltyr, + 1pc,2pc, + 1Å,2Å, + 1Å,2Å, + 1fm,2fm + "#; + test("pl", "SimpleSpeak", expr, + "1 jednostka astronomiczna, przecinek; 2 jednostka astronomicznas; przecinek; 1 rok świetlny, przecinek; 2 rok świetlnys, przecinek; 1 parsek, przecinek; 2 parseks, przecinek; 1 angstrem, przecinek; 2 angstrems, przecinek; 1 angstrem, przecinek; 2 angstrems, przecinek; 1 fermi, przecinek; 2 fermis")?; + return Ok(()); + +} + +#[test] +fn without_prefix_other() -> Result<()> { + let expr = r#" + 1ha,2ha, + 1dB,2dB, + 1atm,2atm, + 1amu,2amu, + 1bar,2bar, + 1cal,2cal, + 1Ci,2Ci, + 1grad,2grad, + 1M,2M, + 1R,2R, + 1rpm,2rpm, + 1fl dr,2fl dr, + 1℧,2℧, + 1dyn,2dyn, + 1erg,2erg + "#; + test("pl", "SimpleSpeak", expr, + "1 hektar, przecinek; 2 hektars, przecinek; 1 decybel, przecinek; 2 decybels, przecinek; 1 atmosfera, przecinek; 2 atmosferas, przecinek; 1 jednostka masy atomowej, przecinek; 2 jednostka masy atomowejs; przecinek, 1 bar, przecinek; 2 bars, przecinek; 1 kaloria, przecinek; 2 kalorias, przecinek; 1 kiur, przecinek; 2 kiurs, przecinek; 1 grad, przecinek; 2 grads, przecinek; 1 molowy, przecinek; 2 molowys, przecinek; 1 rentgen, przecinek; 2 rentgens, przecinek; 1 obrót na minutę, przecinek; 2 obroty na minutę, przecinek; 1 drachma płynu, przecinek; 2 drachma płynus, przecinek; 1 M h o, przecinek; 2 M h os, przecinek; 1 dyna, przecinek; 2 dynas, przecinek, 1 erg, przecinek; 2 ergs")?; + return Ok(()); + +} + +#[test] +fn without_prefix_powers_of_2() -> Result<()> { + let expr = r#" + 1Kib,2Kib, + 1Mib,2Mib, + 1Gib,2Gib, + 1Tib,2Tib, + 1Pib,2Pib, + 1Eib,2Eib, + 1Zib,2Zib, + 1Yib,2Yib, + 1KiB,2KiB, + 1MiB,2MiB, + 1GiB,2GiB, + 1TiB,2TiB, + 1PiB,2PiB, + 1EiB,2EiB, + 1ZiB,2ZiB, + 1YiB,2YiB + "#; + test("pl", "SimpleSpeak", expr, + "1 kibibit, przecinek; 2 kibibits, przecinek; 1 mebibit, przecinek; 2 mebibits, przecinek; 1 gibibit, przecinek; 2 gibibits, przecinek; 1 tebibit, przecinek; 2 tebibits, przecinek; 1 pebibit, przecinek; 2 pebibits, przecinek; 1 eksbibit, przecinek; 2 eksbibits, przecinek; 1 zebibit, przecinek; 2 zebibits, przecinek; 1 jobibit, przecinek; 2 jobibits, przecinek; 1 kibibajt, przecinek; 2 kibibajts, przecinek; 1 mebibajt, przecinek; 2 mebibajts, przecinek; 1 gibibajt, przecinek; 2 gibibajts, przecinek; 1 tebibajt, przecinek; 2 tebibajts, przecinek; 1 pebibajt, przecinek; 2 pebibajts, przecinek; 1 eksbibajt, przecinek; 2 eksbibajts, przecinek; 1 zebibajt, przecinek; 2 zebibajts, przecinek; 1 jobibajt, przecinek; 2 jobibajts")?; + return Ok(()); + +} + + +#[test] +fn si_other_numbers() -> Result<()> { + let expr = r#"1.0l, + 2.0 m, + x ms, + yµs, + dag, + 1235daN, + 2.5µsec, + 32.34mol"#; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Terse")], expr, + "10 l przecinek, 20 m przecinek; x mili-sekundas; przecinek; y mikro-sekundas; przecinek; deka-grams, przecinek; 1235 deka-niutons; przecinek; 25 mikro-sekundas; przecinek; 3234 mols")?; + test_prefs("pl", "ClearSpeak", vec![("Verbosity", "Medium")], expr, + "10 litr, przecinek; 20 metrs, przecinek; x mili-sekundas; przecinek; y mikro-sekundas; przecinek; deka-grams, przecinek; 1235 deka-niutons; przecinek; 25 mikro-sekundas; przecinek; 3234 mols")?; + test_prefs("pl", "SimpleSpeak", vec![("Verbosity", "Verbose")], expr, + "10 litr, przecinek; 20 metrs, przecinek; x mili-sekundas; przecinek; y mikro-sekundas; przecinek; deka-grams, przecinek; 1235 deka-niutons; przecinek; 25 mikro-sekundas; przecinek; 3234 mols")?; + return Ok(()); + +} + + +#[test] +fn test_mtext_inference() -> Result<()> { + let expr = r#"[ + 1t, + 2PA, + 3Pa, + 4.5mT + ]"#; + test("pl", "SimpleSpeak", expr, + "nawias kwadratowy otwierający; 1 tona, przecinek; 2 peta-ampers, przecinek; 3 paskals, przecinek; 45 mili-teslas; nawias kwadratowy zamykający")?; + return Ok(()); + +} + + #[test] + fn infer_unit() -> Result<()> { + let expr = r#" + 3m, + 1km, + 3m, + 310F, + mmin + "#; + test("pl", "SimpleSpeak", expr, + "3 metrs, przecinek; 1 kilo-metr, przecinek; 3 metrs, przecinek; 3 dziesiąte farads, przecinek; m indeks dolny minimum koniec indeksu dolnego")?; + return Ok(()); + + }