Grcov report - 481_number_underscores

1

use ron::Number;

2

3

#[test]

4

#[allow(clippy::unusual_byte_groupings)]

5

#[allow(clippy::inconsistent_digit_grouping)]

6

#[allow(clippy::zero_prefixed_literal)]

7

4

fn de_integer_underscores() {

8

4

    assert_eq!(ron::from_str("0b10_10___101_"), Ok(0b10_10___101__u8));

9

4

    assert_eq!(

10

4

        ron::from_str::<u8>("_0b1"),

11

        Err(ron::error::SpannedError {

12

            code: ron::Error::UnderscoreAtBeginning,

13

            span: ron::error::Span {

14

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

15

                end: ron::error::Position { line: 1, col: 1 },

16

17

})

18

);

19

4

    assert_eq!(

20

4

        ron::from_str::<u8>("_0b1_u8"),

21

        Err(ron::error::SpannedError {

22

            code: ron::Error::UnderscoreAtBeginning,

23

            // ? Start before end ?

24

            span: ron::error::Span {

25

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

26

                end: ron::error::Position { line: 1, col: 1 },

27

28

})

29

);

30

4

    assert_eq!(

31

4

        ron::from_str::<u8>("0b2"),

32

        Err(ron::error::SpannedError {

33

            code: ron::Error::InvalidIntegerDigit {

34

                digit: '2',

35

                base: 2

36

},

37

            span: ron::error::Span {

38

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

39

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

40

41

})

42

);

43

4

    assert_eq!(

44

4

        ron::from_str::<i32>("-0b2_i32"),

45

        Err(ron::error::SpannedError {

46

            code: ron::Error::InvalidIntegerDigit {

47

                digit: '2',

48

                base: 2

49

},

50

            span: ron::error::Span {

51

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

52

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

53

54

})

55

);

56

57

4

    assert_eq!(ron::from_str("0o71_32___145_"), Ok(0o71_32___145_));

58

4

    assert_eq!(

59

4

        ron::from_str::<u8>("_0o5"),

60

        Err(ron::error::SpannedError {

61

            code: ron::Error::UnderscoreAtBeginning,

62

            span: ron::error::Span {

63

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

64

                end: ron::error::Position { line: 1, col: 1 },

65

66

})

67

);

68

4

    assert_eq!(

69

4

        ron::from_str::<u8>("0oA"),

70

        Err(ron::error::SpannedError {

71

            code: ron::Error::InvalidIntegerDigit {

72

                digit: 'A',

73

                base: 8

74

},

75

            span: ron::error::Span {

76

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

77

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

78

79

})

80

);

81

82

4

    assert_eq!(ron::from_str("0xa1_fe___372_"), Ok(0xa1_fe___372_));

83

4

    assert_eq!(

84

4

        ron::from_str::<u8>("_0xF"),

85

        Err(ron::error::SpannedError {

86

            code: ron::Error::UnderscoreAtBeginning,

87

            span: ron::error::Span {

88

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

89

                end: ron::error::Position { line: 1, col: 1 },

90

91

})

92

);

93

4

    assert_eq!(

94

4

        ron::from_str::<u8>("0xZ"),

95

        Err(ron::error::SpannedError {

96

            code: ron::Error::ExpectedInteger,

97

            span: ron::error::Span {

98

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

99

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

100

101

})

102

);

103

104

4

    assert_eq!(ron::from_str("0_6_163_810___17"), Ok(0_6_163_810___17));

105

4

    assert_eq!(

106

4

        ron::from_str::<u8>("_123"),

107

        Err(ron::error::SpannedError {

108

            code: ron::Error::UnderscoreAtBeginning,

109

            span: ron::error::Span {

110

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

111

                end: ron::error::Position { line: 1, col: 1 },

112

113

})

114

);

115

4

    assert_eq!(

116

4

        ron::from_str::<u8>("12a"),

117

        Err(ron::error::SpannedError {

118

            code: ron::Error::InvalidIntegerDigit {

119

                digit: 'a',

120

                base: 10

121

},

122

            span: ron::error::Span {

123

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

124

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

125

126

})

127

);

128

4

129

130

#[test]

131

#[allow(clippy::inconsistent_digit_grouping)]

132

4

fn de_float_underscores() {

133

4

    assert_eq!(ron::from_str("2_18__6_"), Ok(2_18__6__f32));

134

4

    assert_eq!(

135

4

        ron::from_str::<f32>("_286"),

136

        Err(ron::error::SpannedError {

137

            code: ron::Error::UnderscoreAtBeginning,

138

            span: ron::error::Span {

139

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

140

                end: ron::error::Position { line: 1, col: 1 },

141

142

})

143

);

144

4

    assert_eq!(

145

4

        ron::from_str::<f32>("2a86"),

146

        Err(ron::error::SpannedError {

147

            code: ron::Error::TrailingCharacters,

148

            span: ron::error::Span {

149

                start: ron::error::Position { line: 1, col: 2 },

150

                end: ron::error::Position { line: 1, col: 2 },

151

152

})

153

);

154

155

4

    assert_eq!(ron::from_str("2_18__6_."), Ok(2_18__6__f32));

156

4

    assert_eq!(

157

4

        ron::from_str::<f32>("2_18__6_._"),

158

        Err(ron::error::SpannedError {

159

            code: ron::Error::FloatUnderscore,

160

            span: ron::error::Span {

161

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

162

                end: ron::error::Position { line: 1, col: 10 },

163

164

})

165

);

166

4

    assert_eq!(

167

4

        ron::from_str::<f32>("2_18__6_.3__7_"),

168

        Ok(2_18__6_.3__7__f32)

169

);

170

171

4

    assert_eq!(ron::from_str::<f32>(".3__7_"), Ok(0.3__7__f32));

172

4

    assert_eq!(

173

4

        ron::from_str::<f32>("._3__7_"),

174

        Err(ron::error::SpannedError {

175

            code: ron::Error::FloatUnderscore,

176

            span: ron::error::Span {

177

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

178

                end: ron::error::Position { line: 1, col: 2 },

179

180

})

181

);

182

183

4

    assert_eq!(

184

4

        ron::from_str::<f64>("2_18__6_.3__7_e____7_3__"),

185

        Ok(2_18__6_.3__7_e____7_3___f64)

186

);

187

4

    assert_eq!(

188

4

        ron::from_str::<f64>("2_18__6_.3__7_e+____"),

189

        Err(ron::error::SpannedError {

190

            code: ron::Error::ExpectedFloat,

191

            span: ron::error::Span {

192

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

193

                end: ron::error::Position { line: 1, col: 1 },

194

195

})

196

);

197

4

198

199

#[test]

200

4

fn value_number_suffix_roundtrip() {

201

4

    assert_eq!(

202

4

        ron::from_str::<ron::Value>("1_f32").unwrap(),

203

4

        ron::Value::Number(ron::value::Number::new(1_f32))

204

);

205

4

    assert_eq!(

206

4

        ron::from_str::<ron::Value>("-1_f32").unwrap(),

207

4

        ron::Value::Number(ron::value::Number::new(-1_f32))

208

);

209

210

4

    check_number_roundtrip(f32::NAN, "f32", f64::NAN);

211

4

    check_number_roundtrip(-f32::NAN, "f32", -f64::NAN);

212

4

    check_number_roundtrip(f32::INFINITY, "f32", f64::INFINITY);

213

4

    check_number_roundtrip(f32::NEG_INFINITY, "f32", f64::NEG_INFINITY);

214

215

4

    check_number_roundtrip(f64::NAN, "f64", f64::NAN);

216

4

    check_number_roundtrip(-f64::NAN, "f64", -f64::NAN);

217

4

    check_number_roundtrip(f64::INFINITY, "f64", f64::INFINITY);

218

4

    check_number_roundtrip(f64::NEG_INFINITY, "f64", f64::NEG_INFINITY);

219

220

    macro_rules! test_min_max {

221

        ($($ty:ty),*) => {

222

$(

223

                check_number_roundtrip(<$ty>::MIN, stringify!($ty), <$ty>::MIN as f64);

224

                check_number_roundtrip(<$ty>::MAX, stringify!($ty), <$ty>::MAX as f64);

225

)*

226

};

227

228

229

4

    test_min_max! { i8, i16, i32, i64, u8, u16, u32, u64, f32, f64 }

230

    #[cfg(feature = "integer128")]

231

2

    test_min_max! { i128, u128 }

232

4

233

234

120

fn check_number_roundtrip<

235

120

    T: Copy

236

120

        + Into<Number>

237

120

        + serde::Serialize

238

120

        + serde::de::DeserializeOwned

239

120

        + PartialEq

240

120

        + core::fmt::Debug,

241

120

>(

242

120

    n: T,

243

120

    suffix: &str,

244

120

    n_f64: f64,

245

120

) {

246

120

    let number: Number = n.into();

247

120

    let ron = ron::ser::to_string_pretty(

248

120

        &number,

249

120

        ron::ser::PrettyConfig::default().number_suffixes(true),

250

251

120

    .unwrap();

252

120

    assert!(ron.ends_with(suffix));

253

254

120

    let ron =

255

120

        ron::ser::to_string_pretty(&n, ron::ser::PrettyConfig::default().number_suffixes(true))

256

120

            .unwrap();

257

120

    assert!(ron.ends_with(suffix));

258

259

120

    let de: ron::Value = ron::from_str(&ron).unwrap();

260

120

    assert_eq!(de, ron::Value::Number(number));

261

262

120

    let de: T = ron::from_str(&ron).unwrap();

263

120

    let de_number: Number = de.into();

264

120

    assert_eq!(de_number, number);

265

266

120

    assert_eq!(Number::from(de_number.into_f64()), Number::from(n_f64));

267

120

268

269

#[test]

270

4

fn negative_unsigned() {

271

4

    assert_eq!(

272

4

        ron::from_str::<ron::Value>("-1u8"),

273

        Err(ron::error::SpannedError {

274

            code: ron::Error::IntegerOutOfBounds,

275

            span: ron::error::Span {

276

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

277

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

278

279

})

280

);

281

4

    assert_eq!(

282

4

        ron::from_str::<ron::Value>("-1u16"),

283

        Err(ron::error::SpannedError {

284

            code: ron::Error::IntegerOutOfBounds,

285

            span: ron::error::Span {

286

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

287

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

288

289

})

290

);

291

4

    assert_eq!(

292

4

        ron::from_str::<ron::Value>("-1u32"),

293

        Err(ron::error::SpannedError {

294

            code: ron::Error::IntegerOutOfBounds,

295

            span: ron::error::Span {

296

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

297

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

298

299

})

300

);

301

4

    assert_eq!(

302

4

        ron::from_str::<ron::Value>("-1u64"),

303

        Err(ron::error::SpannedError {

304

            code: ron::Error::IntegerOutOfBounds,

305

            span: ron::error::Span {

306

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

307

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

308

309

})

310

);

311

    #[cfg(feature = "integer128")]

312

2

    assert_eq!(

313

2

        ron::from_str::<ron::Value>("-1u128"),

314

        Err(ron::error::SpannedError {

315

            code: ron::Error::IntegerOutOfBounds,

316

            span: ron::error::Span {

317

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

318

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

319

320

})

321

);

322

323

4

    assert_eq!(

324

4

        ron::from_str::<u8>("-1u8"),

325

        Err(ron::error::SpannedError {

326

            code: ron::Error::IntegerOutOfBounds,

327

            span: ron::error::Span {

328

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

329

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

330

331

})

332

);

333

4

    assert_eq!(

334

4

        ron::from_str::<u16>("-1u16"),

335

        Err(ron::error::SpannedError {

336

            code: ron::Error::IntegerOutOfBounds,

337

            span: ron::error::Span {

338

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

339

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

340

341

})

342

);

343

4

    assert_eq!(

344

4

        ron::from_str::<u32>("-1u32"),

345

        Err(ron::error::SpannedError {

346

            code: ron::Error::IntegerOutOfBounds,

347

            span: ron::error::Span {

348

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

349

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

350

351

})

352

);

353

4

    assert_eq!(

354

4

        ron::from_str::<u64>("-1u64"),

355

        Err(ron::error::SpannedError {

356

            code: ron::Error::IntegerOutOfBounds,

357

            span: ron::error::Span {

358

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

359

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

360

361

})

362

);

363

    #[cfg(feature = "integer128")]

364

2

    assert_eq!(

365

2

        ron::from_str::<u128>("-1u128"),

366

        Err(ron::error::SpannedError {

367

            code: ron::Error::IntegerOutOfBounds,

368

            span: ron::error::Span {

369

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

370

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

371

372

})

373

);

374

4

375

376

#[test]

377

4

fn invalid_suffix() {

378

4

    assert_eq!(

379

4

        ron::from_str::<ron::Value>("1u7"),

380

        Err(ron::error::SpannedError {

381

            code: ron::Error::TrailingCharacters,

382

            span: ron::error::Span {

383

                start: ron::error::Position { line: 1, col: 2 },

384

                end: ron::error::Position { line: 1, col: 2 },

385

386

})

387

);

388

4

    assert_eq!(

389

4

        ron::from_str::<ron::Value>("1f17"),

390

        Err(ron::error::SpannedError {

391

            code: ron::Error::TrailingCharacters,

392

            span: ron::error::Span {

393

                start: ron::error::Position { line: 1, col: 2 },

394

                end: ron::error::Position { line: 1, col: 2 },

395

396

})

397

);

398

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

399

2

    assert_eq!(

400

2

        ron::from_str::<ron::Value>("1u128"),

401

        Err(ron::error::SpannedError {

402

            code: ron::Error::TrailingCharacters,

403

            span: ron::error::Span {

404

                start: ron::error::Position { line: 1, col: 2 },

405

                end: ron::error::Position { line: 1, col: 2 },

406

407

})

408

);

409

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

410

2

    assert_eq!(

411

2

        ron::from_str::<ron::Value>("1i128"),

412

        Err(ron::error::SpannedError {

413

            code: ron::Error::TrailingCharacters,

414

            span: ron::error::Span {

415

                start: ron::error::Position { line: 1, col: 2 },

416

                end: ron::error::Position { line: 1, col: 2 },

417

418

})

419

);

420

421

4

    assert_eq!(

422

4

        ron::from_str::<u8>("1u7"),

423

        Err(ron::error::SpannedError {

424

            code: ron::Error::TrailingCharacters,

425

            span: ron::error::Span {

426

                start: ron::error::Position { line: 1, col: 2 },

427

                end: ron::error::Position { line: 1, col: 2 },

428

429

})

430

);

431

4

    assert_eq!(

432

4

        ron::from_str::<f32>("1f17"),

433

        Err(ron::error::SpannedError {

434

            code: ron::Error::TrailingCharacters,

435

            span: ron::error::Span {

436

                start: ron::error::Position { line: 1, col: 2 },

437

                end: ron::error::Position { line: 1, col: 2 },

438

439

})

440

);

441

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

442

2

    assert_eq!(

443

2

        ron::from_str::<u64>("1u128"),

444

        Err(ron::error::SpannedError {

445

            code: ron::Error::TrailingCharacters,

446

            span: ron::error::Span {

447

                start: ron::error::Position { line: 1, col: 2 },

448

                end: ron::error::Position { line: 1, col: 2 },

449

450

})

451

);

452

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

453

2

    assert_eq!(

454

2

        ron::from_str::<i64>("1i128"),

455

        Err(ron::error::SpannedError {

456

            code: ron::Error::TrailingCharacters,

457

            span: ron::error::Span {

458

                start: ron::error::Position { line: 1, col: 2 },

459

                end: ron::error::Position { line: 1, col: 2 },

460

461

})

462

);

463

4

464

465

#[test]

466

4

fn number_type_mismatch() {

467

4

    assert_eq!(

468

4

        ron::from_str::<u8>("1i32"),

469

4

        Err(ron::error::SpannedError {

470

4

            code: ron::Error::InvalidValueForType {

471

4

                expected: String::from("an 8-bit unsigned integer"),

472

4

                found: String::from("1i32")

473

4

},

474

4

            span: ron::error::Span {

475

4

                start: ron::error::Position { line: 1, col: 2 },

476

4

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

477

4

478

4

})

479

);

480

481

4

    assert_eq!(

482

4

        ron::from_str::<i64>("-1u8"),

483

        Err(ron::error::SpannedError {

484

            code: ron::Error::IntegerOutOfBounds,

485

            span: ron::error::Span {

486

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

487

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

488

489

})

490

);

491

492

4

    assert_eq!(

493

4

        ron::from_str::<f32>("1f64"),

494

4

        Err(ron::error::SpannedError {

495

4

            code: ron::Error::InvalidValueForType {

496

4

                expected: String::from("a 32-bit floating point number"),

497

4

                found: String::from("1f64")

498

4

},

499

4

            span: ron::error::Span {

500

4

                start: ron::error::Position { line: 1, col: 2 },

501

4

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

502

4

503

4

})

504

);

505

506

4

    assert_eq!(

507

4

        ron::from_str::<f64>("1f32"),

508

4

        Err(ron::error::SpannedError {

509

4

            code: ron::Error::InvalidValueForType {

510

4

                expected: String::from("a 64-bit floating point number"),

511

4

                found: String::from("1f32")

512

4

},

513

4

            span: ron::error::Span {

514

4

                start: ron::error::Position { line: 1, col: 2 },

515

4

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

516

4

517

4

})

518

);

519

520

    macro_rules! test_mismatch {

521

        ($($ty:ty),*) => {

522

$(

523

                check_number_type_mismatch::<$ty>("i8");

524

                check_number_type_mismatch::<$ty>("i16");

525

                check_number_type_mismatch::<$ty>("i32");

526

                check_number_type_mismatch::<$ty>("i64");

527

                #[cfg(feature = "integer128")]

528

                check_number_type_mismatch::<$ty>("i128");

529

                check_number_type_mismatch::<$ty>("u8");

530

                check_number_type_mismatch::<$ty>("u16");

531

                check_number_type_mismatch::<$ty>("u32");

532

                check_number_type_mismatch::<$ty>("u64");

533

                #[cfg(feature = "integer128")]

534

                check_number_type_mismatch::<$ty>("u128");

535

)*

536

};

537

538

539

4

    test_mismatch! { i8, i16, i32, i64, u8, u16, u32, u64 }

540

    #[cfg(feature = "integer128")]

541

2

    test_mismatch! { i128, u128 }

542

4

543

544

328

fn check_number_type_mismatch<T: core::fmt::Debug + serde::de::DeserializeOwned>(suffix: &str) {

545

328

    let ron = format!("0{suffix}");

546

547

328

    if suffix.starts_with(std::any::type_name::<T>()) {

548

36

        assert!(ron::from_str::<T>(&ron).is_ok());

549

36

        return;

550

292

551

552

292

    let err = ron::from_str::<T>(&ron).unwrap_err();

553

554

292

    println!("{:?} {}", err, suffix);

555

556

292

    assert_eq!(

557

        err.span.end,

558

292

        ron::error::Position {

559

292

            line: 1,

560

292

            col: 2 + suffix.len()

561

292

562

);

563

564

292

    if !matches!(&err.code, ron::Error::InvalidValueForType { found, .. } if found == &ron ) {

565

        panic!("{:?}", err.code); // GRCOV_EXCL_LINE

566

292

567

328

568

569

#[test]

570

4

fn float_const_prefix() {

571

4

    assert_eq!(

572

4

        ron::from_str::<f32>("NaNf32a").unwrap_err(),

573

        ron::error::SpannedError {

574

            code: ron::Error::ExpectedFloat,

575

            span: ron::error::Span {

576

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

577

                end: ron::error::Position { line: 1, col: 1 },

578

579

580

);

581

582

4

    assert_eq!(

583

4

        ron::from_str::<f64>("-inff64a").unwrap_err(),

584

        ron::error::SpannedError {

585

            code: ron::Error::ExpectedFloat,

586

            span: ron::error::Span {

587

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

588

                end: ron::error::Position { line: 1, col: 1 },

589

590

591

);

592

593

4

    assert_eq!(

594

4

        ron::from_str::<f32>("+NaNf17").unwrap_err(),

595

        ron::error::SpannedError {

596

            code: ron::Error::ExpectedFloat,

597

            span: ron::error::Span {

598

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

599

                end: ron::error::Position { line: 1, col: 1 },

600

601

602

);

603

4

604

605

#[test]

606

4

fn invalid_float() {

607

4

    assert_eq!(

608

4

        ron::from_str::<f32>("1ee3").unwrap_err(),

609

        ron::error::SpannedError {

610

            code: ron::Error::ExpectedFloat,

611

            span: ron::error::Span {

612

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

613

                end: ron::error::Position { line: 1, col: 1 },

614

615

616

);

617

4

    assert_eq!(

618

4

        ron::from_str::<f32>("1ee3f32").unwrap_err(),

619

        ron::error::SpannedError {

620

            code: ron::Error::ExpectedFloat,

621

            // ? Start before end ?

622

            span: ron::error::Span {

623

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

624

                end: ron::error::Position { line: 1, col: 1 },

625

626

627

);

628

4

    assert_eq!(

629

4

        ron::from_str::<f64>("1ee3f64").unwrap_err(),

630

        ron::error::SpannedError {

631

            code: ron::Error::ExpectedFloat,

632

            // ? Start before end ?

633

            span: ron::error::Span {

634

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

635

                end: ron::error::Position { line: 1, col: 1 },

636

637

638

);

639

4

640

641

#[test]

642

4

fn fuzzer_found_issues() {

643

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

644

    enum A {

645

        #[serde(rename = "true")]

646

        True(bool),

647

        #[serde(rename = "false")]

648

        False(bool),

649

        #[serde(rename = "Some")]

650

        Some(bool),

651

        #[serde(rename = "None")]

652

        None(bool),

653

        #[serde(rename = "inf")]

654

        Inf(bool),

655

        #[serde(rename = "inff32")]

656

        InfF32(bool),

657

        #[serde(rename = "inff64")]

658

        InfF64(bool),

659

        #[serde(rename = "NaN")]

660

        NaN(bool),

661

        #[serde(rename = "NaNf32")]

662

        NaNF32(bool),

663

        #[serde(rename = "NaNf64")]

664

        NaNF64(bool),

665

666

667

4

    assert_eq!(ron::to_string(&A::True(false)).unwrap(), "r#true(false)");

668

4

    assert_eq!(ron::from_str::<A>("r#true(false)").unwrap(), A::True(false));

669

4

    assert_eq!(

670

4

        ron::from_str::<ron::Value>("true(false)").unwrap_err(),

671

        ron::error::SpannedError {

672

            code: ron::Error::TrailingCharacters,

673

            span: ron::error::Span {

674

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

675

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

676

677

678

);

679

680

4

    assert_eq!(ron::to_string(&A::False(true)).unwrap(), "r#false(true)");

681

4

    assert_eq!(ron::from_str::<A>("r#false(true)").unwrap(), A::False(true));

682

4

    assert_eq!(

683

4

        ron::from_str::<ron::Value>("false(true)").unwrap_err(),

684

        ron::error::SpannedError {

685

            code: ron::Error::TrailingCharacters,

686

            span: ron::error::Span {

687

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

688

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

689

690

691

);

692

693

4

    assert_eq!(ron::to_string(&A::Some(false)).unwrap(), "r#Some(false)");

694

4

    assert_eq!(ron::from_str::<A>("r#Some(false)").unwrap(), A::Some(false));

695

4

    assert_eq!(

696

4

        ron::from_str::<ron::Value>("Some(false)").unwrap(),

697

4

        ron::Value::Option(Some(Box::new(ron::Value::Bool(false)))),

698

);

699

700

4

    assert_eq!(ron::to_string(&A::None(true)).unwrap(), "r#None(true)");

701

4

    assert_eq!(ron::from_str::<A>("r#None(true)").unwrap(), A::None(true));

702

4

    assert_eq!(

703

4

        ron::from_str::<ron::Value>("None(true)").unwrap_err(),

704

        ron::error::SpannedError {

705

            code: ron::Error::TrailingCharacters,

706

            span: ron::error::Span {

707

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

708

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

709

710

711

);

712

713

4

    assert_eq!(ron::to_string(&A::Inf(false)).unwrap(), "r#inf(false)");

714

4

    assert_eq!(ron::from_str::<A>("r#inf(false)").unwrap(), A::Inf(false));

715

4

    assert_eq!(

716

4

        ron::from_str::<ron::Value>("inf(false)").unwrap_err(),

717

        ron::error::SpannedError {

718

            code: ron::Error::TrailingCharacters,

719

            span: ron::error::Span {

720

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

721

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

722

723

724

);

725

726

4

    assert_eq!(

727

4

        ron::to_string(&A::InfF32(false)).unwrap(),

728

        "r#inff32(false)"

729

);

730

4

    assert_eq!(

731

4

        ron::from_str::<A>("r#inff32(false)").unwrap(),

732

        A::InfF32(false)

733

);

734

4

    assert_eq!(

735

4

        ron::from_str::<ron::Value>("inff32(false)").unwrap_err(),

736

        ron::error::SpannedError {

737

            code: ron::Error::TrailingCharacters,

738

            span: ron::error::Span {

739

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

740

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

741

742

743

);

744

745

4

    assert_eq!(

746

4

        ron::to_string(&A::InfF64(false)).unwrap(),

747

        "r#inff64(false)"

748

);

749

4

    assert_eq!(

750

4

        ron::from_str::<A>("r#inff64(false)").unwrap(),

751

        A::InfF64(false)

752

);

753

4

    assert_eq!(

754

4

        ron::from_str::<ron::Value>("inff64(false)").unwrap_err(),

755

        ron::error::SpannedError {

756

            code: ron::Error::TrailingCharacters,

757

            span: ron::error::Span {

758

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

759

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

760

761

762

);

763

764

4

    assert_eq!(ron::to_string(&A::NaN(true)).unwrap(), "r#NaN(true)");

765

4

    assert_eq!(ron::from_str::<A>("r#NaN(true)").unwrap(), A::NaN(true));

766

4

    assert_eq!(

767

4

        ron::from_str::<ron::Value>("NaN(true)").unwrap_err(),

768

        ron::error::SpannedError {

769

            code: ron::Error::TrailingCharacters,

770

            span: ron::error::Span {

771

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

772

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

773

774

775

);

776

777

4

    assert_eq!(ron::to_string(&A::NaNF32(true)).unwrap(), "r#NaNf32(true)");

778

4

    assert_eq!(

779

4

        ron::from_str::<A>("r#NaNf32(true)").unwrap(),

780

        A::NaNF32(true)

781

);

782

4

    assert_eq!(

783

4

        ron::from_str::<ron::Value>("NaNf32(true)").unwrap_err(),

784

        ron::error::SpannedError {

785

            code: ron::Error::TrailingCharacters,

786

            span: ron::error::Span {

787

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

788

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

789

790

791

);

792

793

4

    assert_eq!(ron::to_string(&A::NaNF64(true)).unwrap(), "r#NaNf64(true)");

794

4

    assert_eq!(

795

4

        ron::from_str::<A>("r#NaNf64(true)").unwrap(),

796

        A::NaNF64(true)

797

);

798

4

    assert_eq!(

799

4

        ron::from_str::<ron::Value>("NaNf64(true)").unwrap_err(),

800

        ron::error::SpannedError {

801

            code: ron::Error::TrailingCharacters,

802

            span: ron::error::Span {

803

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

804

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

805

806

807

);

808

4