Grcov report - mod.rs

1

//! XML/HTML parsing module for the Azul toolkit.

2

//!

3

//! Provides two parsing paths:

4

//! - `parse_xml_string`: builds an `XmlNode` tree (used by `domxml_from_str`)

5

//! - `parse_xml_to_fast_dom_with_css`: builds an arena-based `FastDom` directly from XML tokens

6

//!   (used by `parse_xml_to_styled_dom`)

7

//!

8

//! Both paths handle HTML5-lite features: void elements, auto-closing tags,

9

//! XML entity decoding, `<style>` CSS extraction, and BOM/DOCTYPE stripping.

10

//!

11

//! Data types (`XmlNode`, `XmlError`, etc.) live in `azul_core::xml`; this

12

//! module provides the parsing implementations.

13

14

#![allow(unused_variables)]

15

16

use alloc::{boxed::Box, collections::BTreeMap, string::String, vec::Vec};

17

use core::fmt;

18

#[cfg(feature = "std")]

19

use std::path::Path;

20

21

#[cfg(feature = "svg")]

22

pub mod svg;

23

24

/// Decodes XML/HTML entities in a string.

25

/// Handles standard XML entities: &lt; &gt; &amp; &apos; &quot;

26

/// and numeric character references: &#60; &#x3C;

27

/// Returns `Cow::Borrowed` when no entities are found (zero-alloc fast path).

28

83208

fn decode_xml_entities(s: &str) -> std::borrow::Cow<'_, str> {

29

    // Fast path: if no ampersand, no entities to decode

30

83208

    if !s.contains('&') {

31

83136

        return std::borrow::Cow::Borrowed(s);

32

72

33

72

    decode_xml_entities_slow(s)

34

83208

35

36

85

fn decode_xml_entities_slow(s: &str) -> std::borrow::Cow<'_, str> {

37

85

    let mut result = String::with_capacity(s.len());

38

85

    let mut chars = s.chars().peekable();

39

40

1060354

    while let Some(c) = chars.next() {

41

1060269

        if c == '&' {

42

            // Collect the entity reference

43

50179

            let mut entity = String::new();

44

50179

            let mut found_semicolon = false;

45

46

150501

            while let Some(&next) = chars.peek() {

47

150486

                if next == ';' {

48

50074

                    chars.next();

49

50074

                    found_semicolon = true;

50

50074

                    break;

51

100412

52

100412

                if !next.is_alphanumeric() && next != '#' {

53

86

                    break;

54

100326

55

100326

                entity.push(chars.next().unwrap());

56

100326

                if entity.len() > 10 {

57

                    // Entity too long, not a valid entity

58

4

                    break;

59

100322

60

61

62

50179

            if found_semicolon {

63

                // Try to decode the entity

64

50074

                match entity.as_str() {

65

50074

                    "lt" => result.push('<'),

66

65

                    "gt" => result.push('>'),

67

59

                    "amp" => result.push('&'),

68

43

                    "apos" => result.push('\''),

69

38

                    "quot" => result.push('"'),

70

33

                    "nbsp" => result.push('\u{00A0}'),

71

32

                    s if s.starts_with('#') => {

72

                        // Numeric character reference

73

22

                        let num_str = &s[1..];

74

22

                        let code_point = if num_str.starts_with('x') || num_str.starts_with('X') {

75

                            // Hexadecimal

76

13

                            u32::from_str_radix(&num_str[1..], 16).ok()

77

                        } else {

78

                            // Decimal

79

9

                            num_str.parse::<u32>().ok()

80

};

81

22

                        if let Some(cp) = code_point {

82

19

                            if let Some(ch) = char::from_u32(cp) {

83

13

                                result.push(ch);

84

13

                            } else {

85

6

                                // Invalid code point, keep original

86

6

                                result.push('&');

87

6

                                result.push_str(&entity);

88

6

                                result.push(';');

89

6

90

3

                        } else {

91

3

                            // Parse failed, keep original

92

3

                            result.push('&');

93

3

                            result.push_str(&entity);

94

3

                            result.push(';');

95

3

96

97

10

                    _ => {

98

10

                        // Unknown entity, keep original

99

10

                        result.push('&');

100

10

                        result.push_str(&entity);

101

10

                        result.push(';');

102

10

103

104

105

            } else {

105

                // No semicolon found, not a valid entity reference

106

105

                result.push('&');

107

105

                result.push_str(&entity);

108

105

109

1010090

        } else {

110

1010090

            result.push(c);

111

1010090

112

113

114

85

    std::borrow::Cow::Owned(result)

115

85

116

117

pub use azul_core::xml::*;

118

use azul_core::{dom::Dom, impl_from, styled_dom::StyledDom, window::StringPairVec};

119

#[cfg(feature = "parser")]

120

use azul_css::parser2::CssParseError;

121

use azul_css::{css::Css, AzString, OptionString, U8Vec};

122

use xmlparser::Tokenizer;

123

124

#[cfg(feature = "xml")]

125

#[must_use]

126

2570

pub fn domxml_from_str(xml: &str, component_map: &ComponentMap) -> DomXml {

127

2570

    let error_css = Css::empty();

128

129

2570

    let parsed = match parse_xml_string(xml) {

130

2555

        Ok(parsed) => parsed,

131

15

        Err(e) => {

132

15

            return DomXml {

133

15

                parsed_dom: {

134

15

                    let mut dom = Dom::create_body()

135

15

                        .with_children(vec![Dom::create_p_with_text(format!("{e}"))].into());

136

15

                    StyledDom::create(&mut dom, error_css)

137

15

},

138

15

};

139

140

};

141

142

2555

    let parsed_dom = match str_to_dom(parsed.as_ref(), component_map, None) {

143

2555

        Ok(o) => o,

144

        Err(e) => {

145

            return DomXml {

146

                parsed_dom: {

147

                    let mut dom = Dom::create_body()

148

                        .with_children(vec![Dom::create_p_with_text(format!("{e}"))].into());

149

                    StyledDom::create(&mut dom, error_css)

150

},

151

};

152

153

};

154

155

2555

    DomXml { parsed_dom }

156

2570

157

158

/// Creates a `Dom` from an already-parsed `Xml` structure, for use in layout

159

/// callbacks. CSS from `<style>` tags is attached to `Dom.css` and applied

160

/// during the cascade pass.

161

// FFI-exported (api.json fn_body azul_layout::xml::dom_from_parsed_xml(xml)): owned Xml by value.

162

#[allow(clippy::needless_pass_by_value)]

163

#[must_use]

164

208

pub fn dom_from_parsed_xml(xml: Xml) -> Dom {

165

208

    let component_map = ComponentMap::with_builtin();

166

208

    match str_to_dom_unstyled(xml.root.as_ref(), &component_map) {

167

207

        Ok(dom) => dom,

168

1

        Err(e) => {

169

1

            Dom::create_body().with_children(vec![Dom::create_p_with_text(format!("{e}"))].into())

170

171

172

208

173

174

/// Fastest path: parse XML string directly into `FastDom` without intermediate `XmlNode` tree.

175

///

176

/// Feeds XML tokenizer events directly into `CompactDomBuilder`, skipping both the

177

/// `XmlNode` tree construction AND the Dom tree construction.

178

/// Parse XML string directly into a `FastDom` (arena-based DOM) in a single pass.

179

///

180

/// Also extracts `<style>` tag content as CSS. Returns both the `FastDom` and

181

/// collected CSS stylesheets. No intermediate `XmlNode` tree is built.

182

///

183

/// This is the fastest XML→DOM path: XML tokens feed directly into

184

/// `CompactDomBuilder`, and `<style>` text is collected inline.

185

/// # Errors

186

///

187

/// Returns an `XmlError` if the XML cannot be parsed.

188

135

pub fn parse_xml_to_fast_dom(xml: &str) -> Result<azul_core::dom::FastDom, XmlError> {

189

135

    let (fast_dom, _css) = parse_xml_to_fast_dom_with_css(xml)?;

190

113

    Ok(fast_dom)

191

135

192

193

/// `parse_xml_to_styled_dom`, but resolving `<icon>` nodes on the way.

194

///

195

/// Routes through `Dom` (a real tree) rather than `FastDom`, and that is not an

196

/// oversight: an icon resolves to a SUBTREE, and `FastDom` - like `StyledDom` -

197

/// is a flat arena in DFS order, so a subtree cannot be spliced into it without

198

/// inserting mid-arena and shifting every index after it. Resolving on the tree

199

/// and cascading once is what makes an arbitrary `Dom` usable as an icon.

200

///

201

/// Use this whenever an icon provider is available. `parse_xml_to_styled_dom`

202

/// exists for callers that have none, and differs only in that.

203

///

204

/// # Errors

205

///

206

/// Returns an `XmlError` if the XML cannot be parsed.

207

1

pub fn parse_xml_to_styled_dom_resolving_icons(

208

1

    xml: &str,

209

1

    provider: &azul_core::icon::SharedIconProvider,

210

1

    system_style: &azul_css::system::SystemStyle,

211

1

) -> Result<StyledDom, XmlError> {

212

1

    let parsed = parse_xml(xml)?;

213

1

    let dom = dom_from_parsed_xml(parsed);

214

1

    Ok(azul_core::icon::styled_dom_resolving_icons(

215

1

        dom,

216

1

        provider,

217

1

        system_style,

218

1

))

219

1

220

221

/// Parse XML directly into `FastDom` + extracted CSS, ready for `StyledDom`.

222

#[allow(clippy::cast_precision_loss)] // bounded layout/render numeric cast

223

/// # Errors

224

///

225

/// Returns an `XmlError` if the XML cannot be parsed.

226

231

pub fn parse_xml_to_styled_dom(xml: &str) -> Result<StyledDom, XmlError> {

227

    // Optional per-phase RSS/timing breakdown.

228

    // Gated on AZ_PROFILE=memory — prints

229

    //   [XML] tokenize+fast_dom       : +XX MiB in YY ms

230

    //   [XML] css attach              : +XX MiB in YY ms

231

    //   [XML] create_from_fast_dom    : +XX MiB in YY ms

232

    // to locate which sub-phase of the parse-cascade dominates the

233

    // RSS jump seen between `page start` and `xml parsed`.

234

    static MEM_ENABLED: std::sync::OnceLock<bool> = std::sync::OnceLock::new();

235

231

    let mem_on = *MEM_ENABLED.get_or_init(azul_core::profile::memory_enabled);

236

237

231

    let rss0 = if mem_on { peak_rss_bytes() } else { 0 };

238

231

    let (mut fast_dom, css) = parse_xml_to_fast_dom_with_css(xml)?;

239

209

    if mem_on {

240

        let rss1 = peak_rss_bytes();

241

        eprintln!(

242

            "[XML] tokenize+fast_dom       : +{:.2} MiB",

243

            (rss1.saturating_sub(rss0)) as f64 / 1024.0 / 1024.0,

244

);

245

209

246

247

209

    let rss1 = if mem_on { peak_rss_bytes() } else { 0 };

248

    // Attach CSS to the FastDom

249

209

    if !css.is_empty() {

250

        // Rules AND keyframes: merging by rules alone silently dropped every

251

        // `@keyframes` block a `<style>` element declared, so

252

        // `-azul-animation-out: shrinkOut 1s` fell back to the default slide

253

        // at runtime while the unit parser tests stayed green.

254

195

        let mut combined_rules = Vec::new();

255

195

        let mut combined_keyframes = Vec::new();

256

390

        for c in css {

257

195

            combined_rules.extend(c.rules.into_library_owned_vec());

258

195

            combined_keyframes.extend(c.keyframes.into_library_owned_vec());

259

195

260

195

        let mut combined_css = Css::new(combined_rules);

261

195

        combined_css.keyframes = combined_keyframes.into();

262

195

        fast_dom.css = vec![azul_core::dom::CssWithNodeId {

263

195

            node_id: 0, // global scope

264

195

            css: combined_css,

265

195

}]

266

195

        .into();

267

14

268

209

    if mem_on {

269

        let rss2 = peak_rss_bytes();

270

        eprintln!(

271

            "[XML] css attach              : +{:.2} MiB",

272

            (rss2.saturating_sub(rss1)) as f64 / 1024.0 / 1024.0,

273

);

274

209

275

276

    // Hint the allocator to return pages freed by the CSS parser.

277

    // The tokenizer+parser created many small allocations (selectors,

278

    // declarations, strings) that are now packed into FastDom. Purging

279

    // here returns those pages before the cascade allocates more.

280

209

    crate::probe::hint_purge_allocator();

281

282

209

    let rss2 = if mem_on { peak_rss_bytes() } else { 0 };

283

209

    let styled = StyledDom::create_from_fast_dom(fast_dom);

284

285

    // Major purge point: the cascade just freed ~3 MiB of intermediate

286

    // allocations (build-phase Vecs, CSS selector matching state, pruned

287

    // properties). Tell the allocator to return those pages NOW before

288

    // the layout pass allocates more on top of them.

289

209

    crate::probe::hint_purge_allocator();

290

291

209

    if mem_on {

292

        let rss3 = peak_rss_bytes();

293

        eprintln!(

294

            "[XML] create_from_fast_dom    : +{:.2} MiB",

295

            (rss3.saturating_sub(rss2)) as f64 / 1024.0 / 1024.0,

296

);

297

209

298

299

209

    Ok(styled)

300

231

301

302

/// Resident-set bytes for RSS checkpoints — mirrors servo-shot's

303

/// `peak_rss_bytes()`. Uses `getrusage(RUSAGE_SELF)` via the

304

/// `probe` feature's `libc` dep; returns 0 without it so the

305

/// caller just doesn't emit meaningful deltas.

306

#[cfg(all(unix, feature = "probe"))]

307

2

fn peak_rss_bytes() -> u64 {

308

2

    let mut usage: libc::rusage = unsafe { std::mem::zeroed() };

309

2

    if unsafe { libc::getrusage(libc::RUSAGE_SELF, &raw mut usage) } != 0 {

310

        return 0;

311

2

312

2

    let ru = usage.ru_maxrss as u64;

313

    // macOS reports bytes, Linux reports KiB.

314

    #[cfg(target_os = "macos")]

315

316

ru

317

318

    #[cfg(not(target_os = "macos"))]

319

320

2

        ru.saturating_mul(1024)

321

322

2

323

324

#[cfg(not(all(unix, feature = "probe")))]

325

const fn peak_rss_bytes() -> u64 {

326

327

328

329

/// Internal: parse XML into `FastDom` + collected CSS stylesheets.

330

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // bounded layout/render numeric cast

331

#[allow(clippy::too_many_lines, clippy::cognitive_complexity)] // large but cohesive: single-purpose

332

                                                               // layout/render/parse routine (one

333

                                                               // branch per case)

334

367

fn parse_xml_to_fast_dom_with_css(

335

367

    xml: &str,

336

367

) -> Result<(azul_core::dom::FastDom, Vec<Css>), XmlError> {

337

    use azul_core::{

338

        dom::{IdOrClass, NodeData, NodeType, TabIndex},

339

        xml::CompactDomBuilder,

340

};

341

    use xmlparser::{

342

        ElementEnd::{Close, Empty, Open},

343

        Token::{Attribute, ElementEnd, ElementStart, Text},

344

        Tokenizer,

345

};

346

347

    const ESTIMATED_BYTES_PER_NODE: usize = 20;

348

349

    const VOID_ELEMENTS: &[&str] = &[

350

        "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param",

351

        "source", "track", "wbr",

352

];

353

354

    // Lowercase `src` into `dst`, reusing `dst`'s existing capacity.

355

    // Zero-alloc when dst's capacity is already ≥ src.len() AND no uppercase

356

    // conversion is needed (the happy path for HTML5 where tags are lowercase).

357

11763

    fn lowercase_into(dst: &mut String, src: &str) {

358

11763

        dst.clear();

359

36327

        if src.bytes().all(|b| !b.is_ascii_uppercase()) {

360

11760

            dst.push_str(src);

361

11760

        } else {

362

3

            dst.reserve(src.len());

363

11

            for b in src.bytes() {

364

11

                dst.push(b.to_ascii_lowercase() as char);

365

11

366

367

11763

368

369

    // Strip BOM

370

367

    let xml = xml.strip_prefix('\u{FEFF}').unwrap_or(xml);

371

367

    let mut xml = xml.trim();

372

373

    // Skip <?xml ... ?>

374

367

    if xml.starts_with("<?") {

375

5

        if let Some(pos) = xml.find("?>") {

376

1

            xml = &xml[(pos + 2)..];

377

4

378

362

379

380

    // Skip <!DOCTYPE ...>

381

367

    let mut xml = xml.trim();

382

367

    if xml.len() > 9

383

311

        && xml.is_char_boundary(9)

384

310

        && xml[..9].to_ascii_lowercase().starts_with("<!doctype")

385

386

3

        if let Some(pos) = xml.find('>') {

387

3

            xml = &xml[(pos + 1)..];

388

3

389

364

    } else if xml.starts_with("<!--") {

390

5

        if let Some(end) = xml.find("-->") {

391

1

            xml = &xml[(end + 3)..];

392

1

            xml = xml.trim();

393

4

394

359

395

396

367

    let tokenizer = Tokenizer::from_fragment(xml, 0..xml.len());

397

398

367

    let estimated_nodes = xml.len() / ESTIMATED_BYTES_PER_NODE;

399

367

    let mut builder = CompactDomBuilder::with_capacity(estimated_nodes);

400

367

    let mut collected_css: Vec<Css> = Vec::new();

401

367

    let mut inside_style_tag = false;

402

367

    let mut style_text = String::new();

403

    // Track <head> depth: skip DOM nodes inside <head> (still collect <style> CSS).

404

    // This ensures the FastDom contains only <html><body>... as the layout engine expects.

405

367

    let mut head_depth: usize = 0;

406

407

    // Temporary storage for current element's attributes

408

367

    let mut current_tag: String = String::new();

409

367

    let mut current_attrs: Vec<(String, String)> = Vec::new();

410

367

    let mut pending_open = false;

411

412

    // Pre-compute the CSS key map once (used for style= attribute parsing)

413

367

    let css_key_map = azul_css::props::property::get_css_key_map();

414

415

    // One bump arena for every AzString produced during this parse —

416

    // id/class tokens, text nodes, etc. Replaces ~1k small heap allocs

417

    // with a handful of 64 KiB chunks. Each AzString carries its own

418

    // Arc reference to the arena, so the arena survives until the last

419

    // string is dropped (typically when the StyledDom is dropped).

420

367

    let mut str_arena = azul_css::corety::StringArena::new();

421

422

    // Finalize the pending open element: create NodeData from tag + attrs, push to builder

423

    // tag is already lowercase

424

367

    let finalize_open =

425

        |builder: &mut CompactDomBuilder,

426

         str_arena: &mut azul_css::corety::StringArena,

427

         tag: &str,

428

         attrs: &[(String, String)],

429

11356

         css_key_map: &azul_css::props::property::CssKeyMap| {

430

11356

            let node_type = tag_to_node_type(tag);

431

11356

            let mut nd = NodeData::create_node(node_type);

432

433

            // `<transient-window open="true" anchor="bottom" …>`: the config rides

434

            // INSIDE the NodeType, so its attributes are applied onto that payload

435

            // rather than stored as generic attributes. Done before the generic

436

            // loop so the keys it consumes never reach `attr_vec`.

437

11356

            let mut transient_cfg = match nd.get_node_type() {

438

2

                NodeType::TransientWindow(c) => Some(*c),

439

11354

                _ => None,

440

};

441

442

            // Apply attributes — build AttributeTypeVec directly (avoids the

443

            // clone + retain dance in set_ids_and_classes for fresh NodeData).

444

11356

            let mut attr_vec: Vec<azul_core::dom::AttributeType> = Vec::new();

445

12481

            for (key, value) in attrs {

446

1125

                if let Some(cfg) = transient_cfg.as_mut() {

447

5

                    if cfg.apply_attr(key.as_str(), value.as_str()) {

448

                        // `tearoff="zone:<selector>"`: the MODE rides in the

449

                        // config (it is `Copy`), the selector - a string - stays

450

                        // on the node as its `tearoff-zone` attribute, where the

451

                        // engine's drop handling reads it.

452

4

                        if key == "tearoff" {

453

                            if let Some(selector) = value.trim().strip_prefix("zone:") {

454

                                attr_vec.push(azul_core::dom::AttributeType::Custom(

455

                                    azul_core::dom::AttributeNameValue {

456

                                        attr_name: str_arena.intern("tearoff-zone"),

457

                                        value: str_arena.intern(selector.trim()),

458

},

459

));

460

461

4

462

4

                        continue;

463

1

464

1120

465

1121

                match key.as_str() {

466

1121

                    "id" => {

467

654

                        for id in value.split_whitespace() {

468

654

                            attr_vec.push(azul_core::dom::AttributeType::Id(str_arena.intern(id)));

469

654

470

471

468

                    "class" => {

472

316

                        for class in value.split_whitespace() {

473

316

                            attr_vec.push(azul_core::dom::AttributeType::Class(

474

316

                                str_arena.intern(class),

475

316

));

476

316

477

478

154

                    "focusable" => {

479

5

                        if let Some(f) = parse_bool(value.as_str()) {

480

2

                            nd.set_tab_index(if f {

481

1

                                TabIndex::Auto

482

                            } else {

483

1

                                TabIndex::NoKeyboardFocus

484

});

485

3

486

487

149

                    "tabindex" => {

488

98

                        if let Ok(ti) = value.parse::<isize>() {

489

7

                            match ti {

490

80

                                0 => nd.set_tab_index(TabIndex::Auto),

491

7

                                i if i > 0 => {

492

5

                                    nd.set_tab_index(TabIndex::OverrideInParent(i as u32));

493

5

494

2

                                _ => nd.set_tab_index(TabIndex::NoKeyboardFocus),

495

496

11

497

498

51

                    "style" => {

499

14

                        let mut css_attrs = Vec::new();

500

2026

                        for s in value.split(';') {

501

2026

                            let mut s = s.split(':');

502

2026

                            let Some(key) = s.next() else { continue };

503

2026

                            let Some(val) = s.next() else { continue };

504

                            // Called for its side effect (writes parsed props into

505

                            // `css_attrs`); the returned value is intentionally discarded.

506

2013

                            drop(azul_css::parser2::parse_css_declaration(

507

2013

                                key.trim(),

508

2013

                                val.trim(),

509

2013

                                azul_css::parser2::ErrorLocationRange::default(),

510

2013

                                css_key_map,

511

2013

                                &mut Vec::new(),

512

2013

                                &mut css_attrs,

513

));

514

515

14

                        let props = css_attrs

516

14

                            .into_iter()

517

14

                            .filter_map(|s| {

518

                                use azul_css::{

519

                                    css::CssDeclaration,

520

                                    dynamic_selector::CssPropertyWithConditions,

521

};

522

2

                                match s {

523

2

                                    CssDeclaration::Static(s) => {

524

2

                                        Some(CssPropertyWithConditions::simple(s))

525

526

                                    CssDeclaration::Dynamic(_) => None,

527

528

2

})

529

14

                            .collect::<Vec<_>>();

530

14

                        if !props.is_empty() {

531

2

                            nd.set_css_props(props.into());

532

12

533

534

                    // Boolean attribute: presence is the value, as in HTML.

535

37

                    "autofocus" => attr_vec.push(azul_core::dom::AttributeType::Autofocus),

536

37

                    "placeholder" => attr_vec.push(azul_core::dom::AttributeType::Placeholder(

537

                        value.clone().into(),

538

)),

539

37

                    "contenteditable" => {

540

37

                        match parse_bool(value.as_str()) {

541

30

                            Some(true) => nd.set_contenteditable(true),

542

                            // An explicit `false` is NOT "no attribute": inside an

543

                            // editable host it walls its subtree off (HTML's

544

                            // inheritance rule, `is_node_contenteditable_inherited`)

545

                            // and keeps that subtree out of the host's edit buffer

546

                            // and out of the block the edit is shaped into. Dropped

547

                            // here, a mounted `<p contenteditable="false">` island

548

                            // behaved like any other child — the Rust API's

549

                            // `with_attribute(ContentEditable(false))` and the HTML

550

                            // loader disagreed on the same document.

551

2

                            Some(false) => {

552

2

                                attr_vec

553

2

                                    .push(azul_core::dom::AttributeType::ContentEditable(false));

554

2

555

5

                            None => {}

556

557

558

                    _ => {}

559

560

561

11356

            if !attr_vec.is_empty() {

562

680

                nd.set_attributes(attr_vec.into());

563

10958

564

            // Write the parsed popup config back into the node's payload.

565

11356

            if let Some(cfg) = transient_cfg {

566

2

                nd.set_node_type(NodeType::TransientWindow(cfg));

567

11354

568

569

11356

            builder.open_node(nd);

570

11356

};

571

572

367

    let mut last_was_void = false;

573

367

    let mut tag_stack: Vec<String> = Vec::new(); // for matching close tags

574

575

39151

    for token in tokenizer {

576

38828

        let token = token.map_err(|e| XmlError::ParserError(translate_xmlparser_error(e)))?;

577

23504

        match token {

578

11763

            ElementStart { local, .. } => {

579

                // Flush any pending open element

580

11763

                if pending_open {

581

                    let is_void = VOID_ELEMENTS.contains(&current_tag.as_str());

582

                    if current_tag == "head" {

583

                        head_depth += 1;

584

585

                    if head_depth == 0 {

586

                        finalize_open(

587

                            &mut builder,

588

                            &mut str_arena,

589

                            &current_tag,

590

                            &current_attrs,

591

                            &css_key_map,

592

);

593

                        if is_void {

594

                            builder.close_node();

595

596

597

                    if !is_void {

598

                        tag_stack.push(core::mem::take(&mut current_tag));

599

600

11763

601

602

                // Reuse the current_tag buffer — avoids ~1023 fresh String

603

                // allocations per parse (one per ElementStart).

604

11763

                lowercase_into(&mut current_tag, local.as_str());

605

11763

                current_attrs.clear();

606

11763

                pending_open = true;

607

11763

                last_was_void = VOID_ELEMENTS.contains(&current_tag.as_str());

608

609

1135

            Attribute { local, value, .. } => {

610

1135

                // decode_xml_entities returns Cow::Borrowed when no entities

611

1135

                // are present (the common case), so `.into_owned()` is the

612

1135

                // only fresh allocation here. The key is copied via

613

1135

                // `to_string()` because we can't hold a borrow across token

614

1135

                // iterations. TODO: when we switch current_attrs to

615

1135

                // Vec<(&str, Cow<str>)> this becomes zero-alloc for the key.

616

1135

                current_attrs.push((

617

1135

                    local.to_string(),

618

1135

                    decode_xml_entities(value.as_str()).into_owned(),

619

1135

));

620

1135

621

            ElementEnd { end: Open, .. } => {

622

11746

                if pending_open {

623

11746

                    let is_void = VOID_ELEMENTS.contains(&current_tag.as_str());

624

11746

                    if current_tag == "style" {

625

197

                        inside_style_tag = true;

626

197

                        style_text.clear();

627

11549

628

11746

                    if current_tag == "head" {

629

204

                        head_depth += 1;

630

11542

631

11746

                    if head_depth == 0 {

632

11343

                        finalize_open(

633

11343

                            &mut builder,

634

11343

                            &mut str_arena,

635

11343

                            &current_tag,

636

11343

                            &current_attrs,

637

11343

                            &css_key_map,

638

11343

);

639

11343

                        if is_void {

640

                            builder.close_node();

641

11343

642

403

643

11746

                    if !is_void {

644

11746

                        // Use take() instead of clone() — after pending_open=false,

645

11746

                        // current_tag is not read again until the next ElementStart

646

11746

                        // reassigns it via lowercase_into.

647

11746

                        tag_stack.push(core::mem::take(&mut current_tag));

648

11746

649

11746

                    pending_open = false;

650

651

652

            ElementEnd { end: Empty, .. } => {

653

                // Self-closing element: open + immediately close

654

13

                if pending_open {

655

13

                    if current_tag == "head" {

656

                        head_depth += 1;

657

13

658

13

                    if head_depth == 0 {

659

13

                        finalize_open(

660

13

                            &mut builder,

661

13

                            &mut str_arena,

662

13

                            &current_tag,

663

13

                            &current_attrs,

664

13

                            &css_key_map,

665

13

);

666

13

                        builder.close_node();

667

13

668

13

                    if current_tag == "head" && head_depth > 0 {

669

                        head_depth -= 1;

670

13

671

13

                    pending_open = false;

672

673

674

            ElementEnd {

675

11745

                end: Close(_, close_value),

676

..

677

            } => {

678

11745

                if pending_open {

679

                    let is_void = VOID_ELEMENTS.contains(&current_tag.as_str());

680

                    if current_tag == "head" {

681

                        head_depth += 1;

682

683

                    if head_depth == 0 {

684

                        finalize_open(

685

                            &mut builder,

686

                            &mut str_arena,

687

                            &current_tag,

688

                            &current_attrs,

689

                            &css_key_map,

690

);

691

                        if is_void {

692

                            builder.close_node();

693

694

695

                    if !is_void {

696

                        tag_stack.push(core::mem::take(&mut current_tag));

697

698

                    pending_open = false;

699

11745

700

701

11745

                let close_lower = close_value.as_str().to_ascii_lowercase();

702

11745

                let close_str = close_lower.as_str();

703

11745

                if VOID_ELEMENTS.contains(&close_str) {

704

                    continue;

705

11745

706

707

                // If closing a <style> tag, parse collected CSS

708

11745

                if close_str == "style" && inside_style_tag {

709

197

                    if !style_text.is_empty() {

710

197

                        let parsed_css = Css::from_string(core::mem::take(&mut style_text).into());

711

197

                        collected_css.push(parsed_css);

712

197

713

197

                    inside_style_tag = false;

714

11548

715

716

                // Pop until we find matching tag

717

11753

                while let Some(top) = tag_stack.last() {

718

11727

                    let is_match = top == close_str;

719

11727

                    let was_head = top == "head";

720

                    // Pop this tag (unconditionally auto-close mismatched tags)

721

11727

                    let popped = tag_stack.pop().unwrap();

722

11727

                    if popped == "head" && head_depth > 0 {

723

197

                        head_depth -= 1;

724

11530

725

11727

                    if head_depth == 0 && !was_head {

726

11332

                        builder.close_node();

727

11332

728

11727

                    if is_match {

729

11719

                        break;

730

8

731

732

733

2382

            Text { text } => {

734

2382

                if pending_open {

735

                    let is_void = VOID_ELEMENTS.contains(&current_tag.as_str());

736

                    if current_tag == "style" {

737

                        inside_style_tag = true;

738

                        style_text.clear();

739

740

                    if current_tag == "head" {

741

                        head_depth += 1;

742

743

                    if head_depth == 0 {

744

                        finalize_open(

745

                            &mut builder,

746

                            &mut str_arena,

747

                            &current_tag,

748

                            &current_attrs,

749

                            &css_key_map,

750

);

751

                        if is_void {

752

                            builder.close_node();

753

754

755

                    if !is_void {

756

                        tag_stack.push(current_tag.clone());

757

758

                    pending_open = false;

759

2382

760

761

2382

                let text_str = text.as_str();

762

2382

                if !text_str.is_empty() {

763

2382

                    if inside_style_tag {

764

197

                        style_text.push_str(text_str);

765

2185

                    } else if head_depth == 0 {

766

                        // Skip whitespace-only text at <html> level (between </head> and <body>)

767

                        // but keep whitespace inside <body> (it's significant for inline layout)

768

3045

                        let inside_body = tag_stack.iter().any(|t| t == "body");

769

1816

                        if inside_body || !text_str.trim().is_empty() {

770

1254

                            let decoded = decode_xml_entities(text_str);

771

1254

                            builder.add_leaf(

772

1254

                                NodeData::create_text_do_not_use_without_block_level_wrapper(

773

1254

                                    str_arena.intern(&decoded),

774

1254

),

775

1254

);

776

1264

777

369

778

779

780

            _ => {}

781

782

783

784

    // Close any remaining open elements

785

323

    if pending_open {

786

        finalize_open(

787

            &mut builder,

788

            &mut str_arena,

789

            &current_tag,

790

            &current_attrs,

791

            &css_key_map,

792

);

793

323

794

334

    while tag_stack.pop().is_some() {

795

11

        builder.close_node();

796

11

797

798

    // Drop the arena handle explicitly. AzStrings already embedded in

799

    // the FastDom keep the backing bytes alive via their cloned Arc refs.

800

323

    drop(str_arena);

801

802

323

    Ok((builder.finish(), collected_css))

803

367

804

805

/// Loads, parses and builds a DOM from an XML file

806

///

807

/// **Warning**: The file is reloaded from disk on every function call - do not

808

/// use this in release builds! This function deliberately never fails: In an error case,

809

/// the error gets rendered as a `NodeType::Label`.

810

#[cfg(all(feature = "std", feature = "xml"))]

811

4

pub fn domxml_from_file<I: AsRef<Path>>(file_path: I, component_map: &ComponentMap) -> DomXml {

812

    use std::fs;

813

814

4

    let error_css = Css::empty();

815

816

4

    let xml = match fs::read_to_string(file_path.as_ref()) {

817

        Ok(xml) => xml,

818

4

        Err(e) => {

819

4

            return DomXml {

820

4

                parsed_dom: {

821

4

                    let mut dom = Dom::create_body().with_children(

822

4

                        vec![Dom::create_p_with_text(format!(

823

4

                            "Error reading: \"{}\": {}",

824

4

                            file_path.as_ref().to_string_lossy(),

825

4

826

4

))]

827

4

                        .into(),

828

4

);

829

4

                    StyledDom::create(&mut dom, error_css)

830

4

},

831

4

};

832

833

};

834

835

    domxml_from_str(&xml, component_map)

836

4

837

838

/// Parses the XML string into an XML tree, returns

839

/// the root `<app></app>` node, with the children attached to it.

840

///

841

/// Since the XML allows multiple root nodes, this function returns

842

/// a `Vec<XmlNode>` - which are the "root" nodes, containing all their

843

/// children recursively.

844

#[cfg(feature = "xml")]

845

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

846

/// # Errors

847

///

848

/// Returns an `XmlError` if the XML cannot be parsed.

849

3146

pub fn parse_xml_string(xml: &str) -> Result<Vec<XmlNodeChild>, XmlError> {

850

    use xmlparser::{

851

        ElementEnd::{Close, Empty},

852

        Token::{Attribute, ElementEnd, ElementStart, Text},

853

        Tokenizer,

854

};

855

856

    use self::XmlParseError::*;

857

858

    // HTML5-lite parser: List of void elements that should auto-close

859

    // See: https://developer.mozilla.org/en-US/docs/Glossary/Void_element

860

    const VOID_ELEMENTS: &[&str] = &[

861

        "area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param",

862

        "source", "track", "wbr",

863

];

864

865

    // HTML5-lite parser: Elements that auto-close when certain other elements are encountered

866

    // Format: (element_name, closes_when_encountering)

867

    const AUTO_CLOSE_RULES: &[(&str, &[&str])] = &[

868

        // List items close when encountering another list item or when parent closes

869

        ("li", &["li"]),

870

        // Table cells/rows have complex closing rules

871

        ("td", &["td", "th", "tr"]),

872

        ("th", &["td", "th", "tr"]),

873

        ("tr", &["tr"]),

874

        // Paragraphs close on block-level elements

875

876

            "p",

877

&[

878

                "address",

879

                "article",

880

                "aside",

881

                "blockquote",

882

                "div",

883

                "dl",

884

                "fieldset",

885

                "footer",

886

                "form",

887

                "h1",

888

                "h2",

889

                "h3",

890

                "h4",

891

                "h5",

892

                "h6",

893

                "header",

894

                "hr",

895

                "main",

896

                "nav",

897

                "ol",

898

                "p",

899

                "pre",

900

                "section",

901

                "table",

902

                "ul",

903

],

904

),

905

        // Option closes on another option or optgroup

906

        ("option", &["option", "optgroup"]),

907

        ("optgroup", &["optgroup"]),

908

        // DD/DT close on each other

909

        ("dd", &["dd", "dt"]),

910

        ("dt", &["dd", "dt"]),

911

];

912

913

3146

    let mut root_node = XmlNode::default();

914

915

    // Strip UTF-8 BOM if present (some W3C test files have it)

916

3146

    let xml = xml.strip_prefix('\u{FEFF}').unwrap_or(xml);

917

918

    // Search for "<?xml" and "?>" tags and delete them from the XML

919

3146

    let mut xml = xml.trim();

920

3146

    if xml.starts_with("<?") {

921

27

        let pos = xml

922

27

            .find("?>")

923

27

            .ok_or(XmlError::MalformedHierarchy(MalformedHierarchyError {

924

27

                expected: "<?xml".into(),

925

27

                got: "?>".into(),

926

27

            }))?;

927

21

        xml = &xml[(pos + 2)..];

928

3119

929

930

    // Delete <!DOCTYPE ...> if necessary (case-insensitive)

931

3140

    let mut xml = xml.trim();

932

3140

    if xml.len() > 9

933

3047

        && xml.is_char_boundary(9)

934

3045

        && xml[..9].to_ascii_lowercase().starts_with("<!doctype")

935

936

3

        let pos = xml

937

3

            .find('>')

938

3

            .ok_or(XmlError::MalformedHierarchy(MalformedHierarchyError {

939

3

                expected: "<!DOCTYPE".into(),

940

3

                got: ">".into(),

941

3

            }))?;

942

2

        xml = &xml[(pos + 1)..];

943

3137

    } else if xml.starts_with("<!--") {

944

        // Skip HTML comments at the start

945

15

        if let Some(end) = xml.find("-->") {

946

11

            xml = &xml[(end + 3)..];

947

11

            xml = xml.trim();

948

14

949

3122

950

951

3139

    let tokenizer = Tokenizer::from_fragment(xml, 0..xml.len());

952

953

    // OPTIMIZED: Use a stack of raw pointers to avoid O(n*d) traversal on every token.

954

    // This is safe because:

955

    // 1. All pointers point into `root_node` which is owned and not moved

956

    // 2. We never hold multiple mutable references simultaneously

957

    // 3. The stack is only used within this function

958

3139

    let mut node_stack: Vec<*mut XmlNode> = vec![&raw mut root_node];

959

960

    // Track which hierarchy level is a void element (shouldn't be pushed to hierarchy)

961

3139

    let mut last_was_void = false;

962

963

370143

    for token in tokenizer {

964

367052

        let token = token.map_err(|e| XmlError::ParserError(translate_xmlparser_error(e)))?;

965

173175

        match token {

966

113083

            ElementStart { local, .. } => {

967

113083

                let tag_name = local.to_string();

968

113083

                let is_void_element = VOID_ELEMENTS.contains(&tag_name.as_str());

969

970

                // HTML5-lite: If last element was a void element (like <img src="...">),

971

                // pop it from hierarchy before processing the new element

972

113083

                if last_was_void {

973

4

                    node_stack.pop();

974

4

                    last_was_void = false;

975

113079

976

977

                // HTML5-lite: Check if we need to auto-close the current element

978

113083

                if node_stack.len() > 1 {

979

                    // SAFETY: We only access the last element, which is valid

980

109871

                    let current_element = unsafe { &*node_stack[node_stack.len() - 1] };

981

109871

                    let current_tag = current_element.node_type.as_str();

982

983

                    // Check if current element should auto-close when encountering this new tag

984

1098210

                    for (element, closes_on) in AUTO_CLOSE_RULES {

985

988411

                        if current_tag == *element && closes_on.contains(&tag_name.as_str()) {

986

                            // Auto-close the current element

987

72

                            node_stack.pop();

988

72

                            break;

989

988339

990

991

3212

992

993

                // SAFETY: We access the last element which is valid

994

113083

                if let Some(&current_parent_ptr) = node_stack.last() {

995

113083

                    let current_parent = unsafe { &mut *current_parent_ptr };

996

997

113083

                    current_parent.children.push(XmlNodeChild::Element(XmlNode {

998

113083

                        node_type: tag_name.into(),

999

113083

                        attributes: StringPairVec::new().into(),

1000

113083

                        children: Vec::new().into(),

1001

113083

                    }));

1002

1003

                    // Get pointer to the newly added child

1004

113083

                    let children_len = current_parent.children.len();

1005

113083

                    if let Some(XmlNodeChild::Element(ref mut new_child)) =

1006

113083

                        current_parent.children.as_mut().get_mut(children_len - 1)

1007

113083

1008

113083

                        node_stack.push(std::ptr::from_mut::<XmlNode>(new_child));

1009

113083

1010

1011

113083

                    last_was_void = is_void_element;

1012

1013

1014

            ElementEnd { end: Empty, .. } => {

1015

                // Pop hierarchy for all elements (including void elements after their attributes)

1016

52792

                if node_stack.len() > 1 {

1017

52792

                    node_stack.pop();

1018

52792

1019

52792

                last_was_void = false;

1020

1021

            ElementEnd {

1022

60102

                end: Close(_, close_value),

1023

..

1024

            } => {

1025

                // HTML5-lite: If last element was a void element, pop it first

1026

60102

                if last_was_void {

1027

42

                    node_stack.pop();

1028

42

                    last_was_void = false;

1029

60060

1030

1031

                // HTML5-lite: Check if this is a void element - if so, ignore the closing tag

1032

60102

                let is_void_element = VOID_ELEMENTS.contains(&close_value.as_str());

1033

60102

                if is_void_element {

1034

                    // Void elements shouldn't have closing tags, but tolerate them

1035

42

                    continue;

1036

60060

1037

1038

                // HTML5-lite: Auto-close any elements that should be closed

1039

                // Walk up the hierarchy and auto-close elements until we find a match

1040

60060

                let close_value_str = close_value.as_str();

1041

1042

                // Find matching element in stack (skip root at index 0)

1043

60060

                let mut found_idx = None;

1044

60110

                for i in (1..node_stack.len()).rev() {

1045

                    // SAFETY: All pointers in stack are valid

1046

60106

                    let node = unsafe { &*node_stack[i] };

1047

60106

                    if node.node_type.as_str() == close_value_str {

1048

60048

                        found_idx = Some(i);

1049

60048

                        break;

1050

58

1051

1052

1053

60060

                if let Some(idx) = found_idx {

1054

60048

                    // Pop all elements from current position to the matching element (inclusive)

1055

60048

                    node_stack.truncate(idx);

1056

60048

1057

                // If no match found, just ignore (lenient HTML parsing)

1058

1059

60060

                last_was_void = false;

1060

1061

17318

            Attribute { local, value, .. } => {

1062

                // SAFETY: Last element in stack is valid

1063

17318

                if let Some(&last_ptr) = node_stack.last() {

1064

17318

                    let last = unsafe { &mut *last_ptr };

1065

17318

                    // NOTE: Only lowercase the key ("local"), not the value!

1066

17318

                    // Decode XML entities in attribute values as well

1067

17318

                    last.attributes.push(azul_core::window::AzStringPair {

1068

17318

                        key: local.to_string().into(),

1069

17318

                        value: AzString::from(&*decode_xml_entities(value.as_str())),

1070

17318

});

1071

17318

1072

1073

63428

            Text { text } => {

1074

                // HTML5-lite: If last element was a void element, pop it before adding text

1075

63428

                if last_was_void {

1076

40

                    node_stack.pop();

1077

40

                    last_was_void = false;

1078

63388

1079

1080

                // IMPORTANT: Preserve ALL text nodes including whitespace-only nodes.

1081

                // Whether whitespace is significant depends on the CSS `white-space` property,

1082

                // which is determined during layout, not during parsing.

1083

//

1084

                // For example: <pre><span>    </span></pre> must preserve the 4 spaces.

1085

//

1086

                // We only skip completely EMPTY text nodes (zero-length strings).

1087

63428

                let text_str = text.as_str();

1088

1089

63428

                if !text_str.is_empty() {

1090

                    // SAFETY: Last element in stack is valid

1091

63428

                    if let Some(&current_parent_ptr) = node_stack.last() {

1092

63428

                        let current_parent = unsafe { &mut *current_parent_ptr };

1093

63428

                        // Decode XML entities (e.g., &lt; -> <, &gt; -> >, etc.)

1094

63428

                        let decoded_text = decode_xml_entities(text_str);

1095

63428

                        // Add text as a child node

1096

63428

                        current_parent

1097

63428

                            .children

1098

63428

                            .push(XmlNodeChild::Text(AzString::from(&*decoded_text)));

1099

63428

1100

1101

1102

60281

            _ => {}

1103

1104

1105

1106

    // Clean up: if we ended with a void element, pop it

1107

3091

    if last_was_void {

1108

5

        node_stack.pop();

1109

3086

1110

1111

    // A well-formed document unwinds back to just the root sentinel. If an element was

1112

    // left open (e.g. a bare "<svg" with no closing bracket, which the fragment tokenizer

1113

    // yields as one ElementStart then cleanly ends), node_stack still holds it — reject

1114

    // it instead of returning a "valid" partial tree.

1115

3091

    if node_stack.len() != 1 {

1116

13

        return Err(XmlError::UnclosedRootNode);

1117

3078

1118

1119

3078

    Ok(root_node.children.into())

1120

3146

1121

1122

#[cfg(feature = "xml")]

1123

/// # Errors

1124

///

1125

/// Returns an `XmlError` if the XML cannot be parsed.

1126

156

pub fn parse_xml(s: &str) -> Result<Xml, XmlError> {

1127

    Ok(Xml {

1128

156

        root: parse_xml_string(s)?.into(),

1129

})

1130

156

1131

1132

#[cfg(not(feature = "xml"))]

1133

pub fn parse_xml(s: &str) -> Result<Xml, XmlError> {

1134

    Err(XmlError::NoParserAvailable)

1135

1136

1137

// to_string(&self) -> String

1138

1139

#[cfg(feature = "xml")]

1140

#[must_use]

1141

7

pub fn translate_roxmltree_expandedname(e: roxmltree::ExpandedName<'_, '_>) -> XmlQualifiedName {

1142

7

    let ns: Option<AzString> = e.namespace().map(|e| e.to_string().into());

1143

7

    XmlQualifiedName {

1144

7

        local_name: e.name().to_string().into(),

1145

7

        namespace: ns.into(),

1146

7

1147

7

1148

1149

#[cfg(feature = "xml")]

1150

2

fn translate_roxmltree_attribute(e: roxmltree::Attribute<'_, '_>) -> XmlQualifiedName {

1151

    XmlQualifiedName {

1152

2

        local_name: e.name().to_string().into(),

1153

2

        namespace: e.namespace().map(|e| e.to_string().into()).into(),

1154

1155

2

1156

1157

#[cfg(feature = "xml")]

1158

106

fn translate_xmlparser_streamerror(e: xmlparser::StreamError) -> XmlStreamError {

1159

106

    match e {

1160

8

        xmlparser::StreamError::UnexpectedEndOfStream => XmlStreamError::UnexpectedEndOfStream,

1161

48

        xmlparser::StreamError::InvalidName => XmlStreamError::InvalidName,

1162

1

        xmlparser::StreamError::InvalidReference => XmlStreamError::InvalidReference,

1163

1

        xmlparser::StreamError::InvalidExternalID => XmlStreamError::InvalidExternalID,

1164

1

        xmlparser::StreamError::InvalidCommentData => XmlStreamError::InvalidCommentData,

1165

1

        xmlparser::StreamError::InvalidCommentEnd => XmlStreamError::InvalidCommentEnd,

1166

8

        xmlparser::StreamError::InvalidCharacterData => XmlStreamError::InvalidCharacterData,

1167

11

        xmlparser::StreamError::NonXmlChar(c, tp) => XmlStreamError::NonXmlChar(NonXmlCharError {

1168

11

            ch: c.into(),

1169

11

            pos: translate_xmlparser_textpos(tp),

1170

11

}),

1171

1

        xmlparser::StreamError::InvalidChar(a, b, tp) => {

1172

1

            XmlStreamError::InvalidChar(InvalidCharError {

1173

1

                expected: a,

1174

1

                got: b,

1175

1

                pos: translate_xmlparser_textpos(tp),

1176

1

})

1177

1178

1

        xmlparser::StreamError::InvalidCharMultiple(a, b, tp) => {

1179

1

            XmlStreamError::InvalidCharMultiple(InvalidCharMultipleError {

1180

1

                expected: a,

1181

1

                got: b.to_vec().into(),

1182

1

                pos: translate_xmlparser_textpos(tp),

1183

1

})

1184

1185

8

        xmlparser::StreamError::InvalidQuote(a, tp) => {

1186

8

            XmlStreamError::InvalidQuote(InvalidQuoteError {

1187

8

                got: a,

1188

8

                pos: translate_xmlparser_textpos(tp),

1189

8

})

1190

1191

1

        xmlparser::StreamError::InvalidSpace(a, tp) => {

1192

1

            XmlStreamError::InvalidSpace(InvalidSpaceError {

1193

1

                got: a,

1194

1

                pos: translate_xmlparser_textpos(tp),

1195

1

})

1196

1197

16

        xmlparser::StreamError::InvalidString(a, tp) => {

1198

16

            XmlStreamError::InvalidString(InvalidStringError {

1199

16

                got: a.to_string().into(),

1200

16

                pos: translate_xmlparser_textpos(tp),

1201

16

})

1202

1203

1204

106

1205

1206

#[cfg(feature = "xml")]

1207

102

fn translate_xmlparser_error(e: xmlparser::Error) -> XmlParseError {

1208

102

    match e {

1209

1

        xmlparser::Error::InvalidDeclaration(se, tp) => {

1210

1

            XmlParseError::InvalidDeclaration(XmlTextError {

1211

1

                stream_error: translate_xmlparser_streamerror(se),

1212

1

                pos: translate_xmlparser_textpos(tp),

1213

1

})

1214

1215

9

        xmlparser::Error::InvalidComment(se, tp) => XmlParseError::InvalidComment(XmlTextError {

1216

9

            stream_error: translate_xmlparser_streamerror(se),

1217

9

            pos: translate_xmlparser_textpos(tp),

1218

9

}),

1219

5

        xmlparser::Error::InvalidPI(se, tp) => XmlParseError::InvalidPI(XmlTextError {

1220

5

            stream_error: translate_xmlparser_streamerror(se),

1221

5

            pos: translate_xmlparser_textpos(tp),

1222

5

}),

1223

1

        xmlparser::Error::InvalidDoctype(se, tp) => XmlParseError::InvalidDoctype(XmlTextError {

1224

1

            stream_error: translate_xmlparser_streamerror(se),

1225

1

            pos: translate_xmlparser_textpos(tp),

1226

1

}),

1227

1

        xmlparser::Error::InvalidEntity(se, tp) => XmlParseError::InvalidEntity(XmlTextError {

1228

1

            stream_error: translate_xmlparser_streamerror(se),

1229

1

            pos: translate_xmlparser_textpos(tp),

1230

1

}),

1231

41

        xmlparser::Error::InvalidElement(se, tp) => XmlParseError::InvalidElement(XmlTextError {

1232

41

            stream_error: translate_xmlparser_streamerror(se),

1233

41

            pos: translate_xmlparser_textpos(tp),

1234

41

}),

1235

9

        xmlparser::Error::InvalidAttribute(se, tp) => {

1236

9

            XmlParseError::InvalidAttribute(XmlTextError {

1237

9

                stream_error: translate_xmlparser_streamerror(se),

1238

9

                pos: translate_xmlparser_textpos(tp),

1239

9

})

1240

1241

8

        xmlparser::Error::InvalidCdata(se, tp) => XmlParseError::InvalidCdata(XmlTextError {

1242

8

            stream_error: translate_xmlparser_streamerror(se),

1243

8

            pos: translate_xmlparser_textpos(tp),

1244

8

}),

1245

18

        xmlparser::Error::InvalidCharData(se, tp) => XmlParseError::InvalidCharData(XmlTextError {

1246

18

            stream_error: translate_xmlparser_streamerror(se),

1247

18

            pos: translate_xmlparser_textpos(tp),

1248

18

}),

1249

9

        xmlparser::Error::UnknownToken(tp) => {

1250

9

            XmlParseError::UnknownToken(translate_xmlparser_textpos(tp))

1251

1252

1253

102

1254

1255

#[cfg(feature = "xml")]

1256

#[must_use]

1257

31

pub fn translate_roxmltree_error(e: roxmltree::Error) -> XmlError {

1258

31

    match e {

1259

1

        roxmltree::Error::InvalidXmlPrefixUri(s) => {

1260

1

            XmlError::InvalidXmlPrefixUri(translate_roxml_textpos(s))

1261

1262

1

        roxmltree::Error::UnexpectedXmlUri(s) => {

1263

1

            XmlError::UnexpectedXmlUri(translate_roxml_textpos(s))

1264

1265

1

        roxmltree::Error::UnexpectedXmlnsUri(s) => {

1266

1

            XmlError::UnexpectedXmlnsUri(translate_roxml_textpos(s))

1267

1268

1

        roxmltree::Error::InvalidElementNamePrefix(s) => {

1269

1

            XmlError::InvalidElementNamePrefix(translate_roxml_textpos(s))

1270

1271

1

        roxmltree::Error::DuplicatedNamespace(s, tp) => {

1272

1

            XmlError::DuplicatedNamespace(DuplicatedNamespaceError {

1273

1

                ns: s.into(),

1274

1

                pos: translate_roxml_textpos(tp),

1275

1

})

1276

1277

1

        roxmltree::Error::UnknownNamespace(s, tp) => {

1278

1

            XmlError::UnknownNamespace(UnknownNamespaceError {

1279

1

                ns: s.into(),

1280

1

                pos: translate_roxml_textpos(tp),

1281

1

})

1282

1283

1

        roxmltree::Error::UnexpectedCloseTag(expected, actual, pos) => {

1284

1

            XmlError::UnexpectedCloseTag(UnexpectedCloseTagError {

1285

1

                expected: expected.into(),

1286

1

                actual: actual.into(),

1287

1

                pos: translate_roxml_textpos(pos),

1288

1

})

1289

1290

1

        roxmltree::Error::UnexpectedEntityCloseTag(s) => {

1291

1

            XmlError::UnexpectedEntityCloseTag(translate_roxml_textpos(s))

1292

1293

1

        roxmltree::Error::UnknownEntityReference(s, tp) => {

1294

1

            XmlError::UnknownEntityReference(UnknownEntityReferenceError {

1295

1

                entity: s.into(),

1296

1

                pos: translate_roxml_textpos(tp),

1297

1

})

1298

1299

1

        roxmltree::Error::MalformedEntityReference(s) => {

1300

1

            XmlError::MalformedEntityReference(translate_roxml_textpos(s))

1301

1302

1

        roxmltree::Error::EntityReferenceLoop(s) => {

1303

1

            XmlError::EntityReferenceLoop(translate_roxml_textpos(s))

1304

1305

1

        roxmltree::Error::InvalidAttributeValue(s) => {

1306

1

            XmlError::InvalidAttributeValue(translate_roxml_textpos(s))

1307

1308

1

        roxmltree::Error::DuplicatedAttribute(s, tp) => {

1309

1

            XmlError::DuplicatedAttribute(DuplicatedAttributeError {

1310

1

                attribute: s.into(),

1311

1

                pos: translate_roxml_textpos(tp),

1312

1

})

1313

1314

1

        roxmltree::Error::NoRootNode => XmlError::NoRootNode,

1315

1

        roxmltree::Error::DtdDetected => XmlError::DtdDetected,

1316

1

        roxmltree::Error::UnclosedRootNode => XmlError::UnclosedRootNode,

1317

1

        roxmltree::Error::UnexpectedDeclaration(tp) => {

1318

1

            XmlError::UnexpectedDeclaration(translate_roxml_textpos(tp))

1319

1320

1

        roxmltree::Error::NodesLimitReached => XmlError::NodesLimitReached,

1321

1

        roxmltree::Error::AttributesLimitReached => XmlError::AttributesLimitReached,

1322

1

        roxmltree::Error::NamespacesLimitReached => XmlError::NamespacesLimitReached,

1323

1

        roxmltree::Error::InvalidName(tp) => XmlError::InvalidName(translate_roxml_textpos(tp)),

1324

1

        roxmltree::Error::NonXmlChar(_, tp) => XmlError::NonXmlChar(translate_roxml_textpos(tp)),

1325

1

        roxmltree::Error::InvalidChar(_, _, tp) => {

1326

1

            XmlError::InvalidChar(translate_roxml_textpos(tp))

1327

1328

1

        roxmltree::Error::InvalidChar2(_, _, tp) => {

1329

1

            XmlError::InvalidChar2(translate_roxml_textpos(tp))

1330

1331

1

        roxmltree::Error::InvalidString(_, tp) => {

1332

1

            XmlError::InvalidString(translate_roxml_textpos(tp))

1333

1334

1

        roxmltree::Error::InvalidExternalID(tp) => {

1335

1

            XmlError::InvalidExternalID(translate_roxml_textpos(tp))

1336

1337

1

        roxmltree::Error::InvalidComment(tp) => {

1338

1

            XmlError::InvalidComment(translate_roxml_textpos(tp))

1339

1340

1

        roxmltree::Error::InvalidCharacterData(tp) => {

1341

1

            XmlError::InvalidCharacterData(translate_roxml_textpos(tp))

1342

1343

1

        roxmltree::Error::UnknownToken(tp) => XmlError::UnknownToken(translate_roxml_textpos(tp)),

1344

1

        roxmltree::Error::UnexpectedEndOfStream => XmlError::UnexpectedEndOfStream,

1345

1

        roxmltree::Error::EntityResolver(tp, s) => {

1346

            // New in roxmltree 0.21: EntityResolver error variant

1347

            // For now, treat as a generic entity reference error

1348

1

            XmlError::UnknownEntityReference(UnknownEntityReferenceError {

1349

1

                entity: s.into(),

1350

1

                pos: translate_roxml_textpos(tp),

1351

1

})

1352

1353

1354

31

1355

1356

#[cfg(feature = "xml")]

1357

#[inline]

1358

145

const fn translate_xmlparser_textpos(o: xmlparser::TextPos) -> XmlTextPos {

1359

145

    XmlTextPos {

1360

145

        row: o.row,

1361

145

        col: o.col,

1362

145

1363

145

1364

1365

#[cfg(feature = "xml")]

1366

#[inline]

1367

29

const fn translate_roxml_textpos(o: roxmltree::TextPos) -> XmlTextPos {

1368

29

    XmlTextPos {

1369

29

        row: o.row,

1370

29

        col: o.col,

1371

29

1372

29

1373

1374

/// Extension trait to add XML parsing capabilities to Dom

1375

///

1376

/// This trait provides methods to parse XML/XHTML strings and convert them

1377

/// into Azul DOM trees. It's implemented as a trait to avoid circular dependencies

1378

/// between azul-core and azul-layout.

1379

#[cfg(feature = "xml")]

1380

pub trait DomXmlExt {

1381

    /// Parse XML/XHTML string into a DOM tree

1382

///

1383

    /// This method parses the XML string and converts it to an Azul `StyledDom`.

1384

    /// On error, it returns a `StyledDom` displaying the error message.

1385

///

1386

    /// # Arguments

1387

    /// * `xml` - The XML/XHTML string to parse

1388

///

1389

    /// # Returns

1390

    /// A `StyledDom` tree representing the parsed XML, or an error DOM on parse failure

1391

    fn from_xml_string<S: AsRef<str>>(xml: S) -> StyledDom;

1392

1393

1394

#[cfg(feature = "xml")]

1395

impl DomXmlExt for Dom {

1396

258

    fn from_xml_string<S: AsRef<str>>(xml: S) -> StyledDom {

1397

258

        let component_map = ComponentMap::with_builtin();

1398

258

        let dom_xml = domxml_from_str(xml.as_ref(), &component_map);

1399

258

        dom_xml.parsed_dom

1400

258

1401

1402

1403

// ============================================================================

1404

// Adversarial unit tests (autotest). Inline so the private helpers

1405

// (`decode_xml_entities*`, `parse_xml_to_fast_dom_with_css`, `peak_rss_bytes`,

1406

// `translate_*`) are reachable.

1407

// ============================================================================

1408

1409

#[cfg(test)]

1410

mod autotest_generated {

1411

    use azul_core::dom::{FastDom, NodeData, NodeType, TabIndex};

1412

1413

    use super::*;

1414

1415

    // ------------------------------------------------------------------

1416

    // helpers

1417

    // ------------------------------------------------------------------

1418

1419

    /// Element children of an `XmlNodeChild` slice (skips text nodes).

1420

    #[cfg(feature = "xml")]

1421

    fn elements(children: &[XmlNodeChild]) -> Vec<&XmlNode> {

1422

        children

1423

            .iter()

1424

            .filter_map(XmlNodeChild::as_element)

1425

            .collect()

1426

1427

1428

    /// Text children of an `XmlNodeChild` slice (skips element nodes).

1429

    #[cfg(feature = "xml")]

1430

    fn texts(children: &[XmlNodeChild]) -> Vec<&str> {

1431

        children.iter().filter_map(XmlNodeChild::as_text).collect()

1432

1433

1434

    /// `<html><body>…</body></html>` around `body`.

1435

///

1436

    /// Every fixture goes through this so the document's first 9 bytes are

1437

    /// ASCII: `parse_xml*` slices `xml[..9]` for the DOCTYPE sniff without a

1438

    /// char-boundary check (see

1439

    /// `parse_entrypoints_do_not_panic_on_short_multibyte_input`).

1440

    fn doc(body: &str) -> String {

1441

        format!("<html><body>{body}</body></html>")

1442

1443

1444

    /// Flat node arena of a `FastDom`.

1445

    fn nodes(dom: &FastDom) -> &[NodeData] {

1446

        dom.node_data.as_ref()

1447

1448

1449

    /// Text content of a `NodeType::Text` node (`None` for every other kind).

1450

    fn text_of(nd: &NodeData) -> Option<String> {

1451

        match nd.get_node_type() {

1452

            NodeType::Text(_) => nd.get_node_type().format(),

1453

            _ => None,

1454

1455

1456

1457

    /// Minimal XML escaper — the inverse of `decode_xml_entities`.

1458

    #[cfg(feature = "xml")]

1459

    fn escape(s: &str) -> String {

1460

        let mut out = String::with_capacity(s.len());

1461

        for c in s.chars() {

1462

            match c {

1463

                '&' => out.push_str("&amp;"),

1464

                '<' => out.push_str("&lt;"),

1465

                '>' => out.push_str("&gt;"),

1466

                '"' => out.push_str("&quot;"),

1467

                '\'' => out.push_str("&apos;"),

1468

                _ => out.push(c),

1469

1470

1471

out

1472

1473

1474

    /// Non-grammar / hostile fragments. All ASCII on purpose so they exercise

1475

    /// the tokenizer rather than the `xml[..9]` slice.

1476

    const GARBAGE: &[&str] = &[

1477

        "<<<<>>>>",

1478

        "!!!not xml at all!!!",

1479

        "<a b=c>",

1480

        "</>",

1481

        "</div>",

1482

        "<a></a",

1483

        "&&&&&&&&&&&&",

1484

        "]]>",

1485

        "<!--",

1486

        "<![CDATA[",

1487

        "<?",

1488

        "<!DOCTYPE",

1489

        "\u{0}\u{1}\u{2}",

1490

        "<a><<a><<<a>",

1491

        "= = = = = = = = = =",

1492

];

1493

1494

    // ------------------------------------------------------------------

1495

    // decode_xml_entities / decode_xml_entities_slow

1496

    // ------------------------------------------------------------------

1497

1498

    #[test]

1499

    fn decode_xml_entities_borrows_when_there_is_no_ampersand() {

1500

        for s in ["", "hello", "  ", "日本語 🙂", "<tag/>", "a;b;c;"] {

1501

            assert!(

1502

                matches!(decode_xml_entities(s), std::borrow::Cow::Borrowed(_)),

1503

                "{s:?} has no '&' and must take the zero-alloc path"

1504

);

1505

            assert_eq!(&*decode_xml_entities(s), s);

1506

1507

1508

1509

    #[test]

1510

    fn decode_xml_entities_decodes_the_five_named_entities_and_nbsp() {

1511

        assert_eq!(&*decode_xml_entities("&lt;"), "<");

1512

        assert_eq!(&*decode_xml_entities("&gt;"), ">");

1513

        assert_eq!(&*decode_xml_entities("&amp;"), "&");

1514

        assert_eq!(&*decode_xml_entities("&apos;"), "'");

1515

        assert_eq!(&*decode_xml_entities("&quot;"), "\"");

1516

        assert_eq!(&*decode_xml_entities("&nbsp;"), "\u{00A0}");

1517

        assert_eq!(

1518

            &*decode_xml_entities("a&lt;b&gt;c&amp;d&quot;e&apos;f"),

1519

            "a<b>c&d\"e'f"

1520

);

1521

1522

1523

    #[test]

1524

    fn decode_xml_entities_decodes_numeric_references() {

1525

        // decimal, lowercase hex, uppercase hex marker

1526

        assert_eq!(&*decode_xml_entities("&#60;"), "<");

1527

        assert_eq!(&*decode_xml_entities("&#x3C;"), "<");

1528

        assert_eq!(&*decode_xml_entities("&#X3c;"), "<");

1529

        assert_eq!(&*decode_xml_entities("&#65;"), "A");

1530

        // boundary code points: NUL, BMP max, astral, and the last legal scalar

1531

        assert_eq!(&*decode_xml_entities("&#0;"), "\u{0}");

1532

        assert_eq!(&*decode_xml_entities("&#xFFFF;"), "\u{FFFF}");

1533

        assert_eq!(&*decode_xml_entities("&#65536;"), "\u{10000}");

1534

        assert_eq!(&*decode_xml_entities("&#1114111;"), "\u{10FFFF}");

1535

        assert_eq!(&*decode_xml_entities("&#x10FFFF;"), "\u{10FFFF}");

1536

        // combining marks survive

1537

        assert_eq!(&*decode_xml_entities("e&#x301;"), "e\u{301}");

1538

1539

1540

    #[test]

1541

    fn decode_xml_entities_keeps_out_of_range_and_surrogate_code_points_verbatim() {

1542

        // Every one of these must round-trip to itself: no panic, no

1543

        // replacement char, no silent truncation to a wrong scalar.

1544

        for s in [

1545

            "&#xD800;",      // lone high surrogate

1546

            "&#xDFFF;",      // lone low surrogate

1547

            "&#55296;",      // decimal surrogate

1548

            "&#x110000;",    // one past the last scalar

1549

            "&#1114112;",    // decimal, one past the last scalar

1550

            "&#123456789;",  // entity name is exactly 10 bytes (the length cap)

1551

            "&#4294967296;", // u32::MAX + 1

1552

            "&#99999999999999;",

1553

            "&#x;",

1554

            "&#;",

1555

            "&#xZZ;",

1556

            "&#-1;",

1557

] {

1558

            assert_eq!(

1559

                &*decode_xml_entities(s),

1560

s,

1561

                "{s:?} is not a decodable reference and must be preserved byte-for-byte"

1562

);

1563

1564

1565

1566

    #[test]

1567

    fn decode_xml_entities_keeps_unterminated_and_unknown_entities_verbatim() {

1568

        for s in [

1569

            "&", "&&", "&lt", "&#", "&#x", "&foo;", "&LT;", // entity table is case-sensitive

1570

            "&Amp;", "& lt;", "a & b", "&;",

1571

] {

1572

            assert_eq!(&*decode_xml_entities(s), s, "{s:?} must be preserved");

1573

1574

        // Trailing garbage after a valid entity is still emitted.

1575

        assert_eq!(&*decode_xml_entities("&lt;&"), "<&");

1576

1577

1578

    #[test]

1579

    fn decode_xml_entities_does_not_double_decode() {

1580

        // A single pass only. `&amp;lt;` is the escaped form of the literal

1581

        // text `&lt;` and must NOT collapse to `<` — that would be an

1582

        // injection vector for anything that escapes user text once.

1583

        assert_eq!(&*decode_xml_entities("&amp;lt;"), "&lt;");

1584

        assert_eq!(&*decode_xml_entities("&amp;amp;"), "&amp;");

1585

        assert_eq!(&*decode_xml_entities("&amp;#60;"), "&#60;");

1586

1587

1588

    #[test]

1589

    fn decode_xml_entities_handles_pathological_input_without_panicking() {

1590

        // Entity name far past the 10-byte cap: bails out and preserves input.

1591

        let long_name = format!("&{};", "a".repeat(10_000));

1592

        assert_eq!(&*decode_xml_entities(&long_name), long_name);

1593

1594

        // Unterminated '&' followed by a megabyte of text.

1595

        let long_tail = format!("&{}", "x".repeat(1_000_000));

1596

        assert_eq!(decode_xml_entities(&long_tail).len(), long_tail.len());

1597

1598

        // Multibyte / astral / combining input mixed with entities. The entity

1599

        // scanner uses `char::is_alphanumeric`, so multibyte chars can land in

1600

        // the accumulator — slicing must stay on char boundaries.

1601

        for s in [

1602

            "&\u{1F600}\u{1F600};",

1603

            "&½;",

1604

            "&日本;",

1605

            "&#\u{1F600};",

1606

            "&e\u{301};",

1607

            "🙂&amp;🙂",

1608

] {

1609

            let out = decode_xml_entities(s);

1610

            assert!(

1611

                !out.is_empty(),

1612

                "{s:?} decoded to nothing (input was non-empty)"

1613

);

1614

1615

1616

        // Alternating entities at scale must not go quadratic-and-panic.

1617

        let many = "&lt;".repeat(50_000);

1618

        assert_eq!(decode_xml_entities(&many).chars().count(), 50_000);

1619

1620

1621

    #[test]

1622

    fn decode_xml_entities_slow_matches_the_fast_path() {

1623

        // The fast path is only a `contains('&')` short-circuit: for '&'-free

1624

        // input the slow path must be the identity, and for everything else

1625

        // the two must agree exactly.

1626

        for s in [

1627

"",

1628

            "plain",

1629

            "日本語 🙂",

1630

            "&lt;",

1631

            "&amp;lt;",

1632

            "&#x1F600;",

1633

            "&unknown;",

1634

            "&",

1635

] {

1636

            assert_eq!(

1637

                &*decode_xml_entities(s),

1638

                &*decode_xml_entities_slow(s),

1639

                "fast/slow path disagree on {s:?}"

1640

);

1641

1642

        for s in ["", "plain", "日本語 🙂", "a;b", "<>"] {

1643

            assert_eq!(&*decode_xml_entities_slow(s), s);

1644

1645

1646

1647

    // ------------------------------------------------------------------

1648

    // KNOWN BUG: unchecked `xml[..9]` slice in the DOCTYPE sniff

1649

    // ------------------------------------------------------------------

1650

1651

    /// `parse_xml_string` (line ~737) and `parse_xml_to_fast_dom_with_css`

1652

    /// (line ~328) both do

1653

///

1654

    /// ```ignore

1655

    /// if xml.len() > 9 && xml[..9].to_ascii_lowercase().starts_with("<!doctype")

1656

    /// ```

1657

///

1658

    /// `&str[..9]` panics when byte 9 is not a UTF-8 char boundary, so any

1659

    /// input longer than 9 bytes whose third-or-so character is multibyte

1660

    /// aborts the parse with `byte index 9 is not a char boundary` instead of

1661

    /// returning `Err`. `domxml_from_str`, which documents that it "deliberately

1662

    /// never fails", inherits the panic.

1663

///

1664

    /// The fix belongs in the source (`xml.is_char_boundary(9)` guard, or

1665

    /// `xml.get(..9)`), so this test asserts the correct invariant and is

1666

    /// expected to be RED until that lands.

1667

    #[cfg(feature = "xml")]

1668

    #[test]

1669

    fn parse_entrypoints_do_not_panic_on_short_multibyte_input() {

1670

        // 3 x 4-byte emoji = 12 bytes; boundaries are 0/4/8/12, so 9 is inside

1671

        // the third character.

1672

        const INPUT: &str = "😀😀😀";

1673

        assert!(INPUT.len() > 9 && !INPUT.is_char_boundary(9));

1674

1675

        let a = std::panic::catch_unwind(|| parse_xml_string(INPUT).is_ok());

1676

        let b = std::panic::catch_unwind(|| parse_xml_to_fast_dom(INPUT).is_ok());

1677

1678

        assert!(

1679

            a.is_ok(),

1680

            "parse_xml_string panicked on {INPUT:?}: the DOCTYPE sniff slices xml[..9] without an \

1681

             is_char_boundary check"

1682

);

1683

        assert!(

1684

            b.is_ok(),

1685

            "parse_xml_to_fast_dom panicked on {INPUT:?}: same unchecked xml[..9] slice"

1686

);

1687

1688

1689

    // ------------------------------------------------------------------

1690

    // parse_xml_string

1691

    // ------------------------------------------------------------------

1692

1693

    #[cfg(feature = "xml")]

1694

    #[test]

1695

    fn parse_xml_string_accepts_empty_and_whitespace_only_input() {

1696

        for s in [

1697

"",

1698

            " ",

1699

            "   ",

1700

            "\t\n",

1701

            "\r\n\r\n",

1702

            "\u{FEFF}",

1703

            "\u{FEFF}   ",

1704

] {

1705

            let parsed = parse_xml_string(s)

1706

                .unwrap_or_else(|e| panic!("{s:?} should parse to an empty tree, got {e}"));

1707

            assert!(parsed.is_empty(), "{s:?} produced {} roots", parsed.len());

1708

1709

1710

1711

    #[cfg(feature = "xml")]

1712

    #[test]

1713

    fn parse_xml_string_parses_a_minimal_document() {

1714

        let parsed = parse_xml_string(&doc("<div>hi</div>")).expect("valid document");

1715

        let roots = elements(&parsed);

1716

        assert_eq!(roots.len(), 1);

1717

        assert_eq!(roots[0].node_type.as_str(), "html");

1718

1719

        let body = elements(roots[0].children.as_ref());

1720

        assert_eq!(body.len(), 1);

1721

        assert_eq!(body[0].node_type.as_str(), "body");

1722

1723

        let div = elements(body[0].children.as_ref());

1724

        assert_eq!(div.len(), 1);

1725

        assert_eq!(div[0].node_type.as_str(), "div");

1726

        assert_eq!(texts(div[0].children.as_ref()), vec!["hi"]);

1727

1728

1729

    #[cfg(feature = "xml")]

1730

    #[test]

1731

    fn parse_xml_string_rejects_unclosed_elements() {

1732

        // A well-formed document unwinds to the root sentinel; anything left

1733

        // open must be an error rather than a silently-truncated tree.

1734

        assert!(matches!(

1735

            parse_xml_string("<div>"),

1736

            Err(XmlError::UnclosedRootNode)

1737

));

1738

        assert!(matches!(

1739

            parse_xml_string("<html><body><div>"),

1740

            Err(XmlError::UnclosedRootNode)

1741

));

1742

        assert!(

1743

            parse_xml_string("<html><body><div>text").is_err(),

1744

            "an unclosed element must not yield a partial 'valid' tree"

1745

);

1746

1747

1748

    #[cfg(feature = "xml")]

1749

    #[test]

1750

    fn parse_xml_string_rejects_truncated_declaration_and_doctype() {

1751

        assert!(matches!(

1752

            parse_xml_string("<?xml version=\"1.0\""),

1753

            Err(XmlError::MalformedHierarchy(_))

1754

));

1755

        assert!(matches!(

1756

            parse_xml_string("<!DOCTYPE html PUBLIC \"x\""),

1757

            Err(XmlError::MalformedHierarchy(_))

1758

));

1759

        // ...but the complete forms are stripped and the rest parses.

1760

        for prefix in [

1761

            "<?xml version=\"1.0\"?>",

1762

            "<!DOCTYPE html>",

1763

            "<!doctype HTML>",

1764

            "<!-- leading comment -->",

1765

            "\u{FEFF}",

1766

] {

1767

            let src = format!("{prefix}{}", doc("<div/>"));

1768

            let parsed = parse_xml_string(&src)

1769

                .unwrap_or_else(|e| panic!("{prefix:?} prefix should be stripped, got {e}"));

1770

            let roots = elements(&parsed);

1771

            assert_eq!(roots.len(), 1, "{prefix:?} -> {roots:?}");

1772

            assert_eq!(roots[0].node_type.as_str(), "html");

1773

1774

1775

1776

    #[cfg(feature = "xml")]

1777

    #[test]

1778

    fn parse_xml_string_is_deterministic_on_garbage() {

1779

        for g in GARBAGE {

1780

            // The contract is "Err or a tree", never a panic and never a

1781

            // different answer for the same bytes.

1782

            let a = parse_xml_string(g);

1783

            let b = parse_xml_string(g);

1784

            assert_eq!(a.is_ok(), b.is_ok(), "{g:?} parsed non-deterministically");

1785

            assert_eq!(a.ok(), b.ok(), "{g:?} produced two different trees");

1786

1787

1788

1789

    #[cfg(feature = "xml")]

1790

    #[test]

1791

    fn parse_xml_string_trims_leading_and_trailing_whitespace() {

1792

        let padded = format!("  \t\n{}\n\t  ", doc("<div/>"));

1793

        let a = parse_xml_string(&padded).expect("padded document");

1794

        let b = parse_xml_string(&doc("<div/>")).expect("bare document");

1795

        assert_eq!(a, b, "surrounding whitespace must not change the tree");

1796

1797

1798

    #[cfg(feature = "xml")]

1799

    #[test]

1800

    fn parse_xml_string_keeps_trailing_junk_as_text() {

1801

        // Lenient HTML-ish parsing: trailing junk becomes a text node at the

1802

        // root rather than an error or a dropped document.

1803

        let parsed =

1804

            parse_xml_string(&format!("{};garbage", doc("<div/>"))).expect("lenient parse");

1805

        assert_eq!(elements(&parsed).len(), 1);

1806

        assert_eq!(texts(&parsed), vec![";garbage"]);

1807

1808

1809

    #[cfg(feature = "xml")]

1810

    #[test]

1811

    fn parse_xml_string_round_trips_escaped_text() {

1812

        for raw in [

1813

            "a",

1814

            "<b>bold</b> & \"quotes\" 'apos'",

1815

            "&&&&",

1816

            "  spaced  ",

1817

            "日本語 🙂 combining e\u{301}",

1818

            "1 < 2 > 0 && true",

1819

] {

1820

            let src = doc(&escape(raw));

1821

            let parsed =

1822

                parse_xml_string(&src).unwrap_or_else(|e| panic!("{src:?} should parse, got {e}"));

1823

            let html = elements(&parsed);

1824

            let body = elements(html[0].children.as_ref());

1825

            assert_eq!(

1826

                texts(body[0].children.as_ref()),

1827

                vec![raw],

1828

                "escape -> parse must be the identity for {raw:?}"

1829

);

1830

1831

1832

1833

    #[cfg(feature = "xml")]

1834

    #[test]

1835

    fn parse_xml_string_decodes_attribute_entities() {

1836

        let parsed = parse_xml_string(&doc(

1837

            r#"<div t="&amp;&lt;&gt;&quot;&apos;x" u="&nosuch;" v="&#x1F600;"></div>"#,

1838

))

1839

        .expect("valid document");

1840

        let html = elements(&parsed);

1841

        let body = elements(html[0].children.as_ref());

1842

        let div = elements(body[0].children.as_ref());

1843

        let attrs = &div[0].attributes;

1844

1845

        assert_eq!(attrs.get_key("t").map(AzString::as_str), Some("&<>\"'x"));

1846

        assert_eq!(attrs.get_key("u").map(AzString::as_str), Some("&nosuch;"));

1847

        assert_eq!(attrs.get_key("v").map(AzString::as_str), Some("😀"));

1848

1849

1850

    #[cfg(feature = "xml")]

1851

    #[test]

1852

    fn parse_xml_string_tolerates_extra_and_mismatched_close_tags() {

1853

        let nested = doc("<div></span></div>");

1854

        let paragraphs = doc("<p>one<p>two");

1855

        for src in [

1856

            "<a></a></a>",

1857

            "<a></a></b>",

1858

            nested.as_str(),

1859

            paragraphs.as_str(),

1860

            "<br></br>",

1861

            "<br>",

1862

            "<br><br><br>",

1863

] {

1864

            let a = parse_xml_string(src);

1865

            let b = parse_xml_string(src);

1866

            assert_eq!(a.is_ok(), b.is_ok(), "{src:?} is non-deterministic");

1867

            assert_eq!(a.ok(), b.ok(), "{src:?} produced two different trees");

1868

1869

        // A bare void element is a complete document (auto-closed at EOF).

1870

        let parsed = parse_xml_string("<br>").expect("bare void element");

1871

        assert_eq!(elements(&parsed).len(), 1);

1872

        assert_eq!(elements(&parsed)[0].node_type.as_str(), "br");

1873

1874

1875

    #[cfg(feature = "xml")]

1876

    #[test]

1877

    fn parse_xml_string_handles_deep_nesting_without_stack_overflow() {

1878

        // Building is iterative, but dropping the resulting `XmlNode` tree is

1879

        // recursive, so this pins the depth the *whole* lifecycle survives.

1880

        // (The arena path is exercised at 10k in

1881

        // `parse_xml_to_fast_dom_handles_ten_thousand_nested_elements`.)

1882

        const DEPTH: usize = 1_000;

1883

        let mut src = String::with_capacity(DEPTH * 12);

1884

        for _ in 0..DEPTH {

1885

            src.push_str("<a>");

1886

1887

        for _ in 0..DEPTH {

1888

            src.push_str("</a>");

1889

1890

1891

        let parsed = parse_xml_string(&src).expect("balanced nesting is valid");

1892

        let mut depth = 0_usize;

1893

1894

            let mut cursor: Vec<&XmlNode> = elements(&parsed);

1895

            while !cursor.is_empty() {

1896

                depth += 1;

1897

                let node: &XmlNode = cursor[0];

1898

                cursor = elements(node.children.as_ref());

1899

1900

1901

        assert_eq!(depth, DEPTH, "every nesting level must be preserved");

1902

        // Dropping the tree is the recursive half of the lifecycle — a deeper

1903

        // tree would blow the stack here, not during the (iterative) parse.

1904

        drop(parsed);

1905

1906

1907

    #[cfg(feature = "xml")]

1908

    #[test]

1909

    fn parse_xml_string_handles_a_one_million_char_text_node() {

1910

        let payload = "x".repeat(1_000_000);

1911

        let parsed = parse_xml_string(&doc(&payload)).expect("long text is valid");

1912

        let html = elements(&parsed);

1913

        let body = elements(html[0].children.as_ref());

1914

        let t = texts(body[0].children.as_ref());

1915

        assert_eq!(t.len(), 1);

1916

        assert_eq!(t[0].len(), 1_000_000);

1917

1918

1919

    #[cfg(feature = "xml")]

1920

    #[test]

1921

    fn parse_xml_string_handles_many_sibling_elements() {

1922

        const N: usize = 2_000;

1923

        let parsed = parse_xml_string(&doc(&"<i>x</i>".repeat(N))).expect("wide tree is valid");

1924

        let html = elements(&parsed);

1925

        let body = elements(html[0].children.as_ref());

1926

        assert_eq!(elements(body[0].children.as_ref()).len(), N);

1927

1928

1929

    // ------------------------------------------------------------------

1930

    // parse_xml

1931

    // ------------------------------------------------------------------

1932

1933

    #[cfg(feature = "xml")]

1934

    #[test]

1935

    fn parse_xml_agrees_with_parse_xml_string() {

1936

        let one = doc("<div>hi</div>");

1937

        let two = doc("<i/><i/>");

1938

        for src in ["", "   ", one.as_str(), two.as_str()] {

1939

            let via_xml = parse_xml(src).expect("valid");

1940

            let via_string = parse_xml_string(src).expect("valid");

1941

            assert_eq!(

1942

                via_xml.root.as_ref(),

1943

                via_string.as_slice(),

1944

                "parse_xml must be a thin wrapper over parse_xml_string for {src:?}"

1945

);

1946

1947

        assert!(parse_xml("<div>").is_err());

1948

1949

1950

    #[cfg(not(feature = "xml"))]

1951

    #[test]

1952

    fn parse_xml_without_the_xml_feature_reports_no_parser() {

1953

        for s in ["", "   ", "<div/>", "garbage"] {

1954

            assert!(matches!(parse_xml(s), Err(XmlError::NoParserAvailable)));

1955

1956

1957

1958

    // ------------------------------------------------------------------

1959

    // parse_xml_to_fast_dom / parse_xml_to_fast_dom_with_css

1960

    // ------------------------------------------------------------------

1961

1962

    /// `<transient-window>` parses to its NodeType with the attributes applied

1963

    /// onto the inline config — and those attributes do NOT leak into the

1964

    /// generic attribute list, where they would be meaningless.

1965

    #[test]

1966

    fn transient_window_tag_parses_its_attributes_into_the_config() {

1967

        use azul_core::transient::{TransientAnchor, TransientDismiss};

1968

        let dom = parse_xml_to_fast_dom(

1969

            r#"<div><transient-window open="true" anchor="right" dismiss="escape" size="300x200" class="picker"><p>hi</p></transient-window></div>"#,

1970

1971

        .expect("parses");

1972

        let n = nodes(&dom);

1973

        let tw = n

1974

            .iter()

1975

            .find_map(|nd| match nd.get_node_type() {

1976

                NodeType::TransientWindow(c) => Some((*c, nd)),

1977

                _ => None,

1978

})

1979

            .expect("a TransientWindow node");

1980

        let (cfg, nd) = tw;

1981

        assert!(cfg.open, "open=\"true\" must open it");

1982

        assert_eq!(cfg.anchor, TransientAnchor::Right);

1983

        assert_eq!(cfg.dismiss, TransientDismiss::Escape);

1984

        assert!(

1985

            matches!(cfg.size, azul_core::geom::OptionLogicalSize::Some(s) if s.width == 300.0)

1986

);

1987

        // `class` is an ordinary attribute and must survive; the popup keys

1988

        // must NOT have been stored as attributes.

1989

        let classes: Vec<String> = nd

1990

            .get_ids_and_classes()

1991

            .iter()

1992

            .filter_map(|ic| match ic {

1993

                azul_core::dom::IdOrClass::Class(c) => Some(c.as_str().to_string()),

1994

                _ => None,

1995

})

1996

            .collect();

1997

        assert_eq!(classes, vec!["picker".to_string()]);

1998

1999

2000

    /// With no attributes at all the tag is a CLOSED popup — the default must

2001

    /// never open a window by accident.

2002

    #[test]

2003

    fn a_bare_transient_window_tag_is_closed() {

2004

        let dom = parse_xml_to_fast_dom("<div><transient-window/></div>").expect("parses");

2005

        let closed = nodes(&dom)

2006

            .iter()

2007

            .any(|nd| matches!(nd.get_node_type(), NodeType::TransientWindow(c) if !c.open));

2008

        assert!(closed, "a bare <transient-window/> must parse as closed");

2009

2010

2011

    #[test]

2012

    fn parse_xml_to_fast_dom_accepts_empty_and_whitespace_only_input() {

2013

        for s in ["", " ", "   ", "\t\n", "\u{FEFF}", "\u{FEFF}  \n "] {

2014

            let dom = parse_xml_to_fast_dom(s)

2015

                .unwrap_or_else(|e| panic!("{s:?} should yield an empty arena, got {e}"));

2016

            assert!(

2017

                nodes(&dom).is_empty(),

2018

                "{s:?} produced {} nodes",

2019

                nodes(&dom).len()

2020

);

2021

            assert_eq!(dom.node_hierarchy.as_ref().len(), nodes(&dom).len());

2022

2023

2024

2025

    #[test]

2026

    fn parse_xml_to_fast_dom_builds_the_expected_arena() {

2027

        let dom = parse_xml_to_fast_dom(&doc("<div>hi</div>")).expect("valid document");

2028

        let n = nodes(&dom);

2029

        assert_eq!(n.len(), 4, "html + body + div + text");

2030

        assert_eq!(

2031

            dom.node_hierarchy.as_ref().len(),

2032

            n.len(),

2033

            "hierarchy and node_data arenas must stay parallel"

2034

);

2035

        assert!(matches!(n[0].get_node_type(), NodeType::Html));

2036

        assert!(matches!(n[1].get_node_type(), NodeType::Body));

2037

        assert!(matches!(n[2].get_node_type(), NodeType::Div));

2038

        assert_eq!(text_of(&n[3]).as_deref(), Some("hi"));

2039

2040

2041

    #[test]

2042

    fn parse_xml_to_fast_dom_lowercases_tag_names() {

2043

        let dom = parse_xml_to_fast_dom("<HTML><BODY><DiV/></BODY></HTML>").expect("valid");

2044

        let n = nodes(&dom);

2045

        assert_eq!(n.len(), 3);

2046

        assert!(matches!(n[0].get_node_type(), NodeType::Html));

2047

        assert!(matches!(n[1].get_node_type(), NodeType::Body));

2048

        assert!(matches!(n[2].get_node_type(), NodeType::Div));

2049

2050

2051

    #[test]

2052

    fn parse_xml_to_fast_dom_skips_head_but_collects_style_css() {

2053

        let src = "<html><head><title>T</title><style>div { width: 10px; \

2054

                   }</style></head><body>x</body></html>";

2055

        let (dom, css) = parse_xml_to_fast_dom_with_css(src).expect("valid document");

2056

        let n = nodes(&dom);

2057

2058

        assert_eq!(n.len(), 3, "html + body + text; <head> subtree is dropped");

2059

        assert!(

2060

            !n.iter()

2061

                .any(|nd| matches!(nd.get_node_type(), NodeType::Head | NodeType::Title)),

2062

            "no <head>/<title> node may reach the arena"

2063

);

2064

        assert_eq!(text_of(&n[2]).as_deref(), Some("x"));

2065

        assert_eq!(css.len(), 1, "the <style> body must still be collected");

2066

        assert!(

2067

            !css[0].rules.as_ref().is_empty(),

2068

            "the CSS must have parsed"

2069

);

2070

2071

2072

    #[test]

2073

    fn parse_xml_to_fast_dom_splits_ids_and_classes_on_whitespace() {

2074

        let dom = parse_xml_to_fast_dom(&doc(r#"<div id="a b" class="c  d

2075

        e"></div>"#))

2076

        .expect("valid document");

2077

        let div = &nodes(&dom)[2];

2078

2079

        assert!(div.has_id("a") && div.has_id("b"));

2080

        assert!(div.has_class("c") && div.has_class("d") && div.has_class("e"));

2081

        assert!(!div.has_id("a b"), "the raw joined value must not survive");

2082

        assert_eq!(div.get_ids_and_classes().as_ref().len(), 5);

2083

2084

2085

    /// Reads the tab index of the `<div>` in `doc("<div {attrs}></div>")`.

2086

    fn tab_index_with(attrs: &str) -> Option<TabIndex> {

2087

        let dom = parse_xml_to_fast_dom(&doc(&format!("<div {attrs}></div>")))

2088

            .unwrap_or_else(|e| panic!("{attrs:?} should parse, got {e}"));

2089

        nodes(&dom)[2].get_tab_index()

2090

2091

2092

    #[test]

2093

    fn parse_xml_to_fast_dom_maps_tabindex_boundaries() {

2094

        assert_eq!(tab_index_with(r#"tabindex="0""#), Some(TabIndex::Auto));

2095

        assert_eq!(tab_index_with(r#"tabindex="-0""#), Some(TabIndex::Auto));

2096

        assert_eq!(

2097

            tab_index_with(r#"tabindex="1""#),

2098

            Some(TabIndex::OverrideInParent(1))

2099

);

2100

        assert_eq!(

2101

            tab_index_with(r#"tabindex="+3""#),

2102

            Some(TabIndex::OverrideInParent(3)),

2103

            "isize::from_str accepts a leading '+'"

2104

);

2105

        assert_eq!(

2106

            tab_index_with(r#"tabindex="-1""#),

2107

            Some(TabIndex::NoKeyboardFocus)

2108

);

2109

        assert_eq!(

2110

            tab_index_with(r#"tabindex="-9223372036854775808""#),

2111

            Some(TabIndex::NoKeyboardFocus),

2112

            "i64::MIN is still just 'negative'"

2113

);

2114

2115

        // NodeFlags packs the override value into bits [27:0].

2116

        const MAX_EXACT: u32 = (1 << 28) - 1;

2117

        assert_eq!(

2118

            tab_index_with(&format!(r#"tabindex="{MAX_EXACT}""#)),

2119

            Some(TabIndex::OverrideInParent(MAX_EXACT))

2120

);

2121

        // Past that it truncates rather than saturating or panicking. Two

2122

        // lossy steps stack up here: `isize as u32` in the XML parser, then

2123

        // the 28-bit mask in `NodeFlags::set_tab_index`. Pinned as-is because

2124

        // the safety property is "bounded and deterministic", not "exact".

2125

        assert_eq!(

2126

            tab_index_with(r#"tabindex="268435456""#),

2127

            Some(TabIndex::OverrideInParent(0)),

2128

            "1 << 28 truncates to 0"

2129

);

2130

        assert_eq!(

2131

            tab_index_with(r#"tabindex="9223372036854775807""#),

2132

            Some(TabIndex::OverrideInParent(MAX_EXACT)),

2133

            "i64::MAX -> u32::MAX -> 28-bit mask"

2134

);

2135

2136

2137

    #[test]

2138

    fn parse_xml_to_fast_dom_ignores_unparseable_tabindex() {

2139

        let baseline = tab_index_with("");

2140

        for junk in [

2141

            r#"tabindex="""#,

2142

            r#"tabindex="NaN""#,

2143

            r#"tabindex="inf""#,

2144

            r#"tabindex="-inf""#,

2145

            r#"tabindex="1.0""#,

2146

            r#"tabindex="1e5""#,

2147

            r#"tabindex=" 3 ""#,

2148

            r#"tabindex="0x10""#,

2149

            r#"tabindex="99999999999999999999999999""#,

2150

            r#"tabindex="-99999999999999999999999999""#,

2151

            r#"tabindex="🙂""#,

2152

] {

2153

            assert_eq!(

2154

                tab_index_with(junk),

2155

                baseline,

2156

                "{junk} must leave the tab index untouched"

2157

);

2158

2159

2160

2161

    #[test]

2162

    fn parse_xml_to_fast_dom_parses_bool_attributes_case_sensitively() {

2163

        assert_eq!(tab_index_with(r#"focusable="true""#), Some(TabIndex::Auto));

2164

        assert_eq!(

2165

            tab_index_with(r#"focusable="false""#),

2166

            Some(TabIndex::NoKeyboardFocus)

2167

);

2168

        for junk in [

2169

            r#"focusable="TRUE""#,

2170

            r#"focusable="1""#,

2171

            r#"focusable="yes""#,

2172

] {

2173

            assert_eq!(

2174

                tab_index_with(junk),

2175

                tab_index_with(""),

2176

                "{junk} is not a bool literal and must be ignored"

2177

);

2178

2179

2180

        let editable = |v: &str| {

2181

            let dom = parse_xml_to_fast_dom(&doc(&format!(r#"<div contenteditable="{v}"></div>"#)))

2182

                .expect("valid");

2183

            nodes(&dom)[2].is_contenteditable()

2184

};

2185

        assert!(editable("true"));

2186

        assert!(!editable("false"));

2187

        assert!(!editable("TRUE"));

2188

        assert!(!editable(""));

2189

        assert!(!editable("1"));

2190

2191

        // `contenteditable="false"` is kept as the attribute the editable

2192

        // inheritance walk and the edit-buffer collector wall a subtree off

2193

        // by; anything that is not the literal `false` is not.

2194

        let walled = |v: &str| {

2195

            let dom = parse_xml_to_fast_dom(&doc(&format!(r#"<div contenteditable="{v}"></div>"#)))

2196

                .expect("valid");

2197

            nodes(&dom)[2]

2198

                .attributes()

2199

                .as_ref()

2200

                .iter()

2201

                .any(|a| matches!(a, azul_core::dom::AttributeType::ContentEditable(false)))

2202

};

2203

        assert!(walled("false"));

2204

        assert!(!walled("true"));

2205

        assert!(!walled("FALSE"));

2206

        assert!(!walled(""));

2207

2208

2209

    #[test]

2210

    fn parse_xml_to_fast_dom_survives_malformed_style_attributes() {

2211

        let big = "a:b;".repeat(2_000);

2212

        for style in [

2213

"",

2214

            ";;;;",

2215

            "::::",

2216

            ":",

2217

            "width",

2218

            "width:",

2219

            ":10px",

2220

            "a:b:c",

2221

            ";:;:;:",

2222

            "width:10px",

2223

            "width:10px;;;height:;;",

2224

            "width:not-a-length",

2225

            "🙂:🙂",

2226

            big.as_str(),

2227

] {

2228

            let dom = parse_xml_to_fast_dom(&doc(&format!(r#"<div style="{style}"></div>"#)))

2229

                .unwrap_or_else(|e| panic!("style={style:?} should parse, got {e}"));

2230

            assert_eq!(

2231

                nodes(&dom).len(),

2232

3,

2233

                "style={style:?} must not change the node count"

2234

);

2235

2236

2237

2238

    #[test]

2239

    fn parse_xml_to_fast_dom_survives_unbalanced_tags() {

2240

        // The interesting case: elements opened inside <head> are pushed onto

2241

        // the tag stack but never opened in the builder, so the EOF unwind

2242

        // calls close_node() more often than open_node() ran. That must be a

2243

        // no-op, not an underflow.

2244

        let dom = parse_xml_to_fast_dom("<html><head><title>").expect("lenient parse");

2245

        assert_eq!(nodes(&dom).len(), 1, "only <html> survives");

2246

        assert!(matches!(nodes(&dom)[0].get_node_type(), NodeType::Html));

2247

2248

        for src in [

2249

            "</div>",

2250

            "</div></div></div>",

2251

            "<a></a></a>",

2252

            "<html><body></body></body></html>",

2253

            "<html><head><head><head>",

2254

            "<html><body><div></span></div></body></html>",

2255

] {

2256

            let a = parse_xml_to_fast_dom(src);

2257

            let b = parse_xml_to_fast_dom(src);

2258

            assert_eq!(a.is_ok(), b.is_ok(), "{src:?} is non-deterministic");

2259

            if let (Ok(a), Ok(b)) = (&a, &b) {

2260

                assert_eq!(nodes(a).len(), nodes(b).len(), "{src:?} node count drifted");

2261

2262

2263

2264

2265

    #[test]

2266

    fn parse_xml_to_fast_dom_is_deterministic_on_garbage() {

2267

        for g in GARBAGE {

2268

            let a = parse_xml_to_fast_dom(g);

2269

            let b = parse_xml_to_fast_dom(g);

2270

            assert_eq!(a.is_ok(), b.is_ok(), "{g:?} parsed non-deterministically");

2271

            if let (Ok(a), Ok(b)) = (&a, &b) {

2272

                assert_eq!(nodes(a).len(), nodes(b).len(), "{g:?} node count drifted");

2273

2274

2275

2276

2277

    #[test]

2278

    fn parse_xml_to_fast_dom_handles_ten_thousand_nested_elements() {

2279

        // The arena path is iterative on the way in and flat on the way out,

2280

        // so it should hold a depth the recursive XmlNode tree cannot.

2281

        const DEPTH: usize = 10_000;

2282

        let mut src = String::with_capacity(DEPTH * 12 + 32);

2283

        src.push_str("<html><body>");

2284

        for _ in 0..DEPTH {

2285

            src.push_str("<div>");

2286

2287

        for _ in 0..DEPTH {

2288

            src.push_str("</div>");

2289

2290

        src.push_str("</body></html>");

2291

2292

        let dom = parse_xml_to_fast_dom(&src).expect("balanced nesting is valid");

2293

        assert_eq!(nodes(&dom).len(), DEPTH + 2);

2294

2295

2296

    #[test]

2297

    fn parse_xml_to_fast_dom_handles_a_one_million_char_document() {

2298

        let payload = "x".repeat(1_000_000);

2299

        let dom = parse_xml_to_fast_dom(&doc(&payload)).expect("long text is valid");

2300

        let n = nodes(&dom);

2301

        assert_eq!(n.len(), 3, "html + body + one text node");

2302

        assert_eq!(text_of(&n[2]).map(|s| s.len()), Some(1_000_000));

2303

2304

2305

    #[test]

2306

    fn parse_xml_to_fast_dom_strips_bom_declaration_doctype_and_comments() {

2307

        let expected = nodes(&parse_xml_to_fast_dom(&doc("<div/>")).expect("baseline")).len();

2308

        for prefix in [

2309

            "\u{FEFF}",

2310

            "<?xml version=\"1.0\" encoding=\"utf-8\"?>",

2311

            "<!DOCTYPE html>",

2312

            "<!doctype HTML>",

2313

            "<!DoCtYpE html SYSTEM \"about:legacy-compat\">",

2314

            "<!-- leading comment -->",

2315

] {

2316

            let src = format!("{prefix}{}", doc("<div/>"));

2317

            let dom = parse_xml_to_fast_dom(&src)

2318

                .unwrap_or_else(|e| panic!("{prefix:?} should be stripped, got {e}"));

2319

            assert_eq!(nodes(&dom).len(), expected, "{prefix:?} changed the arena");

2320

2321

2322

2323

    #[test]

2324

    fn parse_xml_to_fast_dom_preserves_unicode_text() {

2325

        for payload in [

2326

            "日本語",

2327

            "🙂🙂🙂🙂",

2328

            "e\u{301}\u{302}\u{303}",

2329

            "\u{200B}\u{FEFF}mid-string BOM",

2330

            "ﷺ",

2331

] {

2332

            let dom = parse_xml_to_fast_dom(&doc(payload))

2333

                .unwrap_or_else(|e| panic!("{payload:?} should parse, got {e}"));

2334

            let n = nodes(&dom);

2335

            assert_eq!(n.len(), 3, "{payload:?}");

2336

            assert_eq!(text_of(&n[2]).as_deref(), Some(payload));

2337

2338

2339

2340

    #[test]

2341

    fn parse_xml_to_fast_dom_treats_numeric_looking_documents_as_text() {

2342

        // Boundary numeric strings are markup content here, not numbers: they

2343

        // must survive verbatim rather than being coerced or rejected.

2344

        for payload in [

2345

            "0",

2346

            "-0",

2347

            "9223372036854775807",

2348

            "-9223372036854775808",

2349

            "18446744073709551616",

2350

            "1e309",

2351

            "-1e-309",

2352

            "NaN",

2353

            "inf",

2354

            "-inf",

2355

] {

2356

            let dom = parse_xml_to_fast_dom(&doc(payload))

2357

                .unwrap_or_else(|e| panic!("{payload:?} should parse, got {e}"));

2358

            assert_eq!(text_of(&nodes(&dom)[2]).as_deref(), Some(payload));

2359

2360

2361

2362

    // ------------------------------------------------------------------

2363

    // parse_xml_to_styled_dom

2364

    // ------------------------------------------------------------------

2365

2366

    #[test]

2367

    fn icon_tag_yields_unnamed_icon_nodes_with_spec_text_children() {

2368

        use azul_core::dom::NodeType;

2369

2370

        // The tokenizer stays fully generic: `<icon>spec</icon>` is an

2371

        // un-named Icon node with its spec preserved as a text child.

2372

        // The RESOLVER consumes the spec (see the resolution test below).

2373

        let fast =

2374

            parse_xml_to_fast_dom("<html><body><icon> content_copy </icon><p>x</p></body></html>")

2375

                .expect("icon markup must parse");

2376

2377

        let icon_names: Vec<&str> = nodes(&fast)

2378

            .iter()

2379

            .filter_map(|nd| match nd.get_node_type() {

2380

                NodeType::Icon(name) => Some(name.as_ref().as_str()),

2381

                _ => None,

2382

})

2383

            .collect();

2384

        assert_eq!(

2385

            icon_names,

2386

            vec![""],

2387

            "the builder must not interpret the spec"

2388

);

2389

2390

        let spec_preserved = nodes(&fast).iter().any(|nd| {

2391

            matches!(nd.get_node_type(), NodeType::Text(t) if t.as_ref().as_str().trim() == "content_copy")

2392

});

2393

        assert!(

2394

            spec_preserved,

2395

            "the spec text child must be preserved for the resolver"

2396

);

2397

2398

2399

    #[test]

2400

    fn icon_resolution_consumes_the_spec_text_like_a_ligature_font() {

2401

        use azul_core::{

2402

            dom::NodeType,

2403

            icon::{IconProviderHandle, SharedIconProvider},

2404

            refany::{OptionRefAny, RefAny},

2405

            styled_dom::StyledDom,

2406

};

2407

        use azul_css::system::SystemStyle;

2408

2409

        // Marker resolver: registered icons become a Text("RESOLVED") node,

2410

        // unregistered ones become Text("MISSING") — enough to observe both

2411

        // the spec-derived LOOKUP and the replacement without a real font.

2412

        extern "C" fn marker_resolver(

2413

            data: OptionRefAny,

2414

            original: &azul_core::dom::NodeData,

2415

            _: &SystemStyle,

2416

        ) -> Dom {

2417

            let marker = if data.is_some() {

2418

                "RESOLVED"

2419

            } else {

2420

                "MISSING"

2421

};

2422

            let mut replacement = Dom::create_div();

2423

            replacement.root = original.clone();

2424

            replacement

2425

                .root

2426

                .set_node_type(NodeType::Text(azul_css::css::BoxOrStatic::heap(

2427

                    marker.into(),

2428

                )));

2429

            replacement

2430

2431

2432

        let mut provider = IconProviderHandle::with_resolver(marker_resolver);

2433

        provider.register_icon("testpack", "content_copy", RefAny::new(1u8));

2434

        let provider = SharedIconProvider::from_handle(provider);

2435

2436

        // Both the bare-name spec and the pack-qualified fallback-list spec

2437

        // (`missing:x` first — must fall through to `testpack:content_copy`).

2438

        let styled = parse_xml_to_styled_dom_resolving_icons(

2439

            "<html><body><icon> content_copy </icon><icon>missing:x, \

2440

             testpack:CONTENT_COPY</icon><icon>unknown_icon</icon></body></html>",

2441

            &provider,

2442

            &SystemStyle::default(),

2443

2444

        .expect("icon markup must cascade");

2445

2446

        let texts: Vec<String> = styled

2447

            .node_data

2448

            .as_ref()

2449

            .iter()

2450

            .filter_map(|nd| match nd.get_node_type() {

2451

                NodeType::Text(t) => Some(t.as_ref().as_str().to_string()),

2452

                _ => None,

2453

})

2454

            .collect();

2455

2456

        let resolved = texts.iter().filter(|t| t.as_str() == "RESOLVED").count();

2457

        let missing = texts.iter().filter(|t| t.as_str() == "MISSING").count();

2458

        assert_eq!(

2459

            resolved, 2,

2460

            "bare + pack-qualified specs must both resolve: {texts:?}"

2461

);

2462

        assert_eq!(

2463

            missing, 1,

2464

            "the unknown spec resolves to no data: {texts:?}"

2465

);

2466

2467

        // The spec text was consumed — it must not survive as renderable text.

2468

        assert!(

2469

            !texts

2470

                .iter()

2471

                .any(|t| t.contains("content_copy") || t.contains("unknown_icon")),

2472

            "spec text children must be cleared after resolution: {texts:?}"

2473

);

2474

2475

2476

    #[test]

2477

    fn parse_xml_to_styled_dom_accepts_empty_and_whitespace_only_input() {

2478

        for s in ["", "   ", "\t\n", "\u{FEFF}"] {

2479

            let styled = parse_xml_to_styled_dom(s)

2480

                .unwrap_or_else(|e| panic!("{s:?} should cascade cleanly, got {e}"));

2481

            assert!(styled.node_data.as_ref().is_empty(), "{s:?}");

2482

2483

2484

2485

    #[test]

2486

    fn parse_xml_to_styled_dom_keeps_the_fast_dom_node_count() {

2487

        for src in [

2488

            doc("<div>hi</div>"),

2489

            doc("<div><span>a</span><span>b</span></div>"),

2490

            "<html><head><style>div { width: 10px; }</style></head><body><div/></body></html>"

2491

                .to_string(),

2492

] {

2493

            let fast = parse_xml_to_fast_dom(&src).expect("fast path");

2494

            let styled = parse_xml_to_styled_dom(&src).expect("styled path");

2495

            assert_eq!(

2496

                styled.node_data.as_ref().len(),

2497

                nodes(&fast).len(),

2498

                "the cascade must not add or drop nodes for {src:?}"

2499

);

2500

            assert_eq!(

2501

                styled.node_hierarchy.as_ref().len(),

2502

                styled.node_data.as_ref().len()

2503

);

2504

2505

2506

2507

    #[test]

2508

    fn parse_xml_to_styled_dom_is_deterministic_on_garbage() {

2509

        for g in GARBAGE {

2510

            let a = parse_xml_to_styled_dom(g);

2511

            let b = parse_xml_to_styled_dom(g);

2512

            assert_eq!(a.is_ok(), b.is_ok(), "{g:?} cascaded non-deterministically");

2513

2514

2515

2516

    // ------------------------------------------------------------------

2517

    // dom_from_parsed_xml

2518

    // ------------------------------------------------------------------

2519

2520

    #[test]

2521

    fn a_fragment_becomes_a_document_and_a_broken_one_still_reports() {

2522

        // BROWSER-LIKE: a fragment gets a synthesised `<html><body>` root,

2523

        // so it renders as ITSELF rather than as the text "No <html> node

2524

        // found as the root of the file" - which used to lay out and paint

2525

        // like any other text, so a caller measuring pixels saw an error

2526

        // message it never asked for.

2527

        for root in [

2528

            Vec::new(),

2529

            vec![XmlNodeChild::Text("bare text".into())],

2530

            vec![XmlNodeChild::Element(XmlNode::create("div"))],

2531

            vec![XmlNodeChild::Element(XmlNode::create("svg"))],

2532

] {

2533

            let dom = dom_from_parsed_xml(Xml { root: root.into() });

2534

            assert!(

2535

                matches!(dom.root.get_node_type(), NodeType::Html),

2536

                "a real document is rooted at <html>, got {:?} - a <body> root here would mean \

2537

                 the ERROR Dom came back instead",

2538

                dom.root.get_node_type()

2539

);

2540

2541

2542

        // An EXPLICIT `<html>` with no `<body>` is still an error Dom: the

2543

        // author stated the structure, so a missing body is their mistake and

2544

        // reporting it is more useful than guessing.

2545

        let broken = dom_from_parsed_xml(Xml {

2546

            root: vec![XmlNodeChild::Element(XmlNode::create("html"))].into(),

2547

});

2548

        assert!(matches!(broken.root.get_node_type(), NodeType::Body));

2549

        assert_eq!(broken.children.as_ref().len(), 1, "one label child");

2550

2551

2552

    #[test]

2553

    fn dom_from_parsed_xml_builds_a_dom_for_a_minimal_document() {

2554

        let body = XmlNode::create("body")

2555

            .with_children(vec![XmlNodeChild::Element(XmlNode::create("div"))]);

2556

        let html = XmlNode::create("html").with_children(vec![XmlNodeChild::Element(body)]);

2557

        let dom = dom_from_parsed_xml(Xml {

2558

            root: vec![XmlNodeChild::Element(html)].into(),

2559

});

2560

2561

        assert!(matches!(dom.root.get_node_type(), NodeType::Html));

2562

        assert_eq!(dom.children.as_ref().len(), 1, "the <body> subtree");

2563

2564

2565

    /// Runs on a thread with an 8 MiB stack ON PURPOSE - see the twin

2566

    /// `xml_node_to_dom_fast_deep_nesting_ok` in azul-core. libtest hands each

2567

    /// test the platform default (2 MiB on Linux), which is smaller than any

2568

    /// context this code really runs in; a debug-profile frame of the builder

2569

    /// is big enough that the 512 the cap allows clear 2 MiB, so the

2570

    /// dev-profile CI job aborted here with "has overflowed its stack" while

2571

    /// the product itself was fine on its 8 MiB main thread.

2572

    #[test]

2573

    fn dom_from_parsed_xml_caps_recursion_on_deeply_nested_input() {

2574

        std::thread::Builder::new()

2575

            .stack_size(8 * 1024 * 1024)

2576

            .spawn(|| {

2577

                // MAX_XML_NESTING_DEPTH is 512; past it the builder drops children

2578

                // instead of blowing the native stack.

2579

                const DEPTH: usize = 550;

2580

                let mut node = XmlNode::create("div");

2581

                for _ in 0..DEPTH {

2582

                    node = XmlNode::create("div").with_children(vec![XmlNodeChild::Element(node)]);

2583

2584

                let body = XmlNode::create("body").with_children(vec![XmlNodeChild::Element(node)]);

2585

                let html = XmlNode::create("html").with_children(vec![XmlNodeChild::Element(body)]);

2586

2587

                let dom = dom_from_parsed_xml(Xml {

2588

                    root: vec![XmlNodeChild::Element(html)].into(),

2589

});

2590

                assert!(matches!(dom.root.get_node_type(), NodeType::Html));

2591

})

2592

            .expect("spawn deep-nesting probe")

2593

            .join()

2594

            .expect("deep DOM build must not overflow the stack");

2595

2596

2597

    // ------------------------------------------------------------------

2598

    // domxml_from_str / domxml_from_file / DomXmlExt

2599

    // ------------------------------------------------------------------

2600

2601

    #[cfg(feature = "xml")]

2602

    #[test]

2603

    fn domxml_from_str_never_fails() {

2604

        let map = ComponentMap::with_builtin();

2605

        let mut cases: Vec<String> = GARBAGE.iter().map(|s| (*s).to_string()).collect();

2606

        cases.push(String::new());

2607

        cases.push("   ".to_string());

2608

        cases.push("<svg".to_string());

2609

        cases.push("<?xml".to_string());

2610

        cases.push(doc("<div>hi</div>"));

2611

2612

        for src in cases {

2613

            let dom_xml = domxml_from_str(&src, &map);

2614

            assert!(

2615

                !dom_xml.parsed_dom.node_data.as_ref().is_empty(),

2616

                "{src:?} produced an empty StyledDom; errors must render as a label"

2617

);

2618

2619

2620

2621

    #[cfg(all(feature = "std", feature = "xml"))]

2622

    #[test]

2623

    fn domxml_from_file_renders_io_errors_as_a_dom() {

2624

        let map = ComponentMap::with_builtin();

2625

        for path in [

2626

            "/nonexistent-azul-autotest-dir/definitely-not-here.xml",

2627

"",

2628

            "/",

2629

            "/proc/self/nonexistent-🙂",

2630

] {

2631

            let dom_xml = domxml_from_file(path, &map);

2632

            assert!(

2633

                !dom_xml.parsed_dom.node_data.as_ref().is_empty(),

2634

                "{path:?} must render the io::Error as a label, not fail"

2635

);

2636

2637

2638

2639

    #[cfg(feature = "xml")]

2640

    #[test]

2641

    fn dom_xml_ext_matches_domxml_from_str() {

2642

        let map = ComponentMap::with_builtin();

2643

        let valid = doc("<div>hi</div>");

2644

        for src in ["", "<svg", valid.as_str()] {

2645

            let via_ext = <Dom as DomXmlExt>::from_xml_string(src);

2646

            let via_fn = domxml_from_str(src, &map).parsed_dom;

2647

            assert_eq!(

2648

                via_ext.node_data.as_ref().len(),

2649

                via_fn.node_data.as_ref().len(),

2650

                "the extension trait must be a pure delegation for {src:?}"

2651

);

2652

2653

2654

2655

    // ------------------------------------------------------------------

2656

    // peak_rss_bytes

2657

    // ------------------------------------------------------------------

2658

2659

    #[test]

2660

    fn peak_rss_bytes_never_panics_and_never_goes_backwards() {

2661

        let a = peak_rss_bytes();

2662

        let _ballast = "x".repeat(4 * 1024 * 1024);

2663

        let b = peak_rss_bytes();

2664

2665

        #[cfg(all(unix, feature = "probe"))]

2666

        assert!(

2667

            b >= a,

2668

            "ru_maxrss is a high-water mark and must never decrease ({a} -> {b})"

2669

);

2670

        #[cfg(not(all(unix, feature = "probe")))]

2671

        assert_eq!(

2672

            (a, b),

2673

            (0, 0),

2674

            "without the probe feature the stub must be a constant 0"

2675

);

2676

2677

2678

    // ------------------------------------------------------------------

2679

    // translate_* (xmlparser / roxmltree -> FFI-stable azul types)

2680

    // ------------------------------------------------------------------

2681

2682

    #[cfg(feature = "xml")]

2683

    #[test]

2684

    fn translate_textpos_round_trips_boundary_values() {

2685

        for (row, col) in [

2686

            (0, 0),

2687

            (1, 1),

2688

            (0, u32::MAX),

2689

            (u32::MAX, 0),

2690

            (u32::MAX, u32::MAX),

2691

] {

2692

            let expected = XmlTextPos { row, col };

2693

            assert_eq!(

2694

                translate_xmlparser_textpos(xmlparser::TextPos::new(row, col)),

2695

                expected

2696

);

2697

            assert_eq!(

2698

                translate_roxml_textpos(roxmltree::TextPos::new(row, col)),

2699

                expected

2700

);

2701

2702

2703

2704

    #[cfg(feature = "xml")]

2705

    #[test]

2706

    fn translate_roxmltree_expandedname_preserves_name_and_namespace() {

2707

        let plain: roxmltree::ExpandedName<'_, '_> = "rect".into();

2708

        let out = translate_roxmltree_expandedname(plain);

2709

        assert_eq!(out.local_name.as_str(), "rect");

2710

        assert!(out.namespace.as_ref().is_none());

2711

2712

        let ns: roxmltree::ExpandedName<'_, '_> = ("http://www.w3.org/2000/svg", "rect").into();

2713

        let out = translate_roxmltree_expandedname(ns);

2714

        assert_eq!(out.local_name.as_str(), "rect");

2715

        assert_eq!(

2716

            out.namespace.as_ref().map(AzString::as_str),

2717

            Some("http://www.w3.org/2000/svg")

2718

);

2719

2720

        // Degenerate names must survive untouched, not be normalised away.

2721

        for name in ["", " ", "日本語-🙂", "a:b"] {

2722

            let e: roxmltree::ExpandedName<'_, '_> = name.into();

2723

            assert_eq!(

2724

                translate_roxmltree_expandedname(e).local_name.as_str(),

2725

                name

2726

);

2727

2728

        let empty_ns: roxmltree::ExpandedName<'_, '_> = ("", "x").into();

2729

        assert_eq!(

2730

            translate_roxmltree_expandedname(empty_ns)

2731

                .namespace

2732

                .as_ref()

2733

                .map(AzString::as_str),

2734

            Some(""),

2735

            "an empty namespace URI is Some(\"\"), not None"

2736

);

2737

2738

2739

    #[cfg(feature = "xml")]

2740

    #[test]

2741

    fn translate_roxmltree_attribute_preserves_name_and_namespace() {

2742

        let rdoc =

2743

            roxmltree::Document::parse(r#"<e xmlns:x="urn:x" x:a="1" b="2"/>"#).expect("valid XML");

2744

        let attrs: Vec<XmlQualifiedName> = rdoc

2745

            .root_element()

2746

            .attributes()

2747

            .map(translate_roxmltree_attribute)

2748

            .collect();

2749

2750

        assert_eq!(attrs.len(), 2, "xmlns declarations are not attributes");

2751

        let a = attrs

2752

            .iter()

2753

            .find(|q| q.local_name.as_str() == "a")

2754

            .expect("x:a");

2755

        assert_eq!(a.namespace.as_ref().map(AzString::as_str), Some("urn:x"));

2756

        let b = attrs

2757

            .iter()

2758

            .find(|q| q.local_name.as_str() == "b")

2759

            .expect("b");

2760

        assert!(

2761

            b.namespace.as_ref().is_none(),

2762

            "an unprefixed attribute has no namespace"

2763

);

2764

2765

2766

    #[cfg(feature = "xml")]

2767

    #[test]

2768

    fn translate_xmlparser_streamerror_maps_every_variant() {

2769

        use xmlparser::StreamError as Se;

2770

2771

        let p = xmlparser::TextPos::new(3, 7);

2772

        let x = XmlTextPos { row: 3, col: 7 };

2773

2774

        assert_eq!(

2775

            translate_xmlparser_streamerror(Se::UnexpectedEndOfStream),

2776

            XmlStreamError::UnexpectedEndOfStream

2777

);

2778

        assert_eq!(

2779

            translate_xmlparser_streamerror(Se::InvalidName),

2780

            XmlStreamError::InvalidName

2781

);

2782

        assert_eq!(

2783

            translate_xmlparser_streamerror(Se::InvalidReference),

2784

            XmlStreamError::InvalidReference

2785

);

2786

        assert_eq!(

2787

            translate_xmlparser_streamerror(Se::InvalidExternalID),

2788

            XmlStreamError::InvalidExternalID

2789

);

2790

        assert_eq!(

2791

            translate_xmlparser_streamerror(Se::InvalidCommentData),

2792

            XmlStreamError::InvalidCommentData

2793

);

2794

        assert_eq!(

2795

            translate_xmlparser_streamerror(Se::InvalidCommentEnd),

2796

            XmlStreamError::InvalidCommentEnd

2797

);

2798

        assert_eq!(

2799

            translate_xmlparser_streamerror(Se::InvalidCharacterData),

2800

            XmlStreamError::InvalidCharacterData

2801

);

2802

        // Astral char -> u32 (the FFI-stable representation) without loss.

2803

        assert_eq!(

2804

            translate_xmlparser_streamerror(Se::NonXmlChar('\u{1F600}', p)),

2805

            XmlStreamError::NonXmlChar(NonXmlCharError {

2806

                ch: 0x1F600,

2807

                pos: x

2808

})

2809

);

2810

        assert_eq!(

2811

            translate_xmlparser_streamerror(Se::InvalidQuote(b'`', p)),

2812

            XmlStreamError::InvalidQuote(InvalidQuoteError { got: b'`', pos: x })

2813

);

2814

        assert_eq!(

2815

            translate_xmlparser_streamerror(Se::InvalidSpace(b'\t', p)),

2816

            XmlStreamError::InvalidSpace(InvalidSpaceError { got: b'\t', pos: x })

2817

);

2818

        assert_eq!(

2819

            translate_xmlparser_streamerror(Se::InvalidString("?>", p)),

2820

            XmlStreamError::InvalidString(InvalidStringError {

2821

                got: "?>".into(),

2822

                pos: x

2823

})

2824

);

2825

        // NOTE: xmlparser documents InvalidChar/InvalidCharMultiple as

2826

        // (actual, expected, pos), but the translation stores the first field

2827

        // as `expected` and the second as `got` — i.e. the two are swapped.

2828

        // Characterised here rather than "fixed" in the test: it only affects

2829

        // error-message wording, and pinning it makes the swap visible if the

2830

        // mapping is ever corrected.

2831

        assert_eq!(

2832

            translate_xmlparser_streamerror(Se::InvalidChar(b'a', b'b', p)),

2833

            XmlStreamError::InvalidChar(InvalidCharError {

2834

                expected: b'a',

2835

                got: b'b',

2836

                pos: x

2837

})

2838

);

2839

        assert_eq!(

2840

            translate_xmlparser_streamerror(Se::InvalidCharMultiple(b'a', &b"xy"[..], p)),

2841

            XmlStreamError::InvalidCharMultiple(InvalidCharMultipleError {

2842

                expected: b'a',

2843

                got: vec![b'x', b'y'].into(),

2844

                pos: x

2845

})

2846

);

2847

2848

2849

    #[cfg(feature = "xml")]

2850

    #[test]

2851

    fn translate_xmlparser_error_maps_every_variant() {

2852

        use xmlparser::{Error as Xe, StreamError as Se};

2853

2854

        let p = xmlparser::TextPos::new(9, 4);

2855

        let x = XmlTextPos { row: 9, col: 4 };

2856

        let te = XmlTextError {

2857

            stream_error: XmlStreamError::InvalidName,

2858

            pos: x,

2859

};

2860

2861

        assert_eq!(

2862

            translate_xmlparser_error(Xe::InvalidDeclaration(Se::InvalidName, p)),

2863

            XmlParseError::InvalidDeclaration(te.clone())

2864

);

2865

        assert_eq!(

2866

            translate_xmlparser_error(Xe::InvalidComment(Se::InvalidName, p)),

2867

            XmlParseError::InvalidComment(te.clone())

2868

);

2869

        assert_eq!(

2870

            translate_xmlparser_error(Xe::InvalidPI(Se::InvalidName, p)),

2871

            XmlParseError::InvalidPI(te.clone())

2872

);

2873

        assert_eq!(

2874

            translate_xmlparser_error(Xe::InvalidDoctype(Se::InvalidName, p)),

2875

            XmlParseError::InvalidDoctype(te.clone())

2876

);

2877

        assert_eq!(

2878

            translate_xmlparser_error(Xe::InvalidEntity(Se::InvalidName, p)),

2879

            XmlParseError::InvalidEntity(te.clone())

2880

);

2881

        assert_eq!(

2882

            translate_xmlparser_error(Xe::InvalidElement(Se::InvalidName, p)),

2883

            XmlParseError::InvalidElement(te.clone())

2884

);

2885

        assert_eq!(

2886

            translate_xmlparser_error(Xe::InvalidAttribute(Se::InvalidName, p)),

2887

            XmlParseError::InvalidAttribute(te.clone())

2888

);

2889

        assert_eq!(

2890

            translate_xmlparser_error(Xe::InvalidCdata(Se::InvalidName, p)),

2891

            XmlParseError::InvalidCdata(te.clone())

2892

);

2893

        assert_eq!(

2894

            translate_xmlparser_error(Xe::InvalidCharData(Se::InvalidName, p)),

2895

            XmlParseError::InvalidCharData(te)

2896

);

2897

        assert_eq!(

2898

            translate_xmlparser_error(Xe::UnknownToken(p)),

2899

            XmlParseError::UnknownToken(x)

2900

);

2901

2902

2903

    #[cfg(feature = "xml")]

2904

    #[test]

2905

    fn translate_roxmltree_error_maps_every_variant() {

2906

        use roxmltree::Error as Re;

2907

2908

        let p = roxmltree::TextPos::new(2, 5);

2909

        let x = XmlTextPos { row: 2, col: 5 };

2910

2911

        assert_eq!(

2912

            translate_roxmltree_error(Re::InvalidXmlPrefixUri(p)),

2913

            XmlError::InvalidXmlPrefixUri(x)

2914

);

2915

        assert_eq!(

2916

            translate_roxmltree_error(Re::UnexpectedXmlUri(p)),

2917

            XmlError::UnexpectedXmlUri(x)

2918

);

2919

        assert_eq!(

2920

            translate_roxmltree_error(Re::UnexpectedXmlnsUri(p)),

2921

            XmlError::UnexpectedXmlnsUri(x)

2922

);

2923

        assert_eq!(

2924

            translate_roxmltree_error(Re::InvalidElementNamePrefix(p)),

2925

            XmlError::InvalidElementNamePrefix(x)

2926

);

2927

        assert_eq!(

2928

            translate_roxmltree_error(Re::DuplicatedNamespace(String::from("ns"), p)),

2929

            XmlError::DuplicatedNamespace(DuplicatedNamespaceError {

2930

                ns: "ns".into(),

2931

                pos: x

2932

})

2933

);

2934

        assert_eq!(

2935

            translate_roxmltree_error(Re::UnknownNamespace(String::from("ns"), p)),

2936

            XmlError::UnknownNamespace(UnknownNamespaceError {

2937

                ns: "ns".into(),

2938

                pos: x

2939

})

2940

);

2941

        assert_eq!(

2942

            translate_roxmltree_error(Re::UnexpectedCloseTag(

2943

                String::from("a"),

2944

                String::from("b"),

2945

2946

)),

2947

            XmlError::UnexpectedCloseTag(UnexpectedCloseTagError {

2948

                expected: "a".into(),

2949

                actual: "b".into(),

2950

                pos: x

2951

})

2952

);

2953

        assert_eq!(

2954

            translate_roxmltree_error(Re::UnexpectedEntityCloseTag(p)),

2955

            XmlError::UnexpectedEntityCloseTag(x)

2956

);

2957

        assert_eq!(

2958

            translate_roxmltree_error(Re::UnknownEntityReference(String::from("e"), p)),

2959

            XmlError::UnknownEntityReference(UnknownEntityReferenceError {

2960

                entity: "e".into(),

2961

                pos: x

2962

})

2963

);

2964

        assert_eq!(

2965

            translate_roxmltree_error(Re::MalformedEntityReference(p)),

2966

            XmlError::MalformedEntityReference(x)

2967

);

2968

        assert_eq!(

2969

            translate_roxmltree_error(Re::EntityReferenceLoop(p)),

2970

            XmlError::EntityReferenceLoop(x)

2971

);

2972

        assert_eq!(

2973

            translate_roxmltree_error(Re::InvalidAttributeValue(p)),

2974

            XmlError::InvalidAttributeValue(x)

2975

);

2976

        assert_eq!(

2977

            translate_roxmltree_error(Re::DuplicatedAttribute(String::from("a"), p)),

2978

            XmlError::DuplicatedAttribute(DuplicatedAttributeError {

2979

                attribute: "a".into(),

2980

                pos: x

2981

})

2982

);

2983

        assert_eq!(

2984

            translate_roxmltree_error(Re::NoRootNode),

2985

            XmlError::NoRootNode

2986

);

2987

        assert_eq!(

2988

            translate_roxmltree_error(Re::DtdDetected),

2989

            XmlError::DtdDetected

2990

);

2991

        assert_eq!(

2992

            translate_roxmltree_error(Re::UnclosedRootNode),

2993

            XmlError::UnclosedRootNode

2994

);

2995

        assert_eq!(

2996

            translate_roxmltree_error(Re::UnexpectedDeclaration(p)),

2997

            XmlError::UnexpectedDeclaration(x)

2998

);

2999

        assert_eq!(

3000

            translate_roxmltree_error(Re::NodesLimitReached),

3001

            XmlError::NodesLimitReached

3002

);

3003

        assert_eq!(

3004

            translate_roxmltree_error(Re::AttributesLimitReached),

3005

            XmlError::AttributesLimitReached

3006

);

3007

        assert_eq!(

3008

            translate_roxmltree_error(Re::NamespacesLimitReached),

3009

            XmlError::NamespacesLimitReached

3010

);

3011

        assert_eq!(

3012

            translate_roxmltree_error(Re::InvalidName(p)),

3013

            XmlError::InvalidName(x)

3014

);

3015

        assert_eq!(

3016

            translate_roxmltree_error(Re::NonXmlChar('\u{0}', p)),

3017

            XmlError::NonXmlChar(x)

3018

);

3019

        assert_eq!(

3020

            translate_roxmltree_error(Re::InvalidChar(b'a', b'b', p)),

3021

            XmlError::InvalidChar(x)

3022

);

3023

        assert_eq!(

3024

            translate_roxmltree_error(Re::InvalidChar2("ab", b'c', p)),

3025

            XmlError::InvalidChar2(x)

3026

);

3027

        assert_eq!(

3028

            translate_roxmltree_error(Re::InvalidString("s", p)),

3029

            XmlError::InvalidString(x)

3030

);

3031

        assert_eq!(

3032

            translate_roxmltree_error(Re::InvalidExternalID(p)),

3033

            XmlError::InvalidExternalID(x)

3034

);

3035

        assert_eq!(

3036

            translate_roxmltree_error(Re::InvalidComment(p)),

3037

            XmlError::InvalidComment(x)

3038

);

3039

        assert_eq!(

3040

            translate_roxmltree_error(Re::InvalidCharacterData(p)),

3041

            XmlError::InvalidCharacterData(x)

3042

);

3043

        assert_eq!(

3044

            translate_roxmltree_error(Re::UnknownToken(p)),

3045

            XmlError::UnknownToken(x)

3046

);

3047

        assert_eq!(

3048

            translate_roxmltree_error(Re::UnexpectedEndOfStream),

3049

            XmlError::UnexpectedEndOfStream

3050

);

3051

        // roxmltree 0.21's EntityResolver is folded into UnknownEntityReference.

3052

        assert_eq!(

3053

            translate_roxmltree_error(Re::EntityResolver(p, String::from("e"))),

3054

            XmlError::UnknownEntityReference(UnknownEntityReferenceError {

3055

                entity: "e".into(),

3056

                pos: x

3057

})

3058

);

3059

3060