Grcov report - 502_known

1

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

2

3

use ron::{error::Position, error::SpannedError, extensions::Extensions, ser::PrettyConfig, Error};

4

use serde::{Deserialize, Serialize};

5

6

#[test]

7

4

fn struct_names_inside_internally_tagged() {

8

16

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

9

    struct A {

10

        hi: i32,

11

12

13

32

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

14

    #[serde(tag = "tag")]

15

    enum InternallyTagged {

16

        B { ho: i32, a: A },

17

18

19

4

    assert_eq!(

20

4

        check_roundtrip(

21

4

            &InternallyTagged::B {

22

4

                ho: 24,

23

4

                a: A { hi: 42 }

24

4

},

25

4

            PrettyConfig::default()

26

4

),

27

4

        Ok(())

28

4

);

29

4

    assert_eq!(

30

4

        check_roundtrip(

31

4

            &InternallyTagged::B {

32

4

                ho: 24,

33

4

                a: A { hi: 42 }

34

4

},

35

4

            PrettyConfig::default().struct_names(true)

36

4

),

37

4

        Err(Err(SpannedError {

38

4

            code: Error::MissingStructField {

39

4

                field: "hi",

40

4

                outer: None

41

4

},

42

4

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

43

4

        })),

44

4

);

45

4

46

47

#[test]

48

4

fn struct_names_inside_adjacently_tagged() {

49

24

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

50

    struct A {

51

        hi: i32,

52

53

54

88

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

55

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

56

    enum AdjacentlyTagged {

57

        B { ho: i32, a: A },

58

59

60

4

    assert_eq!(

61

4

        check_roundtrip(

62

4

            &AdjacentlyTagged::B {

63

4

                ho: 24,

64

4

                a: A { hi: 42 }

65

4

},

66

4

            PrettyConfig::default()

67

4

),

68

4

        Ok(())

69

4

);

70

4

    assert_eq!(

71

4

        check_roundtrip(

72

4

            &AdjacentlyTagged::B {

73

4

                ho: 24,

74

4

                a: A { hi: 42 }

75

4

},

76

4

            PrettyConfig::default().struct_names(true)

77

4

),

78

4

        Ok(()),

79

4

);

80

4

    assert_eq!(

81

4

        ron::from_str::<AdjacentlyTagged>(

82

4

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

83

4

),

84

4

        Ok(AdjacentlyTagged::B {

85

4

            ho: 24,

86

4

            a: A { hi: 42 }

87

4

}),

88

4

);

89

4

    assert_eq!(

90

4

        ron::from_str::<AdjacentlyTagged>(

91

4

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

92

4

),

93

4

        Err(SpannedError {

94

4

            code: Error::MissingStructField {

95

4

                field: "ho",

96

4

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

97

4

},

98

4

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

99

4

}),

100

4

);

101

4

102

103

#[test]

104

4

fn struct_names_inside_untagged() {

105

8

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

106

    struct A {

107

        hi: i32,

108

109

110

20

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

111

    #[serde(untagged)]

112

    enum Untagged {

113

        B { ho: i32, a: A },

114

115

116

4

    assert_eq!(

117

4

        check_roundtrip(

118

4

            &Untagged::B {

119

4

                ho: 24,

120

4

                a: A { hi: 42 }

121

4

},

122

4

            PrettyConfig::default()

123

4

),

124

4

        Ok(())

125

4

);

126

4

    assert_eq!(

127

4

        check_roundtrip(

128

4

            &Untagged::B {

129

4

                ho: 24,

130

4

                a: A { hi: 42 }

131

4

},

132

4

            PrettyConfig::default().struct_names(true)

133

4

),

134

4

        Err(Err(SpannedError {

135

4

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

136

4

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

137

4

)),

138

4

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

139

4

        })),

140

4

);

141

4

142

143

#[test]

144

4

fn struct_names_inside_flatten_struct() {

145

16

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

146

    struct A {

147

        hi: i32,

148

149

150

20

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

151

    struct B {

152

        a: A,

153

154

155

24

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

156

    struct FlattenedStruct {

157

        ho: i32,

158

        #[serde(flatten)]

159

        a: B,

160

161

162

4

    assert_eq!(

163

4

        check_roundtrip(

164

4

            &FlattenedStruct {

165

4

                ho: 24,

166

4

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

167

4

},

168

4

            PrettyConfig::default()

169

4

),

170

4

        Ok(())

171

4

);

172

4

    assert_eq!(

173

4

        check_roundtrip(

174

4

            &FlattenedStruct {

175

4

                ho: 24,

176

4

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

177

4

},

178

4

            PrettyConfig::default().struct_names(true)

179

4

),

180

4

        Err(Err(SpannedError {

181

4

            code: Error::MissingStructField {

182

4

                field: "hi",

183

4

                outer: None

184

4

},

185

4

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

186

4

        })),

187

4

);

188

4

189

190

#[test]

191

4

fn struct_names_inside_flatten_struct_variant() {

192

16

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

193

    struct A {

194

        hi: i32,

195

196

197

20

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

198

    struct B {

199

        a: A,

200

201

202

40

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

203

    enum FlattenedStructVariant {

204

C {

205

            ho: i32,

206

            #[serde(flatten)]

207

            a: B,

208

},

209

210

211

4

    assert_eq!(

212

4

        check_roundtrip(

213

4

            &FlattenedStructVariant::C {

214

4

                ho: 24,

215

4

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

216

4

},

217

4

            PrettyConfig::default()

218

4

),

219

4

        Ok(())

220

4

);

221

4

    assert_eq!(

222

4

        check_roundtrip(

223

4

            &FlattenedStructVariant::C {

224

4

                ho: 24,

225

4

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

226

4

},

227

4

            PrettyConfig::default().struct_names(true)

228

4

),

229

4

        Err(Err(SpannedError {

230

4

            code: Error::MissingStructField {

231

4

                field: "hi",

232

4

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

233

4

},

234

4

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

235

4

        })),

236

4

);

237

4

238

239

#[test]

240

4

fn implicit_some_inside_internally_tagged() {

241

16

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

242

    struct A {

243

        hi: Option<Option<()>>,

244

245

246

32

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

247

    #[serde(tag = "tag")]

248

    enum InternallyTagged {

249

        B { ho: i32, a: A },

250

251

252

4

    assert_eq!(

253

4

        check_roundtrip(

254

4

            &InternallyTagged::B {

255

4

                ho: 24,

256

4

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

257

4

},

258

4

            PrettyConfig::default()

259

4

),

260

4

        Ok(())

261

4

);

262

4

    assert_eq!(

263

4

        check_roundtrip(

264

4

            &InternallyTagged::B {

265

4

                ho: 24,

266

4

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

267

4

},

268

4

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

269

4

),

270

4

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

271

4

);

272

4

273

274

#[test]

275

4

fn implicit_some_inside_adjacently_tagged() {

276

12

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

277

    struct Unit;

278

279

32

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

280

    struct A {

281

        hi: Option<Option<Unit>>,

282

283

284

92

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

285

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

286

    enum AdjacentlyTagged {

287

        B { ho: i32, a: A },

288

289

290

4

    assert_eq!(

291

4

        check_roundtrip(

292

4

            &AdjacentlyTagged::B {

293

4

                ho: 24,

294

4

                a: A {

295

4

                    hi: Some(Some(Unit))

296

4

297

4

},

298

4

            PrettyConfig::default()

299

4

),

300

4

        Ok(())

301

4

);

302

4

    assert_eq!(

303

4

        check_roundtrip(

304

4

            &AdjacentlyTagged::B {

305

4

                ho: 24,

306

4

                a: A {

307

4

                    hi: Some(Some(Unit))

308

4

309

4

},

310

4

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

311

4

),

312

4

        Ok(()),

313

4

);

314

4

    assert_eq!(

315

4

        ron::from_str::<AdjacentlyTagged>(

316

4

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

317

4

),

318

4

        Ok(AdjacentlyTagged::B {

319

4

            ho: 24,

320

4

            a: A {

321

4

                hi: Some(Some(Unit))

322

4

323

4

}),

324

4

);

325

4

    assert_eq!(

326

4

        ron::from_str::<AdjacentlyTagged>(

327

4

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

328

4

),

329

4

        Ok(AdjacentlyTagged::B {

330

4

            ho: 24,

331

4

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

332

4

}),

333

4

);

334

4

335

336

#[test]

337

4

fn implicit_some_inside_untagged() {

338

16

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

339

    struct A {

340

        hi: Option<Option<()>>,

341

342

343

24

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

344

    #[serde(untagged)]

345

    enum Untagged {

346

        B { ho: i32, a: A },

347

348

349

4

    assert_eq!(

350

4

        check_roundtrip(

351

4

            &Untagged::B {

352

4

                ho: 24,

353

4

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

354

4

},

355

4

            PrettyConfig::default()

356

4

),

357

4

        Ok(())

358

4

);

359

4

    assert_eq!(

360

4

        check_roundtrip(

361

4

            &Untagged::B {

362

4

                ho: 24,

363

4

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

364

4

},

365

4

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

366

4

),

367

4

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

368

4

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

369

4

        )))),

370

4

);

371

4

372

373

#[test]

374

4

fn implicit_some_inside_flatten_struct() {

375

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

376

    #[serde(untagged)]

377

    enum Untagged {

378

        Unit,

379

380

381

16

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

382

    struct A {

383

        hi: Option<Option<Untagged>>,

384

385

386

16

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

387

    struct B {

388

        a: A,

389

390

391

24

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

392

    struct FlattenedStruct {

393

        ho: i32,

394

        #[serde(flatten)]

395

        a: B,

396

397

398

4

    assert_eq!(

399

4

        check_roundtrip(

400

4

            &FlattenedStruct {

401

4

                ho: 24,

402

4

                a: B {

403

4

                    a: A {

404

4

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

405

4

406

4

407

4

},

408

4

            PrettyConfig::default()

409

4

),

410

4

        Ok(())

411

4

);

412

4

    assert_eq!(

413

4

        check_roundtrip(

414

4

            &FlattenedStruct {

415

4

                ho: 24,

416

4

                a: B {

417

4

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

418

4

419

4

},

420

4

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

421

4

),

422

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 } } }"))))

423

4

);

424

4

425

426

#[test]

427

4

fn implicit_some_inside_flatten_struct_variant() {

428

20

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

429

    struct A {

430

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

431

432

433

20

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

434

    struct B {

435

        a: A,

436

437

438

40

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

439

    enum FlattenedStructVariant {

440

C {

441

            ho: i32,

442

            #[serde(flatten)]

443

            a: B,

444

},

445

446

447

4

    assert_eq!(

448

4

        check_roundtrip(

449

4

            &FlattenedStructVariant::C {

450

4

                ho: 24,

451

4

                a: B {

452

4

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

453

4

454

4

},

455

4

            PrettyConfig::default()

456

4

),

457

4

        Err(Err(SpannedError {

458

4

            code: Error::InvalidValueForType {

459

4

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

460

4

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

461

4

},

462

4

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

463

4

}))

464

4

);

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().extensions(Extensions::IMPLICIT_SOME)

474

4

),

475

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 } } }"))))

476

4

);

477

4

478

479

#[test]

480

4

fn newtype_inside_internally_tagged() {

481

8

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

482

    struct A(i32);

483

484

16

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

485

    #[serde(tag = "tag")]

486

    enum InternallyTagged {

487

        B { ho: i32, a: A },

488

489

490

    // NOTE:

491

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

492

    // 2. newtype asks ContentDeserializer for newtype

493

    // 3. ContentDeserializer forwards any value to visit_newtype_struct

494

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

495

496

4

    assert_eq!(

497

4

        check_roundtrip(

498

4

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

499

4

            PrettyConfig::default()

500

4

),

501

4

        Err(Err(SpannedError {

502

4

            code: Error::InvalidValueForType {

503

4

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

504

4

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

505

4

},

506

4

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

507

4

}))

508

4

);

509

4

510

511

#[test]

512

4

fn newtype_inside_adjacently_tagged() {

513

16

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

514

    struct A(i32);

515

516

68

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

517

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

518

    enum AdjacentlyTagged {

519

        B { ho: i32, a: A },

520

521

522

4

    assert_eq!(

523

4

        check_roundtrip(

524

4

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

525

4

            PrettyConfig::default()

526

4

),

527

4

        Ok(())

528

4

);

529

4

    assert_eq!(

530

4

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

531

4

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

532

4

);

533

4

    assert_eq!(

534

4

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

535

4

        Err(SpannedError {

536

4

            code: Error::InvalidValueForType {

537

4

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

538

4

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

539

4

},

540

4

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

541

4

})

542

4

);

543

4

544

545

#[test]

546

4

fn newtype_inside_untagged() {

547

8

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

548

    struct A(i32);

549

550

12

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

551

    #[serde(untagged)]

552

    enum Untagged {

553

        B { ho: i32, a: A },

554

555

556

4

    assert_eq!(

557

4

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

558

4

        Err(Err(SpannedError {

559

4

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

560

4

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

561

4

)),

562

4

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

563

4

}))

564

4

);

565

4

566

567

#[test]

568

4

fn newtype_inside_flatten_struct() {

569

8

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

570

    struct A(i32);

571

572

12

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

573

    struct B {

574

        a: A,

575

576

577

12

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

578

    struct FlattenedStruct {

579

        ho: i32,

580

        #[serde(flatten)]

581

        a: B,

582

583

584

4

    assert_eq!(

585

4

        check_roundtrip(

586

4

            &FlattenedStruct {

587

4

                ho: 24,

588

4

                a: B { a: A(42) }

589

4

},

590

4

            PrettyConfig::default()

591

4

),

592

4

        Err(Err(SpannedError {

593

4

            code: Error::InvalidValueForType {

594

4

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

595

4

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

596

4

},

597

4

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

598

4

}))

599

4

);

600

4

601

602

#[test]

603

4

fn newtype_inside_flatten_struct_variant() {

604

8

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

605

    struct A(i32);

606

607

12

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

608

    struct B {

609

        a: A,

610

611

612

20

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

613

    enum FlattenedStructVariant {

614

C {

615

            ho: i32,

616

            #[serde(flatten)]

617

            a: B,

618

},

619

620

621

4

    assert_eq!(

622

4

        check_roundtrip(

623

4

            &FlattenedStructVariant::C {

624

4

                ho: 24,

625

4

                a: B { a: A(42) }

626

4

},

627

4

            PrettyConfig::default()

628

4

),

629

4

        Err(Err(SpannedError {

630

4

            code: Error::InvalidValueForType {

631

4

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

632

4

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

633

4

},

634

4

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

635

4

}))

636

4

);

637

4

638

639

#[test]

640

4

fn one_tuple_inside_unwrapped_newtype_variant_inside_internally_tagged() {

641

16

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

642

    enum A {

643

        Newtype((i32,)),

644

645

646

32

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

647

    #[serde(tag = "tag")]

648

    enum InternallyTagged {

649

        B { ho: i32, a: A },

650

651

652

4

    assert_eq!(

653

4

        check_roundtrip(

654

4

            &InternallyTagged::B {

655

4

                ho: 24,

656

4

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

657

4

},

658

4

            PrettyConfig::default()

659

4

),

660

4

        Ok(())

661

4

);

662

4

    assert_eq!(

663

4

        check_roundtrip(

664

4

            &InternallyTagged::B {

665

4

                ho: 24,

666

4

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

667

4

},

668

4

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

669

4

),

670

4

        Err(Err(SpannedError {

671

4

            code: Error::InvalidValueForType {

672

4

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

673

4

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

674

4

},

675

4

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

676

4

}))

677

4

);

678

4

679

680

#[test]

681

4

fn one_tuple_inside_unwrapped_newtype_variant_inside_adjacently_tagged() {

682

32

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

683

    enum A {

684

        Newtype([i32; 1]),

685

686

687

92

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

688

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

689

    enum AdjacentlyTagged {

690

        B { ho: i32, a: A },

691

692

693

4

    assert_eq!(

694

4

        check_roundtrip(

695

4

            &AdjacentlyTagged::B {

696

4

                ho: 24,

697

4

                a: A::Newtype([42])

698

4

},

699

4

            PrettyConfig::default()

700

4

),

701

4

        Ok(())

702

4

);

703

4

    assert_eq!(

704

4

        check_roundtrip(

705

4

            &AdjacentlyTagged::B {

706

4

                ho: 24,

707

4

                a: A::Newtype([42])

708

4

},

709

4

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

710

4

),

711

4

        Ok(())

712

4

);

713

4

    assert_eq!(

714

4

        ron::from_str::<AdjacentlyTagged>(

715

4

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

716

4

),

717

4

        Ok(AdjacentlyTagged::B {

718

4

            ho: 24,

719

4

            a: A::Newtype([42])

720

4

}),

721

4

);

722

4

    assert_eq!(

723

4

        ron::from_str::<AdjacentlyTagged>(

724

4

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

725

4

),

726

4

        Err(SpannedError {

727

4

            code: Error::InvalidValueForType {

728

4

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

729

4

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

730

4

},

731

4

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

732

4

})

733

4

);

734

4

735

736

#[test]

737

4

fn one_tuple_inside_unwrapped_newtype_variant_inside_untagged() {

738

4

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

739

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

740

741

24

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

742

    #[serde(untagged)]

743

    enum Untagged {

744

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

745

746

747

4

    assert_eq!(

748

4

        check_roundtrip(

749

4

            &Untagged::B {

750

4

                ho: 24,

751

4

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

752

4

},

753

4

            PrettyConfig::default()

754

4

),

755

4

        Ok(())

756

4

);

757

4

    assert_eq!(

758

4

        check_roundtrip(

759

4

            &Untagged::B {

760

4

                ho: 24,

761

4

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

762

4

},

763

4

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

764

4

),

765

4

        Err(Err(SpannedError {

766

4

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

767

4

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

768

4

)),

769

4

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

770

4

}))

771

4

);

772

4

773

774

#[test]

775

4

fn one_tuple_inside_unwrapped_newtype_variant_inside_flatten_struct() {

776

16

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

777

    enum A {

778

        Newtype([i32; 1]),

779

780

781

20

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

782

    struct B {

783

        a: A,

784

785

786

24

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

787

    struct FlattenedStruct {

788

        ho: i32,

789

        #[serde(flatten)]

790

        a: B,

791

792

793

4

    assert_eq!(

794

4

        check_roundtrip(

795

4

            &FlattenedStruct {

796

4

                ho: 24,

797

4

                a: B {

798

4

                    a: A::Newtype([42])

799

4

800

4

},

801

4

            PrettyConfig::default()

802

4

),

803

4

        Ok(())

804

4

);

805

4

    assert_eq!(

806

4

        check_roundtrip(

807

4

            &FlattenedStruct {

808

4

                ho: 24,

809

4

                a: B {

810

4

                    a: A::Newtype([42])

811

4

812

4

},

813

4

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

814

4

),

815

4

        Err(Err(SpannedError {

816

4

            code: Error::InvalidValueForType {

817

4

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

818

4

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

819

4

},

820

4

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

821

4

}))

822

4

);

823

4

824

825

#[test]

826

4

fn one_tuple_inside_unwrapped_newtype_variant_inside_flatten_struct_variant() {

827

16

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

828

    enum A {

829

        Newtype((i32,)),

830

831

832

20

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

833

    struct B {

834

        a: A,

835

836

837

40

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

838

    enum FlattenedStructVariant {

839

C {

840

            ho: i32,

841

            #[serde(flatten)]

842

            a: B,

843

},

844

845

846

4

    assert_eq!(

847

4

        check_roundtrip(

848

4

            &FlattenedStructVariant::C {

849

4

                ho: 24,

850

4

                a: B {

851

4

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

852

4

853

4

},

854

4

            PrettyConfig::default()

855

4

),

856

4

        Ok(()),

857

4

);

858

4

    assert_eq!(

859

4

        check_roundtrip(

860

4

            &FlattenedStructVariant::C {

861

4

                ho: 24,

862

4

                a: B {

863

4

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

864

4

865

4

},

866

4

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

867

4

),

868

4

        Err(Err(SpannedError {

869

4

            code: Error::InvalidValueForType {

870

4

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

871

4

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

872

4

},

873

4

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

874

4

}))

875

4

);

876

4

877

878

#[test]

879

4

fn one_tuple_variant_inside_internally_tagged() {

880

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

881

8

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

882

    enum OneEnum {

883

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

884

885

886

12

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

887

    struct A {

888

        hi: OneEnum,

889

890

891

16

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

892

    #[serde(tag = "tag")]

893

    enum InternallyTagged {

894

        B { ho: i32, a: A },

895

896

897

4

    assert_eq!(

898

4

        check_roundtrip(

899

4

            &InternallyTagged::B {

900

4

                ho: 24,

901

4

                a: A {

902

4

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

903

4

904

4

},

905

4

            PrettyConfig::default()

906

4

),

907

4

        Err(Err(SpannedError {

908

4

            code: Error::InvalidValueForType {

909

4

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

910

4

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

911

4

},

912

4

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

913

4

}))

914

4

);

915

4

916

917

#[test]

918

4

fn one_tuple_variant_inside_adjacently_tagged() {

919

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

920

32

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

921

    enum OneEnum {

922

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

923

924

925

28

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

926

    struct A {

927

        hi: OneEnum,

928

929

930

68

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

931

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

932

    enum AdjacentlyTagged {

933

        B { ho: i32, a: A },

934

935

936

4

    assert_eq!(

937

4

        check_roundtrip(

938

4

            &AdjacentlyTagged::B {

939

4

                ho: 24,

940

4

                a: A {

941

4

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

942

4

943

4

},

944

4

            PrettyConfig::default()

945

4

),

946

4

        Ok(())

947

4

);

948

4

    assert_eq!(

949

4

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

950

4

        Ok(AdjacentlyTagged::B {

951

4

            ho: 24,

952

4

            a: A {

953

4

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

954

4

955

4

}),

956

4

);

957

4

    assert_eq!(

958

4

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

959

4

        Err(SpannedError {

960

4

            code: Error::InvalidValueForType {

961

4

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

962

4

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

963

4

},

964

4

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

965

4

})

966

4

);

967

4

968

969

#[test]

970

4

fn one_tuple_variant_inside_untagged() {

971

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

972

8

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

973

    enum OneEnum {

974

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

975

976

977

12

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

978

    struct A {

979

        hi: OneEnum,

980

981

982

12

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

983

    #[serde(untagged)]

984

    enum Untagged {

985

        B { ho: i32, a: A },

986

987

988

4

    assert_eq!(

989

4

        check_roundtrip(

990

4

            &Untagged::B {

991

4

                ho: 24,

992

4

                a: A {

993

4

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

994

4

995

4

},

996

4

            PrettyConfig::default()

997

4

),

998

4

        Err(Err(SpannedError {

999

4

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

1000

4

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

1001

4

)),

1002

4

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

1003

4

}))

1004

4

);

1005

4

1006

1007

#[test]

1008

4

fn one_tuple_variant_inside_flatten_struct() {

1009

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

1010

8

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

1011

    enum OneEnum {

1012

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

1013

1014

1015

12

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

1016

    struct A {

1017

        hi: OneEnum,

1018

1019

1020

12

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

1021

    struct B {

1022

        a: A,

1023

1024

1025

12

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

1026

    struct FlattenedStruct {

1027

        ho: i32,

1028

        #[serde(flatten)]

1029

        a: B,

1030

1031

1032

4

    assert_eq!(

1033

4

        check_roundtrip(

1034

4

            &FlattenedStruct {

1035

4

                ho: 24,

1036

4

                a: B {

1037

4

                    a: A {

1038

4

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

1039

4

1040

4

1041

4

},

1042

4

            PrettyConfig::default()

1043

4

),

1044

4

        Err(Err(SpannedError {

1045

4

            code: Error::InvalidValueForType {

1046

4

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

1047

4

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

1048

4

},

1049

4

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

1050

4

}))

1051

4

);

1052

4

1053

1054

#[test]

1055

4

fn one_tuple_variant_inside_flatten_struct_variant() {

1056

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

1057

8

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

1058

    enum OneEnum {

1059

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

1060

1061

1062

12

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

1063

    struct A {

1064

        hi: OneEnum,

1065

1066

1067

12

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

1068

    struct B {

1069

        a: A,

1070

1071

1072

20

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

1073

    enum FlattenedStructVariant {

1074

C {

1075

            ho: i32,

1076

            #[serde(flatten)]

1077

            a: B,

1078

},

1079

1080

1081

4

    assert_eq!(

1082

4

        check_roundtrip(

1083

4

            &FlattenedStructVariant::C {

1084

4

                ho: 24,

1085

4

                a: B {

1086

4

                    a: A {

1087

4

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

1088

4

1089

4

1090

4

},

1091

4

            PrettyConfig::default()

1092

4

),

1093

4

        Err(Err(SpannedError {

1094

4

            code: Error::InvalidValueForType {

1095

4

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

1096

4

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

1097

4

},

1098

4

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

1099

4

}))

1100

4

);

1101

4

1102

1103

#[test]

1104

4

fn raw_value_inside_internally_tagged() {

1105

12

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

1106

    struct A {

1107

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

1108

1109

1110

16

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

1111

    #[serde(tag = "tag")]

1112

    enum InternallyTagged {

1113

        B { ho: i32, a: A },

1114

1115

1116

4

    assert_eq!(

1117

4

        check_roundtrip(

1118

4

            &InternallyTagged::B {

1119

4

                ho: 24,

1120

4

                a: A {

1121

4

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

1122

4

                        .unwrap(),

1123

4

1124

4

},

1125

4

            PrettyConfig::default()

1126

4

),

1127

4

        Err(Err(SpannedError {

1128

4

            code: Error::InvalidValueForType {

1129

4

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

1130

4

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

1131

4

},

1132

4

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

1133

4

}))

1134

4

);

1135

4

1136

1137

#[test]

1138

4

fn raw_value_inside_adjacently_tagged() {

1139

28

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

1140

    struct A {

1141

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

1142

1143

1144

68

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

1145

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

1146

    enum AdjacentlyTagged {

1147

        B { ho: i32, a: A },

1148

1149

1150

4

    assert_eq!(

1151

4

        check_roundtrip(

1152

4

            &AdjacentlyTagged::B {

1153

4

                ho: 24,

1154

4

                a: A {

1155

4

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

1156

4

                        .unwrap(),

1157

4

1158

4

},

1159

4

            PrettyConfig::default()

1160

4

),

1161

4

        // adds an extra space

1162

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) } }"))))

1163

4

);

1164

4

    assert_eq!(

1165

4

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

1166

4

        Ok(AdjacentlyTagged::B {

1167

4

            ho: 24,

1168

4

            a: A {

1169

4

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

1170

4

                    .unwrap(),

1171

4

1172

4

}),

1173

4

);

1174

4

    assert_eq!(

1175

4

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

1176

4

        Err(SpannedError {

1177

4

            code: Error::InvalidValueForType {

1178

4

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

1179

4

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

1180

4

},

1181

4

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

1182

4

})

1183

4

);

1184

4

1185

1186

#[test]

1187

4

fn raw_value_inside_untagged() {

1188

12

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

1189

    struct A {

1190

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

1191

1192

1193

12

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

1194

    #[serde(untagged)]

1195

    enum Untagged {

1196

        B { ho: i32, a: A },

1197

1198

1199

4

    assert_eq!(

1200

4

        check_roundtrip(

1201

4

            &Untagged::B {

1202

4

                ho: 24,

1203

4

                a: A {

1204

4

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

1205

4

                        .unwrap(),

1206

4

1207

4

},

1208

4

            PrettyConfig::default()

1209

4

),

1210

4

        Err(Err(SpannedError {

1211

4

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

1212

4

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

1213

4

)),

1214

4

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

1215

4

}))

1216

4

);

1217

4

1218

1219

#[test]

1220

4

fn raw_value_inside_flatten_struct() {

1221

12

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

1222

    struct A {

1223

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

1224

1225

1226

12

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

1227

    struct B {

1228

        a: A,

1229

1230

1231

12

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

1232

    struct FlattenedStruct {

1233

        ho: i32,

1234

        #[serde(flatten)]

1235

        a: B,

1236

1237

1238

4

    assert_eq!(

1239

4

        check_roundtrip(

1240

4

            &FlattenedStruct {

1241

4

                ho: 24,

1242

4

                a: B {

1243

4

                    a: A {

1244

4

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

1245

4

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

1246

4

1247

4

                        .unwrap(),

1248

4

1249

4

1250

4

},

1251

4

            PrettyConfig::default()

1252

4

),

1253

4

        Err(Err(SpannedError {

1254

4

            code: Error::InvalidValueForType {

1255

4

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

1256

4

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

1257

4

},

1258

4

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

1259

4

}))

1260

4

);

1261

4

1262

1263

#[test]

1264

4

fn raw_value_inside_flatten_struct_variant() {

1265

12

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

1266

    struct A {

1267

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

1268

1269

1270

12

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

1271

    struct B {

1272

        a: A,

1273

1274

1275

20

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

1276

    enum FlattenedStructVariant {

1277

C {

1278

            ho: i32,

1279

            #[serde(flatten)]

1280

            a: B,

1281

},

1282

1283

1284

4

    assert_eq!(

1285

4

        check_roundtrip(

1286

4

            &FlattenedStructVariant::C {

1287

4

                ho: 24,

1288

4

                a: B {

1289

4

                    a: A {

1290

4

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

1291

4

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

1292

4

1293

4

                        .unwrap(),

1294

4

1295

4

1296

4

},

1297

4

            PrettyConfig::default()

1298

4

),

1299

4

        Err(Err(SpannedError {

1300

4

            code: Error::InvalidValueForType {

1301

4

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

1302

4

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

1303

4

},

1304

4

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

1305

4

}))

1306

4

);

1307

4

1308

1309

#[test]

1310

4

fn unit_like_zero_length_inside_internally_tagged() {

1311

12

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

1312

    struct A {

1313

        hi: [i32; 0],

1314

1315

1316

16

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

1317

    #[serde(tag = "tag")]

1318

    enum InternallyTagged {

1319

        B { ho: i32, a: A },

1320

1321

1322

4

    assert_eq!(

1323

4

        check_roundtrip(

1324

4

            &InternallyTagged::B {

1325

4

                ho: 24,

1326

4

                a: A { hi: [] }

1327

4

},

1328

4

            PrettyConfig::default()

1329

4

),

1330

4

        Err(Err(SpannedError {

1331

4

            code: Error::InvalidValueForType {

1332

4

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

1333

4

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

1334

4

},

1335

4

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

1336

4

}))

1337

4

);

1338

4

1339

1340

#[test]

1341

4

fn unit_like_zero_length_inside_adjacently_tagged() {

1342

12

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

1343

    struct TupleStruct();

1344

1345

28

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

1346

    struct A {

1347

        hi: TupleStruct,

1348

1349

1350

68

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

1351

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

1352

    enum AdjacentlyTagged {

1353

        B { ho: i32, a: A },

1354

1355

1356

4

    assert_eq!(

1357

4

        check_roundtrip(

1358

4

            &AdjacentlyTagged::B {

1359

4

                ho: 24,

1360

4

                a: A { hi: TupleStruct() }

1361

4

},

1362

4

            PrettyConfig::default()

1363

4

),

1364

4

        Ok(()),

1365

4

);

1366

4

    assert_eq!(

1367

4

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

1368

4

        Ok(AdjacentlyTagged::B {

1369

4

            ho: 24,

1370

4

            a: A { hi: TupleStruct() }

1371

4

}),

1372

4

);

1373

4

    assert_eq!(

1374

4

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

1375

4

        Err(SpannedError {

1376

4

            code: Error::InvalidValueForType {

1377

4

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

1378

4

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

1379

4

},

1380

4

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

1381

4

})

1382

4

);

1383

4

1384

1385

#[test]

1386

4

fn unit_like_zero_length_inside_untagged() {

1387

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

1388

    struct Struct {}

1389

1390

12

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

1391

    struct A {

1392

        hi: Struct,

1393

1394

1395

12

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

1396

    #[serde(untagged)]

1397

    enum Untagged {

1398

        B { ho: i32, a: A },

1399

1400

1401

4

    assert_eq!(

1402

4

        check_roundtrip(

1403

4

            &Untagged::B {

1404

4

                ho: 24,

1405

4

                a: A { hi: Struct {} }

1406

4

},

1407

4

            PrettyConfig::default()

1408

4

),

1409

4

        Err(Err(SpannedError {

1410

4

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

1411

4

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

1412

4

)),

1413

4

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

1414

4

}))

1415

4

);

1416

4

1417

1418

#[test]

1419

4

fn unit_like_zero_length_inside_flatten_struct() {

1420

8

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

1421

    enum Enum {

1422

        Tuple(),

1423

1424

1425

12

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

1426

    struct A {

1427

        hi: Enum,

1428

1429

1430

12

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

1431

    struct B {

1432

        a: A,

1433

1434

1435

12

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

1436

    struct FlattenedStruct {

1437

        ho: i32,

1438

        #[serde(flatten)]

1439

        a: B,

1440

1441

1442

4

    assert_eq!(

1443

4

        check_roundtrip(

1444

4

            &FlattenedStruct {

1445

4

                ho: 24,

1446

4

                a: B {

1447

4

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

1448

4

1449

4

},

1450

4

            PrettyConfig::default()

1451

4

),

1452

4

        Err(Err(SpannedError {

1453

4

            code: Error::InvalidValueForType {

1454

4

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

1455

4

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

1456

4

},

1457

4

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

1458

4

}))

1459

4

);

1460

4

1461

1462

#[test]

1463

4

fn unit_like_zero_length_inside_flatten_struct_variant() {

1464

8

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

1465

    enum Enum {

1466

        Struct {},

1467

1468

1469

12

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

1470

    struct A {

1471

        hi: Enum,

1472

1473

1474

12

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

1475

    struct B {

1476

        a: A,

1477

1478

1479

20

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

1480

    enum FlattenedStructVariant {

1481

C {

1482

            ho: i32,

1483

            #[serde(flatten)]

1484

            a: B,

1485

},

1486

1487

1488

4

    assert_eq!(

1489

4

        check_roundtrip(

1490

4

            &FlattenedStructVariant::C {

1491

4

                ho: 24,

1492

4

                a: B {

1493

4

                    a: A {

1494

4

                        hi: Enum::Struct {}

1495

4

1496

4

1497

4

},

1498

4

            PrettyConfig::default()

1499

4

),

1500

4

        Err(Err(SpannedError {

1501

4

            code: Error::InvalidValueForType {

1502

4

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

1503

4

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

1504

4

},

1505

4

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

1506

4

}))

1507

4

);

1508

4

1509

1510

#[test]

1511

4

fn i128_inside_internally_tagged() {

1512

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

1513

    struct A {

1514

        hi: i128,

1515

1516

1517

2

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

1518

    #[serde(tag = "tag")]

1519

    enum InternallyTagged {

1520

        B { ho: i32, a: A },

1521

1522

1523

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

1524

2

    assert_eq!(

1525

2

        check_roundtrip(

1526

2

            &InternallyTagged::B {

1527

2

                ho: 24,

1528

2

                a: A { hi: i128::MAX }

1529

2

},

1530

2

            PrettyConfig::default()

1531

2

),

1532

2

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

1533

2

);

1534

    #[cfg(feature = "integer128")]

1535

2

    assert_eq!(

1536

2

        check_roundtrip(

1537

2

            &InternallyTagged::B {

1538

2

                ho: 24,

1539

2

                a: A { hi: i128::MAX }

1540

2

},

1541

2

            PrettyConfig::default()

1542

2

),

1543

2

        Err(Err(SpannedError {

1544

2

            code: Error::InvalidValueForType {

1545

2

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

1546

2

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

1547

2

},

1548

2

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

1549

2

}))

1550

2

);

1551

4

1552

1553

#[test]

1554

4

fn u128_inside_adjacently_tagged() {

1555

8

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

1556

    struct A {

1557

        hi: u128,

1558

1559

1560

30

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

1561

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

1562

    enum AdjacentlyTagged {

1563

        B { ho: i32, a: A },

1564

1565

1566

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

1567

2

    assert_eq!(

1568

2

        check_roundtrip(

1569

2

            &AdjacentlyTagged::B {

1570

2

                ho: 24,

1571

2

                a: A { hi: u128::MAX }

1572

2

},

1573

2

            PrettyConfig::default()

1574

2

),

1575

2

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

1576

2

);

1577

    #[cfg(feature = "integer128")]

1578

2

    assert_eq!(

1579

2

        check_roundtrip(

1580

2

            &AdjacentlyTagged::B {

1581

2

                ho: 24,

1582

2

                a: A { hi: u128::MAX }

1583

2

},

1584

2

            PrettyConfig::default()

1585

2

),

1586

2

        Ok(()),

1587

2

);

1588

    #[cfg(feature = "integer128")]

1589

2

    assert_eq!(

1590

2

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

1591

2

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

1592

2

            u128::MAX

1593

2

        ),),

1594

2

        Ok(AdjacentlyTagged::B {

1595

2

            ho: 24,

1596

2

            a: A { hi: u128::MAX }

1597

2

}),

1598

2

);

1599

    #[cfg(feature = "integer128")]

1600

2

    assert_eq!(

1601

2

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

1602

2

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

1603

2

            u128::MAX

1604

2

        ),),

1605

2

        Err(SpannedError {

1606

2

            code: Error::InvalidValueForType {

1607

2

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

1608

2

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

1609

2

},

1610

2

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

1611

2

}),

1612

2

);

1613

4

1614

1615

#[test]

1616

4

fn i128_inside_untagged() {

1617

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

1618

    struct A {

1619

        hi: i128,

1620

1621

1622

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

1623

    #[serde(untagged)]

1624

    enum Untagged {

1625

        B { ho: i32, a: A },

1626

1627

1628

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

1629

2

    assert_eq!(

1630

2

        check_roundtrip(

1631

2

            &Untagged::B {

1632

2

                ho: 24,

1633

2

                a: A { hi: i128::MIN }

1634

2

},

1635

2

            PrettyConfig::default()

1636

2

),

1637

2

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

1638

2

);

1639

    #[cfg(feature = "integer128")]

1640

2

    assert_eq!(

1641

2

        check_roundtrip(

1642

2

            &Untagged::B {

1643

2

                ho: 24,

1644

2

                a: A { hi: i128::MIN }

1645

2

},

1646

2

            PrettyConfig::default()

1647

2

),

1648

2

        Err(Err(SpannedError {

1649

2

            code: Error::InvalidValueForType {

1650

2

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

1651

2

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

1652

2

},

1653

2

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

1654

2

}))

1655

2

);

1656

4

1657

1658

#[test]

1659

4

fn u128_inside_flatten_struct() {

1660

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

1661

    struct A {

1662

        hi: u128,

1663

1664

1665

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

1666

    struct B {

1667

        a: A,

1668

1669

1670

6

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

1671

    struct FlattenedStruct {

1672

        ho: i32,

1673

        #[serde(flatten)]

1674

        a: B,

1675

1676

1677

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

1678

2

    assert_eq!(

1679

2

        check_roundtrip(

1680

2

            &FlattenedStruct {

1681

2

                ho: 24,

1682

2

                a: B {

1683

2

                    a: A { hi: u128::MAX }

1684

2

1685

2

},

1686

2

            PrettyConfig::default()

1687

2

),

1688

2

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

1689

2

);

1690

    #[cfg(feature = "integer128")]

1691

2

    assert_eq!(

1692

2

        check_roundtrip(

1693

2

            &FlattenedStruct {

1694

2

                ho: 24,

1695

2

                a: B {

1696

2

                    a: A { hi: u128::MAX }

1697

2

1698

2

},

1699

2

            PrettyConfig::default()

1700

2

),

1701

2

        Err(Err(SpannedError {

1702

2

            code: Error::InvalidValueForType {

1703

2

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

1704

2

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

1705

2

},

1706

2

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

1707

2

}))

1708

2

);

1709

4

1710

1711

#[test]

1712

4

fn i128_inside_flatten_struct_variant() {

1713

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

1714

    struct A {

1715

        hi: i128,

1716

1717

1718

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

1719

    struct B {

1720

        a: A,

1721

1722

1723

14

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

1724

    enum FlattenedStructVariant {

1725

C {

1726

            ho: i32,

1727

            #[serde(flatten)]

1728

            a: B,

1729

},

1730

1731

1732

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

1733

2

    assert_eq!(

1734

2

        check_roundtrip(

1735

2

            &FlattenedStructVariant::C {

1736

2

                ho: 24,

1737

2

                a: B {

1738

2

                    a: A { hi: i128::MIN }

1739

2

1740

2

},

1741

2

            PrettyConfig::default()

1742

2

),

1743

2

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

1744

2

);

1745

    #[cfg(feature = "integer128")]

1746

2

    assert_eq!(

1747

2

        check_roundtrip(

1748

2

            &FlattenedStructVariant::C {

1749

2

                ho: 24,

1750

2

                a: B {

1751

2

                    a: A { hi: i128::MIN }

1752

2

1753

2

},

1754

2

            PrettyConfig::default()

1755

2

),

1756

2

        Err(Err(SpannedError {

1757

2

            code: Error::InvalidValueForType {

1758

2

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

1759

2

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

1760

2

},

1761

2

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

1762

2

}))

1763

2

);

1764

4

1765

1766

#[test]

1767

4

fn duplicate_key_inside_flatten_struct() {

1768

12

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

1769

    struct FlattenedStruct {

1770

        ho: i32,

1771

        #[serde(flatten)]

1772

        other: HashMap<String, i32>,

1773

1774

1775

4

    assert_eq!(

1776

4

        check_roundtrip(

1777

4

            &FlattenedStruct {

1778

4

                ho: 24,

1779

4

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

1780

4

},

1781

4

            PrettyConfig::default()

1782

4

),

1783

4

        Err(Err(SpannedError {

1784

4

            code: Error::DuplicateStructField {

1785

4

                field: "ho",

1786

4

                outer: None

1787

4

},

1788

4

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

1789

4

}))

1790

4

);

1791

4

1792

1793

#[test]

1794

4

fn duplicate_key_inside_flatten_struct_variant() {

1795

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

1796

    struct C {

1797

        ho: i32,

1798

        hi: bool,

1799

1800

1801

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

1802

    struct B {

1803

        #[serde(flatten)]

1804

        inner: C,

1805

1806

1807

20

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

1808

    enum FlattenedStructVariant {

1809

A {

1810

            ho: i32,

1811

            #[serde(flatten)]

1812

            inner: B,

1813

},

1814

1815

1816

4

    assert_eq!(

1817

4

        check_roundtrip(

1818

4

            &FlattenedStructVariant::A {

1819

4

                ho: 24,

1820

4

                inner: B {

1821

4

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

1822

4

1823

4

},

1824

4

            PrettyConfig::default()

1825

4

),

1826

4

        Err(Err(SpannedError {

1827

4

            code: Error::DuplicateStructField {

1828

4

                field: "ho",

1829

4

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

1830

4

},

1831

4

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

1832

4

}))

1833

4

);

1834

4

1835

1836

#[test]

1837

4

fn non_string_key_inside_flatten_struct() {

1838

8

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

1839

    struct FlattenedStruct {

1840

        ho: i32,

1841

        #[serde(flatten)]

1842

        other: HashMap<i32, bool>,

1843

1844

1845

4

    assert_eq!(

1846

4

        check_roundtrip(

1847

4

            &FlattenedStruct {

1848

4

                ho: 24,

1849

4

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

1850

4

},

1851

4

            PrettyConfig::default()

1852

4

),

1853

4

        Err(Err(SpannedError {

1854

4

            code: Error::ExpectedString,

1855

4

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

1856

4

}))

1857

4

);

1858

4

1859

1860

#[test]

1861

4

fn non_string_key_inside_flatten_struct_variant() {

1862

16

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

1863

    enum FlattenedStructVariant {

1864

A {

1865

            ho: i32,

1866

            #[serde(flatten)]

1867

            other: HashMap<char, u8>,

1868

},

1869

1870

1871

4

    assert_eq!(

1872

4

        check_roundtrip(

1873

4

            &FlattenedStructVariant::A {

1874

4

                ho: 24,

1875

4

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

1876

4

},

1877

4

            PrettyConfig::default()

1878

4

),

1879

4

        Err(Err(SpannedError {

1880

4

            code: Error::ExpectedString,

1881

4

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

1882

4

}))

1883

4

);

1884

4

1885

1886

#[test]

1887

4

fn more_than_one_flatten_map_inside_flatten_struct() {

1888

4

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

1889

    struct Deep {

1890

        #[serde(flatten)]

1891

        other: HashMap<String, bool>,

1892

1893

1894

4

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

1895

    struct Inner {

1896

        #[serde(flatten)]

1897

        deep: Deep,

1898

1899

1900

12

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

1901

    struct FlattenedStruct {

1902

        ho: i32,

1903

        #[serde(flatten)]

1904

        hi: Inner,

1905

        #[serde(flatten)]

1906

        other: HashMap<String, bool>,

1907

1908

1909

4

    assert_eq!(

1910

4

        check_roundtrip(

1911

4

            &FlattenedStruct {

1912

4

                ho: 24,

1913

4

                hi: Inner {

1914

4

                    deep: Deep {

1915

4

                        other: HashMap::new(),

1916

4

},

1917

4

},

1918

4

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

1919

4

},

1920

4

            PrettyConfig::default()

1921

4

),

1922

4

        // both maps collect all the unknown keys

1923

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} }"))))

1924

4

);

1925

4

1926

1927

#[test]

1928

4

fn more_than_one_flatten_map_inside_flatten_struct_variant() {

1929

4

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

1930

    struct Deep {

1931

        #[serde(flatten)]

1932

        other: HashMap<String, bool>,

1933

1934

1935

4

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

1936

    struct Inner {

1937

        #[serde(flatten)]

1938

        deep: Deep,

1939

1940

1941

20

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

1942

    enum FlattenedStructVariant {

1943

A {

1944

            ho: i32,

1945

            #[serde(flatten)]

1946

            hi: Inner,

1947

            #[serde(flatten)]

1948

            other: HashMap<String, bool>,

1949

},

1950

1951

1952

4

    assert_eq!(

1953

4

        check_roundtrip(

1954

4

            &FlattenedStructVariant::A {

1955

4

                ho: 24,

1956

4

                hi: Inner {

1957

4

                    deep: Deep {

1958

4

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

1959

4

},

1960

4

},

1961

4

                other: HashMap::new(),

1962

4

},

1963

4

            PrettyConfig::default()

1964

4

),

1965

4

        // both maps collect all the unknown keys

1966

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} }"))))

1967

4

);

1968

4

1969

1970

#[test]

1971

4

fn flatten_struct_beside_map_inside_flatten_struct() {

1972

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

1973

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

1974

    struct Flattened {

1975

        hi: i32,

1976

        #[serde(flatten)]

1977

        flat: (),

1978

1979

1980

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

1981

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

1982

    struct Inner {

1983

        flat: Flattened,

1984

1985

1986

12

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

1987

    struct FlattenedStruct {

1988

        ho: i32,

1989

        #[serde(flatten)]

1990

        other: HashMap<String, i32>,

1991

        #[serde(flatten)]

1992

        inner: Inner,

1993

1994

1995

4

    assert_eq!(

1996

4

        check_roundtrip(

1997

4

            &FlattenedStruct {

1998

4

                ho: 24,

1999

4

                other: HashMap::new(),

2000

4

                inner: Inner {

2001

4

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

2002

4

},

2003

4

},

2004

4

            PrettyConfig::default()

2005

4

),

2006

4

        Err(Err(SpannedError {

2007

4

            code: Error::InvalidValueForType {

2008

4

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

2009

4

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

2010

4

},

2011

4

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

2012

4

}))

2013

4

);

2014

4

2015

2016

#[test]

2017

4

fn flatten_struct_beside_map_inside_flatten_struct_variant() {

2018

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

2019

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

2020

    struct Flattened {

2021

        hi: i32,

2022

        #[serde(flatten)]

2023

        flat: (),

2024

2025

2026

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

2027

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

2028

    struct Inner {

2029

        flat: Flattened,

2030

2031

2032

20

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

2033

    enum FlattenedStructVariant {

2034

A {

2035

            ho: i32,

2036

            #[serde(flatten)]

2037

            other: HashMap<String, i32>,

2038

            #[serde(flatten)]

2039

            inner: Inner,

2040

},

2041

2042

2043

4

    assert_eq!(

2044

4

        check_roundtrip(

2045

4

            &FlattenedStructVariant::A {

2046

4

                ho: 24,

2047

4

                other: HashMap::new(),

2048

4

                inner: Inner {

2049

4

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

2050

4

},

2051

4

},

2052

4

            PrettyConfig::default()

2053

4

),

2054

4

        Err(Err(SpannedError {

2055

4

            code: Error::InvalidValueForType {

2056

4

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

2057

4

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

2058

4

},

2059

4

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

2060

4

}))

2061

4

);

2062

4

2063

2064

#[test]

2065

4

fn untagged_flatten_struct_variant_beside_map_inside_flatten_struct() {

2066

8

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

2067

    #[serde(untagged)]

2068

    enum Flattened {

2069

        Struct {

2070

            hi: i32,

2071

            #[serde(flatten)]

2072

            flat: (),

2073

},

2074

2075

2076

12

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

2077

    struct FlattenedStruct {

2078

        ho: i32,

2079

        #[serde(flatten)]

2080

        other: HashMap<String, i32>,

2081

        #[serde(flatten)]

2082

        flat: Flattened,

2083

2084

2085

4

    assert_eq!(

2086

4

        check_roundtrip(

2087

4

            &FlattenedStruct {

2088

4

                ho: 24,

2089

4

                other: HashMap::new(),

2090

4

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

2091

4

},

2092

4

            PrettyConfig::default()

2093

4

),

2094

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: () } }"))))

2095

4

);

2096

4

2097

2098

#[test]

2099

4

fn untagged_flatten_struct_variant_beside_map_inside_flatten_struct_variant() {

2100

8

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

2101

    #[serde(untagged)]

2102

    enum Flattened {

2103

        Struct {

2104

            hi: i32,

2105

            #[serde(flatten)]

2106

            flat: (),

2107

},

2108

2109

2110

20

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

2111

    enum FlattenedStructVariant {

2112

A {

2113

            ho: i32,

2114

            #[serde(flatten)]

2115

            other: HashMap<String, i32>,

2116

            #[serde(flatten)]

2117

            flat: Flattened,

2118

},

2119

2120

2121

4

    assert_eq!(

2122

4

        check_roundtrip(

2123

4

            &FlattenedStructVariant::A {

2124

4

                ho: 24,

2125

4

                other: HashMap::new(),

2126

4

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

2127

4

},

2128

4

            PrettyConfig::default()

2129

4

),

2130

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: () } }"))))

2131

4

);

2132

4

2133

2134

#[test]

2135

4

fn externally_tagged_newtype_variant_beside_map_inside_flatten_struct_variant() {

2136

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

2137

    enum Flattened {

2138

        Newtype(()),

2139

2140

2141

20

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

2142

    enum FlattenedStructVariant {

2143

A {

2144

            ho: i32,

2145

            #[serde(flatten)]

2146

            other: HashMap<String, i32>,

2147

            #[serde(flatten)]

2148

            flat: Flattened,

2149

},

2150

2151

2152

4

    assert_eq!(

2153

4

        check_roundtrip(

2154

4

            &FlattenedStructVariant::A {

2155

4

                ho: 24,

2156

4

                other: HashMap::new(),

2157

4

                flat: Flattened::Newtype(()),

2158

4

},

2159

4

            PrettyConfig::default()

2160

4

),

2161

4

        Err(Err(SpannedError {

2162

4

            code: Error::InvalidValueForType {

2163

4

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

2164

4

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

2165

4

},

2166

4

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

2167

4

}))

2168

4

);

2169

4

2170

2171

#[test]

2172

4

fn externally_tagged_struct_variant_beside_map_inside_flatten_struct() {

2173

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

2174

    enum Flattened {

2175

        Struct { hi: i32 },

2176

2177

2178

12

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

2179

    struct FlattenedStruct {

2180

        ho: i32,

2181

        #[serde(flatten)]

2182

        other: HashMap<String, i32>,

2183

        #[serde(flatten)]

2184

        flat: Flattened,

2185

2186

2187

4

    assert_eq!(

2188

4

        check_roundtrip(

2189

4

            &FlattenedStruct {

2190

4

                ho: 24,

2191

4

                other: HashMap::new(),

2192

4

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

2193

4

},

2194

4

            PrettyConfig::default()

2195

4

),

2196

4

        Err(Err(SpannedError {

2197

4

            code: Error::InvalidValueForType {

2198

4

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

2199

4

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

2200

4

},

2201

4

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

2202

4

}))

2203

4

);

2204

4

2205

2206

#[test]

2207

4

fn externally_tagged_tuple_variant_beside_map_inside_flatten_struct_variant() {

2208

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

2209

    enum Flattened {

2210

        Tuple(i32, bool),

2211

2212

2213

20

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

2214

    enum FlattenedStructVariant {

2215

A {

2216

            ho: i32,

2217

            #[serde(flatten)]

2218

            other: HashMap<String, i32>,

2219

            #[serde(flatten)]

2220

            flat: Flattened,

2221

},

2222

2223

2224

4

    assert_eq!(

2225

4

        check_roundtrip(

2226

4

            &FlattenedStructVariant::A {

2227

4

                ho: 24,

2228

4

                other: HashMap::new(),

2229

4

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

2230

4

},

2231

4

            PrettyConfig::default()

2232

4

),

2233

4

        Err(Err(SpannedError {

2234

4

            code: Error::InvalidValueForType {

2235

4

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

2236

4

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

2237

4

},

2238

4

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

2239

4

}))

2240

4

);

2241

4

2242

2243

#[test]

2244

4

fn internally_tagged_unit_variant_beside_map_inside_flatten_struct() {

2245

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

2246

    #[serde(tag = "tag")]

2247

    enum Flattened {

2248

        Unit,

2249

2250

2251

12

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

2252

    struct FlattenedStruct {

2253

        ho: i32,

2254

        #[serde(flatten)]

2255

        other: HashMap<String, i32>,

2256

        #[serde(flatten)]

2257

        flat: Flattened,

2258

2259

2260

4

    assert_eq!(

2261

4

        check_roundtrip(

2262

4

            &FlattenedStruct {

2263

4

                ho: 24,

2264

4

                other: HashMap::new(),

2265

4

                flat: Flattened::Unit,

2266

4

},

2267

4

            PrettyConfig::default()

2268

4

),

2269

4

        Err(Err(SpannedError {

2270

4

            code: Error::InvalidValueForType {

2271

4

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

2272

4

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

2273

4

},

2274

4

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

2275

4

}))

2276

4

);

2277

4

2278

2279

#[test]

2280

4

fn internally_tagged_newtype_variant_beside_map_inside_flatten_struct_variant() {

2281

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

2282

    #[serde(tag = "tag")]

2283

    enum Flattened {

2284

        Newtype(()),

2285

2286

2287

20

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

2288

    enum FlattenedStructVariant {

2289

A {

2290

            ho: i32,

2291

            #[serde(flatten)]

2292

            other: HashMap<String, i32>,

2293

            #[serde(flatten)]

2294

            flat: Flattened,

2295

},

2296

2297

2298

4

    assert_eq!(

2299

4

        check_roundtrip(

2300

4

            &FlattenedStructVariant::A {

2301

4

                ho: 24,

2302

4

                other: HashMap::new(),

2303

4

                flat: Flattened::Newtype(()),

2304

4

},

2305

4

            PrettyConfig::default()

2306

4

),

2307

4

        Err(Err(SpannedError {

2308

4

            code: Error::InvalidValueForType {

2309

4

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

2310

4

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

2311

4

},

2312

4

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

2313

4

}))

2314

4

);

2315

4

2316

2317

#[test]

2318

4

fn internally_tagged_struct_variant_beside_map_inside_flatten_struct() {

2319

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

2320

    #[serde(tag = "tag")]

2321

    enum Flattened {

2322

        Struct { hi: i32 },

2323

2324

2325

16

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

2326

    struct FlattenedStruct {

2327

        ho: i32,

2328

        #[serde(flatten)]

2329

        other: HashMap<String, i32>,

2330

        #[serde(flatten)]

2331

        flat: Flattened,

2332

2333

2334

4

    assert_eq!(

2335

4

        check_roundtrip(

2336

4

            &FlattenedStruct {

2337

4

                ho: 24,

2338

4

                other: HashMap::new(),

2339

4

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

2340

4

},

2341

4

            PrettyConfig::default()

2342

4

),

2343

4

        Err(Err(SpannedError {

2344

4

            code: Error::InvalidValueForType {

2345

4

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

2346

4

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

2347

4

},

2348

4

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

2349

4

}))

2350

4

);

2351

4

2352

2353

#[test]

2354

4

fn adjacently_tagged_unit_variant_beside_map_inside_flatten_struct() {

2355

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

2356

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

2357

    enum Flattened {

2358

        Unit,

2359

2360

2361

12

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

2362

    struct FlattenedStruct {

2363

        ho: i32,

2364

        #[serde(flatten)]

2365

        other: HashMap<String, i32>,

2366

        #[serde(flatten)]

2367

        flat: Flattened,

2368

2369

2370

4

    assert_eq!(

2371

4

        check_roundtrip(

2372

4

            &FlattenedStruct {

2373

4

                ho: 24,

2374

4

                other: HashMap::new(),

2375

4

                flat: Flattened::Unit,

2376

4

},

2377

4

            PrettyConfig::default()

2378

4

),

2379

4

        Err(Err(SpannedError {

2380

4

            code: Error::InvalidValueForType {

2381

4

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

2382

4

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

2383

4

},

2384

4

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

2385

4

}))

2386

4

);

2387

4

2388

2389

#[test]

2390

4

fn adjacently_tagged_newtype_variant_beside_map_inside_flatten_struct_variant() {

2391

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

2392

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

2393

    enum Flattened {

2394

        Newtype(()),

2395

2396

2397

24

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

2398

    enum FlattenedStructVariant {

2399

A {

2400

            ho: i32,

2401

            #[serde(flatten)]

2402

            other: HashMap<String, i32>,

2403

            #[serde(flatten)]

2404

            flat: Flattened,

2405

},

2406

2407

2408

4

    assert_eq!(

2409

4

        check_roundtrip(

2410

4

            &FlattenedStructVariant::A {

2411

4

                ho: 24,

2412

4

                other: HashMap::new(),

2413

4

                flat: Flattened::Newtype(()),

2414

4

},

2415

4

            PrettyConfig::default()

2416

4

),

2417

4

        Err(Err(SpannedError {

2418

4

            code: Error::InvalidValueForType {

2419

4

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

2420

4

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

2421

4

},

2422

4

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

2423

4

}))

2424

4

);

2425

4

2426

2427

#[test]

2428

4

fn adjacently_tagged_struct_variant_beside_map_inside_flatten_struct() {

2429

4

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

2430

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

2431

    enum Flattened {

2432

        Struct { hi: i32 },

2433

2434

2435

16

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

2436

    struct FlattenedStruct {

2437

        ho: i32,

2438

        #[serde(flatten)]

2439

        other: HashMap<String, i32>,

2440

        #[serde(flatten)]

2441

        flat: Flattened,

2442

2443

2444

4

    assert_eq!(

2445

4

        check_roundtrip(

2446

4

            &FlattenedStruct {

2447

4

                ho: 24,

2448

4

                other: HashMap::new(),

2449

4

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

2450

4

},

2451

4

            PrettyConfig::default()

2452

4

),

2453

4

        Err(Err(SpannedError {

2454

4

            code: Error::InvalidValueForType {

2455

4

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

2456

4

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

2457

4

},

2458

4

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

2459

4

}))

2460

4

);

2461

4

2462

2463

#[test]

2464

4

fn adjacently_tagged_tuple_variant_beside_map_inside_flatten_struct_variant() {

2465

4

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

2466

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

2467

    enum Flattened {

2468

        Tuple(i32, bool),

2469

2470

2471

24

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

2472

    enum FlattenedStructVariant {

2473

A {

2474

            ho: i32,

2475

            #[serde(flatten)]

2476

            other: HashMap<String, i32>,

2477

            #[serde(flatten)]

2478

            flat: Flattened,

2479

},

2480

2481

2482

4

    assert_eq!(

2483

4

        check_roundtrip(

2484

4

            &FlattenedStructVariant::A {

2485

4

                ho: 24,

2486

4

                other: HashMap::new(),

2487

4

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

2488

4

},

2489

4

            PrettyConfig::default()

2490

4

),

2491

4

        Err(Err(SpannedError {

2492

4

            code: Error::InvalidValueForType {

2493

4

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

2494

4

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

2495

4

},

2496

4

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

2497

4

}))

2498

4

);

2499

4

2500

2501

#[test]

2502

4

fn tagged_struct_beside_map_inside_flatten_struct() {

2503

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

2504

    #[serde(tag = "tag")]

2505

    struct Flattened {

2506

        hi: i32,

2507

2508

2509

16

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

2510

    struct FlattenedStruct {

2511

        ho: i32,

2512

        #[serde(flatten)]

2513

        other: HashMap<String, i32>,

2514

        #[serde(flatten)]

2515

        flat: Flattened,

2516

2517

2518

4

    assert_eq!(

2519

4

        check_roundtrip(

2520

4

            &FlattenedStruct {

2521

4

                ho: 24,

2522

4

                other: HashMap::new(),

2523

4

                flat: Flattened { hi: 42 },

2524

4

},

2525

4

            PrettyConfig::default()

2526

4

),

2527

4

        Err(Err(SpannedError {

2528

4

            code: Error::InvalidValueForType {

2529

4

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

2530

4

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

2531

4

},

2532

4

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

2533

4

}))

2534

4

);

2535

4

2536

2537

#[test]

2538

4

fn tagged_struct_beside_map_inside_flatten_struct_variant() {

2539

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

2540

    #[serde(tag = "tag")]

2541

    struct Flattened {

2542

        hi: i32,

2543

2544

2545

24

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

2546

    enum FlattenedStructVariant {

2547

A {

2548

            ho: i32,

2549

            #[serde(flatten)]

2550

            other: HashMap<String, i32>,

2551

            #[serde(flatten)]

2552

            flat: Flattened,

2553

},

2554

2555

2556

4

    assert_eq!(

2557

4

        check_roundtrip(

2558

4

            &FlattenedStructVariant::A {

2559

4

                ho: 24,

2560

4

                other: HashMap::new(),

2561

4

                flat: Flattened { hi: 42 },

2562

4

},

2563

4

            PrettyConfig::default()

2564

4

),

2565

4

        Err(Err(SpannedError {

2566

4

            code: Error::InvalidValueForType {

2567

4

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

2568

4

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

2569

4

},

2570

4

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

2571

4

}))

2572

4

);

2573

4

2574

2575

#[test]

2576

4

fn zero_length_untagged_tuple_variant() {

2577

4

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

2578

    #[serde(untagged)]

2579

    enum Untagged {

2580

        A(),

2581

2582

2583

4

    assert_eq!(

2584

4

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

2585

4

        Err(Err(SpannedError {

2586

4

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

2587

4

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

2588

4

)),

2589

4

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

2590

4

}))

2591

4

);

2592

4

2593

2594

#[test]

2595

4

fn zero_length_untagged_struct_variant() {

2596

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

2597

    #[serde(untagged)]

2598

    enum Untagged {

2599

        A {},

2600

2601

2602

4

    assert_eq!(

2603

4

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

2604

4

        Err(Err(SpannedError {

2605

4

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

2606

4

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

2607

4

)),

2608

4

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

2609

4

}))

2610

4

);

2611

4

2612

2613

#[test]

2614

4

fn unwrapped_one_element_untagged_tuple_variant() {

2615

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

2616

8

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

2617

    #[serde(untagged)]

2618

    enum Untagged {

2619

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

2620

2621

2622

4

    assert_eq!(

2623

4

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

2624

4

        Ok(())

2625

4

);

2626

4

    assert_eq!(

2627

4

        check_roundtrip(

2628

4

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

2629

4

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

2630

4

),

2631

4

        Ok(())

2632

4

);

2633

4

2634

2635

#[test]

2636

4

fn unit_inside_untagged_newtype_variant_inside_internally_tagged_newtype_variant() {

2637

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

2638

    #[serde(untagged)]

2639

    enum Untagged {

2640

        Newtype(()),

2641

2642

2643

4

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

2644

    #[serde(tag = "tag")]

2645

    enum InternallyTagged {

2646

        Newtype(Untagged),

2647

2648

2649

4

    assert_eq!(

2650

4

        check_roundtrip(

2651

4

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

2652

4

            PrettyConfig::default()

2653

4

),

2654

4

        Err(Err(SpannedError {

2655

4

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

2656

4

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

2657

4

)),

2658

4

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

2659

4

}))

2660

4

);

2661

4

2662

2663

#[test]

2664

4

fn unit_inside_untagged_newtype_variant_inside_flatten_struct() {

2665

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

2666

    #[serde(untagged)]

2667

    enum Untagged {

2668

        Newtype(()),

2669

2670

2671

8

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

2672

    struct FlattenedStruct {

2673

        ho: i32,

2674

        #[serde(flatten)]

2675

        a: Untagged,

2676

2677

2678

4

    assert_eq!(

2679

4

        check_roundtrip(

2680

4

            &FlattenedStruct {

2681

4

                ho: 24,

2682

4

                a: Untagged::Newtype(()),

2683

4

},

2684

4

            PrettyConfig::default()

2685

4

),

2686

4

        Err(Err(SpannedError {

2687

4

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

2688

4

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

2689

4

)),

2690

4

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

2691

4

}))

2692

4

);

2693

4

2694

2695

#[test]

2696

4

fn unit_struct_inside_untagged_newtype_variant_inside_internally_tagged_newtype_variant() {

2697

4

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

2698

    struct Unit;

2699

2700

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

2701

    #[serde(untagged)]

2702

    enum Untagged {

2703

        Newtype(Unit),

2704

2705

2706

4

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

2707

    #[serde(tag = "tag")]

2708

    enum InternallyTagged {

2709

        Newtype(Untagged),

2710

2711

2712

4

    assert_eq!(

2713

4

        check_roundtrip(

2714

4

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

2715

4

            PrettyConfig::default()

2716

4

),

2717

4

        Err(Err(SpannedError {

2718

4

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

2719

4

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

2720

4

)),

2721

4

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

2722

4

}))

2723

4

);

2724

4

2725

2726

#[test]

2727

4

fn untagged_unit_variant_inside_internally_tagged_newtype_variant() {

2728

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

2729

    #[serde(untagged)]

2730

    enum Untagged {

2731

        Unit,

2732

2733

2734

16

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

2735

    enum FlattenedStructVariant {

2736

C {

2737

            ho: i32,

2738

            #[serde(flatten)]

2739

            a: Untagged,

2740

},

2741

2742

2743

4

    assert_eq!(

2744

4

        check_roundtrip(

2745

4

            &FlattenedStructVariant::C {

2746

4

                ho: 24,

2747

4

                a: Untagged::Unit,

2748

4

},

2749

4

            PrettyConfig::default()

2750

4

),

2751

4

        Err(Err(SpannedError {

2752

4

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

2753

4

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

2754

4

)),

2755

4

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

2756

4

}))

2757

4

);

2758

4

2759

2760

#[test]

2761

4

fn untagged_unit_variant_inside_flatten_struct_variant() {

2762

8

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

2763

    enum Enum {

2764

        Unit,

2765

2766

2767

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

2768

    #[serde(untagged)]

2769

    enum Untagged {

2770

        Unit,

2771

        Newtype(Enum),

2772

2773

2774

8

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

2775

    #[serde(tag = "tag")]

2776

    enum InternallyTagged {

2777

        Newtype(Untagged),

2778

2779

2780

4

    assert_eq!(

2781

4

        check_roundtrip(

2782

4

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

2783

4

            PrettyConfig::default()

2784

4

),

2785

4

        Ok(())

2786

4

);

2787

4

    assert_eq!(

2788

4

        check_roundtrip(

2789

4

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

2790

4

            PrettyConfig::default()

2791

4

),

2792

4

        Err(Err(SpannedError {

2793

4

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

2794

4

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

2795

4

)),

2796

4

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

2797

4

}))

2798

4

);

2799

4

2800

2801

#[test]

2802

4

fn unit_inside_internally_tagged_newtype_variant_inside_multi_flatten_struct() {

2803

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

2804

    struct AnotherFlattenedStruct {

2805

        hi: i32,

2806

2807

2808

4

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

2809

    #[serde(tag = "tag")]

2810

    enum InternallyTagged {

2811

        Newtype(()),

2812

2813

2814

16

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

2815

    struct FlattenedStruct {

2816

        ho: i32,

2817

        #[serde(flatten)]

2818

        a: InternallyTagged,

2819

        #[serde(flatten)]

2820

        b: AnotherFlattenedStruct,

2821

2822

2823

4

    assert_eq!(

2824

4

        check_roundtrip(

2825

4

            &FlattenedStruct {

2826

4

                ho: 24,

2827

4

                a: InternallyTagged::Newtype(()),

2828

4

                b: AnotherFlattenedStruct { hi: 42 },

2829

4

},

2830

4

            PrettyConfig::default()

2831

4

),

2832

4

        Err(Err(SpannedError {

2833

4

            code: Error::InvalidValueForType {

2834

4

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

2835

4

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

2836

4

},

2837

4

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

2838

4

}))

2839

4

);

2840

4

2841

2842

#[test]

2843

4

fn untagged_unit_variant_inside_internally_tagged_newtype_variant_inside_multi_flatten_struct() {

2844

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

2845

    #[serde(untagged)]

2846

    enum Untagged {

2847

        Unit,

2848

2849

2850

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

2851

    struct AnotherFlattenedStruct {

2852

        hi: i32,

2853

2854

2855

4

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

2856

    #[serde(tag = "tag")]

2857

    enum InternallyTagged {

2858

        Newtype(Untagged),

2859

2860

2861

16

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

2862

    struct FlattenedStruct {

2863

        ho: i32,

2864

        #[serde(flatten)]

2865

        a: InternallyTagged,

2866

        #[serde(flatten)]

2867

        b: AnotherFlattenedStruct,

2868

2869

2870

4

    assert_eq!(

2871

4

        check_roundtrip(

2872

4

            &FlattenedStruct {

2873

4

                ho: 24,

2874

4

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

2875

4

                b: AnotherFlattenedStruct { hi: 42 },

2876

4

},

2877

4

            PrettyConfig::default()

2878

4

),

2879

4

        Err(Err(SpannedError {

2880

4

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

2881

4

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

2882

4

)),

2883

4

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

2884

4

}))

2885

4

);

2886

4

2887

2888

#[test]

2889

4

fn flattened_externally_tagged_newtype_variant_beside_flattened_intenally_tagged_enum() {

2890

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

2891

    enum ExternallyTagged {

2892

        Newtype(()),

2893

        Other(()),

2894

2895

2896

4

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

2897

    #[serde(tag = "tag")]

2898

    enum InternallyTagged {

2899

        Newtype(ExternallyTagged),

2900

2901

2902

4

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

2903

    struct Flattened {

2904

        #[serde(flatten)]

2905

        a: InternallyTagged,

2906

        #[serde(flatten)]

2907

        b: ExternallyTagged,

2908

2909

2910

4

    assert_eq!(

2911

4

        check_roundtrip(

2912

4

            &Flattened {

2913

4

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

2914

4

                b: ExternallyTagged::Newtype(()),

2915

4

},

2916

4

            PrettyConfig::default()

2917

4

),

2918

4

        Err(Err(SpannedError {

2919

4

            code: Error::InvalidValueForType {

2920

4

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

2921

4

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

2922

4

},

2923

4

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

2924

4

}))

2925

4

);

2926

4

2927

2928

#[test]

2929

4

fn flattened_externally_tagged_struct_variant_beside_flattened_intenally_tagged_enum() {

2930

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

2931

    enum ExternallyTagged {

2932

        Struct { a: i32 },

2933

        Other(()),

2934

2935

2936

4

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

2937

    #[serde(tag = "tag")]

2938

    enum InternallyTagged {

2939

        Newtype(ExternallyTagged),

2940

2941

2942

4

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

2943

    struct Flattened {

2944

        #[serde(flatten)]

2945

        a: InternallyTagged,

2946

        #[serde(flatten)]

2947

        b: ExternallyTagged,

2948

2949

2950

4

    assert_eq!(

2951

4

        check_roundtrip(

2952

4

            &Flattened {

2953

4

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

2954

4

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

2955

4

},

2956

4

            PrettyConfig::default()

2957

4

),

2958

4

        Err(Err(SpannedError {

2959

4

            code: Error::InvalidValueForType {

2960

4

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

2961

4

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

2962

4

},

2963

4

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

2964

4

}))

2965

4

);

2966

4

2967

2968

#[test]

2969

4

fn flattened_map_inside_option_beside_flattened_struct_variant() {

2970

12

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

2971

    #[serde(untagged)]

2972

    enum Untagged {

2973

        Struct { a: i32 },

2974

2975

2976

4

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

2977

    struct Flattened {

2978

        #[serde(flatten)]

2979

        a: Untagged,

2980

        #[serde(flatten)]

2981

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

2982

2983

2984

4

    assert_eq!(

2985

4

        check_roundtrip(

2986

4

            &Flattened {

2987

4

                a: Untagged::Struct {

2988

4

                    a: 42,

2989

4

},

2990

4

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

2991

4

},

2992

4

            PrettyConfig::default()

2993

4

),

2994

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}) }"))))

2995

4

);

2996

4

2997

2998

#[test]

2999

4

fn flattened_untagged_struct_beside_flattened_untagged_struct() {

3000

24

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

3001

    #[serde(untagged)]

3002

    enum Untagged {

3003

        Struct { a: i32 },

3004

        Other { b: i32 },

3005

3006

3007

4

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

3008

    struct Flattened {

3009

        #[serde(flatten)]

3010

        a: Untagged,

3011

        #[serde(flatten)]

3012

        b: Untagged,

3013

3014

3015

4

    assert_eq!(

3016

4

        check_roundtrip(

3017

4

            &Flattened {

3018

4

                a: Untagged::Struct {

3019

4

                    a: 42,

3020

4

},

3021

4

                b: Untagged::Other {

3022

4

                    b: 24,

3023

4

},

3024

4

},

3025

4

            PrettyConfig::default()

3026

4

),

3027

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 } }"))))

3028

4

);

3029

4

3030

3031

#[test]

3032

4

fn flattened_field_inside_flattened_struct_alongside_map() {

3033

12

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

3034

    struct Units {

3035

        a: i32,

3036

        #[serde(flatten)]

3037

        b: (),

3038

3039

3040

4

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

3041

    struct Flattened {

3042

        #[serde(flatten)]

3043

        a: Units,

3044

        #[serde(flatten)]

3045

        b: BTreeMap<String, i32>,

3046

3047

3048

4

    assert_eq!(

3049

4

        check_roundtrip(

3050

4

            &Flattened {

3051

4

                a: Units {

3052

4

                    a: 42,

3053

4

                    b: (),

3054

4

},

3055

4

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

3056

4

},

3057

4

            PrettyConfig::default()

3058

4

),

3059

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} }"))))

3060

4

);

3061

4

3062

3063

376

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

3064

376

    val: &T,

3065

376

    config: PrettyConfig,

3066

376

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

3067

376

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

3068

366

    println!("{ron}");

3069

366

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

3070

142

    if val == &de {

3071

94

        Ok(())

3072

    } else {

3073

48

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

3074

48

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

3075

48

            val, de

3076

48

        ))))

3077

3078

376