Grcov report - 502_known

1

use std::collections::{BTreeMap, HashMap};

2

3

use ron::{

4

    error::Position, error::Span, error::SpannedError, extensions::Extensions, ser::PrettyConfig,

5

    Error,

6

};

7

use serde::{Deserialize, Serialize};

8

9

#[test]

10

4

fn struct_names_inside_internally_tagged() {

11

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

12

    struct A {

13

        hi: i32,

14

15

16

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

17

    #[serde(tag = "tag")]

18

    enum InternallyTagged {

19

        B { ho: i32, a: A },

20

21

22

4

    assert_eq!(

23

4

        check_roundtrip(

24

4

            &InternallyTagged::B {

25

4

                ho: 24,

26

4

                a: A { hi: 42 }

27

4

},

28

4

            PrettyConfig::default()

29

),

30

        Ok(())

31

);

32

4

    assert_eq!(

33

4

        check_roundtrip(

34

4

            &InternallyTagged::B {

35

4

                ho: 24,

36

4

                a: A { hi: 42 }

37

4

},

38

4

            PrettyConfig::default().struct_names(true)

39

),

40

        Err(Err(SpannedError {

41

            code: Error::MissingStructField {

42

                field: "hi",

43

                outer: None

44

},

45

            span: Span {

46

                start: Position { line: 7, col: 1 },

47

                end: Position { line: 7, col: 2 }

48

49

        })),

50

);

51

4

52

53

#[test]

54

4

fn struct_names_inside_adjacently_tagged() {

55

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

56

    struct A {

57

        hi: i32,

58

59

60

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

61

    #[serde(tag = "tag", content = "content")]

62

    enum AdjacentlyTagged {

63

        B { ho: i32, a: A },

64

65

66

4

    assert_eq!(

67

4

        check_roundtrip(

68

4

            &AdjacentlyTagged::B {

69

4

                ho: 24,

70

4

                a: A { hi: 42 }

71

4

},

72

4

            PrettyConfig::default()

73

),

74

        Ok(())

75

);

76

4

    assert_eq!(

77

4

        check_roundtrip(

78

4

            &AdjacentlyTagged::B {

79

4

                ho: 24,

80

4

                a: A { hi: 42 }

81

4

},

82

4

            PrettyConfig::default().struct_names(true)

83

),

84

        Ok(()),

85

);

86

4

    assert_eq!(

87

4

        ron::from_str::<AdjacentlyTagged>(

88

4

            "AdjacentlyTagged(tag: B, content: B(ho: 24, a: A(hi: 42)))"

89

),

90

        Ok(AdjacentlyTagged::B {

91

            ho: 24,

92

            a: A { hi: 42 }

93

}),

94

);

95

4

    assert_eq!(

96

4

        ron::from_str::<AdjacentlyTagged>(

97

4

            "AdjacentlyTagged(content: B(ho: 24, a: A(hi: 42)), tag: B)"

98

),

99

4

        Err(SpannedError {

100

4

            code: Error::MissingStructField {

101

4

                field: "ho",

102

4

                outer: Some(String::from("AdjacentlyTagged"))

103

4

},

104

4

            span: Span {

105

4

                start: Position { line: 1, col: 58 },

106

4

                end: Position { line: 1, col: 58 }

107

4

108

4

}),

109

);

110

4

111

112

#[test]

113

4

fn struct_names_inside_untagged() {

114

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

115

    struct A {

116

        hi: i32,

117

118

119

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

120

    #[serde(untagged)]

121

    enum Untagged {

122

        B { ho: i32, a: A },

123

124

125

4

    assert_eq!(

126

4

        check_roundtrip(

127

4

            &Untagged::B {

128

4

                ho: 24,

129

4

                a: A { hi: 42 }

130

4

},

131

4

            PrettyConfig::default()

132

),

133

        Ok(())

134

);

135

4

    assert_eq!(

136

4

        check_roundtrip(

137

4

            &Untagged::B {

138

4

                ho: 24,

139

4

                a: A { hi: 42 }

140

4

},

141

4

            PrettyConfig::default().struct_names(true)

142

),

143

4

        Err(Err(SpannedError {

144

4

            code: Error::Message(String::from(

145

4

                "data did not match any variant of untagged enum Untagged"

146

4

)),

147

4

            span: Span {

148

4

                start: Position { line: 6, col: 1 },

149

4

                end: Position { line: 6, col: 2 }

150

4

151

4

        })),

152

);

153

4

154

155

#[test]

156

4

fn struct_names_inside_flatten_struct() {

157

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

158

    struct A {

159

        hi: i32,

160

161

162

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

163

    struct B {

164

        a: A,

165

166

167

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

168

    struct FlattenedStruct {

169

        ho: i32,

170

        #[serde(flatten)]

171

        a: B,

172

173

174

4

    assert_eq!(

175

4

        check_roundtrip(

176

4

            &FlattenedStruct {

177

4

                ho: 24,

178

4

                a: B { a: A { hi: 42 } }

179

4

},

180

4

            PrettyConfig::default()

181

),

182

        Ok(())

183

);

184

4

    assert_eq!(

185

4

        check_roundtrip(

186

4

            &FlattenedStruct {

187

4

                ho: 24,

188

4

                a: B { a: A { hi: 42 } }

189

4

},

190

4

            PrettyConfig::default().struct_names(true)

191

),

192

        Err(Err(SpannedError {

193

            code: Error::MissingStructField {

194

                field: "hi",

195

                outer: None

196

},

197

            span: Span {

198

                start: Position { line: 6, col: 1 },

199

                end: Position { line: 6, col: 1 }

200

201

        })),

202

);

203

4

204

205

#[test]

206

4

fn struct_names_inside_flatten_struct_variant() {

207

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

208

    struct A {

209

        hi: i32,

210

211

212

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

213

    struct B {

214

        a: A,

215

216

217

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

218

    enum FlattenedStructVariant {

219

C {

220

            ho: i32,

221

            #[serde(flatten)]

222

            a: B,

223

},

224

225

226

4

    assert_eq!(

227

4

        check_roundtrip(

228

4

            &FlattenedStructVariant::C {

229

4

                ho: 24,

230

4

                a: B { a: A { hi: 42 } }

231

4

},

232

4

            PrettyConfig::default()

233

),

234

        Ok(())

235

);

236

4

    assert_eq!(

237

4

        check_roundtrip(

238

4

            &FlattenedStructVariant::C {

239

4

                ho: 24,

240

4

                a: B { a: A { hi: 42 } }

241

4

},

242

4

            PrettyConfig::default().struct_names(true)

243

),

244

4

        Err(Err(SpannedError {

245

4

            code: Error::MissingStructField {

246

4

                field: "hi",

247

4

                outer: Some(String::from("C"))

248

4

},

249

4

            span: Span {

250

4

                start: Position { line: 6, col: 1 },

251

4

                end: Position { line: 6, col: 1 }

252

4

253

4

        })),

254

);

255

4

256

257

#[test]

258

4

fn implicit_some_inside_internally_tagged() {

259

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

260

    struct A {

261

        hi: Option<Option<()>>,

262

263

264

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

265

    #[serde(tag = "tag")]

266

    enum InternallyTagged {

267

        B { ho: i32, a: A },

268

269

270

4

    assert_eq!(

271

4

        check_roundtrip(

272

4

            &InternallyTagged::B {

273

4

                ho: 24,

274

4

                a: A { hi: Some(Some(())) }

275

4

},

276

4

            PrettyConfig::default()

277

),

278

        Ok(())

279

);

280

4

    assert_eq!(

281

4

        check_roundtrip(

282

4

            &InternallyTagged::B {

283

4

                ho: 24,

284

4

                a: A { hi: Some(Some(())) }

285

4

},

286

4

            PrettyConfig::default().extensions(Extensions::IMPLICIT_SOME)

287

),

288

4

        Err(Ok(Error::Message(String::from("ROUNDTRIP error: B { ho: 24, a: A { hi: Some(Some(())) } } != B { ho: 24, a: A { hi: None } }"))))

289

);

290

4

291

292

#[test]

293

4

fn implicit_some_inside_adjacently_tagged() {

294

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

295

    struct Unit;

296

297

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

298

    struct A {

299

        hi: Option<Option<Unit>>,

300

301

302

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

303

    #[serde(tag = "tag", content = "content")]

304

    enum AdjacentlyTagged {

305

        B { ho: i32, a: A },

306

307

308

4

    assert_eq!(

309

4

        check_roundtrip(

310

4

            &AdjacentlyTagged::B {

311

4

                ho: 24,

312

4

                a: A {

313

4

                    hi: Some(Some(Unit))

314

4

315

4

},

316

4

            PrettyConfig::default()

317

),

318

        Ok(())

319

);

320

4

    assert_eq!(

321

4

        check_roundtrip(

322

4

            &AdjacentlyTagged::B {

323

4

                ho: 24,

324

4

                a: A {

325

4

                    hi: Some(Some(Unit))

326

4

327

4

},

328

4

            PrettyConfig::default().extensions(Extensions::IMPLICIT_SOME)

329

),

330

        Ok(()),

331

);

332

4

    assert_eq!(

333

4

        ron::from_str::<AdjacentlyTagged>(

334

4

            "#![enable(implicit_some)] (tag: B, content: (ho: 24, a: A(hi: ())))"

335

),

336

        Ok(AdjacentlyTagged::B {

337

            ho: 24,

338

            a: A {

339

                hi: Some(Some(Unit))

340

341

}),

342

);

343

4

    assert_eq!(

344

4

        ron::from_str::<AdjacentlyTagged>(

345

4

            "#![enable(implicit_some)] (content: (ho: 24, a: A(hi: ())), tag: B)"

346

),

347

        Ok(AdjacentlyTagged::B {

348

            ho: 24,

349

            a: A { hi: None } // THIS IS WRONG

350

}),

351

);

352

4

353

354

#[test]

355

4

fn implicit_some_inside_untagged() {

356

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

357

    struct A {

358

        hi: Option<Option<()>>,

359

360

361

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

362

    #[serde(untagged)]

363

    enum Untagged {

364

        B { ho: i32, a: A },

365

366

367

4

    assert_eq!(

368

4

        check_roundtrip(

369

4

            &Untagged::B {

370

4

                ho: 24,

371

4

                a: A { hi: Some(Some(())) }

372

4

},

373

4

            PrettyConfig::default()

374

),

375

        Ok(())

376

);

377

4

    assert_eq!(

378

4

        check_roundtrip(

379

4

            &Untagged::B {

380

4

                ho: 24,

381

4

                a: A { hi: Some(Some(())) }

382

4

},

383

4

            PrettyConfig::default().extensions(Extensions::IMPLICIT_SOME)

384

),

385

4

        Err(Ok(Error::Message(String::from(

386

4

            "ROUNDTRIP error: B { ho: 24, a: A { hi: Some(Some(())) } } != B { ho: 24, a: A { hi: None } }"

387

4

        )))),

388

);

389

4

390

391

#[test]

392

4

fn implicit_some_inside_flatten_struct() {

393

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

394

    #[serde(untagged)]

395

    enum Untagged {

396

        Unit,

397

398

399

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

400

    struct A {

401

        hi: Option<Option<Untagged>>,

402

403

404

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

405

    struct B {

406

        a: A,

407

408

409

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

410

    struct FlattenedStruct {

411

        ho: i32,

412

        #[serde(flatten)]

413

        a: B,

414

415

416

4

    assert_eq!(

417

4

        check_roundtrip(

418

4

            &FlattenedStruct {

419

4

                ho: 24,

420

4

                a: B {

421

4

                    a: A {

422

4

                        hi: Some(Some(Untagged::Unit))

423

4

424

4

425

4

},

426

4

            PrettyConfig::default()

427

),

428

        Ok(())

429

);

430

4

    assert_eq!(

431

4

        check_roundtrip(

432

4

            &FlattenedStruct {

433

4

                ho: 24,

434

4

                a: B {

435

4

                    a: A { hi: Some(Some(Untagged::Unit)) }

436

4

437

4

},

438

4

            PrettyConfig::default().extensions(Extensions::IMPLICIT_SOME)

439

),

440

4

        Err(Ok(Error::Message(String::from("ROUNDTRIP error: FlattenedStruct { ho: 24, a: B { a: A { hi: Some(Some(Unit)) } } } != FlattenedStruct { ho: 24, a: B { a: A { hi: None } } }"))))

441

);

442

4

443

444

#[test]

445

4

fn implicit_some_inside_flatten_struct_variant() {

446

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

447

    struct A {

448

        hi: Option<Option<[u8; 0]>>,

449

450

451

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

452

    struct B {

453

        a: A,

454

455

456

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

457

    enum FlattenedStructVariant {

458

C {

459

            ho: i32,

460

            #[serde(flatten)]

461

            a: B,

462

},

463

464

465

4

    assert_eq!(

466

4

        check_roundtrip(

467

4

            &FlattenedStructVariant::C {

468

4

                ho: 24,

469

4

                a: B {

470

4

                    a: A { hi: Some(Some([])) }

471

4

472

4

},

473

4

            PrettyConfig::default()

474

),

475

4

        Err(Err(SpannedError {

476

4

            code: Error::InvalidValueForType {

477

4

                expected: String::from("an empty array"),

478

4

                found: String::from("a unit value")

479

4

},

480

4

            span: Span {

481

4

                start: Position { line: 6, col: 1 },

482

4

                end: Position { line: 6, col: 1 }

483

4

484

4

}))

485

);

486

4

    assert_eq!(

487

4

        check_roundtrip(

488

4

            &FlattenedStructVariant::C {

489

4

                ho: 24,

490

4

                a: B {

491

4

                    a: A { hi: Some(Some([])) }

492

4

493

4

},

494

4

            PrettyConfig::default().extensions(Extensions::IMPLICIT_SOME)

495

),

496

4

        Err(Ok(Error::Message(String::from("ROUNDTRIP error: C { ho: 24, a: B { a: A { hi: Some(Some([])) } } } != C { ho: 24, a: B { a: A { hi: None } } }"))))

497

);

498

4

499

500

#[test]

501

4

fn newtype_inside_internally_tagged() {

502

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

503

    struct A(i32);

504

505

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

506

    #[serde(tag = "tag")]

507

    enum InternallyTagged {

508

        B { ho: i32, a: A },

509

510

511

    // NOTE:

512

    // 1. ron is correctly collected into Content, newtype is a one-seq here

513

    // 2. newtype asks ContentDeserializer for newtype

514

    // 3. ContentDeserializer forwards any value to visit_newtype_struct

515

    //    https://github.com/serde-rs/serde/blob/8c4aad3a59515f7b779f764d5e16d6bae297ab7f/serde/src/private/de.rs#L1347-L1359

516

517

4

    assert_eq!(

518

4

        check_roundtrip(

519

4

            &InternallyTagged::B { ho: 24, a: A(42) },

520

4

            PrettyConfig::default()

521

),

522

4

        Err(Err(SpannedError {

523

4

            code: Error::InvalidValueForType {

524

4

                expected: String::from("i32"),

525

4

                found: String::from("a sequence")

526

4

},

527

4

            span: Span {

528

4

                start: Position { line: 5, col: 1 },

529

4

                end: Position { line: 5, col: 2 }

530

4

531

4

}))

532

);

533

4

534

535

#[test]

536

4

fn newtype_inside_adjacently_tagged() {

537

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

538

    struct A(i32);

539

540

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

541

    #[serde(tag = "tag", content = "content")]

542

    enum AdjacentlyTagged {

543

        B { ho: i32, a: A },

544

545

546

4

    assert_eq!(

547

4

        check_roundtrip(

548

4

            &AdjacentlyTagged::B { ho: 24, a: A(42) },

549

4

            PrettyConfig::default()

550

),

551

        Ok(())

552

);

553

4

    assert_eq!(

554

4

        ron::from_str::<AdjacentlyTagged>("(tag: B, content: (ho: 24, a: (42)))"),

555

        Ok(AdjacentlyTagged::B { ho: 24, a: A(42) }),

556

);

557

4

    assert_eq!(

558

4

        ron::from_str::<AdjacentlyTagged>("(content: (ho: 24, a: (42)), tag: B)"),

559

4

        Err(SpannedError {

560

4

            code: Error::InvalidValueForType {

561

4

                expected: String::from("i32"),

562

4

                found: String::from("a sequence")

563

4

},

564

4

            span: Span {

565

4

                start: Position { line: 1, col: 36 },

566

4

                end: Position { line: 1, col: 36 }

567

4

568

4

})

569

);

570

4

571

572

#[test]

573

4

fn newtype_inside_untagged() {

574

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

575

    struct A(i32);

576

577

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

578

    #[serde(untagged)]

579

    enum Untagged {

580

        B { ho: i32, a: A },

581

582

583

4

    assert_eq!(

584

4

        check_roundtrip(&Untagged::B { ho: 24, a: A(42) }, PrettyConfig::default()),

585

4

        Err(Err(SpannedError {

586

4

            code: Error::Message(String::from(

587

4

                "data did not match any variant of untagged enum Untagged"

588

4

)),

589

4

            span: Span {

590

4

                start: Position { line: 4, col: 1 },

591

4

                end: Position { line: 4, col: 2 }

592

4

593

4

}))

594

);

595

4

596

597

#[test]

598

4

fn newtype_inside_flatten_struct() {

599

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

600

    struct A(i32);

601

602

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

603

    struct B {

604

        a: A,

605

606

607

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

608

    struct FlattenedStruct {

609

        ho: i32,

610

        #[serde(flatten)]

611

        a: B,

612

613

614

4

    assert_eq!(

615

4

        check_roundtrip(

616

4

            &FlattenedStruct {

617

4

                ho: 24,

618

4

                a: B { a: A(42) }

619

4

},

620

4

            PrettyConfig::default()

621

),

622

4

        Err(Err(SpannedError {

623

4

            code: Error::InvalidValueForType {

624

4

                expected: String::from("i32"),

625

4

                found: String::from("a sequence")

626

4

},

627

4

            span: Span {

628

4

                start: Position { line: 4, col: 1 },

629

4

                end: Position { line: 4, col: 1 }

630

4

631

4

}))

632

);

633

4

634

635

#[test]

636

4

fn newtype_inside_flatten_struct_variant() {

637

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

638

    struct A(i32);

639

640

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

641

    struct B {

642

        a: A,

643

644

645

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

646

    enum FlattenedStructVariant {

647

C {

648

            ho: i32,

649

            #[serde(flatten)]

650

            a: B,

651

},

652

653

654

4

    assert_eq!(

655

4

        check_roundtrip(

656

4

            &FlattenedStructVariant::C {

657

4

                ho: 24,

658

4

                a: B { a: A(42) }

659

4

},

660

4

            PrettyConfig::default()

661

),

662

4

        Err(Err(SpannedError {

663

4

            code: Error::InvalidValueForType {

664

4

                expected: String::from("i32"),

665

4

                found: String::from("a sequence")

666

4

},

667

4

            span: Span {

668

4

                start: Position { line: 4, col: 1 },

669

4

                end: Position { line: 4, col: 1 }

670

4

671

4

}))

672

);

673

4

674

675

#[test]

676

4

fn one_tuple_inside_unwrapped_newtype_variant_inside_internally_tagged() {

677

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

678

    enum A {

679

        Newtype((i32,)),

680

681

682

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

683

    #[serde(tag = "tag")]

684

    enum InternallyTagged {

685

        B { ho: i32, a: A },

686

687

688

4

    assert_eq!(

689

4

        check_roundtrip(

690

4

            &InternallyTagged::B {

691

4

                ho: 24,

692

4

                a: A::Newtype((42,))

693

4

},

694

4

            PrettyConfig::default()

695

),

696

        Ok(())

697

);

698

4

    assert_eq!(

699

4

        check_roundtrip(

700

4

            &InternallyTagged::B {

701

4

                ho: 24,

702

4

                a: A::Newtype((42,))

703

4

},

704

4

            PrettyConfig::default().extensions(Extensions::UNWRAP_VARIANT_NEWTYPES)

705

),

706

4

        Err(Err(SpannedError {

707

4

            code: Error::InvalidValueForType {

708

4

                expected: String::from("a tuple of size 1"),

709

4

                found: String::from("the unsigned integer `42`")

710

4

},

711

4

            span: Span {

712

4

                start: Position { line: 6, col: 1 },

713

4

                end: Position { line: 6, col: 2 }

714

4

715

4

}))

716

);

717

4

718

719

#[test]

720

4

fn one_tuple_inside_unwrapped_newtype_variant_inside_adjacently_tagged() {

721

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

722

    enum A {

723

        Newtype([i32; 1]),

724

725

726

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

727

    #[serde(tag = "tag", content = "content")]

728

    enum AdjacentlyTagged {

729

        B { ho: i32, a: A },

730

731

732

4

    assert_eq!(

733

4

        check_roundtrip(

734

4

            &AdjacentlyTagged::B {

735

4

                ho: 24,

736

4

                a: A::Newtype([42])

737

4

},

738

4

            PrettyConfig::default()

739

),

740

        Ok(())

741

);

742

4

    assert_eq!(

743

4

        check_roundtrip(

744

4

            &AdjacentlyTagged::B {

745

4

                ho: 24,

746

4

                a: A::Newtype([42])

747

4

},

748

4

            PrettyConfig::default().extensions(Extensions::UNWRAP_VARIANT_NEWTYPES)

749

),

750

        Ok(())

751

);

752

4

    assert_eq!(

753

4

        ron::from_str::<AdjacentlyTagged>(

754

4

            "#![enable(unwrap_variant_newtypes)] (tag: B, content: (ho: 24, a: Newtype(42)))"

755

),

756

        Ok(AdjacentlyTagged::B {

757

            ho: 24,

758

            a: A::Newtype([42])

759

}),

760

);

761

4

    assert_eq!(

762

4

        ron::from_str::<AdjacentlyTagged>(

763

4

            "#![enable(unwrap_variant_newtypes)] (content: (ho: 24, a: Newtype(42)), tag: B)"

764

),

765

4

        Err(SpannedError {

766

4

            code: Error::InvalidValueForType {

767

4

                expected: String::from("an array of length 1"),

768

4

                found: String::from("the unsigned integer `42`")

769

4

},

770

4

            span: Span {

771

4

                start: Position { line: 1, col: 79 },

772

4

                end: Position { line: 1, col: 79 }

773

4

774

4

})

775

);

776

4

777

778

#[test]

779

4

fn one_tuple_inside_unwrapped_newtype_variant_inside_untagged() {

780

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

781

    struct OneTuple(i32, #[serde(skip)] ());

782

783

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

784

    #[serde(untagged)]

785

    enum Untagged {

786

        B { ho: i32, a: Option<OneTuple> },

787

788

789

4

    assert_eq!(

790

4

        check_roundtrip(

791

4

            &Untagged::B {

792

4

                ho: 24,

793

4

                a: Some(OneTuple(42, ()))

794

4

},

795

4

            PrettyConfig::default()

796

),

797

        Ok(())

798

);

799

4

    assert_eq!(

800

4

        check_roundtrip(

801

4

            &Untagged::B {

802

4

                ho: 24,

803

4

                a: Some(OneTuple(42, ()))

804

4

},

805

4

            PrettyConfig::default().extensions(Extensions::UNWRAP_VARIANT_NEWTYPES)

806

),

807

4

        Err(Err(SpannedError {

808

4

            code: Error::Message(String::from(

809

4

                "data did not match any variant of untagged enum Untagged"

810

4

)),

811

4

            span: Span {

812

4

                start: Position { line: 5, col: 1 },

813

4

                end: Position { line: 5, col: 2 }

814

4

815

4

}))

816

);

817

4

818

819

#[test]

820

4

fn one_tuple_inside_unwrapped_newtype_variant_inside_flatten_struct() {

821

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

822

    enum A {

823

        Newtype([i32; 1]),

824

825

826

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

827

    struct B {

828

        a: A,

829

830

831

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

832

    struct FlattenedStruct {

833

        ho: i32,

834

        #[serde(flatten)]

835

        a: B,

836

837

838

4

    assert_eq!(

839

4

        check_roundtrip(

840

4

            &FlattenedStruct {

841

4

                ho: 24,

842

4

                a: B {

843

4

                    a: A::Newtype([42])

844

4

845

4

},

846

4

            PrettyConfig::default()

847

),

848

        Ok(())

849

);

850

4

    assert_eq!(

851

4

        check_roundtrip(

852

4

            &FlattenedStruct {

853

4

                ho: 24,

854

4

                a: B {

855

4

                    a: A::Newtype([42])

856

4

857

4

},

858

4

            PrettyConfig::default().extensions(Extensions::UNWRAP_VARIANT_NEWTYPES)

859

),

860

4

        Err(Err(SpannedError {

861

4

            code: Error::InvalidValueForType {

862

4

                expected: String::from("an array of length 1"),

863

4

                found: String::from("the unsigned integer `42`")

864

4

},

865

4

            span: Span {

866

4

                start: Position { line: 5, col: 1 },

867

4

                end: Position { line: 5, col: 1 }

868

4

869

4

}))

870

);

871

4

872

873

#[test]

874

4

fn one_tuple_inside_unwrapped_newtype_variant_inside_flatten_struct_variant() {

875

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

876

    enum A {

877

        Newtype((i32,)),

878

879

880

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

881

    struct B {

882

        a: A,

883

884

885

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

886

    enum FlattenedStructVariant {

887

C {

888

            ho: i32,

889

            #[serde(flatten)]

890

            a: B,

891

},

892

893

894

4

    assert_eq!(

895

4

        check_roundtrip(

896

4

            &FlattenedStructVariant::C {

897

4

                ho: 24,

898

4

                a: B {

899

4

                    a: A::Newtype((42,))

900

4

901

4

},

902

4

            PrettyConfig::default()

903

),

904

        Ok(()),

905

);

906

4

    assert_eq!(

907

4

        check_roundtrip(

908

4

            &FlattenedStructVariant::C {

909

4

                ho: 24,

910

4

                a: B {

911

4

                    a: A::Newtype((42,))

912

4

913

4

},

914

4

            PrettyConfig::default().extensions(Extensions::UNWRAP_VARIANT_NEWTYPES)

915

),

916

4

        Err(Err(SpannedError {

917

4

            code: Error::InvalidValueForType {

918

4

                expected: String::from("a tuple of size 1"),

919

4

                found: String::from("the unsigned integer `42`")

920

4

},

921

4

            span: Span {

922

4

                start: Position { line: 5, col: 1 },

923

4

                end: Position { line: 5, col: 1 }

924

4

925

4

}))

926

);

927

4

928

929

#[test]

930

4

fn one_tuple_variant_inside_internally_tagged() {

931

    // A tuple variant with just one element that is not a newtype variant

932

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

933

    enum OneEnum {

934

        OneTuple(i32, #[serde(skip)] ()),

935

936

937

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

938

    struct A {

939

        hi: OneEnum,

940

941

942

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

943

    #[serde(tag = "tag")]

944

    enum InternallyTagged {

945

        B { ho: i32, a: A },

946

947

948

4

    assert_eq!(

949

4

        check_roundtrip(

950

4

            &InternallyTagged::B {

951

4

                ho: 24,

952

4

                a: A {

953

4

                    hi: OneEnum::OneTuple(42, ())

954

4

955

4

},

956

4

            PrettyConfig::default()

957

),

958

4

        Err(Err(SpannedError {

959

4

            code: Error::InvalidValueForType {

960

4

                expected: String::from("tuple variant"),

961

4

                found: String::from("the unsigned integer `42`")

962

4

},

963

4

            span: Span {

964

4

                start: Position { line: 7, col: 1 },

965

4

                end: Position { line: 7, col: 2 }

966

4

967

4

}))

968

);

969

4

970

971

#[test]

972

4

fn one_tuple_variant_inside_adjacently_tagged() {

973

    // A tuple variant with just one element that is not a newtype variant

974

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

975

    enum OneEnum {

976

        OneTuple(i32, #[serde(skip)] ()),

977

978

979

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

980

    struct A {

981

        hi: OneEnum,

982

983

984

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

985

    #[serde(tag = "tag", content = "content")]

986

    enum AdjacentlyTagged {

987

        B { ho: i32, a: A },

988

989

990

4

    assert_eq!(

991

4

        check_roundtrip(

992

4

            &AdjacentlyTagged::B {

993

4

                ho: 24,

994

4

                a: A {

995

4

                    hi: OneEnum::OneTuple(42, ())

996

4

997

4

},

998

4

            PrettyConfig::default()

999

),

1000

        Ok(())

1001

);

1002

4

    assert_eq!(

1003

4

        ron::from_str::<AdjacentlyTagged>("(tag: B, content: (ho: 24, a: (hi: OneTuple(42))))"),

1004

        Ok(AdjacentlyTagged::B {

1005

            ho: 24,

1006

            a: A {

1007

                hi: OneEnum::OneTuple(42, ())

1008

1009

}),

1010

);

1011

4

    assert_eq!(

1012

4

        ron::from_str::<AdjacentlyTagged>("(content: (ho: 24, a: (hi: OneTuple(42))), tag: B)"),

1013

4

        Err(SpannedError {

1014

4

            code: Error::InvalidValueForType {

1015

4

                expected: String::from("tuple variant"),

1016

4

                found: String::from("the unsigned integer `42`")

1017

4

},

1018

4

            span: Span {

1019

4

                start: Position { line: 1, col: 50 },

1020

4

                end: Position { line: 1, col: 50 }

1021

4

1022

4

})

1023

);

1024

4

1025

1026

#[test]

1027

4

fn one_tuple_variant_inside_untagged() {

1028

    // A tuple variant with just one element that is not a newtype variant

1029

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1030

    enum OneEnum {

1031

        OneTuple(i32, #[serde(skip)] ()),

1032

1033

1034

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1035

    struct A {

1036

        hi: OneEnum,

1037

1038

1039

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1040

    #[serde(untagged)]

1041

    enum Untagged {

1042

        B { ho: i32, a: A },

1043

1044

1045

4

    assert_eq!(

1046

4

        check_roundtrip(

1047

4

            &Untagged::B {

1048

4

                ho: 24,

1049

4

                a: A {

1050

4

                    hi: OneEnum::OneTuple(42, ())

1051

4

1052

4

},

1053

4

            PrettyConfig::default()

1054

),

1055

4

        Err(Err(SpannedError {

1056

4

            code: Error::Message(String::from(

1057

4

                "data did not match any variant of untagged enum Untagged"

1058

4

)),

1059

4

            span: Span {

1060

4

                start: Position { line: 6, col: 1 },

1061

4

                end: Position { line: 6, col: 2 }

1062

4

1063

4

}))

1064

);

1065

4

1066

1067

#[test]

1068

4

fn one_tuple_variant_inside_flatten_struct() {

1069

    // A tuple variant with just one element that is not a newtype variant

1070

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1071

    enum OneEnum {

1072

        OneTuple(i32, #[serde(skip)] ()),

1073

1074

1075

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1076

    struct A {

1077

        hi: OneEnum,

1078

1079

1080

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1081

    struct B {

1082

        a: A,

1083

1084

1085

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1086

    struct FlattenedStruct {

1087

        ho: i32,

1088

        #[serde(flatten)]

1089

        a: B,

1090

1091

1092

4

    assert_eq!(

1093

4

        check_roundtrip(

1094

4

            &FlattenedStruct {

1095

4

                ho: 24,

1096

4

                a: B {

1097

4

                    a: A {

1098

4

                        hi: OneEnum::OneTuple(42, ())

1099

4

1100

4

1101

4

},

1102

4

            PrettyConfig::default()

1103

),

1104

4

        Err(Err(SpannedError {

1105

4

            code: Error::InvalidValueForType {

1106

4

                expected: String::from("tuple variant"),

1107

4

                found: String::from("the unsigned integer `42`")

1108

4

},

1109

4

            span: Span {

1110

4

                start: Position { line: 6, col: 1 },

1111

4

                end: Position { line: 6, col: 1 }

1112

4

1113

4

}))

1114

);

1115

4

1116

1117

#[test]

1118

4

fn one_tuple_variant_inside_flatten_struct_variant() {

1119

    // A tuple variant with just one element that is not a newtype variant

1120

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1121

    enum OneEnum {

1122

        OneTuple(i32, #[serde(skip)] ()),

1123

1124

1125

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1126

    struct A {

1127

        hi: OneEnum,

1128

1129

1130

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1131

    struct B {

1132

        a: A,

1133

1134

1135

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1136

    enum FlattenedStructVariant {

1137

C {

1138

            ho: i32,

1139

            #[serde(flatten)]

1140

            a: B,

1141

},

1142

1143

1144

4

    assert_eq!(

1145

4

        check_roundtrip(

1146

4

            &FlattenedStructVariant::C {

1147

4

                ho: 24,

1148

4

                a: B {

1149

4

                    a: A {

1150

4

                        hi: OneEnum::OneTuple(42, ())

1151

4

1152

4

1153

4

},

1154

4

            PrettyConfig::default()

1155

),

1156

4

        Err(Err(SpannedError {

1157

4

            code: Error::InvalidValueForType {

1158

4

                expected: String::from("tuple variant"),

1159

4

                found: String::from("the unsigned integer `42`")

1160

4

},

1161

4

            span: Span {

1162

4

                start: Position { line: 6, col: 1 },

1163

4

                end: Position { line: 6, col: 1 }

1164

4

1165

4

}))

1166

);

1167

4

1168

1169

#[test]

1170

4

fn raw_value_inside_internally_tagged() {

1171

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1172

    struct A {

1173

        hi: Box<ron::value::RawValue>,

1174

1175

1176

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1177

    #[serde(tag = "tag")]

1178

    enum InternallyTagged {

1179

        B { ho: i32, a: A },

1180

1181

1182

4

    assert_eq!(

1183

4

        check_roundtrip(

1184

4

            &InternallyTagged::B {

1185

4

                ho: 24,

1186

4

                a: A {

1187

4

                    hi: ron::value::RawValue::from_boxed_ron(String::from("42").into_boxed_str())

1188

4

                        .unwrap(),

1189

4

1190

4

},

1191

4

            PrettyConfig::default()

1192

),

1193

4

        Err(Err(SpannedError {

1194

4

            code: Error::InvalidValueForType {

1195

4

                expected: String::from("any valid RON-value-string"),

1196

4

                found: String::from("the unsigned integer `42`")

1197

4

},

1198

4

            span: Span {

1199

4

                start: Position { line: 7, col: 1 },

1200

4

                end: Position { line: 7, col: 2 }

1201

4

1202

4

}))

1203

);

1204

4

1205

1206

#[test]

1207

4

fn raw_value_inside_adjacently_tagged() {

1208

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1209

    struct A {

1210

        hi: Box<ron::value::RawValue>,

1211

1212

1213

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1214

    #[serde(tag = "tag", content = "content")]

1215

    enum AdjacentlyTagged {

1216

        B { ho: i32, a: A },

1217

1218

1219

4

    assert_eq!(

1220

4

        check_roundtrip(

1221

4

            &AdjacentlyTagged::B {

1222

4

                ho: 24,

1223

4

                a: A {

1224

4

                    hi: ron::value::RawValue::from_boxed_ron(String::from("42").into_boxed_str())

1225

4

                        .unwrap(),

1226

4

1227

4

},

1228

4

            PrettyConfig::default()

1229

),

1230

        // adds an extra space

1231

4

        Err(Ok(Error::Message(String::from("ROUNDTRIP error: B { ho: 24, a: A { hi: RawValue(42) } } != B { ho: 24, a: A { hi: RawValue( 42) } }"))))

1232

);

1233

4

    assert_eq!(

1234

4

        ron::from_str::<AdjacentlyTagged>("(tag: B, content: (ho: 24, a: (hi:42)))"),

1235

4

        Ok(AdjacentlyTagged::B {

1236

4

            ho: 24,

1237

4

            a: A {

1238

4

                hi: ron::value::RawValue::from_boxed_ron(String::from("42").into_boxed_str())

1239

4

                    .unwrap(),

1240

4

1241

4

}),

1242

);

1243

4

    assert_eq!(

1244

4

        ron::from_str::<AdjacentlyTagged>("(content: (ho: 24, a: (hi:42)), tag: B)"),

1245

4

        Err(SpannedError {

1246

4

            code: Error::InvalidValueForType {

1247

4

                expected: String::from("any valid RON-value-string"),

1248

4

                found: String::from("the unsigned integer `42`")

1249

4

},

1250

4

            span: Span {

1251

4

                start: Position { line: 1, col: 39 },

1252

4

                end: Position { line: 1, col: 39 }

1253

4

1254

4

})

1255

);

1256

4

1257

1258

#[test]

1259

4

fn raw_value_inside_untagged() {

1260

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1261

    struct A {

1262

        hi: Box<ron::value::RawValue>,

1263

1264

1265

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1266

    #[serde(untagged)]

1267

    enum Untagged {

1268

        B { ho: i32, a: A },

1269

1270

1271

4

    assert_eq!(

1272

4

        check_roundtrip(

1273

4

            &Untagged::B {

1274

4

                ho: 24,

1275

4

                a: A {

1276

4

                    hi: ron::value::RawValue::from_boxed_ron(String::from("42").into_boxed_str())

1277

4

                        .unwrap(),

1278

4

1279

4

},

1280

4

            PrettyConfig::default()

1281

),

1282

4

        Err(Err(SpannedError {

1283

4

            code: Error::Message(String::from(

1284

4

                "data did not match any variant of untagged enum Untagged"

1285

4

)),

1286

4

            span: Span {

1287

4

                start: Position { line: 6, col: 1 },

1288

4

                end: Position { line: 6, col: 2 }

1289

4

1290

4

}))

1291

);

1292

4

1293

1294

#[test]

1295

4

fn raw_value_inside_flatten_struct() {

1296

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1297

    struct A {

1298

        hi: Box<ron::value::RawValue>,

1299

1300

1301

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1302

    struct B {

1303

        a: A,

1304

1305

1306

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1307

    struct FlattenedStruct {

1308

        ho: i32,

1309

        #[serde(flatten)]

1310

        a: B,

1311

1312

1313

4

    assert_eq!(

1314

4

        check_roundtrip(

1315

4

            &FlattenedStruct {

1316

4

                ho: 24,

1317

4

                a: B {

1318

4

                    a: A {

1319

4

                        hi: ron::value::RawValue::from_boxed_ron(

1320

4

                            String::from("42").into_boxed_str()

1321

4

1322

4

                        .unwrap(),

1323

4

1324

4

1325

4

},

1326

4

            PrettyConfig::default()

1327

),

1328

4

        Err(Err(SpannedError {

1329

4

            code: Error::InvalidValueForType {

1330

4

                expected: String::from("any valid RON-value-string"),

1331

4

                found: String::from("the unsigned integer `42`")

1332

4

},

1333

4

            span: Span {

1334

4

                start: Position { line: 6, col: 1 },

1335

4

                end: Position { line: 6, col: 1 }

1336

4

1337

4

}))

1338

);

1339

4

1340

1341

#[test]

1342

4

fn raw_value_inside_flatten_struct_variant() {

1343

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1344

    struct A {

1345

        hi: Box<ron::value::RawValue>,

1346

1347

1348

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1349

    struct B {

1350

        a: A,

1351

1352

1353

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1354

    enum FlattenedStructVariant {

1355

C {

1356

            ho: i32,

1357

            #[serde(flatten)]

1358

            a: B,

1359

},

1360

1361

1362

4

    assert_eq!(

1363

4

        check_roundtrip(

1364

4

            &FlattenedStructVariant::C {

1365

4

                ho: 24,

1366

4

                a: B {

1367

4

                    a: A {

1368

4

                        hi: ron::value::RawValue::from_boxed_ron(

1369

4

                            String::from("42").into_boxed_str()

1370

4

1371

4

                        .unwrap(),

1372

4

1373

4

1374

4

},

1375

4

            PrettyConfig::default()

1376

),

1377

4

        Err(Err(SpannedError {

1378

4

            code: Error::InvalidValueForType {

1379

4

                expected: String::from("any valid RON-value-string"),

1380

4

                found: String::from("the unsigned integer `42`")

1381

4

},

1382

4

            span: Span {

1383

4

                start: Position { line: 6, col: 1 },

1384

4

                end: Position { line: 6, col: 1 }

1385

4

1386

4

}))

1387

);

1388

4

1389

1390

#[test]

1391

4

fn unit_like_zero_length_inside_internally_tagged() {

1392

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1393

    struct A {

1394

        hi: [i32; 0],

1395

1396

1397

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1398

    #[serde(tag = "tag")]

1399

    enum InternallyTagged {

1400

        B { ho: i32, a: A },

1401

1402

1403

4

    assert_eq!(

1404

4

        check_roundtrip(

1405

4

            &InternallyTagged::B {

1406

4

                ho: 24,

1407

4

                a: A { hi: [] }

1408

4

},

1409

4

            PrettyConfig::default()

1410

),

1411

4

        Err(Err(SpannedError {

1412

4

            code: Error::InvalidValueForType {

1413

4

                expected: String::from("an empty array"),

1414

4

                found: String::from("a unit value")

1415

4

},

1416

4

            span: Span {

1417

4

                start: Position { line: 7, col: 1 },

1418

4

                end: Position { line: 7, col: 2 }

1419

4

1420

4

}))

1421

);

1422

4

1423

1424

#[test]

1425

4

fn unit_like_zero_length_inside_adjacently_tagged() {

1426

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1427

    struct TupleStruct();

1428

1429

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1430

    struct A {

1431

        hi: TupleStruct,

1432

1433

1434

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1435

    #[serde(tag = "tag", content = "content")]

1436

    enum AdjacentlyTagged {

1437

        B { ho: i32, a: A },

1438

1439

1440

4

    assert_eq!(

1441

4

        check_roundtrip(

1442

4

            &AdjacentlyTagged::B {

1443

4

                ho: 24,

1444

4

                a: A { hi: TupleStruct() }

1445

4

},

1446

4

            PrettyConfig::default()

1447

),

1448

        Ok(()),

1449

);

1450

4

    assert_eq!(

1451

4

        ron::from_str::<AdjacentlyTagged>("(tag: B, content: (ho: 24, a: (hi: ())))"),

1452

        Ok(AdjacentlyTagged::B {

1453

            ho: 24,

1454

            a: A { hi: TupleStruct() }

1455

}),

1456

);

1457

4

    assert_eq!(

1458

4

        ron::from_str::<AdjacentlyTagged>("(content: (ho: 24, a: (hi: ())), tag: B)"),

1459

4

        Err(SpannedError {

1460

4

            code: Error::InvalidValueForType {

1461

4

                expected: String::from("tuple struct TupleStruct"),

1462

4

                found: String::from("a unit value")

1463

4

},

1464

4

            span: Span {

1465

4

                start: Position { line: 1, col: 40 },

1466

4

                end: Position { line: 1, col: 40 }

1467

4

1468

4

})

1469

);

1470

4

1471

1472

#[test]

1473

4

fn unit_like_zero_length_inside_untagged() {

1474

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1475

    struct Struct {}

1476

1477

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1478

    struct A {

1479

        hi: Struct,

1480

1481

1482

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1483

    #[serde(untagged)]

1484

    enum Untagged {

1485

        B { ho: i32, a: A },

1486

1487

1488

4

    assert_eq!(

1489

4

        check_roundtrip(

1490

4

            &Untagged::B {

1491

4

                ho: 24,

1492

4

                a: A { hi: Struct {} }

1493

4

},

1494

4

            PrettyConfig::default()

1495

),

1496

4

        Err(Err(SpannedError {

1497

4

            code: Error::Message(String::from(

1498

4

                "data did not match any variant of untagged enum Untagged"

1499

4

)),

1500

4

            span: Span {

1501

4

                start: Position { line: 6, col: 1 },

1502

4

                end: Position { line: 6, col: 2 }

1503

4

1504

4

}))

1505

);

1506

4

1507

1508

#[test]

1509

4

fn unit_like_zero_length_inside_flatten_struct() {

1510

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1511

    enum Enum {

1512

        Tuple(),

1513

1514

1515

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1516

    struct A {

1517

        hi: Enum,

1518

1519

1520

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1521

    struct B {

1522

        a: A,

1523

1524

1525

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1526

    struct FlattenedStruct {

1527

        ho: i32,

1528

        #[serde(flatten)]

1529

        a: B,

1530

1531

1532

4

    assert_eq!(

1533

4

        check_roundtrip(

1534

4

            &FlattenedStruct {

1535

4

                ho: 24,

1536

4

                a: B {

1537

4

                    a: A { hi: Enum::Tuple() }

1538

4

1539

4

},

1540

4

            PrettyConfig::default()

1541

),

1542

4

        Err(Err(SpannedError {

1543

4

            code: Error::InvalidValueForType {

1544

4

                expected: String::from("tuple variant"),

1545

4

                found: String::from("a unit value")

1546

4

},

1547

4

            span: Span {

1548

4

                start: Position { line: 6, col: 1 },

1549

4

                end: Position { line: 6, col: 1 }

1550

4

1551

4

}))

1552

);

1553

4

1554

1555

#[test]

1556

4

fn unit_like_zero_length_inside_flatten_struct_variant() {

1557

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1558

    enum Enum {

1559

        Struct {},

1560

1561

1562

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1563

    struct A {

1564

        hi: Enum,

1565

1566

1567

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1568

    struct B {

1569

        a: A,

1570

1571

1572

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1573

    enum FlattenedStructVariant {

1574

C {

1575

            ho: i32,

1576

            #[serde(flatten)]

1577

            a: B,

1578

},

1579

1580

1581

4

    assert_eq!(

1582

4

        check_roundtrip(

1583

4

            &FlattenedStructVariant::C {

1584

4

                ho: 24,

1585

4

                a: B {

1586

4

                    a: A {

1587

4

                        hi: Enum::Struct {}

1588

4

1589

4

1590

4

},

1591

4

            PrettyConfig::default()

1592

),

1593

4

        Err(Err(SpannedError {

1594

4

            code: Error::InvalidValueForType {

1595

4

                expected: String::from("struct variant"),

1596

4

                found: String::from("a unit value")

1597

4

},

1598

4

            span: Span {

1599

4

                start: Position { line: 6, col: 1 },

1600

4

                end: Position { line: 6, col: 1 }

1601

4

1602

4

}))

1603

);

1604

4

1605

1606

#[test]

1607

4

fn i128_inside_internally_tagged() {

1608

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1609

    struct A {

1610

        hi: i128,

1611

1612

1613

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1614

    #[serde(tag = "tag")]

1615

    enum InternallyTagged {

1616

        B { ho: i32, a: A },

1617

1618

1619

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

1620

2

    assert_eq!(

1621

2

        check_roundtrip(

1622

2

            &InternallyTagged::B {

1623

2

                ho: 24,

1624

2

                a: A { hi: i128::MAX }

1625

2

},

1626

2

            PrettyConfig::default()

1627

),

1628

2

        Err(Ok(Error::Message(String::from("i128 is not supported"))))

1629

);

1630

    #[cfg(feature = "integer128")]

1631

2

    assert_eq!(

1632

2

        check_roundtrip(

1633

2

            &InternallyTagged::B {

1634

2

                ho: 24,

1635

2

                a: A { hi: i128::MAX }

1636

2

},

1637

2

            PrettyConfig::default()

1638

),

1639

2

        Err(Err(SpannedError {

1640

2

            code: Error::InvalidValueForType {

1641

2

                expected: String::from("any value"),

1642

2

                found: format!("integer `{}` as u128", i128::MAX)

1643

2

},

1644

2

            span: Span {

1645

2

                start: Position { line: 5, col: 13 },

1646

2

                end: Position { line: 5, col: 52 }

1647

2

1648

2

}))

1649

);

1650

4

1651

1652

#[test]

1653

4

fn u128_inside_adjacently_tagged() {

1654

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1655

    struct A {

1656

        hi: u128,

1657

1658

1659

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1660

    #[serde(tag = "tag", content = "content")]

1661

    enum AdjacentlyTagged {

1662

        B { ho: i32, a: A },

1663

1664

1665

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

1666

2

    assert_eq!(

1667

2

        check_roundtrip(

1668

2

            &AdjacentlyTagged::B {

1669

2

                ho: 24,

1670

2

                a: A { hi: u128::MAX }

1671

2

},

1672

2

            PrettyConfig::default()

1673

),

1674

2

        Err(Ok(Error::Message(String::from("u128 is not supported"))))

1675

);

1676

    #[cfg(feature = "integer128")]

1677

2

    assert_eq!(

1678

2

        check_roundtrip(

1679

2

            &AdjacentlyTagged::B {

1680

2

                ho: 24,

1681

2

                a: A { hi: u128::MAX }

1682

2

},

1683

2

            PrettyConfig::default()

1684

),

1685

        Ok(()),

1686

);

1687

    #[cfg(feature = "integer128")]

1688

2

    assert_eq!(

1689

2

        ron::from_str::<AdjacentlyTagged>(&format!(

1690

2

            "(tag: B, content: (ho: 24, a: (hi: {})))",

1691

2

            u128::MAX

1692

2

        ),),

1693

        Ok(AdjacentlyTagged::B {

1694

            ho: 24,

1695

            a: A { hi: u128::MAX }

1696

}),

1697

);

1698

    #[cfg(feature = "integer128")]

1699

2

    assert_eq!(

1700

2

        ron::from_str::<AdjacentlyTagged>(&format!(

1701

2

            "(content: (ho: 24, a: (hi: {})), tag: B)",

1702

2

            u128::MAX

1703

2

        ),),

1704

2

        Err(SpannedError {

1705

2

            code: Error::InvalidValueForType {

1706

2

                expected: String::from("any value"),

1707

2

                found: format!("integer `{}` as u128", u128::MAX)

1708

2

},

1709

2

            span: Span {

1710

2

                start: Position { line: 1, col: 28 },

1711

2

                end: Position { line: 1, col: 67 }

1712

2

1713

2

}),

1714

);

1715

4

1716

1717

#[test]

1718

4

fn i128_inside_untagged() {

1719

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1720

    struct A {

1721

        hi: i128,

1722

1723

1724

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1725

    #[serde(untagged)]

1726

    enum Untagged {

1727

        B { ho: i32, a: A },

1728

1729

1730

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

1731

2

    assert_eq!(

1732

2

        check_roundtrip(

1733

2

            &Untagged::B {

1734

2

                ho: 24,

1735

2

                a: A { hi: i128::MIN }

1736

2

},

1737

2

            PrettyConfig::default()

1738

),

1739

2

        Err(Ok(Error::Message(String::from("i128 is not supported"))))

1740

);

1741

    #[cfg(feature = "integer128")]

1742

2

    assert_eq!(

1743

2

        check_roundtrip(

1744

2

            &Untagged::B {

1745

2

                ho: 24,

1746

2

                a: A { hi: i128::MIN }

1747

2

},

1748

2

            PrettyConfig::default()

1749

),

1750

2

        Err(Err(SpannedError {

1751

2

            code: Error::InvalidValueForType {

1752

2

                expected: String::from("any value"),

1753

2

                found: format!("integer `{}` as i128", i128::MIN)

1754

2

},

1755

2

            span: Span {

1756

2

                start: Position { line: 4, col: 14 },

1757

2

                end: Position { line: 4, col: 53 }

1758

2

1759

2

}))

1760

);

1761

4

1762

1763

#[test]

1764

4

fn u128_inside_flatten_struct() {

1765

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1766

    struct A {

1767

        hi: u128,

1768

1769

1770

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1771

    struct B {

1772

        a: A,

1773

1774

1775

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1776

    struct FlattenedStruct {

1777

        ho: i32,

1778

        #[serde(flatten)]

1779

        a: B,

1780

1781

1782

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

1783

2

    assert_eq!(

1784

2

        check_roundtrip(

1785

2

            &FlattenedStruct {

1786

2

                ho: 24,

1787

2

                a: B {

1788

2

                    a: A { hi: u128::MAX }

1789

2

1790

2

},

1791

2

            PrettyConfig::default()

1792

),

1793

2

        Err(Ok(Error::Message(String::from("u128 is not supported"))))

1794

);

1795

    #[cfg(feature = "integer128")]

1796

2

    assert_eq!(

1797

2

        check_roundtrip(

1798

2

            &FlattenedStruct {

1799

2

                ho: 24,

1800

2

                a: B {

1801

2

                    a: A { hi: u128::MAX }

1802

2

1803

2

},

1804

2

            PrettyConfig::default()

1805

),

1806

2

        Err(Err(SpannedError {

1807

2

            code: Error::InvalidValueForType {

1808

2

                expected: String::from("any value"),

1809

2

                found: format!("integer `{}` as u128", u128::MAX)

1810

2

},

1811

2

            span: Span {

1812

2

                start: Position { line: 4, col: 13 },

1813

2

                end: Position { line: 4, col: 52 }

1814

2

1815

2

}))

1816

);

1817

4

1818

1819

#[test]

1820

4

fn i128_inside_flatten_struct_variant() {

1821

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1822

    struct A {

1823

        hi: i128,

1824

1825

1826

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1827

    struct B {

1828

        a: A,

1829

1830

1831

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1832

    enum FlattenedStructVariant {

1833

C {

1834

            ho: i32,

1835

            #[serde(flatten)]

1836

            a: B,

1837

},

1838

1839

1840

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

1841

2

    assert_eq!(

1842

2

        check_roundtrip(

1843

2

            &FlattenedStructVariant::C {

1844

2

                ho: 24,

1845

2

                a: B {

1846

2

                    a: A { hi: i128::MIN }

1847

2

1848

2

},

1849

2

            PrettyConfig::default()

1850

),

1851

2

        Err(Ok(Error::Message(String::from("i128 is not supported"))))

1852

);

1853

    #[cfg(feature = "integer128")]

1854

2

    assert_eq!(

1855

2

        check_roundtrip(

1856

2

            &FlattenedStructVariant::C {

1857

2

                ho: 24,

1858

2

                a: B {

1859

2

                    a: A { hi: i128::MIN }

1860

2

1861

2

},

1862

2

            PrettyConfig::default()

1863

),

1864

2

        Err(Err(SpannedError {

1865

2

            code: Error::InvalidValueForType {

1866

2

                expected: String::from("any value"),

1867

2

                found: format!("integer `{}` as i128", i128::MIN)

1868

2

},

1869

2

            span: Span {

1870

2

                start: Position { line: 4, col: 14 },

1871

2

                end: Position { line: 4, col: 53 }

1872

2

1873

2

}))

1874

);

1875

4

1876

1877

#[test]

1878

4

fn duplicate_key_inside_flatten_struct() {

1879

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1880

    struct FlattenedStruct {

1881

        ho: i32,

1882

        #[serde(flatten)]

1883

        other: HashMap<String, i32>,

1884

1885

1886

4

    assert_eq!(

1887

4

        check_roundtrip(

1888

4

            &FlattenedStruct {

1889

4

                ho: 24,

1890

4

                other: [(String::from("ho"), 42)].into_iter().collect(),

1891

4

},

1892

4

            PrettyConfig::default()

1893

),

1894

        Err(Err(SpannedError {

1895

            code: Error::DuplicateStructField {

1896

                field: "ho",

1897

                outer: None

1898

},

1899

            span: Span {

1900

                start: Position { line: 3, col: 6 },

1901

                end: Position { line: 3, col: 9 }

1902

1903

}))

1904

);

1905

4

1906

1907

#[test]

1908

4

fn duplicate_key_inside_flatten_struct_variant() {

1909

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1910

    struct C {

1911

        ho: i32,

1912

        hi: bool,

1913

1914

1915

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1916

    struct B {

1917

        #[serde(flatten)]

1918

        inner: C,

1919

1920

1921

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1922

    enum FlattenedStructVariant {

1923

A {

1924

            ho: i32,

1925

            #[serde(flatten)]

1926

            inner: B,

1927

},

1928

1929

1930

4

    assert_eq!(

1931

4

        check_roundtrip(

1932

4

            &FlattenedStructVariant::A {

1933

4

                ho: 24,

1934

4

                inner: B {

1935

4

                    inner: C { ho: 42, hi: false }

1936

4

1937

4

},

1938

4

            PrettyConfig::default()

1939

),

1940

4

        Err(Err(SpannedError {

1941

4

            code: Error::DuplicateStructField {

1942

4

                field: "ho",

1943

4

                outer: Some(String::from("A"))

1944

4

},

1945

4

            span: Span {

1946

4

                start: Position { line: 3, col: 6 },

1947

4

                end: Position { line: 3, col: 9 }

1948

4

1949

4

}))

1950

);

1951

4

1952

1953

#[test]

1954

4

fn non_string_key_inside_flatten_struct() {

1955

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1956

    struct FlattenedStruct {

1957

        ho: i32,

1958

        #[serde(flatten)]

1959

        other: HashMap<i32, bool>,

1960

1961

1962

4

    assert_eq!(

1963

4

        check_roundtrip(

1964

4

            &FlattenedStruct {

1965

4

                ho: 24,

1966

4

                other: [(1, true), (0, false)].into_iter().collect(),

1967

4

},

1968

4

            PrettyConfig::default()

1969

),

1970

        Err(Err(SpannedError {

1971

            code: Error::ExpectedString,

1972

            span: Span {

1973

                start: Position { line: 3, col: 5 },

1974

                end: Position { line: 3, col: 5 }

1975

1976

}))

1977

);

1978

4

1979

1980

#[test]

1981

4

fn non_string_key_inside_flatten_struct_variant() {

1982

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

1983

    enum FlattenedStructVariant {

1984

A {

1985

            ho: i32,

1986

            #[serde(flatten)]

1987

            other: HashMap<char, u8>,

1988

},

1989

1990

1991

4

    assert_eq!(

1992

4

        check_roundtrip(

1993

4

            &FlattenedStructVariant::A {

1994

4

                ho: 24,

1995

4

                other: [('h', 0), ('i', 1)].into_iter().collect(),

1996

4

},

1997

4

            PrettyConfig::default()

1998

),

1999

        Err(Err(SpannedError {

2000

            code: Error::ExpectedString,

2001

            span: Span {

2002

                start: Position { line: 3, col: 5 },

2003

                end: Position { line: 3, col: 5 }

2004

2005

}))

2006

);

2007

4

2008

2009

#[test]

2010

4

fn more_than_one_flatten_map_inside_flatten_struct() {

2011

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2012

    struct Deep {

2013

        #[serde(flatten)]

2014

        other: HashMap<String, bool>,

2015

2016

2017

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2018

    struct Inner {

2019

        #[serde(flatten)]

2020

        deep: Deep,

2021

2022

2023

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2024

    struct FlattenedStruct {

2025

        ho: i32,

2026

        #[serde(flatten)]

2027

        hi: Inner,

2028

        #[serde(flatten)]

2029

        other: HashMap<String, bool>,

2030

2031

2032

4

    assert_eq!(

2033

4

        check_roundtrip(

2034

4

            &FlattenedStruct {

2035

4

                ho: 24,

2036

4

                hi: Inner {

2037

4

                    deep: Deep {

2038

4

                        other: HashMap::new(),

2039

4

},

2040

4

},

2041

4

                other: [(String::from("42"), true)].into_iter().collect(),

2042

4

},

2043

4

            PrettyConfig::default()

2044

),

2045

        // both maps collect all the unknown keys

2046

4

        Err(Ok(Error::Message(String::from("ROUNDTRIP error: FlattenedStruct { ho: 24, hi: Inner { deep: Deep { other: {} } }, other: {\"42\": true} } != FlattenedStruct { ho: 24, hi: Inner { deep: Deep { other: {\"42\": true} } }, other: {\"42\": true} }"))))

2047

);

2048

4

2049

2050

#[test]

2051

4

fn more_than_one_flatten_map_inside_flatten_struct_variant() {

2052

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2053

    struct Deep {

2054

        #[serde(flatten)]

2055

        other: HashMap<String, bool>,

2056

2057

2058

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2059

    struct Inner {

2060

        #[serde(flatten)]

2061

        deep: Deep,

2062

2063

2064

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2065

    enum FlattenedStructVariant {

2066

A {

2067

            ho: i32,

2068

            #[serde(flatten)]

2069

            hi: Inner,

2070

            #[serde(flatten)]

2071

            other: HashMap<String, bool>,

2072

},

2073

2074

2075

4

    assert_eq!(

2076

4

        check_roundtrip(

2077

4

            &FlattenedStructVariant::A {

2078

4

                ho: 24,

2079

4

                hi: Inner {

2080

4

                    deep: Deep {

2081

4

                        other: [(String::from("24"), false)].into_iter().collect(),

2082

4

},

2083

4

},

2084

4

                other: HashMap::new(),

2085

4

},

2086

4

            PrettyConfig::default()

2087

),

2088

        // both maps collect all the unknown keys

2089

4

        Err(Ok(Error::Message(String::from("ROUNDTRIP error: A { ho: 24, hi: Inner { deep: Deep { other: {\"24\": false} } }, other: {} } != A { ho: 24, hi: Inner { deep: Deep { other: {\"24\": false} } }, other: {\"24\": false} }"))))

2090

);

2091

4

2092

2093

#[test]

2094

4

fn flatten_struct_beside_map_inside_flatten_struct() {

2095

    // The non-flattened struct must contain some flattened fields

2096

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2097

    struct Flattened {

2098

        hi: i32,

2099

        #[serde(flatten)]

2100

        flat: (),

2101

2102

2103

    // The non-flattened struct must be behind a level of flatten

2104

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2105

    struct Inner {

2106

        flat: Flattened,

2107

2108

2109

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2110

    struct FlattenedStruct {

2111

        ho: i32,

2112

        #[serde(flatten)]

2113

        other: HashMap<String, i32>,

2114

        #[serde(flatten)]

2115

        inner: Inner,

2116

2117

2118

4

    assert_eq!(

2119

4

        check_roundtrip(

2120

4

            &FlattenedStruct {

2121

4

                ho: 24,

2122

4

                other: HashMap::new(),

2123

4

                inner: Inner {

2124

4

                    flat: Flattened { hi: 42, flat: () },

2125

4

},

2126

4

},

2127

4

            PrettyConfig::default()

2128

),

2129

4

        Err(Err(SpannedError {

2130

4

            code: Error::InvalidValueForType {

2131

4

                expected: String::from("i32"),

2132

4

                found: String::from("a map")

2133

4

},

2134

4

            span: Span {

2135

4

                start: Position { line: 6, col: 1 },

2136

4

                end: Position { line: 6, col: 1 }

2137

4

2138

4

}))

2139

);

2140

4

2141

2142

#[test]

2143

4

fn flatten_struct_beside_map_inside_flatten_struct_variant() {

2144

    // The non-flattened struct must contain some flattened fields

2145

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2146

    struct Flattened {

2147

        hi: i32,

2148

        #[serde(flatten)]

2149

        flat: (),

2150

2151

2152

    // The non-flattened struct must be behind a level of flatten

2153

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2154

    struct Inner {

2155

        flat: Flattened,

2156

2157

2158

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2159

    enum FlattenedStructVariant {

2160

A {

2161

            ho: i32,

2162

            #[serde(flatten)]

2163

            other: HashMap<String, i32>,

2164

            #[serde(flatten)]

2165

            inner: Inner,

2166

},

2167

2168

2169

4

    assert_eq!(

2170

4

        check_roundtrip(

2171

4

            &FlattenedStructVariant::A {

2172

4

                ho: 24,

2173

4

                other: HashMap::new(),

2174

4

                inner: Inner {

2175

4

                    flat: Flattened { hi: 42, flat: () },

2176

4

},

2177

4

},

2178

4

            PrettyConfig::default()

2179

),

2180

4

        Err(Err(SpannedError {

2181

4

            code: Error::InvalidValueForType {

2182

4

                expected: String::from("i32"),

2183

4

                found: String::from("a map")

2184

4

},

2185

4

            span: Span {

2186

4

                start: Position { line: 6, col: 1 },

2187

4

                end: Position { line: 6, col: 1 }

2188

4

2189

4

}))

2190

);

2191

4

2192

2193

#[test]

2194

4

fn untagged_flatten_struct_variant_beside_map_inside_flatten_struct() {

2195

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2196

    #[serde(untagged)]

2197

    enum Flattened {

2198

        Struct {

2199

            hi: i32,

2200

            #[serde(flatten)]

2201

            flat: (),

2202

},

2203

2204

2205

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2206

    struct FlattenedStruct {

2207

        ho: i32,

2208

        #[serde(flatten)]

2209

        other: HashMap<String, i32>,

2210

        #[serde(flatten)]

2211

        flat: Flattened,

2212

2213

2214

4

    assert_eq!(

2215

4

        check_roundtrip(

2216

4

            &FlattenedStruct {

2217

4

                ho: 24,

2218

4

                other: HashMap::new(),

2219

4

                flat: Flattened::Struct { hi: 42, flat: () },

2220

4

},

2221

4

            PrettyConfig::default()

2222

),

2223

4

        Err(Ok(Error::Message(String::from("ROUNDTRIP error: FlattenedStruct { ho: 24, other: {}, flat: Struct { hi: 42, flat: () } } != FlattenedStruct { ho: 24, other: {\"hi\": 42}, flat: Struct { hi: 42, flat: () } }"))))

2224

);

2225

4

2226

2227

#[test]

2228

4

fn untagged_flatten_struct_variant_beside_map_inside_flatten_struct_variant() {

2229

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2230

    #[serde(untagged)]

2231

    enum Flattened {

2232

        Struct {

2233

            hi: i32,

2234

            #[serde(flatten)]

2235

            flat: (),

2236

},

2237

2238

2239

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2240

    enum FlattenedStructVariant {

2241

A {

2242

            ho: i32,

2243

            #[serde(flatten)]

2244

            other: HashMap<String, i32>,

2245

            #[serde(flatten)]

2246

            flat: Flattened,

2247

},

2248

2249

2250

4

    assert_eq!(

2251

4

        check_roundtrip(

2252

4

            &FlattenedStructVariant::A {

2253

4

                ho: 24,

2254

4

                other: HashMap::new(),

2255

4

                flat: Flattened::Struct { hi: 42, flat: () },

2256

4

},

2257

4

            PrettyConfig::default()

2258

),

2259

4

        Err(Ok(Error::Message(String::from("ROUNDTRIP error: A { ho: 24, other: {}, flat: Struct { hi: 42, flat: () } } != A { ho: 24, other: {\"hi\": 42}, flat: Struct { hi: 42, flat: () } }"))))

2260

);

2261

4

2262

2263

#[test]

2264

4

fn externally_tagged_newtype_variant_beside_map_inside_flatten_struct_variant() {

2265

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2266

    enum Flattened {

2267

        Newtype(()),

2268

2269

2270

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2271

    enum FlattenedStructVariant {

2272

A {

2273

            ho: i32,

2274

            #[serde(flatten)]

2275

            other: HashMap<String, i32>,

2276

            #[serde(flatten)]

2277

            flat: Flattened,

2278

},

2279

2280

2281

4

    assert_eq!(

2282

4

        check_roundtrip(

2283

4

            &FlattenedStructVariant::A {

2284

4

                ho: 24,

2285

4

                other: HashMap::new(),

2286

4

                flat: Flattened::Newtype(()),

2287

4

},

2288

4

            PrettyConfig::default()

2289

),

2290

4

        Err(Err(SpannedError {

2291

4

            code: Error::InvalidValueForType {

2292

4

                expected: String::from("i32"),

2293

4

                found: String::from("a unit value")

2294

4

},

2295

4

            span: Span {

2296

4

                start: Position { line: 4, col: 1 },

2297

4

                end: Position { line: 4, col: 1 }

2298

4

2299

4

}))

2300

);

2301

4

2302

2303

#[test]

2304

4

fn externally_tagged_struct_variant_beside_map_inside_flatten_struct() {

2305

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2306

    enum Flattened {

2307

        Struct { hi: i32 },

2308

2309

2310

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2311

    struct FlattenedStruct {

2312

        ho: i32,

2313

        #[serde(flatten)]

2314

        other: HashMap<String, i32>,

2315

        #[serde(flatten)]

2316

        flat: Flattened,

2317

2318

2319

4

    assert_eq!(

2320

4

        check_roundtrip(

2321

4

            &FlattenedStruct {

2322

4

                ho: 24,

2323

4

                other: HashMap::new(),

2324

4

                flat: Flattened::Struct { hi: 42 },

2325

4

},

2326

4

            PrettyConfig::default()

2327

),

2328

4

        Err(Err(SpannedError {

2329

4

            code: Error::InvalidValueForType {

2330

4

                expected: String::from("i32"),

2331

4

                found: String::from("a map")

2332

4

},

2333

4

            span: Span {

2334

4

                start: Position { line: 6, col: 1 },

2335

4

                end: Position { line: 6, col: 1 }

2336

4

2337

4

}))

2338

);

2339

4

2340

2341

#[test]

2342

4

fn externally_tagged_tuple_variant_beside_map_inside_flatten_struct_variant() {

2343

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2344

    enum Flattened {

2345

        Tuple(i32, bool),

2346

2347

2348

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2349

    enum FlattenedStructVariant {

2350

A {

2351

            ho: i32,

2352

            #[serde(flatten)]

2353

            other: HashMap<String, i32>,

2354

            #[serde(flatten)]

2355

            flat: Flattened,

2356

},

2357

2358

2359

4

    assert_eq!(

2360

4

        check_roundtrip(

2361

4

            &FlattenedStructVariant::A {

2362

4

                ho: 24,

2363

4

                other: HashMap::new(),

2364

4

                flat: Flattened::Tuple(42, true),

2365

4

},

2366

4

            PrettyConfig::default()

2367

),

2368

4

        Err(Err(SpannedError {

2369

4

            code: Error::InvalidValueForType {

2370

4

                expected: String::from("i32"),

2371

4

                found: String::from("a sequence")

2372

4

},

2373

4

            span: Span {

2374

4

                start: Position { line: 7, col: 1 },

2375

4

                end: Position { line: 7, col: 1 }

2376

4

2377

4

}))

2378

);

2379

4

2380

2381

#[test]

2382

4

fn internally_tagged_unit_variant_beside_map_inside_flatten_struct() {

2383

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2384

    #[serde(tag = "tag")]

2385

    enum Flattened {

2386

        Unit,

2387

2388

2389

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2390

    struct FlattenedStruct {

2391

        ho: i32,

2392

        #[serde(flatten)]

2393

        other: HashMap<String, i32>,

2394

        #[serde(flatten)]

2395

        flat: Flattened,

2396

2397

2398

4

    assert_eq!(

2399

4

        check_roundtrip(

2400

4

            &FlattenedStruct {

2401

4

                ho: 24,

2402

4

                other: HashMap::new(),

2403

4

                flat: Flattened::Unit,

2404

4

},

2405

4

            PrettyConfig::default()

2406

),

2407

4

        Err(Err(SpannedError {

2408

4

            code: Error::InvalidValueForType {

2409

4

                expected: String::from("i32"),

2410

4

                found: String::from("the string \"Unit\"")

2411

4

},

2412

4

            span: Span {

2413

4

                start: Position { line: 4, col: 1 },

2414

4

                end: Position { line: 4, col: 1 }

2415

4

2416

4

}))

2417

);

2418

4

2419

2420

#[test]

2421

4

fn internally_tagged_newtype_variant_beside_map_inside_flatten_struct_variant() {

2422

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2423

    #[serde(tag = "tag")]

2424

    enum Flattened {

2425

        Newtype(()),

2426

2427

2428

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2429

    enum FlattenedStructVariant {

2430

A {

2431

            ho: i32,

2432

            #[serde(flatten)]

2433

            other: HashMap<String, i32>,

2434

            #[serde(flatten)]

2435

            flat: Flattened,

2436

},

2437

2438

2439

4

    assert_eq!(

2440

4

        check_roundtrip(

2441

4

            &FlattenedStructVariant::A {

2442

4

                ho: 24,

2443

4

                other: HashMap::new(),

2444

4

                flat: Flattened::Newtype(()),

2445

4

},

2446

4

            PrettyConfig::default()

2447

),

2448

4

        Err(Err(SpannedError {

2449

4

            code: Error::InvalidValueForType {

2450

4

                expected: String::from("i32"),

2451

4

                found: String::from("the string \"Newtype\"")

2452

4

},

2453

4

            span: Span {

2454

4

                start: Position { line: 4, col: 1 },

2455

4

                end: Position { line: 4, col: 1 }

2456

4

2457

4

}))

2458

);

2459

4

2460

2461

#[test]

2462

4

fn internally_tagged_struct_variant_beside_map_inside_flatten_struct() {

2463

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2464

    #[serde(tag = "tag")]

2465

    enum Flattened {

2466

        Struct { hi: i32 },

2467

2468

2469

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2470

    struct FlattenedStruct {

2471

        ho: i32,

2472

        #[serde(flatten)]

2473

        other: HashMap<String, i32>,

2474

        #[serde(flatten)]

2475

        flat: Flattened,

2476

2477

2478

4

    assert_eq!(

2479

4

        check_roundtrip(

2480

4

            &FlattenedStruct {

2481

4

                ho: 24,

2482

4

                other: HashMap::new(),

2483

4

                flat: Flattened::Struct { hi: 42 },

2484

4

},

2485

4

            PrettyConfig::default()

2486

),

2487

4

        Err(Err(SpannedError {

2488

4

            code: Error::InvalidValueForType {

2489

4

                expected: String::from("i32"),

2490

4

                found: String::from("the string \"Struct\"")

2491

4

},

2492

4

            span: Span {

2493

4

                start: Position { line: 5, col: 1 },

2494

4

                end: Position { line: 5, col: 1 }

2495

4

2496

4

}))

2497

);

2498

4

2499

2500

#[test]

2501

4

fn adjacently_tagged_unit_variant_beside_map_inside_flatten_struct() {

2502

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2503

    #[serde(tag = "tag", content = "content")]

2504

    enum Flattened {

2505

        Unit,

2506

2507

2508

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2509

    struct FlattenedStruct {

2510

        ho: i32,

2511

        #[serde(flatten)]

2512

        other: HashMap<String, i32>,

2513

        #[serde(flatten)]

2514

        flat: Flattened,

2515

2516

2517

4

    assert_eq!(

2518

4

        check_roundtrip(

2519

4

            &FlattenedStruct {

2520

4

                ho: 24,

2521

4

                other: HashMap::new(),

2522

4

                flat: Flattened::Unit,

2523

4

},

2524

4

            PrettyConfig::default()

2525

),

2526

4

        Err(Err(SpannedError {

2527

4

            code: Error::InvalidValueForType {

2528

4

                expected: String::from("i32"),

2529

4

                found: String::from("the string \"Unit\"")

2530

4

},

2531

4

            span: Span {

2532

4

                start: Position { line: 4, col: 1 },

2533

4

                end: Position { line: 4, col: 1 }

2534

4

2535

4

}))

2536

);

2537

4

2538

2539

#[test]

2540

4

fn adjacently_tagged_newtype_variant_beside_map_inside_flatten_struct_variant() {

2541

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2542

    #[serde(tag = "tag", content = "content")]

2543

    enum Flattened {

2544

        Newtype(()),

2545

2546

2547

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2548

    enum FlattenedStructVariant {

2549

A {

2550

            ho: i32,

2551

            #[serde(flatten)]

2552

            other: HashMap<String, i32>,

2553

            #[serde(flatten)]

2554

            flat: Flattened,

2555

},

2556

2557

2558

4

    assert_eq!(

2559

4

        check_roundtrip(

2560

4

            &FlattenedStructVariant::A {

2561

4

                ho: 24,

2562

4

                other: HashMap::new(),

2563

4

                flat: Flattened::Newtype(()),

2564

4

},

2565

4

            PrettyConfig::default()

2566

),

2567

4

        Err(Err(SpannedError {

2568

4

            code: Error::InvalidValueForType {

2569

4

                expected: String::from("i32"),

2570

4

                found: String::from("the string \"Newtype\"")

2571

4

},

2572

4

            span: Span {

2573

4

                start: Position { line: 5, col: 1 },

2574

4

                end: Position { line: 5, col: 1 }

2575

4

2576

4

}))

2577

);

2578

4

2579

2580

#[test]

2581

4

fn adjacently_tagged_struct_variant_beside_map_inside_flatten_struct() {

2582

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2583

    #[serde(tag = "tag", content = "content")]

2584

    enum Flattened {

2585

        Struct { hi: i32 },

2586

2587

2588

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2589

    struct FlattenedStruct {

2590

        ho: i32,

2591

        #[serde(flatten)]

2592

        other: HashMap<String, i32>,

2593

        #[serde(flatten)]

2594

        flat: Flattened,

2595

2596

2597

4

    assert_eq!(

2598

4

        check_roundtrip(

2599

4

            &FlattenedStruct {

2600

4

                ho: 24,

2601

4

                other: HashMap::new(),

2602

4

                flat: Flattened::Struct { hi: 42 },

2603

4

},

2604

4

            PrettyConfig::default()

2605

),

2606

4

        Err(Err(SpannedError {

2607

4

            code: Error::InvalidValueForType {

2608

4

                expected: String::from("i32"),

2609

4

                found: String::from("the string \"Struct\"")

2610

4

},

2611

4

            span: Span {

2612

4

                start: Position { line: 7, col: 1 },

2613

4

                end: Position { line: 7, col: 1 }

2614

4

2615

4

}))

2616

);

2617

4

2618

2619

#[test]

2620

4

fn adjacently_tagged_tuple_variant_beside_map_inside_flatten_struct_variant() {

2621

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2622

    #[serde(tag = "tag", content = "content")]

2623

    enum Flattened {

2624

        Tuple(i32, bool),

2625

2626

2627

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2628

    enum FlattenedStructVariant {

2629

A {

2630

            ho: i32,

2631

            #[serde(flatten)]

2632

            other: HashMap<String, i32>,

2633

            #[serde(flatten)]

2634

            flat: Flattened,

2635

},

2636

2637

2638

4

    assert_eq!(

2639

4

        check_roundtrip(

2640

4

            &FlattenedStructVariant::A {

2641

4

                ho: 24,

2642

4

                other: HashMap::new(),

2643

4

                flat: Flattened::Tuple(42, true),

2644

4

},

2645

4

            PrettyConfig::default()

2646

),

2647

4

        Err(Err(SpannedError {

2648

4

            code: Error::InvalidValueForType {

2649

4

                expected: String::from("i32"),

2650

4

                found: String::from("the string \"Tuple\"")

2651

4

},

2652

4

            span: Span {

2653

4

                start: Position { line: 5, col: 1 },

2654

4

                end: Position { line: 5, col: 1 }

2655

4

2656

4

}))

2657

);

2658

4

2659

2660

#[test]

2661

4

fn tagged_struct_beside_map_inside_flatten_struct() {

2662

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2663

    #[serde(tag = "tag")]

2664

    struct Flattened {

2665

        hi: i32,

2666

2667

2668

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2669

    struct FlattenedStruct {

2670

        ho: i32,

2671

        #[serde(flatten)]

2672

        other: HashMap<String, i32>,

2673

        #[serde(flatten)]

2674

        flat: Flattened,

2675

2676

2677

4

    assert_eq!(

2678

4

        check_roundtrip(

2679

4

            &FlattenedStruct {

2680

4

                ho: 24,

2681

4

                other: HashMap::new(),

2682

4

                flat: Flattened { hi: 42 },

2683

4

},

2684

4

            PrettyConfig::default()

2685

),

2686

4

        Err(Err(SpannedError {

2687

4

            code: Error::InvalidValueForType {

2688

4

                expected: String::from("i32"),

2689

4

                found: String::from("the string \"Flattened\"")

2690

4

},

2691

4

            span: Span {

2692

4

                start: Position { line: 5, col: 1 },

2693

4

                end: Position { line: 5, col: 1 }

2694

4

2695

4

}))

2696

);

2697

4

2698

2699

#[test]

2700

4

fn tagged_struct_beside_map_inside_flatten_struct_variant() {

2701

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2702

    #[serde(tag = "tag")]

2703

    struct Flattened {

2704

        hi: i32,

2705

2706

2707

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2708

    enum FlattenedStructVariant {

2709

A {

2710

            ho: i32,

2711

            #[serde(flatten)]

2712

            other: HashMap<String, i32>,

2713

            #[serde(flatten)]

2714

            flat: Flattened,

2715

},

2716

2717

2718

4

    assert_eq!(

2719

4

        check_roundtrip(

2720

4

            &FlattenedStructVariant::A {

2721

4

                ho: 24,

2722

4

                other: HashMap::new(),

2723

4

                flat: Flattened { hi: 42 },

2724

4

},

2725

4

            PrettyConfig::default()

2726

),

2727

4

        Err(Err(SpannedError {

2728

4

            code: Error::InvalidValueForType {

2729

4

                expected: String::from("i32"),

2730

4

                found: String::from("the string \"Flattened\"")

2731

4

},

2732

4

            span: Span {

2733

4

                start: Position { line: 5, col: 1 },

2734

4

                end: Position { line: 5, col: 1 }

2735

4

2736

4

}))

2737

);

2738

4

2739

2740

#[test]

2741

4

fn zero_length_untagged_tuple_variant() {

2742

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2743

    #[serde(untagged)]

2744

    enum Untagged {

2745

        A(),

2746

2747

2748

4

    assert_eq!(

2749

4

        check_roundtrip(&Untagged::A(), PrettyConfig::default()),

2750

4

        Err(Err(SpannedError {

2751

4

            code: Error::Message(String::from(

2752

4

                "data did not match any variant of untagged enum Untagged"

2753

4

)),

2754

4

            span: Span {

2755

4

                start: Position { line: 1, col: 1 },

2756

4

                end: Position { line: 1, col: 3 }

2757

4

2758

4

}))

2759

);

2760

4

2761

2762

#[test]

2763

4

fn zero_length_untagged_struct_variant() {

2764

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2765

    #[serde(untagged)]

2766

    enum Untagged {

2767

        A {},

2768

2769

2770

4

    assert_eq!(

2771

4

        check_roundtrip(&Untagged::A {}, PrettyConfig::default()),

2772

4

        Err(Err(SpannedError {

2773

4

            code: Error::Message(String::from(

2774

4

                "data did not match any variant of untagged enum Untagged"

2775

4

)),

2776

4

            span: Span {

2777

4

                start: Position { line: 1, col: 1 },

2778

4

                end: Position { line: 1, col: 3 }

2779

4

2780

4

}))

2781

);

2782

4

2783

2784

#[test]

2785

4

fn unwrapped_one_element_untagged_tuple_variant() {

2786

    // A tuple variant with just one element that is not a newtype variant

2787

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2788

    #[serde(untagged)]

2789

    enum Untagged {

2790

        OneTuple(i32, #[serde(skip)] ()),

2791

2792

2793

4

    assert_eq!(

2794

4

        check_roundtrip(&Untagged::OneTuple(42, ()), PrettyConfig::default()),

2795

        Ok(())

2796

);

2797

4

    assert_eq!(

2798

4

        check_roundtrip(

2799

4

            &Untagged::OneTuple(42, ()),

2800

4

            PrettyConfig::default().extensions(Extensions::UNWRAP_VARIANT_NEWTYPES)

2801

),

2802

        Ok(())

2803

);

2804

4

2805

2806

#[test]

2807

4

fn unit_inside_untagged_newtype_variant_inside_internally_tagged_newtype_variant() {

2808

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2809

    #[serde(untagged)]

2810

    enum Untagged {

2811

        Newtype(()),

2812

2813

2814

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2815

    #[serde(tag = "tag")]

2816

    enum InternallyTagged {

2817

        Newtype(Untagged),

2818

2819

2820

4

    assert_eq!(

2821

4

        check_roundtrip(

2822

4

            &InternallyTagged::Newtype(Untagged::Newtype(())),

2823

4

            PrettyConfig::default()

2824

),

2825

4

        Err(Err(SpannedError {

2826

4

            code: Error::Message(String::from(

2827

4

                "data did not match any variant of untagged enum Untagged"

2828

4

)),

2829

4

            span: Span {

2830

4

                start: Position { line: 3, col: 1 },

2831

4

                end: Position { line: 3, col: 2 }

2832

4

2833

4

}))

2834

);

2835

4

2836

2837

#[test]

2838

4

fn unit_inside_untagged_newtype_variant_inside_flatten_struct() {

2839

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2840

    #[serde(untagged)]

2841

    enum Untagged {

2842

        Newtype(()),

2843

2844

2845

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2846

    struct FlattenedStruct {

2847

        ho: i32,

2848

        #[serde(flatten)]

2849

        a: Untagged,

2850

2851

2852

4

    assert_eq!(

2853

4

        check_roundtrip(

2854

4

            &FlattenedStruct {

2855

4

                ho: 24,

2856

4

                a: Untagged::Newtype(()),

2857

4

},

2858

4

            PrettyConfig::default()

2859

),

2860

4

        Err(Err(SpannedError {

2861

4

            code: Error::Message(String::from(

2862

4

                "data did not match any variant of untagged enum Untagged"

2863

4

)),

2864

4

            span: Span {

2865

4

                start: Position { line: 3, col: 1 },

2866

4

                end: Position { line: 3, col: 1 }

2867

4

2868

4

}))

2869

);

2870

4

2871

2872

#[test]

2873

4

fn unit_struct_inside_untagged_newtype_variant_inside_internally_tagged_newtype_variant() {

2874

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2875

    struct Unit;

2876

2877

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2878

    #[serde(untagged)]

2879

    enum Untagged {

2880

        Newtype(Unit),

2881

2882

2883

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2884

    #[serde(tag = "tag")]

2885

    enum InternallyTagged {

2886

        Newtype(Untagged),

2887

2888

2889

4

    assert_eq!(

2890

4

        check_roundtrip(

2891

4

            &InternallyTagged::Newtype(Untagged::Newtype(Unit)),

2892

4

            PrettyConfig::default()

2893

),

2894

4

        Err(Err(SpannedError {

2895

4

            code: Error::Message(String::from(

2896

4

                "data did not match any variant of untagged enum Untagged"

2897

4

)),

2898

4

            span: Span {

2899

4

                start: Position { line: 3, col: 1 },

2900

4

                end: Position { line: 3, col: 2 }

2901

4

2902

4

}))

2903

);

2904

4

2905

2906

#[test]

2907

4

fn untagged_unit_variant_inside_internally_tagged_newtype_variant() {

2908

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2909

    #[serde(untagged)]

2910

    enum Untagged {

2911

        Unit,

2912

2913

2914

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2915

    enum FlattenedStructVariant {

2916

C {

2917

            ho: i32,

2918

            #[serde(flatten)]

2919

            a: Untagged,

2920

},

2921

2922

2923

4

    assert_eq!(

2924

4

        check_roundtrip(

2925

4

            &FlattenedStructVariant::C {

2926

4

                ho: 24,

2927

4

                a: Untagged::Unit,

2928

4

},

2929

4

            PrettyConfig::default()

2930

),

2931

4

        Err(Err(SpannedError {

2932

4

            code: Error::Message(String::from(

2933

4

                "data did not match any variant of untagged enum Untagged"

2934

4

)),

2935

4

            span: Span {

2936

4

                start: Position { line: 3, col: 1 },

2937

4

                end: Position { line: 3, col: 1 }

2938

4

2939

4

}))

2940

);

2941

4

2942

2943

#[test]

2944

4

fn untagged_unit_variant_inside_flatten_struct_variant() {

2945

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2946

    enum Enum {

2947

        Unit,

2948

2949

2950

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2951

    #[serde(untagged)]

2952

    enum Untagged {

2953

        Unit,

2954

        Newtype(Enum),

2955

2956

2957

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2958

    #[serde(tag = "tag")]

2959

    enum InternallyTagged {

2960

        Newtype(Untagged),

2961

2962

2963

4

    assert_eq!(

2964

4

        check_roundtrip(

2965

4

            &InternallyTagged::Newtype(Untagged::Newtype(Enum::Unit)),

2966

4

            PrettyConfig::default()

2967

),

2968

        Ok(())

2969

);

2970

4

    assert_eq!(

2971

4

        check_roundtrip(

2972

4

            &InternallyTagged::Newtype(Untagged::Unit),

2973

4

            PrettyConfig::default()

2974

),

2975

4

        Err(Err(SpannedError {

2976

4

            code: Error::Message(String::from(

2977

4

                "data did not match any variant of untagged enum Untagged"

2978

4

)),

2979

4

            span: Span {

2980

4

                start: Position { line: 3, col: 1 },

2981

4

                end: Position { line: 3, col: 2 }

2982

4

2983

4

}))

2984

);

2985

4

2986

2987

#[test]

2988

4

fn unit_inside_internally_tagged_newtype_variant_inside_multi_flatten_struct() {

2989

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2990

    struct AnotherFlattenedStruct {

2991

        hi: i32,

2992

2993

2994

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

2995

    #[serde(tag = "tag")]

2996

    enum InternallyTagged {

2997

        Newtype(()),

2998

2999

3000

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3001

    struct FlattenedStruct {

3002

        ho: i32,

3003

        #[serde(flatten)]

3004

        a: InternallyTagged,

3005

        #[serde(flatten)]

3006

        b: AnotherFlattenedStruct,

3007

3008

3009

4

    assert_eq!(

3010

4

        check_roundtrip(

3011

4

            &FlattenedStruct {

3012

4

                ho: 24,

3013

4

                a: InternallyTagged::Newtype(()),

3014

4

                b: AnotherFlattenedStruct { hi: 42 },

3015

4

},

3016

4

            PrettyConfig::default()

3017

),

3018

4

        Err(Err(SpannedError {

3019

4

            code: Error::InvalidValueForType {

3020

4

                expected: String::from("unit"),

3021

4

                found: String::from("a map")

3022

4

},

3023

4

            span: Span {

3024

4

                start: Position { line: 5, col: 1 },

3025

4

                end: Position { line: 5, col: 1 }

3026

4

3027

4

}))

3028

);

3029

4

3030

3031

#[test]

3032

4

fn untagged_unit_variant_inside_internally_tagged_newtype_variant_inside_multi_flatten_struct() {

3033

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3034

    #[serde(untagged)]

3035

    enum Untagged {

3036

        Unit,

3037

3038

3039

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3040

    struct AnotherFlattenedStruct {

3041

        hi: i32,

3042

3043

3044

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3045

    #[serde(tag = "tag")]

3046

    enum InternallyTagged {

3047

        Newtype(Untagged),

3048

3049

3050

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3051

    struct FlattenedStruct {

3052

        ho: i32,

3053

        #[serde(flatten)]

3054

        a: InternallyTagged,

3055

        #[serde(flatten)]

3056

        b: AnotherFlattenedStruct,

3057

3058

3059

4

    assert_eq!(

3060

4

        check_roundtrip(

3061

4

            &FlattenedStruct {

3062

4

                ho: 24,

3063

4

                a: InternallyTagged::Newtype(Untagged::Unit),

3064

4

                b: AnotherFlattenedStruct { hi: 42 },

3065

4

},

3066

4

            PrettyConfig::default()

3067

),

3068

4

        Err(Err(SpannedError {

3069

4

            code: Error::Message(String::from(

3070

4

                "data did not match any variant of untagged enum Untagged"

3071

4

)),

3072

4

            span: Span {

3073

4

                start: Position { line: 5, col: 1 },

3074

4

                end: Position { line: 5, col: 1 }

3075

4

3076

4

}))

3077

);

3078

4

3079

3080

#[test]

3081

4

fn flattened_externally_tagged_newtype_variant_beside_flattened_intenally_tagged_enum() {

3082

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3083

    enum ExternallyTagged {

3084

        Newtype(()),

3085

        Other(()),

3086

3087

3088

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3089

    #[serde(tag = "tag")]

3090

    enum InternallyTagged {

3091

        Newtype(ExternallyTagged),

3092

3093

3094

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3095

    struct Flattened {

3096

        #[serde(flatten)]

3097

        a: InternallyTagged,

3098

        #[serde(flatten)]

3099

        b: ExternallyTagged,

3100

3101

3102

4

    assert_eq!(

3103

4

        check_roundtrip(

3104

4

            &Flattened {

3105

4

                a: InternallyTagged::Newtype(ExternallyTagged::Other(())),

3106

4

                b: ExternallyTagged::Newtype(()),

3107

4

},

3108

4

            PrettyConfig::default()

3109

),

3110

4

        Err(Err(SpannedError {

3111

4

            code: Error::InvalidValueForType {

3112

4

                expected: String::from("map with a single key"),

3113

4

                found: String::from("a map"),

3114

4

},

3115

4

            span: Span {

3116

4

                start: Position { line: 5, col: 1 },

3117

4

                end: Position { line: 5, col: 1 }

3118

4

3119

4

}))

3120

);

3121

4

3122

3123

#[test]

3124

4

fn flattened_externally_tagged_struct_variant_beside_flattened_intenally_tagged_enum() {

3125

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3126

    enum ExternallyTagged {

3127

        Struct { a: i32 },

3128

        Other(()),

3129

3130

3131

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3132

    #[serde(tag = "tag")]

3133

    enum InternallyTagged {

3134

        Newtype(ExternallyTagged),

3135

3136

3137

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3138

    struct Flattened {

3139

        #[serde(flatten)]

3140

        a: InternallyTagged,

3141

        #[serde(flatten)]

3142

        b: ExternallyTagged,

3143

3144

3145

4

    assert_eq!(

3146

4

        check_roundtrip(

3147

4

            &Flattened {

3148

4

                a: InternallyTagged::Newtype(ExternallyTagged::Other(())),

3149

4

                b: ExternallyTagged::Struct { a: 42 },

3150

4

},

3151

4

            PrettyConfig::default()

3152

),

3153

4

        Err(Err(SpannedError {

3154

4

            code: Error::InvalidValueForType {

3155

4

                expected: String::from("map with a single key"),

3156

4

                found: String::from("a map"),

3157

4

},

3158

4

            span: Span {

3159

4

                start: Position { line: 7, col: 1 },

3160

4

                end: Position { line: 7, col: 1 }

3161

4

3162

4

}))

3163

);

3164

4

3165

3166

#[test]

3167

4

fn flattened_map_inside_option_beside_flattened_struct_variant() {

3168

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3169

    #[serde(untagged)]

3170

    enum Untagged {

3171

        Struct { a: i32 },

3172

3173

3174

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3175

    struct Flattened {

3176

        #[serde(flatten)]

3177

        a: Untagged,

3178

        #[serde(flatten)]

3179

        b: Option<BTreeMap<String, i32>>,

3180

3181

3182

4

    assert_eq!(

3183

4

        check_roundtrip(

3184

4

            &Flattened {

3185

4

                a: Untagged::Struct {

3186

4

                    a: 42,

3187

4

},

3188

4

                b: Some([(String::from("b"), 24)].into_iter().collect()),

3189

4

},

3190

4

            PrettyConfig::default()

3191

),

3192

4

        Err(Ok(Error::Message(String::from("ROUNDTRIP error: Flattened { a: Struct { a: 42 }, b: Some({\"b\": 24}) } != Flattened { a: Struct { a: 42 }, b: Some({\"a\": 42, \"b\": 24}) }"))))

3193

);

3194

4

3195

3196

#[test]

3197

4

fn flattened_untagged_struct_beside_flattened_untagged_struct() {

3198

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3199

    #[serde(untagged)]

3200

    enum Untagged {

3201

        Struct { a: i32 },

3202

        Other { b: i32 },

3203

3204

3205

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3206

    struct Flattened {

3207

        #[serde(flatten)]

3208

        a: Untagged,

3209

        #[serde(flatten)]

3210

        b: Untagged,

3211

3212

3213

4

    assert_eq!(

3214

4

        check_roundtrip(

3215

4

            &Flattened {

3216

4

                a: Untagged::Struct {

3217

4

                    a: 42,

3218

4

},

3219

4

                b: Untagged::Other {

3220

4

                    b: 24,

3221

4

},

3222

4

},

3223

4

            PrettyConfig::default()

3224

),

3225

4

        Err(Ok(Error::Message(String::from("ROUNDTRIP error: Flattened { a: Struct { a: 42 }, b: Other { b: 24 } } != Flattened { a: Struct { a: 42 }, b: Struct { a: 42 } }"))))

3226

);

3227

4

3228

3229

#[test]

3230

4

fn flattened_field_inside_flattened_struct_alongside_map() {

3231

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3232

    struct Units {

3233

        a: i32,

3234

        #[serde(flatten)]

3235

        b: (),

3236

3237

3238

    #[derive(PartialEq, Debug, Serialize, Deserialize)]

3239

    struct Flattened {

3240

        #[serde(flatten)]

3241

        a: Units,

3242

        #[serde(flatten)]

3243

        b: BTreeMap<String, i32>,

3244

3245

3246

4

    assert_eq!(

3247

4

        check_roundtrip(

3248

4

            &Flattened {

3249

4

                a: Units {

3250

4

                    a: 42,

3251

4

                    b: (),

3252

4

},

3253

4

                b: [(String::from("c"), 24)].into_iter().collect(),

3254

4

},

3255

4

            PrettyConfig::default()

3256

),

3257

4

        Err(Ok(Error::Message(String::from("ROUNDTRIP error: Flattened { a: Units { a: 42, b: () }, b: {\"c\": 24} } != Flattened { a: Units { a: 42, b: () }, b: {\"a\": 42, \"c\": 24} }"))))

3258

);

3259

4

3260

3261

376

fn check_roundtrip<T: PartialEq + core::fmt::Debug + Serialize + serde::de::DeserializeOwned>(

3262

376

    val: &T,

3263

376

    config: PrettyConfig,

3264

376

) -> Result<(), Result<Error, SpannedError>> {

3265

376

    let ron = ron::ser::to_string_pretty(val, config).map_err(|err| Ok(err))?;

3266

366

    println!("{ron}");

3267

366

    let de = ron::from_str(&ron).map_err(|err| Err(err))?;

3268

142

    if val == &de {

3269

94

        Ok(())

3270

    } else {

3271

48

        Err(Ok(Error::Message(format!(

3272

48

            "ROUNDTRIP error: {:?} != {:?}",

3273

48

            val, de

3274

48

        ))))

3275

3276

376