clap-rs/clap | Build 997048815 | src/build/usage_parser.rs | Coveralls

29

    fn new(usage: &'help str) -> Self {

34✔

40

    pub(crate) fn from_usage(usage: &'help str) -> Self {

34✔

42

        UsageParser::new(usage)

34✔

45

    pub(crate) fn parse(mut self) -> Arg<'help> {

34✔

54

            self.stop_at(token);

34✔

55

            if let Some(&c) = self.usage.as_bytes().get(self.pos) {

98✔

57

                    b'-' => self.short_or_long(&mut arg),

95✔

58

                    b'.' => self.multiple(&mut arg),

29✔

59

                    b'@' => self.default(&mut arg),

1✔

60

                    b'\'' => self.help(&mut arg),

59✔

61

                    _ => self.name(&mut arg),

54✔

67

        arg.num_vals = if arg.val_names.len() > 1 {

129✔

68

            Some(arg.val_names.len())

14✔

70

            None

32✔

72

        if !arg.has_switch() && arg.is_set(ArgSettings::MultipleOccurrences) {

77✔

74

            arg.settings.set(ArgSettings::TakesValue);

11✔

75

            arg.settings.set(ArgSettings::MultipleValues);

11✔

76

            arg.settings.unset(ArgSettings::MultipleOccurrences);

11✔

82

    fn name(&mut self, arg: &mut Arg<'help>) {

27✔

84

        if *self

113✔

87

            .get(self.pos)

27✔

90

            && !self.explicit_name_set

10✔

92

            arg.settings.set(ArgSettings::Required);

11✔

94

        self.pos += 1;

27✔

95

        self.stop_at(name_end);

27✔

96

        let name = &self.usage[self.start..self.pos];

27✔

97

        if self.prev == UsageToken::Unknown {

28✔

99

            arg.id = name.into();

55✔

100

            arg.name = name;

19✔

101

            if arg.long.is_none() && arg.short.is_none() {

37✔

103

                self.explicit_name_set = true;

18✔

104

                self.prev = UsageToken::Name;

19✔

108

            if arg.val_names.is_empty() {

60✔

109

                arg.settings.set(ArgSettings::TakesValue);

27✔

111

            let len = arg.val_names.len();

27✔

112

            arg.val_names.insert(len, name);

27✔

113

            self.prev = UsageToken::ValName;

27✔

117

    fn stop_at<F>(&mut self, f: F)

121✔

122

        self.start = self.pos;

121✔

123

        self.pos += self.usage[self.start..]

237✔

125

            .take_while(|&b| f(b))

360✔

129

    fn short_or_long(&mut self, arg: &mut Arg<'help>) {

33✔

131

        self.pos += 1;

33✔

132

        if *self

64✔

135

            .get(self.pos)

31✔

139

            self.pos += 1;

57✔

140

            self.long(arg);

29✔

143

        self.short(arg)

30✔

146

    fn long(&mut self, arg: &mut Arg<'help>) {

29✔

148

        self.stop_at(long_end);

29✔

149

        let name = &self.usage[self.start..self.pos];

30✔

150

        if !self.explicit_name_set {

63✔

152

            arg.id = name.into();

91✔

153

            arg.name = name;

31✔

156

        arg.long = Some(name);

31✔

157

        self.prev = UsageToken::Long;

31✔

160

    fn short(&mut self, arg: &mut Arg<'help>) {

30✔

162

        let start = &self.usage[self.pos..];

30✔

163

        let short = start.chars().next().expect(INTERNAL_ERROR_MSG);

30✔

165

        arg.short = Some(short);

30✔

166

        if arg.name.is_empty() {

66✔

168

            let name = &start[..short.len_utf8()];

58✔

170

            arg.id = name.into();

58✔

171

            arg.name = name;

30✔

173

        self.prev = UsageToken::Short;

30✔

177

    fn multiple(&mut self, arg: &mut Arg) {

15✔

179

        let mut dot_counter = 1;

14✔

180

        let start = self.pos;

15✔

181

        let mut bytes = self.usage[start..].bytes();

15✔

182

        while bytes.next() == Some(b'.') {

30✔

183

            dot_counter += 1;

14✔

184

            self.pos += 1;

16✔

185

            if dot_counter == 3 {

14✔

187

                if arg.is_set(ArgSettings::TakesValue) {

42✔

188

                    arg.settings.set(ArgSettings::MultipleValues);

12✔

190

                arg.settings.set(ArgSettings::MultipleOccurrences);

15✔

191

                self.prev = UsageToken::Multiple;

15✔

192

                self.pos += 1;

15✔

198

    fn help(&mut self, arg: &mut Arg<'help>) {

30✔

200

        self.stop_at(help_start);

30✔

201

        self.start = self.pos + 1;

30✔

202

        self.pos = self.usage.len() - 1;

30✔

207

        arg.about = Some(&self.usage[self.start..self.pos]);

30✔

208

        self.pos += 1; // Move to next byte to keep from thinking ending ' is a start

30✔

209

        self.prev = UsageToken::Help;

30✔

212

    fn default(&mut self, arg: &mut Arg<'help>) {

1✔

217

        self.pos += 1; // Skip @

1✔

218

        self.stop_at(default_value_end); // Find first space after value

1✔

223

        arg.settings.set(ArgSettings::TakesValue);

1✔

224

        arg.default_vals = vec![std::ffi::OsStr::new(&self.usage[self.start..self.pos])];

1✔

225

        self.prev = UsageToken::Default;

1✔

230

fn name_end(b: u8) -> bool {

26✔

231

    b != b']' && b != b'>'

26✔

235

fn token(b: u8) -> bool {

32✔

236

    b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'-' && b != b'@'

63✔

240

fn long_end(b: u8) -> bool {

29✔

241

    b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'=' && b != b' '

38✔

245

fn help_start(b: u8) -> bool {

29✔

246

    b != b'\''

29✔

260

    fn create_flag_usage() {

3✔

261

        let a = Arg::from("[flag] -f 'some help info'");

1✔

262

        assert_eq!(a.name, "flag");

1✔

263

        assert_eq!(a.short.unwrap(), 'f');

1✔

264

        assert!(a.long.is_none());

1✔

265

        assert_eq!(a.about.unwrap(), "some help info");

1✔

266

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

267

        assert!(a.val_names.is_empty());

1✔

268

        assert!(a.num_vals.is_none());

1✔

270

        let a = Arg::from("[flag] --flag 'some help info'");

1✔

271

        assert_eq!(a.name, "flag");

1✔

272

        assert_eq!(a.long.unwrap(), "flag");

1✔

273

        assert!(a.short.is_none());

1✔

274

        assert_eq!(a.about.unwrap(), "some help info");

1✔

275

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

276

        assert!(a.val_names.is_empty());

1✔

277

        assert!(a.num_vals.is_none());

1✔

279

        let a = Arg::from("--flag 'some help info'");

1✔

280

        assert_eq!(a.name, "flag");

1✔

281

        assert_eq!(a.long.unwrap(), "flag");

1✔

282

        assert!(a.short.is_none());

1✔

283

        assert_eq!(a.about.unwrap(), "some help info");

1✔

284

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

285

        assert!(a.val_names.is_empty());

1✔

286

        assert!(a.num_vals.is_none());

1✔

288

        let a = Arg::from("[flag] -f --flag 'some help info'");

1✔

289

        assert_eq!(a.name, "flag");

1✔

290

        assert_eq!(a.short.unwrap(), 'f');

1✔

291

        assert_eq!(a.long.unwrap(), "flag");

1✔

292

        assert_eq!(a.about.unwrap(), "some help info");

1✔

293

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

294

        assert!(a.val_names.is_empty());

1✔

295

        assert!(a.num_vals.is_none());

1✔

297

        let a = Arg::from("[flag] -f... 'some help info'");

1✔

298

        assert_eq!(a.name, "flag");

1✔

299

        assert_eq!(a.short.unwrap(), 'f');

1✔

300

        assert!(a.long.is_none());

1✔

301

        assert_eq!(a.about.unwrap(), "some help info");

1✔

302

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

303

        assert!(a.val_names.is_empty());

1✔

304

        assert!(a.num_vals.is_none());

1✔

306

        let a = Arg::from("[flag] -f --flag... 'some help info'");

1✔

307

        assert_eq!(a.name, "flag");

1✔

308

        assert_eq!(a.long.unwrap(), "flag");

1✔

309

        assert_eq!(a.short.unwrap(), 'f');

1✔

310

        assert_eq!(a.about.unwrap(), "some help info");

1✔

311

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

312

        assert!(a.val_names.is_empty());

1✔

313

        assert!(a.num_vals.is_none());

1✔

315

        let a = Arg::from("-f --flag... 'some help info'");

1✔

316

        assert_eq!(a.name, "flag");

1✔

317

        assert_eq!(a.long.unwrap(), "flag");

1✔

318

        assert_eq!(a.short.unwrap(), 'f');

1✔

319

        assert_eq!(a.about.unwrap(), "some help info");

1✔

320

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

321

        assert!(a.val_names.is_empty());

1✔

322

        assert!(a.num_vals.is_none());

1✔

324

        let a = Arg::from("--flags");

1✔

325

        assert_eq!(a.name, "flags");

1✔

326

        assert_eq!(a.long.unwrap(), "flags");

1✔

327

        assert!(a.val_names.is_empty());

1✔

328

        assert!(a.num_vals.is_none());

1✔

330

        let a = Arg::from("--flags...");

1✔

331

        assert_eq!(a.name, "flags");

1✔

332

        assert_eq!(a.long.unwrap(), "flags");

1✔

333

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

334

        assert!(a.val_names.is_empty());

1✔

335

        assert!(a.num_vals.is_none());

1✔

337

        let a = Arg::from("[flags] -f");

1✔

338

        assert_eq!(a.name, "flags");

1✔

339

        assert_eq!(a.short.unwrap(), 'f');

1✔

340

        assert!(a.val_names.is_empty());

1✔

341

        assert!(a.num_vals.is_none());

1✔

343

        let a = Arg::from("[flags] -f...");

1✔

344

        assert_eq!(a.name, "flags");

1✔

345

        assert_eq!(a.short.unwrap(), 'f');

1✔

346

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

347

        assert!(a.val_names.is_empty());

1✔

348

        assert!(a.num_vals.is_none());

1✔

350

        let a = Arg::from("-f 'some help info'");

1✔

351

        assert_eq!(a.name, "f");

1✔

352

        assert_eq!(a.short.unwrap(), 'f');

1✔

353

        assert!(a.long.is_none());

1✔

354

        assert_eq!(a.about.unwrap(), "some help info");

1✔

355

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

356

        assert!(a.val_names.is_empty());

1✔

357

        assert!(a.num_vals.is_none());

1✔

359

        let a = Arg::from("-f");

1✔

360

        assert_eq!(a.name, "f");

1✔

361

        assert_eq!(a.short.unwrap(), 'f');

1✔

362

        assert!(a.val_names.is_empty());

1✔

363

        assert!(a.num_vals.is_none());

1✔

365

        let a = Arg::from("-f...");

1✔

366

        assert_eq!(a.name, "f");

1✔

367

        assert_eq!(a.short.unwrap(), 'f');

1✔

368

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

369

        assert!(a.val_names.is_empty());

1✔

370

        assert!(a.num_vals.is_none());

1✔

374

    fn create_option_usage0() {

3✔

376

        let a = Arg::from("[option] -o [opt] 'some help info'");

1✔

377

        assert_eq!(a.name, "option");

1✔

378

        assert_eq!(a.short.unwrap(), 'o');

1✔

379

        assert!(a.long.is_none());

1✔

380

        assert_eq!(a.about.unwrap(), "some help info");

1✔

381

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

382

        assert!(!a.is_set(ArgSettings::MultipleValues));

1✔

383

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

384

        assert!(!a.is_set(ArgSettings::Required));

1✔

385

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

386

        assert!(a.num_vals.is_none());

1✔

390

    fn create_option_usage1() {

3✔

391

        let a = Arg::from("-o [opt] 'some help info'");

1✔

392

        assert_eq!(a.name, "o");

1✔

393

        assert_eq!(a.short.unwrap(), 'o');

1✔

394

        assert!(a.long.is_none());

1✔

395

        assert_eq!(a.about.unwrap(), "some help info");

1✔

396

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

397

        assert!(!a.is_set(ArgSettings::MultipleValues));

1✔

398

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

399

        assert!(!a.is_set(ArgSettings::Required));

1✔

400

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

401

        assert!(a.num_vals.is_none());

1✔

405

    fn create_option_usage2() {

3✔

406

        let a = Arg::from("<option> -o <opt> 'some help info'");

1✔

407

        assert_eq!(a.name, "option");

1✔

408

        assert_eq!(a.short.unwrap(), 'o');

1✔

409

        assert!(a.long.is_none());

1✔

410

        assert_eq!(a.about.unwrap(), "some help info");

1✔

411

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

412

        assert!(!a.is_set(ArgSettings::MultipleValues));

1✔

413

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

414

        assert!(a.is_set(ArgSettings::Required));

1✔

415

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

416

        assert!(a.num_vals.is_none());

1✔

420

    fn create_option_usage3() {

3✔

421

        let a = Arg::from("-o <opt> 'some help info'");

1✔

422

        assert_eq!(a.name, "o");

1✔

423

        assert_eq!(a.short.unwrap(), 'o');

1✔

424

        assert!(a.long.is_none());

1✔

425

        assert_eq!(a.about.unwrap(), "some help info");

1✔

426

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

427

        assert!(!a.is_set(ArgSettings::MultipleValues));

1✔

428

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

429

        assert!(a.is_set(ArgSettings::Required));

1✔

430

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

431

        assert!(a.num_vals.is_none());

1✔

435

    fn create_option_usage4() {

3✔

436

        let a = Arg::from("[option] -o [opt]... 'some help info'");

1✔

437

        assert_eq!(a.name, "option");

1✔

438

        assert_eq!(a.short.unwrap(), 'o');

1✔

439

        assert!(a.long.is_none());

1✔

440

        assert_eq!(a.about.unwrap(), "some help info");

1✔

441

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

442

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

443

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

444

        assert!(!a.is_set(ArgSettings::Required));

1✔

445

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

446

        assert!(a.num_vals.is_none());

1✔

450

    fn create_option_usage5() {

3✔

451

        let a = Arg::from("[option]... -o [opt] 'some help info'");

1✔

452

        assert_eq!(a.name, "option");

1✔

453

        assert_eq!(a.short.unwrap(), 'o');

1✔

454

        assert!(a.long.is_none());

1✔

455

        assert_eq!(a.about.unwrap(), "some help info");

1✔

456

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

457

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

458

        assert!(!a.is_set(ArgSettings::Required));

1✔

459

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

460

        assert!(a.num_vals.is_none());

1✔

464

    fn create_option_usage6() {

3✔

465

        let a = Arg::from("-o [opt]... 'some help info'");

1✔

466

        assert_eq!(a.name, "o");

1✔

467

        assert_eq!(a.short.unwrap(), 'o');

1✔

468

        assert!(a.long.is_none());

1✔

469

        assert_eq!(a.about.unwrap(), "some help info");

1✔

470

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

471

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

472

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

473

        assert!(!a.is_set(ArgSettings::Required));

1✔

474

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

475

        assert!(a.num_vals.is_none());

1✔

479

    fn create_option_usage7() {

3✔

480

        let a = Arg::from("<option> -o <opt>... 'some help info'");

1✔

481

        assert_eq!(a.name, "option");

1✔

482

        assert_eq!(a.short.unwrap(), 'o');

1✔

483

        assert!(a.long.is_none());

1✔

484

        assert_eq!(a.about.unwrap(), "some help info");

1✔

485

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

486

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

487

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

488

        assert!(a.is_set(ArgSettings::Required));

1✔

489

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

490

        assert!(a.num_vals.is_none());

1✔

494

    fn create_option_usage8() {

3✔

495

        let a = Arg::from("<option>... -o <opt> 'some help info'");

1✔

496

        assert_eq!(a.name, "option");

1✔

497

        assert_eq!(a.short.unwrap(), 'o');

1✔

498

        assert!(a.long.is_none());

1✔

499

        assert_eq!(a.about.unwrap(), "some help info");

1✔

500

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

501

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

502

        assert!(a.is_set(ArgSettings::Required));

1✔

503

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

504

        assert!(a.num_vals.is_none());

1✔

508

    fn create_option_usage9() {

3✔

509

        let a = Arg::from("-o <opt>... 'some help info'");

1✔

510

        assert_eq!(a.name, "o");

1✔

511

        assert_eq!(a.short.unwrap(), 'o');

1✔

512

        assert!(a.long.is_none());

1✔

513

        assert_eq!(a.about.unwrap(), "some help info");

1✔

514

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

515

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

516

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

517

        assert!(a.is_set(ArgSettings::Required));

1✔

518

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

519

        assert!(a.num_vals.is_none());

1✔

523

    fn create_option_usage_long1() {

3✔

524

        let a = Arg::from("[option] --opt [opt] 'some help info'");

1✔

525

        assert_eq!(a.name, "option");

1✔

526

        assert_eq!(a.long.unwrap(), "opt");

1✔

527

        assert!(a.short.is_none());

1✔

528

        assert_eq!(a.about.unwrap(), "some help info");

1✔

529

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

530

        assert!(!a.is_set(ArgSettings::MultipleValues));

1✔

531

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

532

        assert!(!a.is_set(ArgSettings::Required));

1✔

533

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

534

        assert!(a.num_vals.is_none());

1✔

538

    fn create_option_usage_long2() {

3✔

539

        let a = Arg::from("--opt [option] 'some help info'");

1✔

540

        assert_eq!(a.name, "opt");

1✔

541

        assert_eq!(a.long.unwrap(), "opt");

1✔

542

        assert!(a.short.is_none());

1✔

543

        assert_eq!(a.about.unwrap(), "some help info");

1✔

544

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

545

        assert!(!a.is_set(ArgSettings::MultipleValues));

1✔

546

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

547

        assert!(!a.is_set(ArgSettings::Required));

1✔

548

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

549

        assert!(a.num_vals.is_none());

1✔

553

    fn create_option_usage_long3() {

3✔

554

        let a = Arg::from("<option> --opt <opt> 'some help info'");

1✔

555

        assert_eq!(a.name, "option");

1✔

556

        assert_eq!(a.long.unwrap(), "opt");

1✔

557

        assert!(a.short.is_none());

1✔

558

        assert_eq!(a.about.unwrap(), "some help info");

1✔

559

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

560

        assert!(!a.is_set(ArgSettings::MultipleValues));

1✔

561

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

562

        assert!(a.is_set(ArgSettings::Required));

1✔

563

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

564

        assert!(a.num_vals.is_none());

1✔

568

    fn create_option_usage_long4() {

3✔

569

        let a = Arg::from("--opt <option> 'some help info'");

1✔

570

        assert_eq!(a.name, "opt");

1✔

571

        assert_eq!(a.long.unwrap(), "opt");

1✔

572

        assert!(a.short.is_none());

1✔

573

        assert_eq!(a.about.unwrap(), "some help info");

1✔

574

        assert!(!a.is_set(ArgSettings::MultipleOccurrences));

1✔

575

        assert!(!a.is_set(ArgSettings::MultipleValues));

1✔

576

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

577

        assert!(a.is_set(ArgSettings::Required));

1✔

578

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

579

        assert!(a.num_vals.is_none());

1✔

583

    fn create_option_usage_long5() {

3✔

584

        let a = Arg::from("[option] --opt [opt]... 'some help info'");

1✔

585

        assert_eq!(a.name, "option");

1✔

586

        assert_eq!(a.long.unwrap(), "opt");

1✔

587

        assert!(a.short.is_none());

1✔

588

        assert_eq!(a.about.unwrap(), "some help info");

1✔

589

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

590

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

591

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

592

        assert!(!a.is_set(ArgSettings::Required));

1✔

593

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

594

        assert!(a.num_vals.is_none());

1✔

598

    fn create_option_usage_long6() {

3✔

599

        let a = Arg::from("[option]... --opt [opt] 'some help info'");

1✔

600

        assert_eq!(a.name, "option");

1✔

601

        assert_eq!(a.long.unwrap(), "opt");

1✔

602

        assert!(a.short.is_none());

1✔

603

        assert_eq!(a.about.unwrap(), "some help info");

1✔

604

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

605

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

606

        assert!(!a.is_set(ArgSettings::Required));

1✔

607

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

608

        assert!(a.num_vals.is_none());

1✔

612

    fn create_option_usage_long7() {

3✔

613

        let a = Arg::from("--opt [option]... 'some help info'");

1✔

614

        assert_eq!(a.name, "opt");

1✔

615

        assert_eq!(a.long.unwrap(), "opt");

1✔

616

        assert!(a.short.is_none());

1✔

617

        assert_eq!(a.about.unwrap(), "some help info");

1✔

618

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

619

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

620

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

621

        assert!(!a.is_set(ArgSettings::Required));

1✔

622

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

623

        assert!(a.num_vals.is_none());

1✔

627

    fn create_option_usage_long8() {

3✔

628

        let a = Arg::from("<option> --opt <opt>... 'some help info'");

1✔

629

        assert_eq!(a.name, "option");

1✔

630

        assert_eq!(a.long.unwrap(), "opt");

1✔

631

        assert!(a.short.is_none());

1✔

632

        assert_eq!(a.about.unwrap(), "some help info");

1✔

633

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

634

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

635

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

636

        assert!(a.is_set(ArgSettings::Required));

1✔

637

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

638

        assert!(a.num_vals.is_none());

1✔

642

    fn create_option_usage_long9() {

3✔

643

        let a = Arg::from("<option>... --opt <opt> 'some help info'");

1✔

644

        assert_eq!(a.name, "option");

1✔

645

        assert_eq!(a.long.unwrap(), "opt");

1✔

646

        assert!(a.short.is_none());

1✔

647

        assert_eq!(a.about.unwrap(), "some help info");

1✔

648

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

649

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

650

        assert!(a.is_set(ArgSettings::Required));

1✔

651

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

652

        assert!(a.num_vals.is_none());

1✔

656

    fn create_option_usage_long10() {

3✔

657

        let a = Arg::from("--opt <option>... 'some help info'");

1✔

658

        assert_eq!(a.name, "opt");

1✔

659

        assert_eq!(a.long.unwrap(), "opt");

1✔

660

        assert!(a.short.is_none());

1✔

661

        assert_eq!(a.about.unwrap(), "some help info");

1✔

662

        assert!(

1✔

663

            a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)

1✔

665

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

666

        assert!(a.is_set(ArgSettings::Required));

1✔

667

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

668

        assert!(a.num_vals.is_none());

1✔

672

    fn create_option_usage_long_equals1() {

3✔

673

        let a = Arg::from("[option] --opt=[opt] 'some help info'");

1✔

674

        assert_eq!(a.name, "option");

1✔

675

        assert_eq!(a.long.unwrap(), "opt");

1✔

676

        assert!(a.short.is_none());

1✔

677

        assert_eq!(a.about.unwrap(), "some help info");

1✔

678

        assert!(

1✔

679

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

681

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

682

        assert!(!a.is_set(ArgSettings::Required));

1✔

683

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

684

        assert!(a.num_vals.is_none());

1✔

688

    fn create_option_usage_long_equals2() {

3✔

689

        let a = Arg::from("--opt=[option] 'some help info'");

1✔

690

        assert_eq!(a.name, "opt");

1✔

691

        assert_eq!(a.long.unwrap(), "opt");

1✔

692

        assert!(a.short.is_none());

1✔

693

        assert_eq!(a.about.unwrap(), "some help info");

1✔

694

        assert!(

1✔

695

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

697

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

698

        assert!(!a.is_set(ArgSettings::Required));

1✔

699

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

700

        assert!(a.num_vals.is_none());

1✔

704

    fn create_option_usage_long_equals3() {

3✔

705

        let a = Arg::from("<option> --opt=<opt> 'some help info'");

1✔

706

        assert_eq!(a.name, "option");

1✔

707

        assert_eq!(a.long.unwrap(), "opt");

1✔

708

        assert!(a.short.is_none());

1✔

709

        assert_eq!(a.about.unwrap(), "some help info");

1✔

710

        assert!(

1✔

711

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

713

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

714

        assert!(a.is_set(ArgSettings::Required));

1✔

715

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

716

        assert!(a.num_vals.is_none());

1✔

720

    fn create_option_usage_long_equals4() {

3✔

721

        let a = Arg::from("--opt=<option> 'some help info'");

1✔

722

        assert_eq!(a.name, "opt");

1✔

723

        assert_eq!(a.long.unwrap(), "opt");

1✔

724

        assert!(a.short.is_none());

1✔

725

        assert_eq!(a.about.unwrap(), "some help info");

1✔

726

        assert!(

1✔

727

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

729

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

730

        assert!(a.is_set(ArgSettings::Required));

1✔

731

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

732

        assert!(a.num_vals.is_none());

1✔

736

    fn create_option_usage_long_equals5() {

3✔

737

        let a = Arg::from("[option] --opt=[opt]... 'some help info'");

1✔

738

        assert_eq!(a.name, "option");

1✔

739

        assert_eq!(a.long.unwrap(), "opt");

1✔

740

        assert!(a.short.is_none());

1✔

741

        assert_eq!(a.about.unwrap(), "some help info");

1✔

742

        assert!(

1✔

743

            a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)

1✔

745

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

746

        assert!(!a.is_set(ArgSettings::Required));

1✔

747

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

748

        assert!(a.num_vals.is_none());

1✔

752

    fn create_option_usage_long_equals6() {

3✔

753

        let a = Arg::from("[option]... --opt=[opt] 'some help info'");

1✔

754

        assert_eq!(a.name, "option");

1✔

755

        assert_eq!(a.long.unwrap(), "opt");

1✔

756

        assert!(a.short.is_none());

1✔

757

        assert_eq!(a.about.unwrap(), "some help info");

1✔

758

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

759

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

760

        assert!(!a.is_set(ArgSettings::Required));

1✔

761

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

762

        assert!(a.num_vals.is_none());

1✔

766

    fn create_option_usage_long_equals7() {

3✔

767

        let a = Arg::from("--opt=[option]... 'some help info'");

1✔

768

        assert_eq!(a.name, "opt");

1✔

769

        assert_eq!(a.long.unwrap(), "opt");

1✔

770

        assert!(a.short.is_none());

1✔

771

        assert_eq!(a.about.unwrap(), "some help info");

1✔

772

        assert!(

1✔

773

            a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)

1✔

775

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

776

        assert!(!a.is_set(ArgSettings::Required));

1✔

777

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

778

        assert!(a.num_vals.is_none());

1✔

782

    fn create_option_usage_long_equals8() {

3✔

783

        let a = Arg::from("<option> --opt=<opt>... 'some help info'");

1✔

784

        assert_eq!(a.name, "option");

1✔

785

        assert_eq!(a.long.unwrap(), "opt");

1✔

786

        assert!(a.short.is_none());

1✔

787

        assert_eq!(a.about.unwrap(), "some help info");

1✔

788

        assert!(

1✔

789

            a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)

1✔

791

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

792

        assert!(a.is_set(ArgSettings::Required));

1✔

793

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

794

        assert!(a.num_vals.is_none());

1✔

798

    fn create_option_usage_long_equals9() {

3✔

799

        let a = Arg::from("<option>... --opt=<opt> 'some help info'");

1✔

800

        assert_eq!(a.name, "option");

1✔

801

        assert_eq!(a.long.unwrap(), "opt");

1✔

802

        assert!(a.short.is_none());

1✔

803

        assert_eq!(a.about.unwrap(), "some help info");

1✔

804

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

805

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

806

        assert!(a.is_set(ArgSettings::Required));

1✔

807

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

808

        assert!(a.num_vals.is_none());

1✔

812

    fn create_option_usage_long_equals10() {

3✔

813

        let a = Arg::from("--opt=<option>... 'some help info'");

1✔

814

        assert_eq!(a.name, "opt");

1✔

815

        assert_eq!(a.long.unwrap(), "opt");

1✔

816

        assert!(a.short.is_none());

1✔

817

        assert_eq!(a.about.unwrap(), "some help info");

1✔

818

        assert!(

1✔

819

            a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)

1✔

821

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

822

        assert!(a.is_set(ArgSettings::Required));

1✔

823

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

824

        assert!(a.num_vals.is_none());

1✔

828

    fn create_option_usage_both1() {

3✔

829

        let a = Arg::from("[option] -o --opt [option] 'some help info'");

1✔

830

        assert_eq!(a.name, "option");

1✔

831

        assert_eq!(a.long.unwrap(), "opt");

1✔

832

        assert_eq!(a.short.unwrap(), 'o');

1✔

833

        assert_eq!(a.about.unwrap(), "some help info");

1✔

834

        assert!(

1✔

835

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

837

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

838

        assert!(!a.is_set(ArgSettings::Required));

1✔

839

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

840

        assert!(a.num_vals.is_none());

1✔

844

    fn create_option_usage_both2() {

3✔

845

        let a = Arg::from("-o --opt [option] 'some help info'");

1✔

846

        assert_eq!(a.name, "opt");

1✔

847

        assert_eq!(a.long.unwrap(), "opt");

1✔

848

        assert_eq!(a.short.unwrap(), 'o');

1✔

849

        assert_eq!(a.about.unwrap(), "some help info");

1✔

850

        assert!(

1✔

851

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

853

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

854

        assert!(!a.is_set(ArgSettings::Required));

1✔

855

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

856

        assert!(a.num_vals.is_none());

1✔

860

    fn create_option_usage_both3() {

3✔

861

        let a = Arg::from("<option> -o --opt <opt> 'some help info'");

1✔

862

        assert_eq!(a.name, "option");

1✔

863

        assert_eq!(a.long.unwrap(), "opt");

1✔

864

        assert_eq!(a.short.unwrap(), 'o');

1✔

865

        assert_eq!(a.about.unwrap(), "some help info");

1✔

866

        assert!(

1✔

867

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

869

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

870

        assert!(a.is_set(ArgSettings::Required));

1✔

871

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

872

        assert!(a.num_vals.is_none());

1✔

876

    fn create_option_usage_both4() {

3✔

877

        let a = Arg::from("-o --opt <option> 'some help info'");

1✔

878

        assert_eq!(a.name, "opt");

1✔

879

        assert_eq!(a.long.unwrap(), "opt");

1✔

880

        assert_eq!(a.short.unwrap(), 'o');

1✔

881

        assert_eq!(a.about.unwrap(), "some help info");

1✔

882

        assert!(

1✔

883

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

885

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

886

        assert!(a.is_set(ArgSettings::Required));

1✔

887

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

888

        assert!(a.num_vals.is_none());

1✔

892

    fn create_option_usage_both5() {

3✔

893

        let a = Arg::from("[option]... -o --opt [option] 'some help info'");

1✔

894

        assert_eq!(a.name, "option");

1✔

895

        assert_eq!(a.long.unwrap(), "opt");

1✔

896

        assert_eq!(a.short.unwrap(), 'o');

1✔

897

        assert_eq!(a.about.unwrap(), "some help info");

1✔

898

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

899

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

900

        assert!(!a.is_set(ArgSettings::Required));

1✔

901

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

902

        assert!(a.num_vals.is_none());

1✔

906

    fn create_option_usage_both6() {

3✔

907

        let a = Arg::from("-o --opt [option]... 'some help info'");

1✔

908

        assert_eq!(a.name, "opt");

1✔

909

        assert_eq!(a.long.unwrap(), "opt");

1✔

910

        assert_eq!(a.short.unwrap(), 'o');

1✔

911

        assert_eq!(a.about.unwrap(), "some help info");

1✔

912

        assert!(

1✔

913

            a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)

1✔

915

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

916

        assert!(!a.is_set(ArgSettings::Required));

1✔

917

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

918

        assert!(a.num_vals.is_none());

1✔

922

    fn create_option_usage_both7() {

3✔

923

        let a = Arg::from("<option>... -o --opt <opt> 'some help info'");

1✔

924

        assert_eq!(a.name, "option");

1✔

925

        assert_eq!(a.long.unwrap(), "opt");

1✔

926

        assert_eq!(a.short.unwrap(), 'o');

1✔

927

        assert_eq!(a.about.unwrap(), "some help info");

1✔

928

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

929

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

930

        assert!(a.is_set(ArgSettings::Required));

1✔

931

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

932

        assert!(a.num_vals.is_none());

1✔

936

    fn create_option_usage_both8() {

3✔

937

        let a = Arg::from("-o --opt <option>... 'some help info'");

1✔

938

        assert_eq!(a.name, "opt");

1✔

939

        assert_eq!(a.long.unwrap(), "opt");

1✔

940

        assert_eq!(a.short.unwrap(), 'o');

1✔

941

        assert_eq!(a.about.unwrap(), "some help info");

1✔

942

        assert!(

1✔

943

            a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)

1✔

945

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

946

        assert!(a.is_set(ArgSettings::Required));

1✔

947

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

948

        assert!(a.num_vals.is_none());

1✔

952

    fn create_option_usage_both_equals1() {

3✔

953

        let a = Arg::from("[option] -o --opt=[option] 'some help info'");

1✔

954

        assert_eq!(a.name, "option");

1✔

955

        assert_eq!(a.long.unwrap(), "opt");

1✔

956

        assert_eq!(a.short.unwrap(), 'o');

1✔

957

        assert_eq!(a.about.unwrap(), "some help info");

1✔

958

        assert!(

1✔

959

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

961

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

962

        assert!(!a.is_set(ArgSettings::Required));

1✔

963

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

964

        assert!(a.num_vals.is_none());

1✔

968

    fn create_option_usage_both_equals2() {

3✔

969

        let a = Arg::from("-o --opt=[option] 'some help info'");

1✔

970

        assert_eq!(a.name, "opt");

1✔

971

        assert_eq!(a.long.unwrap(), "opt");

1✔

972

        assert_eq!(a.short.unwrap(), 'o');

1✔

973

        assert_eq!(a.about.unwrap(), "some help info");

1✔

974

        assert!(

1✔

975

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

977

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

978

        assert!(!a.is_set(ArgSettings::Required));

1✔

979

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

980

        assert!(a.num_vals.is_none());

1✔

984

    fn create_option_usage_both_equals3() {

3✔

985

        let a = Arg::from("<option> -o --opt=<opt> 'some help info'");

1✔

986

        assert_eq!(a.name, "option");

1✔

987

        assert_eq!(a.long.unwrap(), "opt");

1✔

988

        assert_eq!(a.short.unwrap(), 'o');

1✔

989

        assert_eq!(a.about.unwrap(), "some help info");

1✔

990

        assert!(

1✔

991

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

993

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

994

        assert!(a.is_set(ArgSettings::Required));

1✔

995

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

996

        assert!(a.num_vals.is_none());

1✔

1000

    fn create_option_usage_both_equals4() {

3✔

1001

        let a = Arg::from("-o --opt=<option> 'some help info'");

1✔

1002

        assert_eq!(a.name, "opt");

1✔

1003

        assert_eq!(a.long.unwrap(), "opt");

1✔

1004

        assert_eq!(a.short.unwrap(), 'o');

1✔

1005

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1006

        assert!(

1✔

1007

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

1009

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1010

        assert!(a.is_set(ArgSettings::Required));

1✔

1011

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

1012

        assert!(a.num_vals.is_none());

1✔

1016

    fn create_option_usage_both_equals5() {

3✔

1017

        let a = Arg::from("[option]... -o --opt=[option] 'some help info'");

1✔

1018

        assert_eq!(a.name, "option");

1✔

1019

        assert_eq!(a.long.unwrap(), "opt");

1✔

1020

        assert_eq!(a.short.unwrap(), 'o');

1✔

1021

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1022

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

1023

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1024

        assert!(!a.is_set(ArgSettings::Required));

1✔

1025

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

1026

        assert!(a.num_vals.is_none());

1✔

1030

    fn create_option_usage_both_equals6() {

3✔

1031

        let a = Arg::from("-o --opt=[option]... 'some help info'");

1✔

1032

        assert_eq!(a.name, "opt");

1✔

1033

        assert_eq!(a.long.unwrap(), "opt");

1✔

1034

        assert_eq!(a.short.unwrap(), 'o');

1✔

1035

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1036

        assert!(

1✔

1037

            a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)

1✔

1039

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1040

        assert!(!a.is_set(ArgSettings::Required));

1✔

1041

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

1042

        assert!(a.num_vals.is_none());

1✔

1046

    fn create_option_usage_both_equals7() {

3✔

1047

        let a = Arg::from("<option>... -o --opt=<opt> 'some help info'");

1✔

1048

        assert_eq!(a.name, "option");

1✔

1049

        assert_eq!(a.long.unwrap(), "opt");

1✔

1050

        assert_eq!(a.short.unwrap(), 'o');

1✔

1051

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1052

        assert!(a.is_set(ArgSettings::MultipleOccurrences));

1✔

1053

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1054

        assert!(a.is_set(ArgSettings::Required));

1✔

1055

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"opt"]);

1✔

1056

        assert!(a.num_vals.is_none());

1✔

1060

    fn create_option_usage_both_equals8() {

3✔

1061

        let a = Arg::from("-o --opt=<option>... 'some help info'");

1✔

1062

        assert_eq!(a.name, "opt");

1✔

1063

        assert_eq!(a.long.unwrap(), "opt");

1✔

1064

        assert_eq!(a.short.unwrap(), 'o');

1✔

1065

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1066

        assert!(

1✔

1067

            a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)

1✔

1069

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1070

        assert!(a.is_set(ArgSettings::Required));

1✔

1071

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"option"]);

1✔

1072

        assert!(a.num_vals.is_none());

1✔

1076

    fn create_option_with_vals1() {

3✔

1077

        let a = Arg::from("-o <file> <mode> 'some help info'");

1✔

1078

        assert_eq!(a.name, "o");

1✔

1079

        assert!(a.long.is_none());

1✔

1080

        assert_eq!(a.short.unwrap(), 'o');

1✔

1081

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1082

        assert!(

1✔

1083

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

1085

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1086

        assert!(a.is_set(ArgSettings::Required));

1✔

1087

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);

1✔

1088

        assert_eq!(a.num_vals.unwrap(), 2);

1✔

1092

    fn create_option_with_vals2() {

3✔

1093

        let a = Arg::from("-o <file> <mode>... 'some help info'");

1✔

1094

        assert_eq!(a.name, "o");

1✔

1095

        assert!(a.long.is_none());

1✔

1096

        assert_eq!(a.short.unwrap(), 'o');

1✔

1097

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1098

        assert!(

1✔

1099

            a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)

1✔

1101

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1102

        assert!(a.is_set(ArgSettings::Required));

1✔

1103

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);

1✔

1104

        assert_eq!(a.num_vals.unwrap(), 2);

1✔

1108

    fn create_option_with_vals3() {

3✔

1109

        let a = Arg::from("--opt <file> <mode>... 'some help info'");

1✔

1110

        assert_eq!(a.name, "opt");

1✔

1111

        assert!(a.short.is_none());

1✔

1112

        assert_eq!(a.long.unwrap(), "opt");

1✔

1113

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1114

        assert!(

1✔

1115

            a.is_set(ArgSettings::MultipleValues) && a.is_set(ArgSettings::MultipleOccurrences)

1✔

1117

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1118

        assert!(a.is_set(ArgSettings::Required));

1✔

1119

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);

1✔

1120

        assert_eq!(a.num_vals.unwrap(), 2);

1✔

1124

    fn create_option_with_vals4() {

3✔

1125

        let a = Arg::from("[myopt] --opt <file> <mode> 'some help info'");

1✔

1126

        assert_eq!(a.name, "myopt");

1✔

1127

        assert!(a.short.is_none());

1✔

1128

        assert_eq!(a.long.unwrap(), "opt");

1✔

1129

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1130

        assert!(

1✔

1131

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

1133

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1134

        assert!(!a.is_set(ArgSettings::Required));

1✔

1135

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);

1✔

1136

        assert_eq!(a.num_vals.unwrap(), 2);

1✔

1140

    fn create_option_with_vals5() {

3✔

1141

        let a = Arg::from("--opt <file> <mode> 'some help info'");

1✔

1142

        assert_eq!(a.name, "opt");

1✔

1143

        assert!(a.short.is_none());

1✔

1144

        assert_eq!(a.long.unwrap(), "opt");

1✔

1145

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1146

        assert!(

1✔

1147

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

1149

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1150

        assert!(a.is_set(ArgSettings::Required));

1✔

1151

        assert_eq!(a.num_vals.unwrap(), 2);

1✔

1155

    fn create_positional_usage() {

3✔

1156

        let a = Arg::from("[pos] 'some help info'");

1✔

1157

        assert_eq!(a.name, "pos");

1✔

1158

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1159

        assert!(

1✔

1160

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

1162

        assert!(!a.is_set(ArgSettings::Required));

1✔

1163

        assert!(a.val_names.is_empty());

1✔

1164

        assert!(a.num_vals.is_none());

1✔

1168

    fn create_positional_usage0() {

3✔

1169

        let a = Arg::from("<pos> 'some help info'");

1✔

1170

        assert_eq!(a.name, "pos");

1✔

1171

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1172

        assert!(

1✔

1173

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

1175

        assert!(a.is_set(ArgSettings::Required));

1✔

1176

        assert!(a.val_names.is_empty());

1✔

1177

        assert!(a.num_vals.is_none());

1✔

1181

    fn pos_mult_help() {

3✔

1182

        let a = Arg::from("[pos]... 'some help info'");

1✔

1183

        assert_eq!(a.name, "pos");

1✔

1184

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1185

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

1186

        assert!(!a.is_set(ArgSettings::Required));

1✔

1187

        assert!(a.val_names.is_empty());

1✔

1188

        assert!(a.num_vals.is_none());

1✔

1192

    fn pos_help_lit_single_quote() {

3✔

1193

        let a = Arg::from("[pos]... 'some help\' info'");

1✔

1194

        assert_eq!(a.name, "pos");

1✔

1195

        assert_eq!(a.about.unwrap(), "some help' info");

1✔

1196

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

1197

        assert!(!a.is_set(ArgSettings::Required));

1✔

1198

        assert!(a.val_names.is_empty());

1✔

1199

        assert!(a.num_vals.is_none());

1✔

1203

    fn pos_help_double_lit_single_quote() {

3✔

1204

        let a = Arg::from("[pos]... 'some \'help\' info'");

1✔

1205

        assert_eq!(a.name, "pos");

1✔

1206

        assert_eq!(a.about.unwrap(), "some 'help' info");

1✔

1207

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

1208

        assert!(!a.is_set(ArgSettings::Required));

1✔

1209

        assert!(a.val_names.is_empty());

1✔

1210

        assert!(a.num_vals.is_none());

1✔

1214

    fn pos_help_newline() {

3✔

1219

        assert_eq!(a.name, "pos");

1✔

1220

        assert_eq!(a.about.unwrap(), "some help\ninfo");

1✔

1221

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

1222

        assert!(!a.is_set(ArgSettings::Required));

1✔

1223

        assert!(a.val_names.is_empty());

1✔

1224

        assert!(a.num_vals.is_none());

1✔

1228

    fn pos_help_newline_lit_sq() {

3✔

1233

        assert_eq!(a.name, "pos");

1✔

1234

        assert_eq!(a.about.unwrap(), "some help' stuff\ninfo");

1✔

1235

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

1236

        assert!(!a.is_set(ArgSettings::Required));

1✔

1237

        assert!(a.val_names.is_empty());

1✔

1238

        assert!(a.num_vals.is_none());

1✔

1242

    fn pos_req_mult_help() {

3✔

1243

        let a = Arg::from("<pos>... 'some help info'");

1✔

1244

        assert_eq!(a.name, "pos");

1✔

1245

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1246

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

1247

        assert!(a.is_set(ArgSettings::Required));

1✔

1248

        assert!(a.val_names.is_empty());

1✔

1249

        assert!(a.num_vals.is_none());

1✔

1253

    fn pos_req() {

3✔

1254

        let a = Arg::from("<pos>");

1✔

1255

        assert_eq!(a.name, "pos");

1✔

1256

        assert!(

1✔

1257

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

1259

        assert!(a.is_set(ArgSettings::Required));

1✔

1260

        assert!(a.val_names.is_empty());

1✔

1261

        assert!(a.num_vals.is_none());

1✔

1265

    fn pos_mult() {

3✔

1266

        let a = Arg::from("[pos]...");

1✔

1267

        assert_eq!(a.name, "pos");

1✔

1268

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

1269

        assert!(!a.is_set(ArgSettings::Required));

1✔

1270

        assert!(a.val_names.is_empty());

1✔

1271

        assert!(a.num_vals.is_none());

1✔

1275

    fn pos_req_mult_def_help() {

3✔

1276

        let a = Arg::from("<pos>... @a 'some help info'");

1✔

1277

        assert_eq!(a.name, "pos");

1✔

1278

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1279

        assert!(a.is_set(ArgSettings::MultipleValues));

1✔

1280

        assert!(a.is_set(ArgSettings::Required));

1✔

1281

        assert!(a.val_names.is_empty());

1✔

1282

        assert!(a.num_vals.is_none());

1✔

1283

        assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);

1✔

1287

    fn create_option_with_vals1_def() {

3✔

1288

        let a = Arg::from("-o <file> <mode> @a 'some help info'");

1✔

1289

        assert_eq!(a.name, "o");

1✔

1290

        assert!(a.long.is_none());

1✔

1291

        assert_eq!(a.short.unwrap(), 'o');

1✔

1292

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1293

        assert!(

1✔

1294

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

1296

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1297

        assert!(a.is_set(ArgSettings::Required));

1✔

1298

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);

1✔

1299

        assert_eq!(a.num_vals.unwrap(), 2);

1✔

1300

        assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);

1✔

1304

    fn create_option_with_vals4_def() {

3✔

1305

        let a = Arg::from("[myopt] --opt <file> <mode> @a 'some help info'");

1✔

1306

        assert_eq!(a.name, "myopt");

1✔

1307

        assert!(a.short.is_none());

1✔

1308

        assert_eq!(a.long.unwrap(), "opt");

1✔

1309

        assert_eq!(a.about.unwrap(), "some help info");

1✔

1310

        assert!(

1✔

1311

            !(a.is_set(ArgSettings::MultipleValues) || a.is_set(ArgSettings::MultipleOccurrences))

1✔

1313

        assert!(a.is_set(ArgSettings::TakesValue));

1✔

1314

        assert!(!a.is_set(ArgSettings::Required));

1✔

1315

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"file", &"mode"]);

1✔

1316

        assert_eq!(a.num_vals.unwrap(), 2);

1✔

1317

        assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);

1✔

1321

    fn nonascii() {

3✔

1322

        let a = Arg::from("<ASCII> 'üñíčöĐ€'");

1✔

1323

        assert_eq!(a.name, "ASCII");

1✔

1324

        assert_eq!(a.about, Some("üñíčöĐ€"));

1✔

1325

        let a = Arg::from("<üñíčöĐ€> 'ASCII'");

1✔

1326

        assert_eq!(a.name, "üñíčöĐ€");

1✔

1327

        assert_eq!(a.about, Some("ASCII"));

1✔

1328

        let a = Arg::from("<üñíčöĐ€> 'üñíčöĐ€'");

1✔

1329

        assert_eq!(a.name, "üñíčöĐ€");

1✔

1330

        assert_eq!(a.about, Some("üñíčöĐ€"));

1✔

1331

        let a = Arg::from("-ø 'ø'");

1✔

1332

        assert_eq!(a.name, "ø");

1✔

1333

        assert_eq!(a.short, Some('ø'));

1✔

1334

        assert_eq!(a.about, Some("ø"));

1✔

1335

        let a = Arg::from("--üñíčöĐ€ 'Nōṫ ASCII'");

1✔

1336

        assert_eq!(a.name, "üñíčöĐ€");

1✔

1337

        assert_eq!(a.long, Some("üñíčöĐ€"));

1✔

1338

        assert_eq!(a.about, Some("Nōṫ ASCII"));

1✔

1339

        let a = Arg::from("[ñämê] --ôpt=[üñíčöĐ€] 'hælp'");

1✔

1340

        assert_eq!(a.name, "ñämê");

1✔

1341

        assert_eq!(a.long, Some("ôpt"));

1✔

1342

        assert_eq!(a.val_names.values().collect::<Vec<_>>(), [&"üñíčöĐ€"]);

1✔

1343

        assert_eq!(a.about, Some("hælp"));

1✔

clap-rs / clap / 997048815

Source File
Press 'n' to go to next uncovered line, 'b' for previous

clap-rs / clap / 997048815

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous