diff --git a/Rules/Languages/hu/ClearSpeak_Rules.yaml b/Rules/Languages/hu/ClearSpeak_Rules.yaml
index 02040fc5..73d8eaf5 100644
--- a/Rules/Languages/hu/ClearSpeak_Rules.yaml
+++ b/Rules/Languages/hu/ClearSpeak_Rules.yaml
@@ -623,7 +623,7 @@
       - test:
           if: "starts-with(name(.), 'open')"
           then: [T: "nem"]      # phrase(the interval from a to b 'not' including b)
-      - T: "tartalmazza a"      # phrase(the interval from a to b not 'including' b)
+      - T: "tartalmazza a(z)"      # phrase(the interval from a to b not 'including' b)
       - x: "*[1]"
       - T: "elemet"
     # logic to deal with [not] arg #1
@@ -647,7 +647,7 @@
               if: "name(.) = 'open-interval' or name(.) = 'closed-open-interval'"
               then: [T: "nem"]      # phrase(the interval 'not' including a)
           - T: "tartalmazza"      # phrase(the interval not 'including' a)
-          - T: "a"
+          - T: "a(z)"
       - x: "*[2]"
       - T: "elemet"
     # onto the [not] [including]... part
diff --git a/Rules/Languages/hu/SimpleSpeak_Rules.yaml b/Rules/Languages/hu/SimpleSpeak_Rules.yaml
index b5f263c3..5037a412 100644
--- a/Rules/Languages/hu/SimpleSpeak_Rules.yaml
+++ b/Rules/Languages/hu/SimpleSpeak_Rules.yaml
@@ -574,7 +574,7 @@
       - test:
           if: "starts-with(name(.), 'open')"
           then: [T: "nem"]      # phrase(the interval from a to b 'not' including b)
-      - T: "tartalmazza a"      # phrase(the interval from a to b not 'including' b)
+      - T: "tartalmazza a(z)"      # phrase(the interval from a to b not 'including' b)
       - x: "*[1]"
       - T: "elemet"
     # logic to deal with [not] arg #1
@@ -598,7 +598,7 @@
               if: "name(.) = 'open-interval' or name(.) = 'closed-open-interval'"
               then: [T: "nem"]      # phrase(the interval 'not' including a)
           - T: "tartalmazza"      # phrase(the interval not 'including' a)
-          - T: "a"
+          - T: "a(z)"
       - x: "*[2]"
       - T: "elemet"
     # onto the [not] [including]... part
diff --git a/Rules/Languages/hu/definitions.yaml b/Rules/Languages/hu/definitions.yaml
index c0e75bee..bdc64942 100644
--- a/Rules/Languages/hu/definitions.yaml
+++ b/Rules/Languages/hu/definitions.yaml
@@ -23,28 +23,28 @@
     #"closed-open-interval":"function=interval between; included and",
     #"open-closed-interval":"function=interval between; and included",
     #"open-interval":"function=open interval between; and",
-    "inverse":"function=inverse || postfix=inverse", 
+    "inverse":"function=inverz || postfix=inverz", 
     "domain": "function= ; domén",
     "codomain": "function= ; kodomán",
-    "image":"function=image", 
+    "image":"function=kép", 
     #"fraction":"function=fraction; over; end fraction", # NOTE: Fails
-    "mixed-fraction":"infix=and", # NOTE: in website says function, but follow infix speech pattern.
-    "greatest-common-divisor": "function=gcd: a GCD: a legnagyobb közös osztó",
-    "quotient":"function=szám rész; osztva ezzel:", # NOTE: Logic somewhere here failing, becomes "divided by of x comma, y" instead of "integer part of x divided by y"
-    "evaluated-at":"infix=értékelték",
-    "remainder":"function=a maradék; osztva ezzel:",
+    "mixed-fraction":"infix=és", # NOTE: in website says function, but follow infix speech pattern.
+    "greatest-common-divisor": "function=a legnagyobb közös osztó",
+    "quotient":"function=egész rész osztva", # NOTE: Logic somewhere here failing, becomes "divided by of x comma, y" instead of "integer part of x divided by y"
+    "evaluated-at":"infix=értékelve || postfix=értékként",
+    "remainder":"function=a maradék, osztva",
     "max":"function=max",
     "min":"function=min",
     "power":"infix=a hatványra",
     "root":"function=root",
-    "imaginary-part": "function=képzeletbeli rész: a képzeletbeli rész: a képzeletbeli rész",
+    "imaginary-part": "a képzeletbeli rész",
     "least-common-multiple": "function=lcm: a legkisebb közös többszörös: a legkisebb közös többszörös",
     "complex-conjugate":"function=Komplex konjugált",
     "complex-arg":"function=argumentum",
-    "polar-coordinate":"function=poláris koordináta; vessző",
-    "spherical-coordinate":"function=gömb koordináta; vessző; vessző",
-    "cartesian-coordinate":"function=derékszögű koordináta; vessző",
-    "coordinate":"function=koordináta; vessző",
+    "polar-coordinate":"function=poláris koordináta",
+    "spherical-coordinate":"function=gömb koordináta",
+    "cartesian-coordinate":"function=derékszögű koordináta",
+    "coordinate":"function=koordináta",
     "floor":"function=lépcső",
     "ceiling":"function=mennyezet",
     "round":"function=kerekített érték",
@@ -60,7 +60,7 @@
     "dimension": "function=; dimenzió : dimenzió: a dimenzió; dimenzió vége",
     "homomorphism": "function= ; homomorfizmus : homomorfizmus: a homomorfizmus; homomorfizmus vége",
     "kernel": "function= ; kernel : kernel: a kernel; kernel vége",
-    "dot-product": "infix=skaláris szorzat: skaláris szorzat: skaláris szorzat: skaláris szorzat",
+    "dot-product": "infix=skaláris szorzat",
 
     #"divergence": "function= ; dihv: divergencia: divergencia; divergencia vége",
     #"laplacian": "function=laplaciáns",   # speech engines don't do a good job with "laplacian"
@@ -69,19 +69,20 @@
     ### Calculus
     "definite-integral":"function=integrál felett || function=integrál innen:; ide:", # Property ???
     "derivative":"function=a deriváltja; mely erre vonatkozik:", # Property ???
-    "tends-to":"infix=általában",
+    "tends-to":"infix=ehhez tart",
     "tends-to-from-above":"infix=általában alulról indul",
-
+    "tends-to-from-below":"infix=alulról indul",
     ### Sets
     "set": "function= ; halmaz: a halmaz",
+    "set-difference":"function=különbséghalmaz || infix=mínusz || postfix=különbséghalmaza", # NOTE: not tested
     "complement":"function=komplemens",
-    "empty-set":"nofix=üres halmaz",
+    "empty-set":"function=üres halmaz",
     "cardinality":"function=számosság", # NOTE: does not have a defined speech template in website
     "list":"function=lista",
     "tuple": "function= ; tuple: a tuple",
     ### Sequence and Series
     "sum":"function= ; összegzés : összeg ; ", #: sum over : sum from; to",
-    "product":"function=produktum || function=produktum vége || function=produktum innen:; ide:",
+    "product":"function=szorzat || function=szorzat vége || function=szorzat innen ide",
 
     ### Elementary classical functions
     "sine":"function=szinusz: szinusz",
@@ -91,23 +92,23 @@
     "cosecant":"function=koszekáns: koszekáns",
     "cotangent":"function=kotangens: kotangens",
     "arcsine":"function=arkusz szinusz",
-    #"arccosine":"function=arkusz koszinusz",
+    "arccosine":"function=arkusz koszinusz",
     "arctangent":"function=arkusz tangens",
     "arcsecant":"function=arkusz szekáns",
     "arccosecant":"function=arkusz koszekáns",
     "arccotangent":"function=arkusz kotangens",
     "hyperbolic-sine":"function=hiperbolikus szinusz",
     "hyperbolic-cosine":"function=hiperbolikus koszinusz",
-    "hyperbolic-tangent":"function=hiperbolikus tangenstanch",
-    "hyperbolic-secant":"function=sech",
-    "hyperbolic-cosecant":"function=cosech",
-    "hyperbolic-cotangent":"function=coth",
-    "arc-hyperbolic-sine":"function=arc shine",
-    "arc-hyperbolic-cosine":"function=arc cosh",
-    "arc-hyperbolic-tangent":"function=arc tanch",
-    "arc-hyperbolic-secant":"function=arc sech",
-    "arc-hyperbolic-cosecant":"function=arc cosech",
-    "arc-hyperbolic-cotangent":"function=arc coth",
+    "hyperbolic-tangent":"function=hiperbolikus tangens",
+    "hyperbolic-secant":"function=hiperbolikus szekáns",
+    "hyperbolic-cosecant":"function=hiperbolikus koszekáns",
+    "hyperbolic-cotangent":"function=hiperbolikus kotangens",
+    "arc-hyperbolic-sine":"function=arkusz hiperbolikus szinusz",
+    "arc-hyperbolic-cosine":"function=arkusz hiperbolikus koszinusz",
+    "arc-hyperbolic-tangent":"function=arkusz hiperbolikus tangens",
+    "arc-hyperbolic-secant":"function=arkusz hiperbolikus szekáns",
+    "arc-hyperbolic-cosecant":"function=arkusz hiperbolikus koszekáns",
+    "arc-hyperbolic-cotangent":"function=arkusz hiperbolikus kotangens",
     "exponential":"function=exponenciális",
     "natural-logarithm": "function=l n: természetes alapú logaritmus: természetes alapú logaritmus",
     "logarithm":"function=logaritmus", ##Check arity 2 
@@ -138,7 +139,7 @@
 
     ### Constants and Sets
     "set-of-integers":"nofix=ℤ: az összes egész szám halmaza",
-    "set-of-reals":"nofix=ℝ: az összes valós szám halmaza",
+    "set-of-reals":"nofix=valós számok halmaza: az összes valós szám halmaza",
     "set-of-rationals":"nofix=ℚ: az összes racionális szám halmaza",
     "set-of-natural-numbers":"nofix=ℕ: az összes természetes szám halmaza",
     "set-of-complex-numbers":"nofix=ℂ: az összes komplex szám halmaza",
@@ -167,13 +168,13 @@
     "highlight":"postfix=kiemelt",
     "least-common-denominator":"function=legkisebb közös nevező",
     "rate":"infix=per",
-    "constraint":"infix= ; korlátozással; ", 
+    "constraint":"infix= ; feltétellel; ", 
 
     "binomial-coefficient":"infix=választ",
     "pochhammer":"function=permutáció",
     "permutation-cycle":"function=permutációs ciklus",
-    "embellished-name":"infix=jegyzetekkel",
-
+    "embellished-name":"infix=megjegyzéssel",
+    "annotation":"infix= ; ami ;",              # NOTE: Follows the same order as indexed-by, in site listed as function. Should it be infix?
     ### Other
     ## Default fixity function
     "curl": "function=rotáció",
@@ -185,7 +186,7 @@
     "angle": "prefix=szög",
     "angle-measure": "prefix=szögmérés",
     "change": "prefix=változás",
-    "for-all": "prefix=mindenkinek",
+    "for-all": "prefix=minden",
     "measured-angle": "prefix=mért szög",
     "not": "prefix=nem",
     "number-of": "prefix=száma",
@@ -198,7 +199,7 @@
 
     ## Default fixity infix
     "and": "infix=és",
-    "applied-to": "infix=alkalmazva erre",
+    "applied-to": "infix=alkalmazva",
     "approximately": "infix=hozzávetőlegesen",
     "congruent": "infix=egybeesik",
     "cartesian-product": "infix=derékszögű szorzat",
@@ -210,7 +211,7 @@
     "does-not-belong-to": "infix=nem tartozik hozzá",
     "does-not-divide": "infix=nem osztja",
     "downwards-diagonal-ellipsis": "infix=lefelé mutató átlós ellipszis",
-    "direct-product": "infix=direkt produktum",
+    "direct-product": "infix=direkt szorzat",
     "element-of": "infix=eleme",
     "ellipsis": "infix=ellipszis",
     "equals": "infix=egyenlő",
@@ -222,7 +223,7 @@
     "identically-equals": "infix=teljesen egyenlő",
     "if-and-only-if": "infix=akkor és csak akkor, ha",
     "implies": "infix=utal",
-    "inner-product": "infix=belső produktum",
+    "inner-product": "infix=belső szorzat",
     "intersection": "infix=keresztezi",
     "less-than": "infix=kisebb, mint",
     "less-than-or-equal-to": "infix=kisebb vagy egyenlő, mint",
@@ -231,13 +232,13 @@
     "member-of": "infix=tagja",
     "minus-or-plus": "infix=mínusz vagy plusz",
     "not-subset": "infix=nem részhalmaza",
-    "not-superset": "infix=nem szuperhalmaz",
+    "not-superset": "infix=nem szuperhalmaza",
     "not-equal-to": "infix=nem egyenlő",
     "not-member-of": "infix=nem tagja",
     "not-parallel-to": "infix=nem párhuzamos",
-    "obtained-from": "infix=származó",
+    "obtained-from": "infix=innen származik",
     "or": "infix=vagy",
-    "outer-product": "infix=külső produktum",
+    "outer-product": "infix=külső szorzata",
     "parallel-to": "infix=párhuzamos",
     "perpendicular": "infix=merőleges",
     "plus": "infix=plusz || prefix=pozitív", # Prefix not tested
@@ -246,16 +247,16 @@
     "precedes": "infix=megelőzi",
     "proportional": "infix=arányos",
     "range-separator": "infix=keresztül",
-    "ratio": "infix=hányados",
+    "ratio": "infix=arány",
     "similar": "infix=hasonló",
     "subset": "infix=részhalmaza",
     "subset-or-equal": "infix=részhalmaza vagy egyenlő",
-    "succeeds": "infix=sikerül",
+    "succeeds": "infix=követi",
     "such-that": "infix=úgy, hogy",
     "superset": "infix=szuperhalmaza",
-    "superset-or-equal": "infix=szuperhalmaz vagy egyenlő",
+    "superset-or-equal": "infix=szuperhalmaza vagy egyenlő",
     "tilde": "infix=tilde",
-    "times": "infix=szorzata",
+    "times": "infix=szorozva",
     "union": "infix=unió",
     "upwards-diagonal-ellipsis": "infix=felfelé átlós ellipszis",
     "vertical-ellipsis": "infix=függőleges ellipszis",
@@ -270,9 +271,9 @@
     "distance":"nofix=távolság; távolság: távolság",
     "probability":"nofix=P: valószínűség",
     "radius":"nofix=r: sugár",
-    "volume":"nofix=V: hangerő || function=",
+    "volume":"nofix=hangerő: hangerő || function=hangerő",
     "exponential-e":"nofix=e",
-    "imaginary-i":"nofix=i",
+    "imaginary-i":"nofix=képzeletbeli én",
     "differential-d":"nofix=d",
     "golden-ratio":"nofix=aranymetszés",
 
@@ -290,11 +291,11 @@
     # These are the parts of a formula that can be navigated to
     "large-op": "base; lower limit; upper limit",
     "mfrac": "numerator; denominator",
-    "fraction": "numerator; denominator",
-    "msqrt": "root",
-    "square-root": "root",
+    "fraction": "számláló; nevező",
+    "msqrt": "gyök",
+    "square-root": "gyök",
     "mroot": "root; root index",
-    "root": "root; root index",
+    "root": "gyök; gyök index",
     "msub": "base; subscript",
     "sub": "base; subscript",
     "logarithm-with-base": "base",
diff --git a/tests/Languages/hu.rs b/tests/Languages/hu.rs
index 45bce3f9..ac24dd22 100644
--- a/tests/Languages/hu.rs
+++ b/tests/Languages/hu.rs
@@ -15,9 +15,9 @@ mod ClearSpeak {
 mod SimpleSpeak {
     mod functions;
     mod large_ops;
-    // mod menclose;
+    mod menclose;
     mod mfrac;
-    // mod mroot;
+    mod mroot;
     mod msup;
     mod sets;
     mod geometry;
@@ -29,6 +29,7 @@ mod shared;
 mod units;
 mod chemistry;
 mod alphabets;
+mod definitions;
 mod intent;
 mod mtable;
 
diff --git a/tests/Languages/hu/ClearSpeak/functions.rs b/tests/Languages/hu/ClearSpeak/functions.rs
index e9449b21..3dd6e94e 100644
--- a/tests/Languages/hu/ClearSpeak/functions.rs
+++ b/tests/Languages/hu/ClearSpeak/functions.rs
@@ -516,7 +516,7 @@ fn explicit_times_none_superscript() -> Result<()> {
         <mo>)</mo></mrow>
     </math>";
     test_ClearSpeak("hu", "ClearSpeak_Paren", "Interval",expr,
-    "c től d ig terjedő intervallum, nem tartalmazza a c elemet vagy d elemet")?;
+    "c től d ig terjedő intervallum, nem tartalmazza a(z) c elemet vagy d elemet")?;
     return Ok(());
 
 }
@@ -530,7 +530,7 @@ fn explicit_times_none_superscript() -> Result<()> {
         <mo>)</mo></mrow>
     </math>";
     test_ClearSpeak("hu", "ClearSpeak_Paren", "Interval ",expr,
-    "c től d ig terjedő intervallum, tartalmazza a c elemet de nem tartalmazza a d elemet")?;
+    "c től d ig terjedő intervallum, tartalmazza a(z) c elemet de nem tartalmazza a(z) d elemet")?;
     return Ok(());
 
 }
@@ -545,7 +545,7 @@ fn parens_interval_open_closed() -> Result<()> {
     <mo>]</mo></mrow>
     </math>";
     test_ClearSpeak("hu", "ClearSpeak_Paren", "Interval ",expr,
-    "c től d ig terjedő intervallum, nem tartalmazza a c elemet de tartalmazza a d elemet")?;
+    "c től d ig terjedő intervallum, nem tartalmazza a(z) c elemet de tartalmazza a(z) d elemet")?;
     return Ok(());
 
 }
@@ -560,7 +560,7 @@ fn parens_interval_closed_closed() -> Result<()> {
     <mo>]</mo></mrow>
 </math>";
 test_ClearSpeak("hu", "ClearSpeak_Paren", "Interval ",expr,
-"c től d ig terjedő intervallum, tartalmazza a c elemet és d elemet")?;
+"c től d ig terjedő intervallum, tartalmazza a(z) c elemet és d elemet")?;
 return Ok(());
 
 }
@@ -573,7 +573,7 @@ return Ok(());
         <mo>)</mo></mrow>
     </math>";
     test_ClearSpeak("hu", "ClearSpeak_Paren", "Interval ",expr,
-    "negatív végtelen től d ig terjedő intervallum, nem tartalmazza a d elemet")?;
+    "negatív végtelen től d ig terjedő intervallum, nem tartalmazza a(z) d elemet")?;
     return Ok(());
 
 }
@@ -586,7 +586,7 @@ return Ok(());
         <mo>]</mo></mrow>
     </math>";
     test_ClearSpeak("hu", "ClearSpeak_Paren", "Interval ",expr,
-    "negatív végtelen től d ig terjedő intervallum, tartalmazza a d elemet")?;
+    "negatív végtelen től d ig terjedő intervallum, tartalmazza a(z) d elemet")?;
     return Ok(());
 
 }
@@ -601,7 +601,7 @@ fn parens_interval_open_open_infinity() -> Result<()> {
     <mo>)</mo></mrow>
     </math>";
     test_ClearSpeak("hu", "ClearSpeak_Paren", "Interval ",expr,
-    "c től végtelen ig terjedő intervallum, nem tartalmazza a c elemet")?;
+    "c től végtelen ig terjedő intervallum, nem tartalmazza a(z) c elemet")?;
     return Ok(());
 
 }
@@ -616,7 +616,7 @@ fn parens_interval_closed_open_infinity() -> Result<()> {
         <mo>)</mo></mrow>
     </math>";
     test_ClearSpeak("hu", "ClearSpeak_Paren", "Interval ",expr,
-"c től végtelen ig terjedő intervallum, tartalmazza a c elemet")?;
+"c től végtelen ig terjedő intervallum, tartalmazza a(z) c elemet")?;
 return Ok(());
 
 }
diff --git a/tests/Languages/hu/SimpleSpeak/functions.rs b/tests/Languages/hu/SimpleSpeak/functions.rs
index aa4c2a43..8ecf02cb 100644
--- a/tests/Languages/hu/SimpleSpeak/functions.rs
+++ b/tests/Languages/hu/SimpleSpeak/functions.rs
@@ -355,7 +355,7 @@ fn no_times_sqrt() -> Result<()> {
         <mrow> <mo arg='open'>(</mo><mi arg='start'>c</mi><mo>,</mo><mi arg='end'>d</mi></mrow><mo arg='close'>)</mo>
         <mo>)</mo></mrow>
     </math>";
-    test("hu", "SimpleSpeak",expr, "c től d ig terjedő intervallum, nem tartalmazza a c elemet vagy d elemet")?;
+    test("hu", "SimpleSpeak",expr, "c től d ig terjedő intervallum, nem tartalmazza a(z) c elemet vagy d elemet")?;
     return Ok(());
 
 }
@@ -368,7 +368,7 @@ fn no_times_sqrt() -> Result<()> {
             <mrow> <mo arg='open'>[(]</mo><mi arg='start'>c</mi><mo>,</mo><mi arg='end'>d</mi></mrow><mo arg='close'>)</mo>
             <mo>)</mo></mrow>
         </math>";
-    test("hu", "SimpleSpeak",expr, "c től d ig terjedő intervallum, tartalmazza a c elemet de nem tartalmazza a d elemet")?;
+    test("hu", "SimpleSpeak",expr, "c től d ig terjedő intervallum, tartalmazza a(z) c elemet de nem tartalmazza a(z) d elemet")?;
     return Ok(());
 
 }
@@ -382,7 +382,7 @@ fn parens_interval_open_closed() -> Result<()> {
         <mrow> <mo arg='open'>(</mo><mi arg='start'>c</mi><mo>,</mo><mi arg='end'>d</mi></mrow><mo arg='close'>]</mo>
         <mo>]</mo></mrow>
     </math>";
-    test("hu", "SimpleSpeak",expr,"c től d ig terjedő intervallum, nem tartalmazza a c elemet de tartalmazza a d elemet")?;
+    test("hu", "SimpleSpeak",expr,"c től d ig terjedő intervallum, nem tartalmazza a(z) c elemet de tartalmazza a(z) d elemet")?;
     return Ok(());
 
 }
@@ -396,7 +396,7 @@ fn parens_interval_closed_closed() -> Result<()> {
             <mrow> <mo arg='open'>[(]</mo><mi arg='start'>c</mi><mo>,</mo><mi arg='end'>d</mi></mrow><mo arg='close'>]</mo>
             <mo>]</mo></mrow>
     </math>";
-    test("hu", "SimpleSpeak",expr, "c től d ig terjedő intervallum, tartalmazza a c elemet és d elemet")?;
+    test("hu", "SimpleSpeak",expr, "c től d ig terjedő intervallum, tartalmazza a(z) c elemet és d elemet")?;
     return Ok(());
 
 }
@@ -409,7 +409,7 @@ fn parens_interval_closed_closed() -> Result<()> {
         <mo>)</mo></mrow>
     </math>";
     test("hu", "SimpleSpeak",expr,
-    "negatív végtelen től d ig terjedő intervallum, nem tartalmazza a d elemet")?;
+    "negatív végtelen től d ig terjedő intervallum, nem tartalmazza a(z) d elemet")?;
     return Ok(());
 
 }
@@ -422,7 +422,7 @@ fn parens_interval_closed_closed() -> Result<()> {
         <mo>]</mo></mrow>
     </math>";
     test("hu", "SimpleSpeak",expr,
-    "negatív végtelen től d ig terjedő intervallum, tartalmazza a d elemet")?;
+    "negatív végtelen től d ig terjedő intervallum, tartalmazza a(z) d elemet")?;
     return Ok(());
 
 }
diff --git a/tests/Languages/hu/SimpleSpeak/menclose.rs b/tests/Languages/hu/SimpleSpeak/menclose.rs
new file mode 100644
index 00000000..33c03f69
--- /dev/null
+++ b/tests/Languages/hu/SimpleSpeak/menclose.rs
@@ -0,0 +1,266 @@
+use crate::common::*;
+use anyhow::Result;
+
+// AI generated
+#[test]
+fn menclose_actuarial() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='actuarial'>  <mn>3</mn><mo>+</mo><mn>2</mn><mi>i</mi> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "aktuárius szimbólum, kezdet: 3 plusz 2 i végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_box() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='box circle'>  <mn>3</mn><mo>+</mo><mn>2</mn><mi>i</mi> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "doboz, kör, kezdet: 3 plusz 2 i végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_left() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='left'>  <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "vonal balra, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_right() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='right'>  <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "vonal jobbra, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_top_bottom() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='top bottom'>  <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "vonal felső, alsó, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_updiagonalstrike() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='updiagonalstrike'>  <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "átlósan felfelé, kihúzva, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_downdiagonalstrike() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='downdiagonalstrike'>  <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "átlósan lefelé, kihúzva, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_cross_out() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='updiagonalstrike downdiagonalstrike'>  <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "x, kihúzva, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_vertical_horizontal_strike() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='verticalstrike horizontalstrike'>  <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "függőleges, vízszintes, kihúzva, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_leftarrow() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='leftarrow'> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "balra nyíl, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_right_up_down_arrow() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation=' rightarrow downarrow  uparrow  '> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "felfelé nyíl, lefelé nyíl, jobbra nyíl, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_northeastarrow() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='northeastarrow'> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "északkeleti nyíl, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_other_single_arrows() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='northwestarrow southwestarrow southeastarrow'> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "délkeleti nyíl, délnyugati nyíl, északnyugati nyíl, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_northwestsoutheastarrow() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='northwestsoutheastarrow'> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "kétvégű lefelé mutató átlós nyíl, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_other_double_arrows() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='updownarrow leftrightarrow northeastsouthwestarrow'>  <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "kétvégű függőleges nyíl, kétvégű vízszintes nyíl, dupla végű átlós nyíl, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_madrub() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='madrub'> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "arab faktoriális szimbólum, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_phasorangle() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='phasorangle'> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "fázisszög, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_circle_phasorangle() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='phasorangle circle'> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "kör, fázisszög, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_longdiv() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='longdiv'> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "hosszú osztásjel, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_longdiv_default() -> Result<()> {
+    let expr = "<math>
+                    <menclose> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "hosszú osztásjel, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_longdiv_empty_string() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation=''> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "hosszú osztásjel, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_longdiv_whitespace_string() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='  '> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "hosszú osztásjel, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn menclose_radical() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='radical'> <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "ClearSpeak", expr, "négyzetgyök, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn simple_speak_menclose_top_bottom() -> Result<()> {
+    let expr = "<math>
+                    <menclose notation='top bottom'>  <mfrac><mn>3</mn><mn>2</mn></mfrac> </menclose>
+                </math>";
+    test("hu", "SimpleSpeak", expr, "vonal felső, alsó, kezdet: 3 ketted végpont vége")?;
+    return Ok(());
+
+}
diff --git a/tests/Languages/hu/SimpleSpeak/mroot.rs b/tests/Languages/hu/SimpleSpeak/mroot.rs
new file mode 100644
index 00000000..225e191c
--- /dev/null
+++ b/tests/Languages/hu/SimpleSpeak/mroot.rs
@@ -0,0 +1,178 @@
+use crate::common::*;
+use anyhow::Result;
+
+// AI generated
+#[test]
+fn msqrt_simple() -> Result<()> {
+    let expr = "<math>
+                    <msqrt> <mi>x</mi> </msqrt>
+                </math>";
+    test("hu", "SimpleSpeak", expr, "a négyzetgyöke ennek: x")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn msqrt_simple_end_root() -> Result<()> {
+    let expr = "<math>
+                    <msqrt> <mi>x</mi> </msqrt>
+                </math>";
+    test_ClearSpeak("hu", "ClearSpeak_Roots", "RootEnd", expr, "négyzetgyök x, gyök vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn msqrt_simple_positive() -> Result<()> {
+    let expr = "<math>
+                    <msqrt> <mi>x</mi> </msqrt>
+                </math>";
+    test_ClearSpeak("hu", "ClearSpeak_Roots", "PosNegSqRoot", expr, "pozitív négyzetgyök x")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn msqrt_simple_pos_end_root() -> Result<()> {
+    let expr = "<math>
+                    <msqrt> <mi>x</mi> </msqrt>
+                </math>";
+    test_ClearSpeak("hu", "ClearSpeak_Roots", "PosNegSqRootEnd", expr, "pozitív négyzetgyök x, gyök vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn msqrt_simple_pos_end_with_neg_root() -> Result<()> {
+    let expr = "<math>
+                    <mo>-</mo> <msqrt> <mi>x</mi> </msqrt>
+                    <mo>-</mo> <mroot> <mi>x</mi> <mn>3</mn></mroot>
+                </math>";
+    test_ClearSpeak("hu", "ClearSpeak_Roots", "PosNegSqRootEnd", expr, 
+    "negatív négyzetgyök x, gyök vége; mínusz, a pozitív köbgyök x, gyök vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn mroot_simple_pos_end_with_neg_root() -> Result<()> {
+    let expr = "<math>
+                    <mo>-</mo> <mroot> <mi>x</mi> <mn>3</mn></mroot>
+                    <mo>-</mo> <msqrt> <mi>x</mi> </msqrt>
+
+                </math>";
+    test_ClearSpeak("hu", "ClearSpeak_Roots", "PosNegSqRoot", expr, 
+    "a negatív köbgyök x; mínusz pozitív négyzetgyök x")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn neg_without_root() -> Result<()> {
+    let expr = "<math>
+                    <mo>-</mo> <mi>x</mi> <mo>-</mo> <mi>y</mi>
+                </math>";
+    test("hu", "ClearSpeak", expr, "negatív x mínusz y")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn msqrt() -> Result<()> {
+    let expr = "<math>
+                    <msqrt>
+                        <mrow> <mi>x</mi> <mo>+</mo> <mi>y</mi> </mrow>
+                    </msqrt>
+                </math>";
+    test("hu", "ClearSpeak", expr, "négyzetgyök x plusz y")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn mroot_as_square_root() -> Result<()> {
+    let expr = "<math>
+                    <mroot> <mi>x</mi> <mn>2</mn> </mroot>
+                </math>";
+    test("hu", "ClearSpeak", expr, "négyzetgyök x")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn cube_root() -> Result<()> {
+    let expr = "<math>
+                    <mroot> <mi>x</mi> <mn>3</mn> </mroot>
+                </math>";
+    test("hu", "ClearSpeak", expr, "a köbgyök x")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn ordinal_root() -> Result<()> {
+    let expr = "<math>
+                    <mroot> <mi>x</mi> <mn>9</mn> </mroot>
+                </math>";
+    test("hu", "ClearSpeak", expr, "a kilencedik gyök x")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn simple_mi_root() -> Result<()> {
+    let expr = "<math>
+                    <mroot> <mi>x</mi> <mi>n</mi> </mroot>
+                </math>";
+    test("hu", "ClearSpeak", expr, "a n-edik gyök x")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn mroot_simple_pos_end_root() -> Result<()> {
+    let expr = "<math>
+                <mroot> <mi>x</mi> <mi>t</mi> </mroot>
+                </math>";
+    test_ClearSpeak("hu", "ClearSpeak_Roots", "PosNegSqRootEnd", expr, "a pozitív t-edik gyök x, gyök vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn mroot_simple_end_root() -> Result<()> {
+    let expr = "<math>
+                    <mroot> <mrow> <mi>x</mi> <mo>+</mo> <mi>y</mi> </mrow> 
+                    <mn>21</mn></mroot>
+                </math>";
+    test_ClearSpeak("hu", "ClearSpeak_Roots", "RootEnd", expr, "a huszonegyedik gyök x plusz y, gyök vége")?;
+    return Ok(());
+
+}
+
+// AI generated
+#[test]
+fn simple_fraction_power() -> Result<()> {
+    let expr = "<math>
+                    <mroot>
+                        <mi>x</mi> 
+                        <mfrac><mn>1</mn><mn>3</mn></mfrac>
+                    </mroot>
+                </math>";
+    test("hu", "ClearSpeak", expr, "a 1 harmad gyök x")?;
+    return Ok(());
+
+}
diff --git a/tests/Languages/hu/definitions.rs b/tests/Languages/hu/definitions.rs
new file mode 100644
index 00000000..bd84fb15
--- /dev/null
+++ b/tests/Languages/hu/definitions.rs
@@ -0,0 +1,1026 @@
+/// Tests for rules in definitions:
+/// *  modified var
+use crate::common::*;
+use anyhow::Result;
+
+#[test]
+fn tuple_basic() -> Result<()> {
+    // function 
+    let expr = r#"
+      <math>
+        <mrow intent="tuple($x,$y)">
+          <mi arg="x">x</mi>
+          <mi arg="y">y</mi>
+        </mrow>
+      </math>
+    "#;
+
+    test("hu", "ClearSpeak", expr, "a tuple x vessző, y")?;
+    test("hu", "SimpleSpeak", expr, "a tuple x vessző, y")?;
+
+    return Ok(());
+}
+
+#[test]
+fn my_set_basic() -> Result<()> {
+    let expr = r#"
+      <math>
+        <mrow intent="set($x,$y)">
+          <mi arg="x">x</mi>
+          <mi arg="y">y</mi>
+        </mrow>
+      </math>
+    "#;
+
+    test("hu", "ClearSpeak", expr, "az üres halmaz")?;
+
+    Ok(())
+}
+
+#[test]
+fn fixed_test() -> Result<()> {
+    let expr = r#"
+      <math>
+        <mi intent="az összes valós szám halmaza">az összes valós szám halmaza
+        </mi>
+      </math>
+    "#;
+
+    test("hu", "ClearSpeak", expr, "az összes valós szám halmaza")?;
+    Ok(())
+}
+
+#[test]
+fn i_test() -> Result<()> {
+    let expr = r#"
+      <math>
+    <mi intent="képzeletbeli én">képzeletbeli én
+        </mi>
+      </math>
+    "#;
+
+    test("hu", "ClearSpeak", expr, "képzeletbeli én")?;
+    Ok(())
+}
+
+
+#[test]
+fn floor_basic() -> Result<()> {
+    let expr = r#"
+      <math>
+        <mrow intent="floor($x)">
+          <mi arg="x">x</mi>
+        </mrow>
+      </math>
+    "#;
+
+    test("hu", "ClearSpeak", expr, "lépcső x")?;
+
+    Ok(())
+}
+
+#[test]
+fn set_difference_basic() -> Result<()> {
+    let expr = r#"
+      <math>
+        <mrow intent="set-difference($A,$B)">
+          <mi arg="A">A</mi>
+          <mo>&#x2216;</mo>
+          <mi arg="B">B</mi>
+        </mrow>
+      </math>
+    "#;
+
+    test( "hu", "ClearSpeak", expr, "különbséghalmaz nagy a vessző, nagy b")?;
+
+    Ok(())
+}
+
+#[test]
+fn postfix_test() -> Result<()> {
+    let tests = [
+        (
+            "transpose",
+            r#"
+            <msup intent="transpose($x)">
+                <mi arg="x">x</mi>
+                <mo>T</mo>
+            </msup>
+            "#,
+            "transzponált x",
+        ),
+        (
+            "highlight",
+            r#"
+            <menclose intent="highlight($x)">
+                <mi arg="x">x</mi>
+            </menclose>
+            "#,
+            "x kiemelt",
+        ),
+    ];
+
+    // Loop through all test cases, name _, body, and expected result
+    for (_, body, expected) in tests {
+        let expr = format!(
+            r#"
+            <math>
+                {}
+            </math>
+            "#,
+            body
+        );
+
+        test("hu", "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#"
+            <mrow intent="limit($x)">
+                <mi arg="x">x</mi>
+            </mrow>
+            "#,
+            "határérték x",
+        ),
+        (
+            "unit-vector",
+            r#"
+            <mover intent="unit-vector($x)">
+                <mi arg="x">x</mi>
+                <mo>^</mo>
+            </mover>
+            "#,
+            "egységvektor x",
+        ),
+        (
+            "line-segment",
+            r#"
+            <mover intent="line-segment($x)">
+                <mi arg="x">x</mi>
+                <mo>¯</mo>
+            </mover>
+            "#,
+            "line segment x",
+        ),
+    ];
+
+    for (_, body, expected) in tests {
+        let expr = format!(
+            r#"
+            <math>
+                {}
+            </math>
+            "#,
+            body
+        );
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+
+#[test]
+fn functions_and_inverses_tests() -> Result<()> {
+    let tests = vec![
+        ("closed-interval", "x től y ig terjedő intervallum, tartalmazza a(z) x elemet és y elemet"),
+        ("closed-open-interval", "x től y ig terjedő intervallum, tartalmazza a(z) x elemet de nem tartalmazza a(z) y elemet"),
+        ("open-closed-interval", "x től y ig terjedő intervallum, nem tartalmazza a(z) x elemet de tartalmazza a(z) y elemet"),
+        ("open-interval", "x től y ig terjedő intervallum, nem tartalmazza a(z) x elemet vagy y elemet"),
+
+        ("inverse", "inverz x"),
+        ("domain", "domén x"),
+        ("codomain", "kodomán x"),
+        ("image", "kép x"),
+
+        //("fraction", "fraction x over y end fraction"),
+        ("mixed-fraction", "x és y"),
+        ("quotient", "egész rész osztva x vessző, y"),
+        ("evaluated-at", "x értékelve y"),
+        ("remainder", "a maradék, osztva x vessző, y"),
+
+        ("max", "max x vessző, y vessző, z"),
+        ("min", "min x vessző, y vessző, z"),
+
+        ("power", "x a(z) y-edik hatványon"),
+
+        //("root", "gyök x"),
+
+        ("greatest-common-divisor", "a legnagyobb közös osztó x vessző, y vessző, z"),
+        ("least-common-multiple", "a legkisebb közös többszörös x vessző, y vessző, z"),
+
+        ("absolute-value", "x abszolút értéke"),
+
+        ("complex-conjugate", "Komplex konjugált x"),
+        ("complex-arg", "argumentum x"),
+        ("real-part", "valós rész"),
+        ("imaginary-part", "képzetes rész"),
+
+        ("polar-coordinate", "poláris koordináta x vessző, y"),
+        ("spherical-coordinate", "gömb koordináta x vessző, y vessző, z"),
+        ("cartesian-coordinate", "derékszögű koordináta x vessző, y vessző, z"),
+        ("coordinate", "pont, x vessző y vessző z"),
+
+        ("floor", "lépcső x"),
+        ("ceiling", "mennyezet x"),
+        ("round", "kerekített érték x"),
+        ("fractional-part", "tört rész x"),
+
+        
+    ];
+
+    for (intent, expected) in tests {
+        let expr = match intent {
+            
+            "max"
+            | "min"
+            | "greatest-common-divisor"
+            | "least-common-multiple"
+            | "spherical-coordinate"
+            | "cartesian-coordinate"
+            | "coordinate" => {
+                format!(
+                    "<math>
+                        <mrow intent='{}($a,$b,$c)'>
+                            <mi arg='a'>x</mi>
+                            <mi arg='b'>y</mi>
+                            <mi arg='c'>z</mi>
+                        </mrow>
+                    </math>",
+                    intent
+                )
+            }
+
+            "power"
+            | "mixed-fraction"
+            | "quotient"
+            | "evaluated-at"
+            | "remainder"
+            | "closed-interval"
+            | "closed-open-interval"
+            | "open-closed-interval"
+            | "open-interval" 
+            | "polar-coordinate" => {
+                format!(
+                    "<math>
+                        <mrow intent='{}($a,$b)'>
+                            <mi arg='a'>x</mi>
+                            <mi arg='b'>y</mi>
+                        </mrow>
+                    </math>",
+                    intent
+                )
+            }
+
+            _ => {
+                format!(
+                    "<math>
+                        <mrow intent='{}($x)'>
+                            <mi arg='x'>x</mi>
+                        </mrow>
+                    </math>",
+                    intent
+                )
+            }
+        };
+
+        test("hu", "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", "határérték x"),
+
+        // infix
+        ("tends-to", "x ehhez tart y"),
+        ("tends-to-from-above", "x általában alulról indul y"),
+        ("tends-to-from-below", "x alulról indul y"),
+    ];
+
+    for (intent, expected) in tests {
+        let expr = match intent {
+            "limit" => {
+                format!(
+                    "<math>
+                        <mrow intent='{}($x)'>
+                            <mi arg='x'>x</mi>
+                        </mrow>
+                    </math>",
+                    intent
+                )
+            }
+
+            _ => {
+                // infix cases
+                format!(
+                    "<math>
+                        <mrow intent='{}($a,$b)'>
+                            <mi arg='a'>x</mi>
+                            <mi arg='b'>y</mi>
+                        </mrow>
+                    </math>",
+                    intent
+                )
+            }
+        };
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+
+#[test]
+fn set_tests() -> Result<()> {
+    let tests = vec![
+        ("set", "a halmaz x"),
+        //("set-difference", "x és y halmaz különbsége"),
+        ("complement", "komplemens x"),
+        //("empty-set", "üres halmaz"),
+        ("cardinality", "számosság x"),
+        ("list", "lista x"),
+        ("tuple", "a tuple x"),
+    ];
+
+    for (intent, expected) in tests {
+        let expr = format!(
+            "<math>
+                <mrow intent='{}($x)'>
+                    <mi arg='x'>x</mi>
+                </mrow>
+            </math>",
+            intent
+        );
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+
+#[test]
+fn sequence_and_series_intents() -> Result<()> {
+    let tests = [
+        (
+            "sum-1",
+            r#"
+            <mrow intent="sum($x)">
+                <mo>&#x2211;</mo>
+                <mi arg="x">x</mi>
+            </mrow>
+            "#,
+            "összeg x",
+        ),
+        (
+            "sum-2",
+            r#"
+            <mrow intent="sum($i,$x)">
+                <mo>&#x2211;</mo>
+                <mi arg="i">i</mi>
+                <mi arg="x">x</mi>
+            </mrow>
+            "#,
+            "összeg i vessző, x",
+        ),
+        (
+            "sum-3",
+            r#"
+            <mrow intent="sum($i,$n,$x)">
+                <mo>&#x2211;</mo>
+                <mi arg="i">i</mi>
+                <mi arg="n">n</mi>
+                <mi arg="x">x</mi>
+            </mrow>
+            "#,
+            "összeg i vessző, n vessző, x",
+        ),
+        (
+            "product-1",
+            r#"
+            <mrow intent="product($x)">
+                <mo>&#x220F;</mo>
+                <mi arg="x">x</mi>
+            </mrow>
+            "#,
+            "szorzat x",
+        ),
+        (
+            "product-2",
+            r#"
+            <mrow intent="product($i,$x)">
+                <mo>&#x220F;</mo>
+                <mi arg="i">i</mi>
+                <mi arg="x">x</mi>
+            </mrow>
+            "#,
+            "szorzat i vessző, x",
+        ),
+        (
+            "product-3",
+            r#"
+            <mrow intent="product($i,$n,$x)">
+                <mo>&#x220F;</mo>
+                <mi arg="i">i</mi>
+                <mi arg="n">n</mi>
+                <mi arg="x">x</mi>
+            </mrow>
+            "#,
+            "szorzat i vessző, n vessző, x",
+        ),
+    ];
+
+    for (_, body, expected) in tests {
+        let expr = format!(
+            r#"
+            <math>
+                {}
+            </math>
+            "#,
+            body
+        );
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn elementary_classical_tests() -> Result<()> {
+    let tests = vec![
+        // Trig
+        ("sine", "szinusz x"),
+        ("cosine", "koszinusz x"),
+        ("tangent", "tangens x"),
+        ("secant", "szekáns x"),
+        ("cosecant", "koszekáns x"),
+        ("cotangent", "kotangens x"),
+
+        // Inverse trig
+        ("arcsine", "arkusz szinusz x"),
+        ("arccosine", "arkusz koszinusz x"),
+        ("arctangent", "arkusz tangens x"),
+        ("arcsecant", "arkusz szekáns x"),
+        ("arccosecant", "arkusz koszekáns x"),
+        ("arccotangent", "arkusz kotangens x"),
+
+        // Hyperbolic trig
+        ("hyperbolic-sine", "hiperbolikus szinusz x"),
+        ("hyperbolic-cosine", "hiperbolikus koszinusz x"),
+        ("hyperbolic-tangent", "hiperbolikus tangens x"),
+        ("hyperbolic-secant", "hiperbolikus szekáns x"),
+        ("hyperbolic-cosecant", "hiperbolikus koszekáns x"),
+        ("hyperbolic-cotangent", "hiperbolikus kotangens x"),
+
+        // Inverse hyperbolic trig
+        ("arc-hyperbolic-sine", "arkusz hiperbolikus szinusz x"),
+        ("arc-hyperbolic-cosine", "arkusz hiperbolikus koszinusz x"),
+        ("arc-hyperbolic-tangent", "arkusz hiperbolikus tangens x"),
+        ("arc-hyperbolic-secant", "arkusz hiperbolikus szekáns x"),
+        ("arc-hyperbolic-cosecant", "arkusz hiperbolikus koszekáns x"),
+        ("arc-hyperbolic-cotangent", "arkusz hiperbolikus kotangens x"),
+    ];
+
+    for (intent, expected) in tests {
+        let expr = format!(
+            "<math>
+                <mrow intent='{}($x)'>
+                    <mi arg='x'>x</mi>
+                </mrow>
+            </math>",
+            intent
+        );
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn statistics_and_probability_tests() -> Result<()> {
+    let tests = vec![
+        ("mean", "jelentése x"),
+        ("standard-deviation", "szórás x"),
+        ("variance", "variencia x"),
+        ("median", "medián x"),
+        ("mode", "mód 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!(
+                "<math>
+                    <mrow intent='{}($A,$B)'>
+                        <mi>P</mi>
+                        <mo>(</mo>
+                        <mrow>
+                          <mi arg='x'>x</mi>
+                          <mo>|</mo>
+                          <mi arg='y'>y</mi>
+                        </mrow>
+                        <mo>)</mo>
+                    </mrow>
+                </math>",
+                intent
+            ),
+            _ => format!(
+                "<math>
+                    <mrow intent='{}($x)'>
+                        <mi arg='x'>x</mi>
+                    </mrow>
+                </math>",
+                intent
+            ),
+        };
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn linear_algebra_tests() -> Result<()> {
+    let tests = vec![
+        ("vector", "vektor x"),
+        // ("matrix", "matrix of x"),
+        ("determinant", "determináns a x"),
+        ("adjugate", "adjugált x"),
+        ("magnitude", "nagyságrend x"),
+        ("norm", "normalizálás x"),
+        ("span", "fesztávolság x"),
+
+        // transpose supports both postfix and function; we test function explicitly
+        ("transpose", "transzponált x"),
+
+        // dimensional product is infix
+        ("dimensional-product", "x a(z) y"),
+
+        // unit-vector is prefix
+        ("unit-vector", "egységvektor x")
+    ];
+
+    for (intent, expected) in tests {
+        let expr: String = match intent {
+          "dimensional-product" => {
+              "<math>
+                  <mrow intent='dimensional-product($x,$y)'>
+                      <mi arg='x'>x</mi>
+                      <mi arg='y'>y</mi>
+                  </mrow>
+              </math>"
+              .to_string()
+          }
+          _ => format!(
+              "<math>
+                  <mrow intent='{intent}($x)'>
+                      <mi arg='x'>x</mi>
+                  </mrow>
+              </math>"
+          ),
+      };
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn nofix_set_tests() -> Result<()> {
+    let tests = vec![
+        ("set-of-integers", "ℤ", "az összes egész szám halmaza"),
+        ("set-of-reals", "valós számok halmaza", "az összes valós szám halmaza"),
+        ("set-of-rationals", "ℚ", "az összes racionális szám halmaza"),
+        ("set-of-natural-numbers", "ℕ", "az összes természetes szám halmaza"),
+        ("set-of-complex-numbers", "ℂ", "az összes komplex szám halmaza"),
+        ("set-of-primes", "ℙ", "az összes prímszám halmaza"),
+    ];
+
+    for (intent, symbol, expected) in tests {
+        let expr = format!(
+            "<math>
+                <mi intent='{}:nofix'>{}</mi>
+            </math>",
+            intent,
+            symbol
+        );
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn geometry_prefix_multi_value_tests() -> Result<()> {
+    let tests = vec![
+        ("line-segment", "vonalszakasz x y"),
+        ("directed-line-segment", "irányított vonalszakasz x y"),
+        ("line", "vonal x y"),
+        ("ray", "sugár x y"),
+        ("arc", "ív x y"),
+        ("point", "pont x y z"),
+    ];
+
+    for (intent, expected) in tests {
+        let expr = match intent{
+            "point" => {
+                format!(
+                    "<math>
+                        <mrow intent='{intent}($x,$y,$z)'>
+                            <mi arg='x'>x</mi>
+                            <mi arg='y'>y</mi>
+                            <mi arg='z'>z</mi>
+                        </mrow>
+                    </math>"
+                )
+            }
+
+            _ => { 
+                format!(
+                    "<math>
+                        <mrow intent='{intent}($x,$y)'>
+                            <mi arg='x'>x</mi>
+                            <mi arg='y'>y</mi>
+                        </mrow>
+                    </math>"
+                )
+            }
+        };
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn geometry_prefix_tests() -> Result<()> {
+    let tests = vec![
+        ("length", "hossz x"),
+        ("area", "terület x"),
+        ("volume", "hangerő x"),
+    ];
+
+    for (intent, expected) in tests {
+        let expr = format!(
+            "<math>
+                <mrow intent='{intent}:function($x)'>
+                    <mi arg='x'>x</mi>
+                </mrow>
+            </math>"
+        );
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn separator_tests() -> Result<()> {
+  let expr = format!(
+        "<math>
+            <mrow intent='time-separator($x,$y)'>
+                <mi arg='x'>x</mi>
+                <mi arg='y'>y</mi>
+            </mrow>
+        </math>"
+    );
+
+    test("hu", "ClearSpeak", &expr, "x y")?;
+    Ok(())
+}
+
+#[test]
+fn general_concepts_tests() -> Result<()> {
+    let tests = vec![
+        // Unary structural
+        ("fenced-group", "bekerített csoport x"),
+        ("highlight", "x kiemelt"),
+        ("least-common-denominator", "legkisebb közös nevező x vessző, y vessző, z"), // add x, y , z ...
+        ("pochhammer", "permutáció x"),
+        ("permutation-cycle", "permutációs ciklus x"),
+
+        // Binary structural / infix-style
+        // ("ordered-pair", "the pair of x and y"),
+        ("rate", "x per y"),
+        
+        ("binomial-coefficient", "x választ y"),
+        ("embellished-name", "x megjegyzéssel y"),
+        ("indexed-by", "x alsó index y"),
+        // ("translation", "translation by x comma, y"), // Changes translation to comma
+        ("constraint", "x feltétellel y"),
+    ];
+
+    for (intent, expected) in tests {
+        let expr = match intent {
+            "ordered-pair"
+            | "rate"
+            | "constraint"
+            | "binomial-coefficient"
+            | "embellished-name"
+            | "translation"
+            | "indexed-by" => {
+                format!(
+                    "<math>
+                        <mrow intent='{}($a,$b)'>
+                            <mi arg='a'>x</mi>
+                            <mi arg='b'>y</mi>
+                        </mrow>
+                    </math>",
+                    intent
+                )
+            }
+            "least-common-denominator" => {
+                format!(
+                    "<math>
+                        <mrow intent='{}($x,$y,$z)'>
+                            <mi arg='x'>x</mi>
+                            <mi arg='y'>y</mi>
+                            <mi arg='z'>z</mi>
+                        </mrow>
+                    </math>",
+                    intent
+                )
+            }
+
+            // unary cases
+            _ => {
+                format!(
+                    "<math>
+                        <mrow intent='{}($x)'>
+                            <mi arg='x'>x</mi>
+                        </mrow>
+                    </math>",
+                    intent
+                )
+            }
+        };
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn grouping_tests() -> Result<()> {
+    let tests = vec![
+("annotation", "x ami y"),
+        // ("braced-group", "grouped x end-grouped"),
+        // ("repeating-decimal", "repeating decimal of x"),
+    ];
+
+    for (intent, expected) in tests {
+        let expr = match intent {
+            "annotation" => {
+                format!(
+                    "<math>
+                        <mrow intent='{}($x,$y)'>
+                            <mi arg='x'>x</mi>
+                            <mi arg='y'>y</mi>
+                        </mrow>
+                    </math>",
+                    intent
+                )
+            }
+            _ => {
+                format!(
+                    "<math>
+                        <mrow intent='{}($x)'>
+                            <mi arg='x'>x</mi>
+                        </mrow>
+                    </math>",
+                    intent
+                )
+            } 
+        };
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn function_default_fixity_tests() -> Result<()> {
+    let tests = vec![
+        ("curl", "rotáció x"),
+        ("divergence", "eltérés x"),
+        ("gradient", "gradiens x"),
+        ("laplacian", "laplaciánus x"),
+    ];
+
+    for (intent, expected) in tests {
+        let expr = format!(
+            "<math>
+                <mrow intent='{}($x)'>
+                    <mi arg='x'>x</mi>
+                </mrow>
+            </math>",
+            intent
+        );
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn prefix_default_fixity_tests() -> Result<()> {
+    let tests = vec![
+        ("angle", "szög x"),
+        ("angle-measure", "szögmérés x"),
+        ("change", "változás x"),
+        ("for-all", "minden x"),
+        ("measured-angle", "mért szög x"),
+        ("not", "nem x"),
+        ("number-of", "száma x"),
+        ("partial-derivative", "parciális derivált x"),
+        ("right-angle", "derékszög x"),
+        ("square-root-of", "négyzetgyöke x"),
+        ("there-does-not-exist", "nem létezik x"),
+        ("there-exists", "létezik x"),
+    ];
+
+    for (intent, expected) in tests {
+        let expr = format!(
+            "<math>
+                <mrow intent='{}($x)'>
+                    <mi arg='x'>x</mi>
+                </mrow>
+            </math>",
+            intent
+        );
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn infix_default_fixity_tests() -> Result<()> {
+    let tests = vec![
+        ("and", "x és y"),
+        ("applied-to", "x alkalmazva y"),
+        ("approximately", "x hozzávetőlegesen y"),
+        ("congruent", "x egybeesik y"),
+        ("cartesian-product", "x derékszögű szorzat y"),
+        ("composed-with", "x komponálva y"),
+        ("cross-product", "x kereszt szorzata y"),
+        ("defined-as", "x definiálva y"),
+        ("divided-by", "x osztva y"),
+        ("divides", "x osztja y"),
+        ("does-not-belong-to", "x nem tartozik hozzá y"),
+        ("does-not-divide", "x nem osztja y"),
+        ("dot-product", "x skaláris szorzat y"),
+        ("downwards-diagonal-ellipsis", "x lefelé mutató átlós ellipszis y"),
+        ("direct-product", "x direkt szorzat y"),
+        ("element-of", "x eleme y"),
+        ("ellipsis", "x ellipszis y"),
+        ("equals", "x egyenlő y"),
+        ("equivalent-to", "x egyenértékű ezzel y"),
+        ("evaluates-to", "x értéke y"),
+        ("given", "x adott y"),
+        ("greater-than", "x nagyobb, mint y"),
+        ("greater-than-or-equal-to", "x nagyobb vagy egyenlő, mint y"),
+        ("identically-equals", "x teljesen egyenlő y"),
+        ("if-and-only-if", "x akkor és csak akkor, ha y"),
+        ("implies", "x utal y"),
+        ("inner-product", "x belső szorzat y"),
+        ("intersection", "x keresztezi y"),
+        ("less-than", "x kisebb, mint y"),
+        ("less-than-or-equal-to", "x kisebb vagy egyenlő, mint y"),
+        ("list-separator", "x vessző y"),
+        ("maps-to", "x megfelel ennek y"),
+        ("member-of", "x tagja y"),
+        ("minus", "x mínusz y"),
+        ("minus-or-plus", "x mínusz vagy plusz y"),
+        ("not-subset", "x nem részhalmaza y"),
+        ("not-superset", "x nem szuperhalmaza y"),
+        ("not-equal-to", "x nem egyenlő y"),
+        ("not-member-of", "x nem tagja y"),
+        ("not-parallel-to", "x nem párhuzamos y"),
+        ("obtained-from", "x innen származik y"),
+        ("or", "x vagy y"),
+        ("outer-product", "x külső szorzata y"),
+        ("parallel-to", "x párhuzamos y"),
+        ("perpendicular", "x merőleges y"),
+        ("plus", "x plusz y"),
+        ("plus-or-minus", "x plusz vagy mínusz y"),
+        ("precedes", "x megelőzi y"),
+        ("proportional", "x arányos y"),
+        ("range-separator", "x keresztül y"),
+        ("ratio", "x arány y"),
+        ("similar", "x hasonló y"),
+        ("subset", "x részhalmaza y"),
+        ("subset-or-equal", "x részhalmaza vagy egyenlő y"),
+        ("succeeds", "x követi y"),
+        ("such-that", "x úgy, hogy y"),
+        ("superset", "x szuperhalmaza y"),
+        ("superset-or-equal", "x szuperhalmaza vagy egyenlő y"),
+        ("tilde", "x tilde y"),
+        ("times", "x szorozva y"),
+        ("union", "x unió y"),
+        ("upwards-diagonal-ellipsis", "x felfelé átlós ellipszis y"),
+        ("vertical-ellipsis", "x függőleges ellipszis y"),
+        ("xor", "x kizárólagos vagy y"),
+    ];
+    
+    for (intent, expected) in tests {
+        let expr = format!(
+            "<math>
+                <mrow intent='{}($a,$b)'>
+                    <mi arg='a'>x</mi>
+                    <mi arg='b'>y</mi>
+                </mrow>
+            </math>",
+            intent
+        );
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn postfix_default_fixity_tests() -> Result<()> {
+    let tests = vec![
+        ("factorial", "x faktoriális"),
+        ("percent", "x százalék"),
+    ];
+
+    for (intent, expected) in tests {
+        let expr = format!(
+            "<math>
+                <mrow intent='{}($x)'>
+                    <mi arg='x'>x</mi>
+                </mrow>
+            </math>",
+            intent
+        );
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn nofix_default_fixity_tests() -> Result<()> {
+    let tests = vec![
+        ("diameter", "átmérő", "átmérő"),
+        ("distance", "távolság", "távolság"),
+        ("probability", "valószínűség", "valószínűség"),
+        ("radius", "sugár", "sugár"),
+        ("volume", "hangerő", "hangerő"),
+        ("exponential-e", "e", "e"),
+        ("imaginary-i", "képzeletbeli én", "képzeletbeli én"),
+        ("differential-d", "d", "d"),
+        ("golden-ratio", "φ", "aranymetszés"),
+    ];
+
+    for (intent, symbol, expected) in tests {
+        let expr = format!(
+            "<math>
+                <mi intent='{}:nofix'>{}</mi>
+            </math>",
+            intent,
+            symbol
+        );
+
+        test("hu", "ClearSpeak", &expr, expected)?;
+    }
+
+    Ok(())
+}
diff --git a/tests/Languages/hu/shared.rs b/tests/Languages/hu/shared.rs
index a97805f8..bd53bb4c 100644
--- a/tests/Languages/hu/shared.rs
+++ b/tests/Languages/hu/shared.rs
@@ -381,7 +381,7 @@ fn bug_199_2pi() -> Result<()> {
         <mo stretchy=\"false\" form=\"postfix\">)</mo>
       </mrow>
     </math>";
-  test("hu", "SimpleSpeak",expr, "0 től 2 pí ig terjedő intervallum, tartalmazza a 0 elemet de nem tartalmazza a 2 pí elemet")?;
+  test("hu", "SimpleSpeak",expr, "0 től 2 pí ig terjedő intervallum, tartalmazza a(z) 0 elemet de nem tartalmazza a(z) 2 pí elemet")?;
   return Ok(());
 
 }