loot/loot-condition-interpreter | Build 16680825703 | src/function/mod.rs | Coveralls

29

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

3✔

30

        match self {

3✔

31

            Self::Equal => write!(f, "=="),

3✔

38

3✔

61

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

25✔

62

        match self {

25✔

63

            Self::FilePath(p) => write!(f, "file(\"{}\")", p.display()),

11✔

64

            Self::FileRegex(p, r) => write!(f, "file(\"{}/{}\")", p.display(), r),

1✔

65

            Self::FileSize(p, s) => write!(f, "file_size(\"{}\", {})", p.display(), s),

1✔

66

            Self::Readable(p) => write!(f, "readable(\"{}\")", p.display()),

1✔

67

            Self::IsExecutable(p) => write!(f, "is_executable(\"{}\")", p.display()),

1✔

68

            Self::ActivePath(p) => write!(f, "active(\"{}\")", p.display()),

1✔

69

            Self::ActiveRegex(r) => write!(f, "active(\"{r}\")"),

1✔

70

            Self::IsMaster(p) => write!(f, "is_master(\"{}\")", p.display()),

1✔

71

            Self::Many(p, r) => write!(f, "many(\"{}/{}\")", p.display(), r),

1✔

72

            Self::ManyActive(r) => write!(f, "many_active(\"{r}\")"),

1✔

73

            Self::Checksum(p, c) => write!(f, "checksum(\"{}\", {:02X})", p.display(), c),

1✔

74

            Self::Version(p, v, c) => write!(f, "version(\"{}\", \"{}\", {})", p.display(), v, c),

1✔

75

            Self::ProductVersion(p, v, c) => {

1✔

76

                write!(f, "product_version(\"{}\", \"{}\", {})", p.display(), v, c)

1✔

78

            Self::FilenameVersion(path, regex, version, comparator) => {

1✔

79

                write!(

1✔

80

f,

1✔

81

                    "filename_version(\"{}/{}\", \"{}\", {})",

1✔

82

                    path.display(),

1✔

88

            Self::DescriptionContains(p, r) => {

1✔

89

                write!(f, "description_contains(\"{}\", \"{}\")", p.display(), r)

1✔

92

25✔

96

    fn eq(&self, other: &Function) -> bool {

71✔

97

        match (self, other) {

71✔

98

            (Self::FilePath(p1), Self::FilePath(p2))

6✔

99

            | (Self::Readable(p1), Self::Readable(p2))

3✔

100

            | (Self::IsExecutable(p1), Self::IsExecutable(p2))

3✔

101

            | (Self::ActivePath(p1), Self::ActivePath(p2))

3✔

102

            | (Self::IsMaster(p1), Self::IsMaster(p2)) => {

3✔

103

                eq(&p1.to_string_lossy(), &p2.to_string_lossy())

18✔

105

            (Self::FileRegex(p1, r1), Self::FileRegex(p2, r2))

4✔

106

            | (Self::Many(p1, r1), Self::Many(p2, r2))

4✔

107

            | (Self::DescriptionContains(p1, r1), Self::DescriptionContains(p2, r2)) => {

4✔

108

                eq(r1.as_str(), r2.as_str()) && eq(&p1.to_string_lossy(), &p2.to_string_lossy())

12✔

110

            (Self::FileSize(p1, s1), Self::FileSize(p2, s2)) => {

4✔

111

                s1 == s2 && eq(&p1.to_string_lossy(), &p2.to_string_lossy())

4✔

113

            (Self::ActiveRegex(r1), Self::ActiveRegex(r2))

3✔

114

            | (Self::ManyActive(r1), Self::ManyActive(r2)) => eq(r1.as_str(), r2.as_str()),

6✔

115

            (Self::Checksum(p1, c1), Self::Checksum(p2, c2)) => {

4✔

116

                c1 == c2 && eq(&p1.to_string_lossy(), &p2.to_string_lossy())

4✔

118

            (Self::Version(p1, v1, c1), Self::Version(p2, v2, c2))

5✔

119

            | (Self::ProductVersion(p1, v1, c1), Self::ProductVersion(p2, v2, c2)) => {

5✔

120

                c1 == c2 && eq(&v1, &v2) && eq(&p1.to_string_lossy(), &p2.to_string_lossy())

10✔

122

            (Self::FilenameVersion(p1, r1, v1, c1), Self::FilenameVersion(p2, r2, v2, c2)) => {

6✔

123

                c1 == c2

6✔

124

                    && eq(&v1, &v2)

5✔

125

                    && eq(r1.as_str(), r2.as_str())

4✔

126

                    && eq(&p1.to_string_lossy(), &p2.to_string_lossy())

3✔

128

            _ => false,

11✔

130

71✔

136

    fn hash<H: Hasher>(&self, state: &mut H) {

258✔

137

        match self {

258✔

138

            Self::FilePath(p)

33✔

139

            | Self::Readable(p)

17✔

140

            | Self::IsExecutable(p)

13✔

141

            | Self::ActivePath(p)

9✔

142

            | Self::IsMaster(p) => {

86✔

143

                p.to_string_lossy().to_lowercase().hash(state);

86✔

144

86✔

145

            Self::FileRegex(p, r) | Self::Many(p, r) | Self::DescriptionContains(p, r) => {

44✔

146

                p.to_string_lossy().to_lowercase().hash(state);

44✔

147

                r.as_str().to_lowercase().hash(state);

44✔

148

44✔

149

            Self::FileSize(p, s) => {

13✔

150

                p.to_string_lossy().to_lowercase().hash(state);

13✔

151

                s.hash(state);

13✔

152

13✔

153

            Self::ActiveRegex(r) | Self::ManyActive(r) => {

14✔

154

                r.as_str().to_lowercase().hash(state);

14✔

155

14✔

156

            Self::Checksum(p, c) => {

8✔

157

                p.to_string_lossy().to_lowercase().hash(state);

8✔

158

                c.hash(state);

8✔

159

8✔

160

            Self::Version(p, v, c) | Self::ProductVersion(p, v, c) => {

64✔

161

                p.to_string_lossy().to_lowercase().hash(state);

64✔

162

                v.to_lowercase().hash(state);

64✔

163

                c.hash(state);

64✔

164

64✔

165

            Self::FilenameVersion(p, r, v, c) => {

29✔

166

                p.to_string_lossy().to_lowercase().hash(state);

29✔

167

                r.as_str().to_lowercase().hash(state);

29✔

168

                v.to_lowercase().hash(state);

29✔

169

                c.hash(state);

29✔

170

29✔

173

        discriminant(self).hash(state);

258✔

174

258✔

184

    fn regex(string: &str) -> Regex {

114✔

185

        Regex::new(string).unwrap()

114✔

186

114✔

192

        fn function_fmt_for_file_path_should_format_correctly() {

1✔

193

            let function = Function::FilePath("subdir/Blank.esm".into());

1✔

195

            assert_eq!("file(\"subdir/Blank.esm\")", &format!("{function}"));

1✔

196

1✔

199

        fn function_fmt_for_file_regex_should_format_correctly() {

1✔

200

            let function = Function::FileRegex("subdir".into(), regex("Blank.*"));

1✔

202

            assert_eq!("file(\"subdir/Blank.*\")", &format!("{function}"));

1✔

203

1✔

206

        fn function_fmt_for_file_size_should_format_correctly() {

1✔

207

            let function = Function::FileSize("subdir/Blank.esm".into(), 12_345_678);

1✔

209

            assert_eq!(

1✔

211

                &format!("{function}")

1✔

213

1✔

216

        fn function_fmt_for_readable_should_format_correctly() {

1✔

217

            let function = Function::Readable("subdir/Blank.esm".into());

1✔

219

            assert_eq!("readable(\"subdir/Blank.esm\")", &format!("{function}"));

1✔

220

1✔

223

        fn function_fmt_for_is_executable_should_format_correctly() {

1✔

224

            let function = Function::IsExecutable("subdir/Blank.esm".into());

1✔

226

            assert_eq!(

1✔

228

                &format!("{function}")

1✔

230

1✔

233

        fn function_fmt_for_active_path_should_format_correctly() {

1✔

234

            let function = Function::ActivePath("Blank.esm".into());

1✔

236

            assert_eq!("active(\"Blank.esm\")", &format!("{function}"));

1✔

237

1✔

240

        fn function_fmt_for_active_regex_should_format_correctly() {

1✔

241

            let function = Function::ActiveRegex(regex("Blank.*"));

1✔

243

            assert_eq!("active(\"Blank.*\")", &format!("{function}"));

1✔

244

1✔

247

        fn function_fmt_for_is_master_should_format_correctly() {

1✔

248

            let function = Function::IsMaster("Blank.esm".into());

1✔

250

            assert_eq!("is_master(\"Blank.esm\")", &format!("{function}"));

1✔

251

1✔

254

        fn function_fmt_for_many_should_format_correctly() {

1✔

255

            let function = Function::Many("subdir".into(), regex("Blank.*"));

1✔

257

            assert_eq!("many(\"subdir/Blank.*\")", &format!("{function}"));

1✔

258

1✔

261

        fn function_fmt_for_many_active_should_format_correctly() {

1✔

262

            let function = Function::ManyActive(regex("Blank.*"));

1✔

264

            assert_eq!("many_active(\"Blank.*\")", &format!("{function}"));

1✔

265

1✔

268

        fn function_fmt_for_checksum_should_format_correctly() {

1✔

269

            let function = Function::Checksum("subdir/Blank.esm".into(), 0xDEAD_BEEF);

1✔

271

            assert_eq!(

1✔

273

                &format!("{function}")

1✔

275

1✔

278

        fn function_fmt_for_version_should_format_correctly() {

1✔

279

            let function = Function::Version(

1✔

280

                "subdir/Blank.esm".into(),

1✔

281

                "1.2a".into(),

1✔

282

                ComparisonOperator::Equal,

1✔

283

);

1✔

285

            assert_eq!(

1✔

287

                &format!("{function}")

1✔

289

1✔

292

        fn function_fmt_for_product_version_should_format_correctly() {

1✔

293

            let function = Function::ProductVersion(

1✔

294

                "../TESV.exe".into(),

1✔

295

                "1.2a".into(),

1✔

296

                ComparisonOperator::Equal,

1✔

297

);

1✔

299

            assert_eq!(

1✔

301

                &format!("{function}")

1✔

303

1✔

306

        fn function_fmt_for_filename_version_should_format_correctly() {

1✔

307

            let function = Function::FilenameVersion(

1✔

308

                "subdir".into(),

1✔

309

                regex(r"filename (\d+(?:[_.-]?\d+)*[a-z]?)\.esp"),

1✔

310

                "1.2a".into(),

1✔

311

                ComparisonOperator::Equal,

1✔

312

);

1✔

314

            assert_eq!(

1✔

316

                &format!("{function}")

1✔

318

1✔

321

        fn function_fmt_for_description_contains_should_format_correctly() {

1✔

322

            let function =

1✔

323

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII));

1✔

325

            assert_eq!(

1✔

326

                &format!("description_contains(\"Blank.esp\", \"{LOWERCASE_NON_ASCII}\")"),

1✔

327

                &format!("{function}")

1✔

329

1✔

336

        fn function_eq_for_file_path_should_check_pathbuf() {

1✔

337

            assert_eq!(

1✔

338

                Function::FilePath("Blank.esm".into()),

1✔

339

                Function::FilePath("Blank.esm".into())

1✔

342

            assert_ne!(

1✔

343

                Function::FilePath("Blank.esp".into()),

1✔

344

                Function::FilePath("Blank.esm".into())

1✔

346

1✔

349

        fn function_eq_for_file_path_should_be_case_insensitive_on_pathbuf() {

1✔

350

            assert_eq!(

1✔

351

                Function::FilePath("Blank.esm".into()),

1✔

352

                Function::FilePath("blank.esm".into())

1✔

354

1✔

357

        fn function_eq_for_file_regex_should_check_pathbuf_and_regex() {

1✔

358

            assert_eq!(

1✔

359

                Function::FileRegex("subdir".into(), regex("blank.*")),

1✔

360

                Function::FileRegex("subdir".into(), regex("blank.*"))

1✔

363

            assert_ne!(

1✔

364

                Function::FileRegex("subdir".into(), regex("blank.*")),

1✔

365

                Function::FileRegex("other".into(), regex("blank.*"))

1✔

367

            assert_ne!(

1✔

368

                Function::FileRegex("subdir".into(), regex("blank.*")),

1✔

369

                Function::FileRegex("subdir".into(), regex(".*"))

1✔

371

1✔

374

        fn function_eq_for_file_regex_should_be_case_insensitive_on_pathbuf_and_regex() {

1✔

375

            assert_eq!(

1✔

376

                Function::FileRegex("subdir".into(), regex("blank.*")),

1✔

377

                Function::FileRegex("Subdir".into(), regex("Blank.*"))

1✔

379

1✔

382

        fn function_eq_for_file_size_should_check_pathbuf_and_size() {

1✔

383

            assert_eq!(

1✔

384

                Function::FileSize("subdir".into(), 1),

1✔

385

                Function::FileSize("subdir".into(), 1)

1✔

388

            assert_ne!(

1✔

389

                Function::FileSize("subdir".into(), 1),

1✔

390

                Function::FileSize("other".into(), 1)

1✔

392

            assert_ne!(

1✔

393

                Function::FileSize("subdir".into(), 1),

1✔

394

                Function::FileSize("subdir".into(), 2)

1✔

396

1✔

399

        fn function_eq_for_file_size_should_be_case_insensitive_on_pathbuf() {

1✔

400

            assert_eq!(

1✔

401

                Function::FileSize("subdir".into(), 1),

1✔

402

                Function::FileSize("Subdir".into(), 1)

1✔

404

1✔

407

        fn function_eq_for_readable_should_check_pathbuf() {

1✔

408

            assert_eq!(

1✔

409

                Function::Readable("Blank.esm".into()),

1✔

410

                Function::Readable("Blank.esm".into())

1✔

413

            assert_ne!(

1✔

414

                Function::Readable("Blank.esp".into()),

1✔

415

                Function::Readable("Blank.esm".into())

1✔

417

1✔

420

        fn function_eq_for_readable_should_be_case_insensitive_on_pathbuf() {

1✔

421

            assert_eq!(

1✔

422

                Function::Readable("Blank.esm".into()),

1✔

423

                Function::Readable("blank.esm".into())

1✔

425

1✔

428

        fn function_eq_for_readable_should_not_be_equal_to_file_path_with_same_pathbuf() {

1✔

429

            assert_ne!(

1✔

430

                Function::Readable("Blank.esm".into()),

1✔

431

                Function::FilePath("Blank.esm".into())

1✔

433

1✔

436

        fn function_eq_for_is_executable_should_check_pathbuf() {

1✔

437

            assert_eq!(

1✔

438

                Function::IsExecutable("Blank.esm".into()),

1✔

439

                Function::IsExecutable("Blank.esm".into())

1✔

442

            assert_ne!(

1✔

443

                Function::IsExecutable("Blank.esp".into()),

1✔

444

                Function::IsExecutable("Blank.esm".into())

1✔

446

1✔

449

        fn function_eq_for_is_executable_should_be_case_insensitive_on_pathbuf() {

1✔

450

            assert_eq!(

1✔

451

                Function::IsExecutable("Blank.esm".into()),

1✔

452

                Function::IsExecutable("blank.esm".into())

1✔

454

1✔

457

        fn function_eq_for_is_executable_should_not_be_equal_to_file_path_or_is_executable_with_same_pathbuf(

1✔

458

) {

1✔

459

            assert_ne!(

1✔

460

                Function::IsExecutable("Blank.esm".into()),

1✔

461

                Function::FilePath("Blank.esm".into())

1✔

463

            assert_ne!(

1✔

464

                Function::IsExecutable("Blank.esm".into()),

1✔

465

                Function::Readable("Blank.esm".into())

1✔

467

1✔

470

        fn function_eq_for_active_path_should_check_pathbuf() {

1✔

471

            assert_eq!(

1✔

472

                Function::ActivePath("Blank.esm".into()),

1✔

473

                Function::ActivePath("Blank.esm".into())

1✔

476

            assert_ne!(

1✔

477

                Function::ActivePath("Blank.esp".into()),

1✔

478

                Function::ActivePath("Blank.esm".into())

1✔

480

1✔

483

        fn function_eq_for_active_path_should_be_case_insensitive_on_pathbuf() {

1✔

484

            assert_eq!(

1✔

485

                Function::ActivePath("Blank.esm".into()),

1✔

486

                Function::ActivePath("blank.esm".into())

1✔

488

1✔

491

        fn function_eq_for_active_path_should_not_be_equal_to_file_path_with_same_pathbuf() {

1✔

492

            assert_ne!(

1✔

493

                Function::ActivePath("Blank.esm".into()),

1✔

494

                Function::FilePath("Blank.esm".into())

1✔

496

1✔

499

        fn function_eq_for_active_path_should_not_be_equal_to_readable_with_same_pathbuf() {

1✔

500

            assert_ne!(

1✔

501

                Function::ActivePath("Blank.esm".into()),

1✔

502

                Function::Readable("Blank.esm".into())

1✔

504

1✔

507

        fn function_eq_for_active_regex_should_check_regex() {

1✔

508

            assert_eq!(

1✔

509

                Function::ActiveRegex(regex("blank.*")),

1✔

510

                Function::ActiveRegex(regex("blank.*"))

1✔

513

            assert_ne!(

1✔

514

                Function::ActiveRegex(regex("blank.*")),

1✔

515

                Function::ActiveRegex(regex(".*"))

1✔

517

1✔

520

        fn function_eq_for_active_regex_should_be_case_insensitive_on_regex() {

1✔

521

            assert_eq!(

1✔

522

                Function::ActiveRegex(regex("blank.*")),

1✔

523

                Function::ActiveRegex(regex("Blank.*"))

1✔

525

1✔

528

        fn function_eq_for_is_master_should_check_pathbuf() {

1✔

529

            assert_eq!(

1✔

530

                Function::IsMaster("Blank.esm".into()),

1✔

531

                Function::IsMaster("Blank.esm".into())

1✔

534

            assert_ne!(

1✔

535

                Function::IsMaster("Blank.esp".into()),

1✔

536

                Function::IsMaster("Blank.esm".into())

1✔

538

1✔

541

        fn function_eq_for_is_master_should_be_case_insensitive_on_pathbuf() {

1✔

542

            assert_eq!(

1✔

543

                Function::IsMaster("Blank.esm".into()),

1✔

544

                Function::IsMaster("blank.esm".into())

1✔

546

1✔

549

        fn function_eq_for_is_master_should_not_be_equal_to_file_path_with_same_pathbuf() {

1✔

550

            assert_ne!(

1✔

551

                Function::IsMaster("Blank.esm".into()),

1✔

552

                Function::FilePath("Blank.esm".into())

1✔

554

1✔

557

        fn function_eq_for_is_master_should_not_be_equal_to_readable_with_same_pathbuf() {

1✔

558

            assert_ne!(

1✔

559

                Function::IsMaster("Blank.esm".into()),

1✔

560

                Function::Readable("Blank.esm".into())

1✔

562

1✔

565

        fn function_eq_for_is_master_should_not_be_equal_to_active_path_with_same_pathbuf() {

1✔

566

            assert_ne!(

1✔

567

                Function::IsMaster("Blank.esm".into()),

1✔

568

                Function::ActivePath("Blank.esm".into())

1✔

570

1✔

573

        fn function_eq_for_many_should_check_pathbuf_and_regex() {

1✔

574

            assert_eq!(

1✔

575

                Function::Many("subdir".into(), regex("blank.*")),

1✔

576

                Function::Many("subdir".into(), regex("blank.*"))

1✔

579

            assert_ne!(

1✔

580

                Function::Many("subdir".into(), regex("blank.*")),

1✔

581

                Function::Many("subdir".into(), regex(".*"))

1✔

583

            assert_ne!(

1✔

584

                Function::Many("subdir".into(), regex("blank.*")),

1✔

585

                Function::Many("other".into(), regex("blank.*"))

1✔

587

1✔

590

        fn function_eq_for_many_should_be_case_insensitive_on_pathbuf_and_regex() {

1✔

591

            assert_eq!(

1✔

592

                Function::Many("subdir".into(), regex("blank.*")),

1✔

593

                Function::Many("Subdir".into(), regex("Blank.*"))

1✔

595

1✔

598

        fn function_eq_many_should_not_be_equal_to_file_regex_with_same_pathbuf_and_regex() {

1✔

599

            assert_ne!(

1✔

600

                Function::Many("subdir".into(), regex("blank.*")),

1✔

601

                Function::FileRegex("subdir".into(), regex("blank.*"))

1✔

603

1✔

606

        fn function_eq_for_many_active_should_check_regex() {

1✔

607

            assert_eq!(

1✔

608

                Function::ManyActive(regex("blank.*")),

1✔

609

                Function::ManyActive(regex("blank.*"))

1✔

612

            assert_ne!(

1✔

613

                Function::ManyActive(regex("blank.*")),

1✔

614

                Function::ManyActive(regex(".*"))

1✔

616

1✔

619

        fn function_eq_for_many_active_should_be_case_insensitive_on_regex() {

1✔

620

            assert_eq!(

1✔

621

                Function::ManyActive(regex("blank.*")),

1✔

622

                Function::ManyActive(regex("Blank.*"))

1✔

624

1✔

627

        fn function_eq_many_active_should_not_be_equal_to_active_regex_with_same_regex() {

1✔

628

            assert_ne!(

1✔

629

                Function::ManyActive(regex("blank.*")),

1✔

630

                Function::ActiveRegex(regex("blank.*"))

1✔

632

1✔

635

        fn function_eq_for_checksum_should_check_pathbuf_and_crc() {

1✔

636

            assert_eq!(

1✔

637

                Function::Checksum("Blank.esm".into(), 1),

1✔

638

                Function::Checksum("Blank.esm".into(), 1)

1✔

641

            assert_ne!(

1✔

642

                Function::Checksum("Blank.esm".into(), 1),

1✔

643

                Function::Checksum("Blank.esm".into(), 2)

1✔

645

            assert_ne!(

1✔

646

                Function::Checksum("Blank.esm".into(), 1),

1✔

647

                Function::Checksum("Blank.esp".into(), 1)

1✔

649

1✔

652

        fn function_eq_for_checksum_should_be_case_insensitive_on_pathbuf() {

1✔

653

            assert_eq!(

1✔

654

                Function::Checksum("Blank.esm".into(), 1),

1✔

655

                Function::Checksum("blank.esm".into(), 1)

1✔

657

1✔

660

        fn function_eq_for_version_should_check_pathbuf_version_and_comparator() {

1✔

661

            assert_eq!(

1✔

662

                Function::Version("Blank.esm".into(), "1".into(), ComparisonOperator::Equal),

1✔

663

                Function::Version("Blank.esm".into(), "1".into(), ComparisonOperator::Equal)

1✔

666

            assert_ne!(

1✔

667

                Function::Version("Blank.esm".into(), "1".into(), ComparisonOperator::Equal),

1✔

668

                Function::Version("Blank.esp".into(), "1".into(), ComparisonOperator::Equal)

1✔

670

            assert_ne!(

1✔

671

                Function::Version("Blank.esm".into(), "1".into(), ComparisonOperator::Equal),

1✔

672

                Function::Version("Blank.esm".into(), "2".into(), ComparisonOperator::Equal)

1✔

674

            assert_ne!(

1✔

675

                Function::Version("Blank.esm".into(), "1".into(), ComparisonOperator::Equal),

1✔

676

                Function::Version("Blank.esm".into(), "1".into(), ComparisonOperator::NotEqual)

1✔

678

1✔

681

        fn function_eq_for_version_should_be_case_insensitive_on_pathbuf_and_version() {

1✔

682

            assert_eq!(

1✔

683

                Function::Version("Blank.esm".into(), "A".into(), ComparisonOperator::Equal),

1✔

684

                Function::Version("blank.esm".into(), "a".into(), ComparisonOperator::Equal)

1✔

686

1✔

689

        fn function_eq_for_product_version_should_check_pathbuf_version_and_comparator() {

1✔

690

            assert_eq!(

1✔

691

                Function::ProductVersion("Blank.esm".into(), "1".into(), ComparisonOperator::Equal),

1✔

692

                Function::ProductVersion("Blank.esm".into(), "1".into(), ComparisonOperator::Equal)

1✔

695

            assert_ne!(

1✔

696

                Function::ProductVersion("Blank.esm".into(), "1".into(), ComparisonOperator::Equal),

1✔

697

                Function::ProductVersion("Blank.esp".into(), "1".into(), ComparisonOperator::Equal)

1✔

699

            assert_ne!(

1✔

700

                Function::ProductVersion("Blank.esm".into(), "1".into(), ComparisonOperator::Equal),

1✔

701

                Function::ProductVersion("Blank.esm".into(), "2".into(), ComparisonOperator::Equal)

1✔

703

            assert_ne!(

1✔

704

                Function::ProductVersion("Blank.esm".into(), "1".into(), ComparisonOperator::Equal),

1✔

705

                Function::ProductVersion(

1✔

706

                    "Blank.esm".into(),

1✔

707

                    "1".into(),

1✔

708

                    ComparisonOperator::NotEqual

1✔

709

1✔

711

1✔

714

        fn function_eq_for_product_version_should_be_case_insensitive_on_pathbuf_and_version() {

1✔

715

            assert_eq!(

1✔

716

                Function::ProductVersion("Blank.esm".into(), "A".into(), ComparisonOperator::Equal),

1✔

717

                Function::ProductVersion("blank.esm".into(), "a".into(), ComparisonOperator::Equal)

1✔

719

1✔

722

        fn function_eq_for_filename_version_should_check_pathbuf_regex_version_and_comparator() {

1✔

723

            assert_eq!(

1✔

724

                Function::FilenameVersion(

1✔

725

                    "subdir".into(),

1✔

726

                    regex("Blank\\.esm"),

1✔

727

                    "1".into(),

1✔

728

                    ComparisonOperator::Equal

1✔

729

),

1✔

730

                Function::FilenameVersion(

1✔

731

                    "subdir".into(),

1✔

732

                    regex("Blank\\.esm"),

1✔

733

                    "1".into(),

1✔

734

                    ComparisonOperator::Equal

1✔

735

1✔

738

            assert_ne!(

1✔

739

                Function::FilenameVersion(

1✔

740

                    "subdir1".into(),

1✔

741

                    regex("Blank\\.esm"),

1✔

742

                    "1".into(),

1✔

743

                    ComparisonOperator::Equal

1✔

744

),

1✔

745

                Function::FilenameVersion(

1✔

746

                    "subdir2".into(),

1✔

747

                    regex("Blank\\.esm"),

1✔

748

                    "1".into(),

1✔

749

                    ComparisonOperator::Equal

1✔

750

1✔

752

            assert_ne!(

1✔

753

                Function::FilenameVersion(

1✔

754

                    "subdir".into(),

1✔

755

                    regex("Blank\\.esm"),

1✔

756

                    "1".into(),

1✔

757

                    ComparisonOperator::Equal

1✔

758

),

1✔

759

                Function::FilenameVersion(

1✔

760

                    "subdir".into(),

1✔

761

                    regex("Blank.esp"),

1✔

762

                    "1".into(),

1✔

763

                    ComparisonOperator::Equal

1✔

764

1✔

766

            assert_ne!(

1✔

767

                Function::FilenameVersion(

1✔

768

                    "subdir".into(),

1✔

769

                    regex("Blank\\.esm"),

1✔

770

                    "1".into(),

1✔

771

                    ComparisonOperator::Equal

1✔

772

),

1✔

773

                Function::FilenameVersion(

1✔

774

                    "subdir".into(),

1✔

775

                    regex("Blank\\.esm"),

1✔

776

                    "2".into(),

1✔

777

                    ComparisonOperator::Equal

1✔

778

1✔

780

            assert_ne!(

1✔

781

                Function::FilenameVersion(

1✔

782

                    "subdir".into(),

1✔

783

                    regex("Blank\\.esm"),

1✔

784

                    "1".into(),

1✔

785

                    ComparisonOperator::Equal

1✔

786

),

1✔

787

                Function::FilenameVersion(

1✔

788

                    "subdir".into(),

1✔

789

                    regex("Blank\\.esm"),

1✔

790

                    "1".into(),

1✔

791

                    ComparisonOperator::NotEqual

1✔

792

1✔

794

1✔

797

        fn function_eq_for_filename_version_should_be_case_insensitive_on_pathbuf_and_version() {

1✔

798

            assert_eq!(

1✔

799

                Function::FilenameVersion(

1✔

800

                    "subdir".into(),

1✔

801

                    regex("Blank\\.esm"),

1✔

802

                    "A".into(),

1✔

803

                    ComparisonOperator::Equal

1✔

804

),

1✔

805

                Function::FilenameVersion(

1✔

806

                    "Subdir".into(),

1✔

807

                    regex("Blank\\.esm"),

1✔

808

                    "a".into(),

1✔

809

                    ComparisonOperator::Equal

1✔

810

1✔

812

1✔

815

        fn function_eq_for_description_contains_should_check_pathbuf_and_regex() {

1✔

816

            assert_eq!(

1✔

817

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII)),

1✔

818

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII))

1✔

821

            assert_ne!(

1✔

822

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII)),

1✔

823

                Function::DescriptionContains("Blank.esp".into(), regex(".*"))

1✔

825

            assert_ne!(

1✔

826

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII)),

1✔

827

                Function::DescriptionContains("other".into(), regex(LOWERCASE_NON_ASCII))

1✔

829

1✔

832

        fn function_eq_for_description_contains_should_be_case_insensitive_on_pathbuf_and_regex() {

1✔

833

            assert_eq!(

1✔

834

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII)),

1✔

835

                Function::DescriptionContains("blank.esp".into(), regex(UPPERCASE_NON_ASCII))

1✔

837

1✔

840

        fn function_eq_description_contains_should_not_be_equal_to_file_regex_with_same_pathbuf_and_regex(

1✔

841

) {

1✔

842

            assert_ne!(

1✔

843

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII)),

1✔

844

                Function::FileRegex("Blank.esp".into(), regex(LOWERCASE_NON_ASCII))

1✔

846

1✔

854

        fn hash(function: &Function) -> u64 {

138✔

855

            let mut hasher = DefaultHasher::new();

138✔

856

            function.hash(&mut hasher);

138✔

857

            hasher.finish()

138✔

858

138✔

861

        fn function_hash_file_path_should_hash_pathbuf() {

1✔

862

            let function1 = Function::FilePath("Blank.esm".into());

1✔

863

            let function2 = Function::FilePath("Blank.esm".into());

1✔

865

            assert_eq!(hash(&function1), hash(&function2));

1✔

867

            let function1 = Function::FilePath("Blank.esm".into());

1✔

868

            let function2 = Function::FilePath("Blank.esp".into());

1✔

870

            assert_ne!(hash(&function1), hash(&function2));

1✔

871

1✔

874

        fn function_hash_file_path_should_be_case_insensitive() {

1✔

875

            let function1 = Function::FilePath("Blank.esm".into());

1✔

876

            let function2 = Function::FilePath("blank.esm".into());

1✔

878

            assert_eq!(hash(&function1), hash(&function2));

1✔

879

1✔

882

        fn function_hash_file_regex_should_hash_pathbuf_and_regex() {

1✔

883

            let function1 = Function::FileRegex("subdir".into(), regex(".*"));

1✔

884

            let function2 = Function::FileRegex("subdir".into(), regex(".*"));

1✔

886

            assert_eq!(hash(&function1), hash(&function2));

1✔

888

            let function1 = Function::FileRegex("subdir".into(), regex(".*"));

1✔

889

            let function2 = Function::FileRegex("other".into(), regex(".*"));

1✔

891

            assert_ne!(hash(&function1), hash(&function2));

1✔

893

            let function1 = Function::FileRegex("subdir".into(), regex(".*"));

1✔

894

            let function2 = Function::FileRegex("subdir".into(), regex("Blank.*"));

1✔

896

            assert_ne!(hash(&function1), hash(&function2));

1✔

897

1✔

900

        fn function_hash_file_regex_should_be_case_insensitive() {

1✔

901

            let function1 = Function::FileRegex("Subdir".into(), regex("Blank.*"));

1✔

902

            let function2 = Function::FileRegex("subdir".into(), regex("blank.*"));

1✔

904

            assert_eq!(hash(&function1), hash(&function2));

1✔

905

1✔

908

        fn function_hash_file_size_should_hash_pathbuf_and_size() {

1✔

909

            let function1 = Function::FileSize("subdir".into(), 1);

1✔

910

            let function2 = Function::FileSize("subdir".into(), 1);

1✔

912

            assert_eq!(hash(&function1), hash(&function2));

1✔

914

            let function1 = Function::FileSize("subdir".into(), 1);

1✔

915

            let function2 = Function::FileSize("other".into(), 1);

1✔

917

            assert_ne!(hash(&function1), hash(&function2));

1✔

919

            let function1 = Function::FileSize("subdir".into(), 1);

1✔

920

            let function2 = Function::FileSize("subdir".into(), 2);

1✔

922

            assert_ne!(hash(&function1), hash(&function2));

1✔

923

1✔

926

        fn function_hash_file_size_should_be_case_insensitive() {

1✔

927

            let function1 = Function::FileSize("Subdir".into(), 1);

1✔

928

            let function2 = Function::FileSize("subdir".into(), 1);

1✔

930

            assert_eq!(hash(&function1), hash(&function2));

1✔

931

1✔

934

        fn function_hash_readable_should_hash_pathbuf() {

1✔

935

            let function1 = Function::Readable("Blank.esm".into());

1✔

936

            let function2 = Function::Readable("Blank.esm".into());

1✔

938

            assert_eq!(hash(&function1), hash(&function2));

1✔

940

            let function1 = Function::Readable("Blank.esm".into());

1✔

941

            let function2 = Function::Readable("Blank.esp".into());

1✔

943

            assert_ne!(hash(&function1), hash(&function2));

1✔

944

1✔

947

        fn function_hash_readable_should_be_case_insensitive() {

1✔

948

            let function1 = Function::Readable("Blank.esm".into());

1✔

949

            let function2 = Function::Readable("blank.esm".into());

1✔

951

            assert_eq!(hash(&function1), hash(&function2));

1✔

952

1✔

955

        fn function_hash_file_path_and_readable_should_not_have_equal_hashes() {

1✔

956

            let function1 = Function::FilePath("Blank.esm".into());

1✔

957

            let function2 = Function::Readable("Blank.esm".into());

1✔

959

            assert_ne!(hash(&function1), hash(&function2));

1✔

960

1✔

963

        fn function_hash_is_executable_should_hash_pathbuf() {

1✔

964

            let function1 = Function::IsExecutable("Blank.esm".into());

1✔

965

            let function2 = Function::IsExecutable("Blank.esm".into());

1✔

967

            assert_eq!(hash(&function1), hash(&function2));

1✔

969

            let function1 = Function::IsExecutable("Blank.esm".into());

1✔

970

            let function2 = Function::IsExecutable("Blank.esp".into());

1✔

972

            assert_ne!(hash(&function1), hash(&function2));

1✔

973

1✔

976

        fn function_hash_is_executable_should_be_case_insensitive() {

1✔

977

            let function1 = Function::IsExecutable("Blank.esm".into());

1✔

978

            let function2 = Function::IsExecutable("blank.esm".into());

1✔

980

            assert_eq!(hash(&function1), hash(&function2));

1✔

981

1✔

984

        fn function_hash_file_path_and_readable_and_is_executable_should_not_have_equal_hashes() {

1✔

985

            let function1 = Function::FilePath("Blank.esm".into());

1✔

986

            let function2 = Function::Readable("Blank.esm".into());

1✔

987

            let function3 = Function::IsExecutable("Blank.esm".into());

1✔

989

            assert_ne!(hash(&function1.clone()), hash(&function2.clone()));

1✔

990

            assert_ne!(hash(&function3.clone()), hash(&function1));

1✔

991

            assert_ne!(hash(&function3), hash(&function2));

1✔

992

1✔

995

        fn function_hash_active_path_should_hash_pathbuf() {

1✔

996

            let function1 = Function::ActivePath("Blank.esm".into());

1✔

997

            let function2 = Function::ActivePath("Blank.esm".into());

1✔

999

            assert_eq!(hash(&function1), hash(&function2));

1✔

1001

            let function1 = Function::ActivePath("Blank.esm".into());

1✔

1002

            let function2 = Function::ActivePath("Blank.esp".into());

1✔

1004

            assert_ne!(hash(&function1), hash(&function2));

1✔

1005

1✔

1008

        fn function_hash_active_path_should_be_case_insensitive() {

1✔

1009

            let function1 = Function::ActivePath("Blank.esm".into());

1✔

1010

            let function2 = Function::ActivePath("blank.esm".into());

1✔

1012

            assert_eq!(hash(&function1), hash(&function2));

1✔

1013

1✔

1016

        fn function_hash_file_path_and_active_path_should_not_have_equal_hashes() {

1✔

1017

            let function1 = Function::FilePath("Blank.esm".into());

1✔

1018

            let function2 = Function::ActivePath("Blank.esm".into());

1✔

1020

            assert_ne!(hash(&function1), hash(&function2));

1✔

1021

1✔

1024

        fn function_hash_readable_and_active_path_should_not_have_equal_hashes() {

1✔

1025

            let function1 = Function::Readable("Blank.esm".into());

1✔

1026

            let function2 = Function::ActivePath("Blank.esm".into());

1✔

1028

            assert_ne!(hash(&function1), hash(&function2));

1✔

1029

1✔

1032

        fn function_hash_active_regex_should_hash_pathbuf_and_regex() {

1✔

1033

            let function1 = Function::ActiveRegex(regex(".*"));

1✔

1034

            let function2 = Function::ActiveRegex(regex(".*"));

1✔

1036

            assert_eq!(hash(&function1), hash(&function2));

1✔

1038

            let function1 = Function::ActiveRegex(regex(".*"));

1✔

1039

            let function2 = Function::ActiveRegex(regex("Blank.*"));

1✔

1041

            assert_ne!(hash(&function1), hash(&function2));

1✔

1042

1✔

1045

        fn function_hash_active_regex_should_be_case_insensitive() {

1✔

1046

            let function1 = Function::ActiveRegex(regex("Blank.*"));

1✔

1047

            let function2 = Function::ActiveRegex(regex("blank.*"));

1✔

1049

            assert_eq!(hash(&function1), hash(&function2));

1✔

1050

1✔

1053

        fn function_hash_is_master_should_hash_pathbuf() {

1✔

1054

            let function1 = Function::IsMaster("Blank.esm".into());

1✔

1055

            let function2 = Function::IsMaster("Blank.esm".into());

1✔

1057

            assert_eq!(hash(&function1), hash(&function2));

1✔

1059

            let function1 = Function::IsMaster("Blank.esm".into());

1✔

1060

            let function2 = Function::IsMaster("Blank.esp".into());

1✔

1062

            assert_ne!(hash(&function1), hash(&function2));

1✔

1063

1✔

1066

        fn function_hash_is_master_should_be_case_insensitive() {

1✔

1067

            let function1 = Function::IsMaster("Blank.esm".into());

1✔

1068

            let function2 = Function::IsMaster("blank.esm".into());

1✔

1070

            assert_eq!(hash(&function1), hash(&function2));

1✔

1071

1✔

1074

        fn function_hash_file_path_and_is_master_should_not_have_equal_hashes() {

1✔

1075

            let function1 = Function::FilePath("Blank.esm".into());

1✔

1076

            let function2 = Function::IsMaster("Blank.esm".into());

1✔

1078

            assert_ne!(hash(&function1), hash(&function2));

1✔

1079

1✔

1082

        fn function_hash_readable_and_is_master_should_not_have_equal_hashes() {

1✔

1083

            let function1 = Function::Readable("Blank.esm".into());

1✔

1084

            let function2 = Function::IsMaster("Blank.esm".into());

1✔

1086

            assert_ne!(hash(&function1), hash(&function2));

1✔

1087

1✔

1090

        fn function_hash_active_path_and_is_master_should_not_have_equal_hashes() {

1✔

1091

            let function1 = Function::ActivePath("Blank.esm".into());

1✔

1092

            let function2 = Function::IsMaster("Blank.esm".into());

1✔

1094

            assert_ne!(hash(&function1), hash(&function2));

1✔

1095

1✔

1098

        fn function_hash_many_should_hash_pathbuf_and_regex() {

1✔

1099

            let function1 = Function::Many("subdir".into(), regex(".*"));

1✔

1100

            let function2 = Function::Many("subdir".into(), regex(".*"));

1✔

1102

            assert_eq!(hash(&function1), hash(&function2));

1✔

1104

            let function1 = Function::Many("subdir".into(), regex(".*"));

1✔

1105

            let function2 = Function::Many("other".into(), regex(".*"));

1✔

1107

            assert_ne!(hash(&function1), hash(&function2));

1✔

1109

            let function1 = Function::Many("subdir".into(), regex(".*"));

1✔

1110

            let function2 = Function::Many("subdir".into(), regex("Blank.*"));

1✔

1112

            assert_ne!(hash(&function1), hash(&function2));

1✔

1113

1✔

1116

        fn function_hash_many_should_be_case_insensitive() {

1✔

1117

            let function1 = Function::Many("Subdir".into(), regex("Blank.*"));

1✔

1118

            let function2 = Function::Many("subdir".into(), regex("blank.*"));

1✔

1120

            assert_eq!(hash(&function1), hash(&function2));

1✔

1121

1✔

1124

        fn function_hash_file_regex_and_many_should_not_have_equal_hashes() {

1✔

1125

            let function1 = Function::FileRegex("subdir".into(), regex(".*"));

1✔

1126

            let function2 = Function::Many("subdir".into(), regex(".*"));

1✔

1128

            assert_ne!(hash(&function1), hash(&function2));

1✔

1129

1✔

1132

        fn function_many_active_should_hash_pathbuf_and_regex() {

1✔

1133

            let function1 = Function::ManyActive(regex(".*"));

1✔

1134

            let function2 = Function::ManyActive(regex(".*"));

1✔

1136

            assert_eq!(hash(&function1), hash(&function2));

1✔

1138

            let function1 = Function::ManyActive(regex(".*"));

1✔

1139

            let function2 = Function::ManyActive(regex("Blank.*"));

1✔

1141

            assert_ne!(hash(&function1), hash(&function2));

1✔

1142

1✔

1145

        fn function_many_active_should_be_case_insensitive() {

1✔

1146

            let function1 = Function::ManyActive(regex("Blank.*"));

1✔

1147

            let function2 = Function::ManyActive(regex("blank.*"));

1✔

1149

            assert_eq!(hash(&function1), hash(&function2));

1✔

1150

1✔

1153

        fn function_hash_active_regex_and_many_active_should_not_have_equal_hashes() {

1✔

1154

            let function1 = Function::ActiveRegex(regex(".*"));

1✔

1155

            let function2 = Function::ManyActive(regex(".*"));

1✔

1157

            assert_ne!(hash(&function1), hash(&function2));

1✔

1158

1✔

1161

        fn function_hash_checksum_should_hash_pathbuf_and_regex() {

1✔

1162

            let function1 = Function::Checksum("subdir".into(), 1);

1✔

1163

            let function2 = Function::Checksum("subdir".into(), 1);

1✔

1165

            assert_eq!(hash(&function1), hash(&function2));

1✔

1167

            let function1 = Function::Checksum("subdir".into(), 1);

1✔

1168

            let function2 = Function::Checksum("other".into(), 1);

1✔

1170

            assert_ne!(hash(&function1), hash(&function2));

1✔

1172

            let function1 = Function::Checksum("subdir".into(), 1);

1✔

1173

            let function2 = Function::Checksum("subdir".into(), 2);

1✔

1175

            assert_ne!(hash(&function1), hash(&function2));

1✔

1176

1✔

1179

        fn function_hash_checksum_should_be_case_insensitive() {

1✔

1180

            let function1 = Function::Checksum("Blank.esm".into(), 1);

1✔

1181

            let function2 = Function::Checksum("Blank.esm".into(), 1);

1✔

1183

            assert_eq!(hash(&function1), hash(&function2));

1✔

1184

1✔

1187

        fn function_hash_version_should_hash_pathbuf_and_version_and_comparator() {

1✔

1188

            let function1 =

1✔

1189

                Function::Version("Blank.esm".into(), "1.2a".into(), ComparisonOperator::Equal);

1✔

1190

            let function2 =

1✔

1191

                Function::Version("Blank.esm".into(), "1.2a".into(), ComparisonOperator::Equal);

1✔

1193

            assert_eq!(hash(&function1), hash(&function2));

1✔

1195

            let function1 =

1✔

1196

                Function::Version("Blank.esm".into(), "1".into(), ComparisonOperator::Equal);

1✔

1197

            let function2 =

1✔

1198

                Function::Version("Blank.esp".into(), "1".into(), ComparisonOperator::Equal);

1✔

1200

            assert_ne!(hash(&function1), hash(&function2));

1✔

1202

            let function1 =

1✔

1203

                Function::Version("Blank.esm".into(), "1".into(), ComparisonOperator::Equal);

1✔

1204

            let function2 =

1✔

1205

                Function::Version("Blank.esm".into(), "2".into(), ComparisonOperator::Equal);

1✔

1207

            assert_ne!(hash(&function1), hash(&function2));

1✔

1209

            let function1 =

1✔

1210

                Function::Version("Blank.esm".into(), "1".into(), ComparisonOperator::Equal);

1✔

1211

            let function2 =

1✔

1212

                Function::Version("Blank.esm".into(), "1".into(), ComparisonOperator::NotEqual);

1✔

1214

            assert_ne!(hash(&function1), hash(&function2));

1✔

1215

1✔

1218

        fn function_hash_version_should_be_case_insensitive() {

1✔

1219

            let function1 =

1✔

1220

                Function::Version("Blank.esm".into(), "1.2a".into(), ComparisonOperator::Equal);

1✔

1221

            let function2 =

1✔

1222

                Function::Version("Blank.esm".into(), "1.2A".into(), ComparisonOperator::Equal);

1✔

1224

            assert_eq!(hash(&function1), hash(&function2));

1✔

1225

1✔

1228

        fn function_hash_product_version_should_hash_pathbuf_and_version_and_comparator() {

1✔

1229

            let function1 = Function::ProductVersion(

1✔

1230

                "Blank.esm".into(),

1✔

1231

                "1.2a".into(),

1✔

1232

                ComparisonOperator::Equal,

1✔

1233

);

1✔

1234

            let function2 = Function::ProductVersion(

1✔

1235

                "Blank.esm".into(),

1✔

1236

                "1.2a".into(),

1✔

1237

                ComparisonOperator::Equal,

1✔

1238

);

1✔

1240

            assert_eq!(hash(&function1), hash(&function2));

1✔

1242

            let function1 =

1✔

1243

                Function::ProductVersion("Blank.esm".into(), "1".into(), ComparisonOperator::Equal);

1✔

1244

            let function2 =

1✔

1245

                Function::ProductVersion("Blank.esp".into(), "1".into(), ComparisonOperator::Equal);

1✔

1247

            assert_ne!(hash(&function1), hash(&function2));

1✔

1249

            let function1 =

1✔

1250

                Function::ProductVersion("Blank.esm".into(), "1".into(), ComparisonOperator::Equal);

1✔

1251

            let function2 =

1✔

1252

                Function::ProductVersion("Blank.esm".into(), "2".into(), ComparisonOperator::Equal);

1✔

1254

            assert_ne!(hash(&function1), hash(&function2));

1✔

1256

            let function1 =

1✔

1257

                Function::ProductVersion("Blank.esm".into(), "1".into(), ComparisonOperator::Equal);

1✔

1258

            let function2 = Function::ProductVersion(

1✔

1259

                "Blank.esm".into(),

1✔

1260

                "1".into(),

1✔

1261

                ComparisonOperator::NotEqual,

1✔

1262

);

1✔

1264

            assert_ne!(hash(&function1), hash(&function2));

1✔

1265

1✔

1268

        fn function_hash_product_version_should_be_case_insensitive() {

1✔

1269

            let function1 = Function::ProductVersion(

1✔

1270

                "Blank.esm".into(),

1✔

1271

                "1.2a".into(),

1✔

1272

                ComparisonOperator::Equal,

1✔

1273

);

1✔

1274

            let function2 = Function::ProductVersion(

1✔

1275

                "Blank.esm".into(),

1✔

1276

                "1.2A".into(),

1✔

1277

                ComparisonOperator::Equal,

1✔

1278

);

1✔

1280

            assert_eq!(hash(&function1), hash(&function2));

1✔

1281

1✔

1284

        fn function_hash_filename_version_should_hash_pathbuf_regex_and_version_and_comparator() {

1✔

1285

            let function1 = Function::FilenameVersion(

1✔

1286

                "subdir".into(),

1✔

1287

                regex("Blank\\.esm"),

1✔

1288

                "1.2a".into(),

1✔

1289

                ComparisonOperator::Equal,

1✔

1290

);

1✔

1291

            let function2 = Function::FilenameVersion(

1✔

1292

                "subdir".into(),

1✔

1293

                regex("Blank\\.esm"),

1✔

1294

                "1.2a".into(),

1✔

1295

                ComparisonOperator::Equal,

1✔

1296

);

1✔

1298

            assert_eq!(hash(&function1), hash(&function2));

1✔

1300

            let function1 = Function::FilenameVersion(

1✔

1301

                "subdir1".into(),

1✔

1302

                regex("Blank\\.esm"),

1✔

1303

                "1".into(),

1✔

1304

                ComparisonOperator::Equal,

1✔

1305

);

1✔

1306

            let function2 = Function::FilenameVersion(

1✔

1307

                "subdir2".into(),

1✔

1308

                regex("Blank\\.esp"),

1✔

1309

                "1".into(),

1✔

1310

                ComparisonOperator::Equal,

1✔

1311

);

1✔

1313

            assert_ne!(hash(&function1), hash(&function2));

1✔

1315

            let function1 = Function::FilenameVersion(

1✔

1316

                "subdir".into(),

1✔

1317

                regex("Blank\\.esm"),

1✔

1318

                "1".into(),

1✔

1319

                ComparisonOperator::Equal,

1✔

1320

);

1✔

1321

            let function2 = Function::FilenameVersion(

1✔

1322

                "subdir".into(),

1✔

1323

                regex("Blank\\.esp"),

1✔

1324

                "1".into(),

1✔

1325

                ComparisonOperator::Equal,

1✔

1326

);

1✔

1328

            assert_ne!(hash(&function1), hash(&function2));

1✔

1330

            let function1 = Function::FilenameVersion(

1✔

1331

                "subdir".into(),

1✔

1332

                regex("Blank\\.esm"),

1✔

1333

                "1".into(),

1✔

1334

                ComparisonOperator::Equal,

1✔

1335

);

1✔

1336

            let function2 = Function::FilenameVersion(

1✔

1337

                "subdir".into(),

1✔

1338

                regex("Blank\\.esm"),

1✔

1339

                "2".into(),

1✔

1340

                ComparisonOperator::Equal,

1✔

1341

);

1✔

1343

            assert_ne!(hash(&function1), hash(&function2));

1✔

1345

            let function1 = Function::FilenameVersion(

1✔

1346

                "subdir".into(),

1✔

1347

                regex("Blank\\.esm"),

1✔

1348

                "1".into(),

1✔

1349

                ComparisonOperator::Equal,

1✔

1350

);

1✔

1351

            let function2 = Function::FilenameVersion(

1✔

1352

                "subdir".into(),

1✔

1353

                regex("Blank\\.esm"),

1✔

1354

                "1".into(),

1✔

1355

                ComparisonOperator::NotEqual,

1✔

1356

);

1✔

1358

            assert_ne!(hash(&function1), hash(&function2));

1✔

1359

1✔

1362

        fn function_hash_filename_version_should_be_case_insensitive() {

1✔

1363

            let function1 = Function::FilenameVersion(

1✔

1364

                "subdir".into(),

1✔

1365

                regex("Blank\\.esm"),

1✔

1366

                "1.2a".into(),

1✔

1367

                ComparisonOperator::Equal,

1✔

1368

);

1✔

1369

            let function2 = Function::FilenameVersion(

1✔

1370

                "Subdir".into(),

1✔

1371

                regex("Blank\\.esm"),

1✔

1372

                "1.2A".into(),

1✔

1373

                ComparisonOperator::Equal,

1✔

1374

);

1✔

1376

            assert_eq!(hash(&function1), hash(&function2));

1✔

1377

1✔

1380

        fn function_hash_description_contains_should_hash_pathbuf_and_regex() {

1✔

1381

            let function1 =

1✔

1382

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII));

1✔

1383

            let function2 =

1✔

1384

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII));

1✔

1386

            assert_eq!(hash(&function1), hash(&function2));

1✔

1388

            let function1 =

1✔

1389

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII));

1✔

1390

            let function2 =

1✔

1391

                Function::DescriptionContains("other".into(), regex(LOWERCASE_NON_ASCII));

1✔

1393

            assert_ne!(hash(&function1), hash(&function2));

1✔

1395

            let function1 =

1✔

1396

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII));

1✔

1397

            let function2 = Function::DescriptionContains("Blank.esp".into(), regex(".*"));

1✔

1399

            assert_ne!(hash(&function1), hash(&function2));

1✔

1400

1✔

1403

        fn function_hash_description_contains_should_be_case_insensitive() {

1✔

1404

            let function1 =

1✔

1405

                Function::DescriptionContains("blank.esp".into(), regex(UPPERCASE_NON_ASCII));

1✔

1406

            let function2 =

1✔

1407

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII));

1✔

1409

            assert_eq!(hash(&function1), hash(&function2));

1✔

1410

1✔

1413

        fn function_hash_file_regex_and_description_contains_should_not_have_equal_hashes() {

1✔

1414

            let function1 = Function::FileRegex("Blank.esp".into(), regex(LOWERCASE_NON_ASCII));

1✔

1415

            let function2 =

1✔

1416

                Function::DescriptionContains("Blank.esp".into(), regex(LOWERCASE_NON_ASCII));

1✔

1418

            assert_ne!(hash(&function1), hash(&function2));

1✔

1419

1✔

loot / loot-condition-interpreter / 16680825703

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

loot / loot-condition-interpreter / 16680825703

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