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

4

        Err(ron::error::SpannedError {

12

4

            code: ron::Error::UnderscoreAtBeginning,

13

4

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

14

4

})

15

4

);

16

4

    assert_eq!(

17

4

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

18

4

        Err(ron::error::SpannedError {

19

4

            code: ron::Error::UnderscoreAtBeginning,

20

4

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

21

4

})

22

4

);

23

4

    assert_eq!(

24

4

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

25

4

        Err(ron::error::SpannedError {

26

4

            code: ron::Error::InvalidIntegerDigit {

27

4

                digit: '2',

28

4

                base: 2

29

4

},

30

4

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

31

4

})

32

4

);

33

4

    assert_eq!(

34

4

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

35

4

        Err(ron::error::SpannedError {

36

4

            code: ron::Error::InvalidIntegerDigit {

37

4

                digit: '2',

38

4

                base: 2

39

4

},

40

4

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

41

4

})

42

4

);

43

44

4

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

45

4

    assert_eq!(

46

4

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

47

4

        Err(ron::error::SpannedError {

48

4

            code: ron::Error::UnderscoreAtBeginning,

49

4

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

50

4

})

51

4

);

52

4

    assert_eq!(

53

4

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

54

4

        Err(ron::error::SpannedError {

55

4

            code: ron::Error::InvalidIntegerDigit {

56

4

                digit: 'A',

57

4

                base: 8

58

4

},

59

4

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

60

4

})

61

4

);

62

63

4

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

64

4

    assert_eq!(

65

4

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

66

4

        Err(ron::error::SpannedError {

67

4

            code: ron::Error::UnderscoreAtBeginning,

68

4

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

69

4

})

70

4

);

71

4

    assert_eq!(

72

4

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

73

4

        Err(ron::error::SpannedError {

74

4

            code: ron::Error::ExpectedInteger,

75

4

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

76

4

})

77

4

);

78

79

4

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

80

4

    assert_eq!(

81

4

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

82

4

        Err(ron::error::SpannedError {

83

4

            code: ron::Error::UnderscoreAtBeginning,

84

4

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

85

4

})

86

4

);

87

4

    assert_eq!(

88

4

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

89

4

        Err(ron::error::SpannedError {

90

4

            code: ron::Error::InvalidIntegerDigit {

91

4

                digit: 'a',

92

4

                base: 10

93

4

},

94

4

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

95

4

})

96

4

);

97

4

98

99

#[test]

100

#[allow(clippy::inconsistent_digit_grouping)]

101

4

fn de_float_underscores() {

102

4

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

103

4

    assert_eq!(

104

4

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

105

4

        Err(ron::error::SpannedError {

106

4

            code: ron::Error::UnderscoreAtBeginning,

107

4

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

108

4

})

109

4

);

110

4

    assert_eq!(

111

4

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

112

4

        Err(ron::error::SpannedError {

113

4

            code: ron::Error::TrailingCharacters,

114

4

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

115

4

})

116

4

);

117

118

4

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

119

4

    assert_eq!(

120

4

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

121

4

        Err(ron::error::SpannedError {

122

4

            code: ron::Error::FloatUnderscore,

123

4

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

124

4

})

125

4

);

126

4

    assert_eq!(

127

4

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

128

4

        Ok(2_18__6_.3__7__f32)

129

4

);

130

131

4

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

132

4

    assert_eq!(

133

4

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

134

4

        Err(ron::error::SpannedError {

135

4

            code: ron::Error::FloatUnderscore,

136

4

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

137

4

})

138

4

);

139

140

4

    assert_eq!(

141

4

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

142

4

        Ok(2_18__6_.3__7_e____7_3___f64)

143

4

);

144

4

    assert_eq!(

145

4

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

146

4

        Err(ron::error::SpannedError {

147

4

            code: ron::Error::ExpectedFloat,

148

4

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

149

4

})

150

4

);

151

4

152

153

#[test]

154

4

fn value_number_suffix_roundtrip() {

155

4

    assert_eq!(

156

4

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

157

4

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

158

4

);

159

4

    assert_eq!(

160

4

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

161

4

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

162

4

);

163

164

4

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

165

4

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

166

4

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

167

4

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

168

4

169

4

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

170

4

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

171

4

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

172

4

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

173

174

    macro_rules! test_min_max {

175

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

176

$(

177

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

178

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

179

)*

180

};

181

182

183

4

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

184

4

    #[cfg(feature = "integer128")]

185

4

    test_min_max! { i128, u128 }

186

4

187

188

120

fn check_number_roundtrip<

189

120

    T: Copy

190

120

        + Into<Number>

191

120

        + serde::Serialize

192

120

        + serde::de::DeserializeOwned

193

120

        + PartialEq

194

120

        + std::fmt::Debug,

195

120

>(

196

120

    n: T,

197

120

    suffix: &str,

198

120

    n_f64: f64,

199

120

) {

200

120

    let number: Number = n.into();

201

120

    let ron = ron::ser::to_string_pretty(

202

120

        &number,

203

120

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

204

120

205

120

    .unwrap();

206

120

    assert!(ron.ends_with(suffix));

207

208

120

    let ron =

209

120

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

210

120

            .unwrap();

211

120

    assert!(ron.ends_with(suffix));

212

213

120

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

214

120

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

215

216

120

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

217

120

    let de_number: Number = de.into();

218

120

    assert_eq!(de_number, number);

219

220

120

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

221

120

222

223

#[test]

224

4

fn negative_unsigned() {

225

4

    assert_eq!(

226

4

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

227

4

        Err(ron::error::SpannedError {

228

4

            code: ron::Error::IntegerOutOfBounds,

229

4

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

230

4

})

231

4

);

232

4

    assert_eq!(

233

4

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

234

4

        Err(ron::error::SpannedError {

235

4

            code: ron::Error::IntegerOutOfBounds,

236

4

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

237

4

})

238

4

);

239

4

    assert_eq!(

240

4

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

241

4

        Err(ron::error::SpannedError {

242

4

            code: ron::Error::IntegerOutOfBounds,

243

4

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

244

4

})

245

4

);

246

4

    assert_eq!(

247

4

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

248

4

        Err(ron::error::SpannedError {

249

4

            code: ron::Error::IntegerOutOfBounds,

250

4

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

251

4

})

252

4

);

253

    #[cfg(feature = "integer128")]

254

2

    assert_eq!(

255

2

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

256

2

        Err(ron::error::SpannedError {

257

2

            code: ron::Error::IntegerOutOfBounds,

258

2

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

259

2

})

260

2

);

261

262

4

    assert_eq!(

263

4

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

264

4

        Err(ron::error::SpannedError {

265

4

            code: ron::Error::IntegerOutOfBounds,

266

4

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

267

4

})

268

4

);

269

4

    assert_eq!(

270

4

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

271

4

        Err(ron::error::SpannedError {

272

4

            code: ron::Error::IntegerOutOfBounds,

273

4

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

274

4

})

275

4

);

276

4

    assert_eq!(

277

4

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

278

4

        Err(ron::error::SpannedError {

279

4

            code: ron::Error::IntegerOutOfBounds,

280

4

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

281

4

})

282

4

);

283

4

    assert_eq!(

284

4

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

285

4

        Err(ron::error::SpannedError {

286

4

            code: ron::Error::IntegerOutOfBounds,

287

4

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

288

4

})

289

4

);

290

    #[cfg(feature = "integer128")]

291

2

    assert_eq!(

292

2

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

293

2

        Err(ron::error::SpannedError {

294

2

            code: ron::Error::IntegerOutOfBounds,

295

2

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

296

2

})

297

2

);

298

4

299

300

#[test]

301

4

fn invalid_suffix() {

302

4

    assert_eq!(

303

4

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

304

4

        Err(ron::error::SpannedError {

305

4

            code: ron::Error::TrailingCharacters,

306

4

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

307

4

})

308

4

);

309

4

    assert_eq!(

310

4

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

311

4

        Err(ron::error::SpannedError {

312

4

            code: ron::Error::TrailingCharacters,

313

4

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

314

4

})

315

4

);

316

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

317

2

    assert_eq!(

318

2

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

319

2

        Err(ron::error::SpannedError {

320

2

            code: ron::Error::TrailingCharacters,

321

2

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

322

2

})

323

2

);

324

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

325

2

    assert_eq!(

326

2

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

327

2

        Err(ron::error::SpannedError {

328

2

            code: ron::Error::TrailingCharacters,

329

2

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

330

2

})

331

2

);

332

333

4

    assert_eq!(

334

4

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

335

4

        Err(ron::error::SpannedError {

336

4

            code: ron::Error::TrailingCharacters,

337

4

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

338

4

})

339

4

);

340

4

    assert_eq!(

341

4

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

342

4

        Err(ron::error::SpannedError {

343

4

            code: ron::Error::TrailingCharacters,

344

4

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

345

4

})

346

4

);

347

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

348

2

    assert_eq!(

349

2

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

350

2

        Err(ron::error::SpannedError {

351

2

            code: ron::Error::TrailingCharacters,

352

2

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

353

2

})

354

2

);

355

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

356

2

    assert_eq!(

357

2

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

358

2

        Err(ron::error::SpannedError {

359

2

            code: ron::Error::TrailingCharacters,

360

2

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

361

2

})

362

2

);

363

4

364

365

#[test]

366

4

fn number_type_mismatch() {

367

4

    assert_eq!(

368

4

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

369

4

        Err(ron::error::SpannedError {

370

4

            code: ron::Error::InvalidValueForType {

371

4

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

372

4

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

373

4

},

374

4

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

375

4

})

376

4

);

377

378

4

    assert_eq!(

379

4

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

380

4

        Err(ron::error::SpannedError {

381

4

            code: ron::Error::IntegerOutOfBounds,

382

4

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

383

4

})

384

4

);

385

386

4

    assert_eq!(

387

4

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

388

4

        Err(ron::error::SpannedError {

389

4

            code: ron::Error::InvalidValueForType {

390

4

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

391

4

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

392

4

},

393

4

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

394

4

})

395

4

);

396

397

4

    assert_eq!(

398

4

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

399

4

        Err(ron::error::SpannedError {

400

4

            code: ron::Error::InvalidValueForType {

401

4

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

402

4

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

403

4

},

404

4

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

405

4

})

406

4

);

407

408

    macro_rules! test_mismatch {

409

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

410

$(

411

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

412

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

413

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

414

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

415

                #[cfg(feature = "integer128")]

416

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

417

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

418

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

419

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

420

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

421

                #[cfg(feature = "integer128")]

422

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

423

)*

424

};

425

426

427

4

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

428

4

    #[cfg(feature = "integer128")]

429

4

    test_mismatch! { i128, u128 }

430

4

431

432

328

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

433

328

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

434

328

435

328

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

436

36

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

437

36

        return;

438

292

439

292

440

292

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

441

292

442

292

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

443

292

444

292

    assert_eq!(

445

292

        err.position,

446

292

        ron::error::Position {

447

292

            line: 1,

448

292

            col: 2 + suffix.len()

449

292

450

292

);

451

452

292

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

453

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

454

292

455

328

456

457

#[test]

458

4

fn float_const_prefix() {

459

4

    assert_eq!(

460

4

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

461

4

        ron::error::SpannedError {

462

4

            code: ron::Error::ExpectedFloat,

463

4

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

464

4

465

4

);

466

467

4

    assert_eq!(

468

4

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

469

4

        ron::error::SpannedError {

470

4

            code: ron::Error::ExpectedFloat,

471

4

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

472

4

473

4

);

474

475

4

    assert_eq!(

476

4

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

477

4

        ron::error::SpannedError {

478

4

            code: ron::Error::ExpectedFloat,

479

4

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

480

4

481

4

);

482

4

483

484

#[test]

485

4

fn invalid_float() {

486

4

    assert_eq!(

487

4

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

488

4

        ron::error::SpannedError {

489

4

            code: ron::Error::ExpectedFloat,

490

4

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

491

4

492

4

);

493

4

    assert_eq!(

494

4

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

495

4

        ron::error::SpannedError {

496

4

            code: ron::Error::ExpectedFloat,

497

4

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

498

4

499

4

);

500

4

    assert_eq!(

501

4

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

502

4

        ron::error::SpannedError {

503

4

            code: ron::Error::ExpectedFloat,

504

4

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

505

4

506

4

);

507

4

508

509

#[test]

510

4

fn fuzzer_found_issues() {

511

80

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

512

    enum A {

513

        #[serde(rename = "true")]

514

        True(bool),

515

        #[serde(rename = "false")]

516

        False(bool),

517

        #[serde(rename = "Some")]

518

        Some(bool),

519

        #[serde(rename = "None")]

520

        None(bool),

521

        #[serde(rename = "inf")]

522

        Inf(bool),

523

        #[serde(rename = "inff32")]

524

        InfF32(bool),

525

        #[serde(rename = "inff64")]

526

        InfF64(bool),

527

        #[serde(rename = "NaN")]

528

        NaN(bool),

529

        #[serde(rename = "NaNf32")]

530

        NaNF32(bool),

531

        #[serde(rename = "NaNf64")]

532

        NaNF64(bool),

533

534

535

4

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

536

4

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

537

4

    assert_eq!(

538

4

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

539

4

        ron::error::SpannedError {

540

4

            code: ron::Error::TrailingCharacters,

541

4

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

542

4

543

4

);

544

545

4

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

546

4

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

547

4

    assert_eq!(

548

4

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

549

4

        ron::error::SpannedError {

550

4

            code: ron::Error::TrailingCharacters,

551

4

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

552

4

553

4

);

554

555

4

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

556

4

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

557

4

    assert_eq!(

558

4

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

559

4

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

560

4

);

561

562

4

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

563

4

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

564

4

    assert_eq!(

565

4

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

566

4

        ron::error::SpannedError {

567

4

            code: ron::Error::TrailingCharacters,

568

4

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

569

4

570

4

);

571

572

4

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

573

4

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

574

4

    assert_eq!(

575

4

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

576

4

        ron::error::SpannedError {

577

4

            code: ron::Error::TrailingCharacters,

578

4

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

579

4

580

4

);

581

582

4

    assert_eq!(

583

4

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

584

4

        "r#inff32(false)"

585

4

);

586

4

    assert_eq!(

587

4

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

588

4

        A::InfF32(false)

589

4

);

590

4

    assert_eq!(

591

4

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

592

4

        ron::error::SpannedError {

593

4

            code: ron::Error::TrailingCharacters,

594

4

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

595

4

596

4

);

597

598

4

    assert_eq!(

599

4

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

600

4

        "r#inff64(false)"

601

4

);

602

4

    assert_eq!(

603

4

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

604

4

        A::InfF64(false)

605

4

);

606

4

    assert_eq!(

607

4

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

608

4

        ron::error::SpannedError {

609

4

            code: ron::Error::TrailingCharacters,

610

4

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

611

4

612

4

);

613

614

4

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

615

4

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

616

4

    assert_eq!(

617

4

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

618

4

        ron::error::SpannedError {

619

4

            code: ron::Error::TrailingCharacters,

620

4

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

621

4

622

4

);

623

624

4

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

625

4

    assert_eq!(

626

4

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

627

4

        A::NaNF32(true)

628

4

);

629

4

    assert_eq!(

630

4

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

631

4

        ron::error::SpannedError {

632

4

            code: ron::Error::TrailingCharacters,

633

4

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

634

4

635

4

);

636

637

4

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

638

4

    assert_eq!(

639

4

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

640

4

        A::NaNF64(true)

641

4

);

642

4

    assert_eq!(

643

4

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

644

4

        ron::error::SpannedError {

645

4

            code: ron::Error::TrailingCharacters,

646

4

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

647

4

648

4

);

649

4