• actyx_sdk 0.3.0/src/offset.rs
    830
    		 
        #[test]
    831
    		 
        #[allow(clippy::eq_op)]
    832
    		 
        pub fn must_calculate_offset_map() {
  • actyx_sdk 0.3.0/src/types/fixnum.rs
    467
    		 
        #[test]
    468
    		 
        #[allow(clippy::eq_op)]
    469
    		 
        pub fn must_compute() {
  • actyxos_sdk 0.6.0/src/event/offsets.rs
    814
    		 
        #[test]
    815
    		 
        #[allow(clippy::eq_op)]
    816
    		 
        pub fn must_calculate_offset_map() {
  • actyxos_sdk 0.6.0/src/types/fixnum.rs
    469
    		 
        #[test]
    470
    		 
        #[allow(clippy::eq_op)]
    471
    		 
        pub fn must_compute() {
  • agb 0.13.0/src/lib.rs
    383
    		 
        #[test_case]
    384
    		 
        #[allow(clippy::eq_op)]
    385
    		 
        fn trivial_test(_gba: &mut Gba) {
  • all-is-cubes 0.5.0/src/universe/uref.rs
    510
    		 
        #[test]
    511
    		 
        #[allow(clippy::eq_op)]
    512
    		 
        fn uref_equality_is_pointer_equality() {
    524
    		 
        #[test]
    525
    		 
        #[allow(clippy::eq_op)]
    526
    		 
        fn pending_uref_equality_is_pointer_equality() {
  • amethyst_core 0.15.3/src/transform/systems.rs
    365
    		 
        #[cfg(debug_assertions)]
    366
    		 
        #[allow(clippy::eq_op, clippy::zero_divided_by_zero)]
    367
    		 
        fn nan_transform() {
  • arrow 32.0.0/tests/array_equal.rs
    220
    		 
    #[allow(clippy::eq_op)]
    221
    		 
    fn test_equal(lhs: &ArrayData, rhs: &ArrayData, expected: bool) {
  • arrow-arith 32.0.0/src/aggregate.rs
    31
    		 
    pub(crate) fn is_nan<T: ArrowNativeType + PartialOrd + Copy>(a: T) -> bool {
    32
    		 
        #[allow(clippy::eq_op)]
    33
    		 
        !(a == a)
  • arrow2 0.15.0/tests/it/array/fixed_size_binary/mutable.rs
    21
    		 
    #[allow(clippy::eq_op)]
    22
    		 
    #[test]
  • arrow2 0.15.0/tests/it/scalar/binary.rs
    6
    		 
    #[allow(clippy::eq_op)]
    7
    		 
    #[test]
  • arrow2 0.15.0/tests/it/scalar/boolean.rs
    6
    		 
    #[allow(clippy::eq_op)]
    7
    		 
    #[test]
  • arrow2 0.15.0/tests/it/scalar/fixed_size_binary.rs
    6
    		 
    #[allow(clippy::eq_op)]
    7
    		 
    #[test]
  • arrow2 0.15.0/tests/it/scalar/fixed_size_list.rs
    7
    		 
    #[allow(clippy::eq_op)]
    8
    		 
    #[test]
  • arrow2 0.15.0/tests/it/scalar/list.rs
    7
    		 
    #[allow(clippy::eq_op)]
    8
    		 
    #[test]
  • arrow2 0.15.0/tests/it/scalar/null.rs
    6
    		 
    #[allow(clippy::eq_op)]
    7
    		 
    #[test]
  • arrow2 0.15.0/tests/it/scalar/primitive.rs
    6
    		 
    #[allow(clippy::eq_op)]
    7
    		 
    #[test]
  • arrow2 0.15.0/tests/it/scalar/struct_.rs
    6
    		 
    #[allow(clippy::eq_op)]
    7
    		 
    #[test]
  • arrow2 0.15.0/tests/it/scalar/utf8.rs
    6
    		 
    #[allow(clippy::eq_op)]
    7
    		 
    #[test]
  • au 0.10.0/src/polynomial/arithmetic.rs
    833
    		 
        #[test]
    834
    		 
        #[allow(clippy::eq_op)]
    835
    		 
        fn poly_sub() {
  • au 0.10.0/src/rational_function/arithmetic.rs
    430
    		 
        #[test]
    431
    		 
        #[allow(clippy::eq_op)]
    432
    		 
        fn div_references() {
  • au 0.10.0/src/transfer_function/mod.rs
    775
    		 
        #[test]
    776
    		 
        #[allow(clippy::eq_op)]
    777
    		 
        fn div_references() {
  • automatica 1.0.0/src/rational_function/arithmetic.rs
    491
    		 
        #[test]
    492
    		 
        #[allow(clippy::eq_op)]
    493
    		 
        fn div_references() {
  • automatica 1.0.0/src/transfer_function/mod.rs
    942
    		 
        #[test]
    943
    		 
        #[allow(clippy::eq_op)]
    944
    		 
        fn div_references() {
  • avm1-types 0.14.0/src/push_value.rs
    142
    		 
      #[allow(clippy::eq_op)]
    143
    		 
      #[test]
  • bacon-sci 0.13.1/src/tests/special/polynomial/mod.rs
    189
    		 
    #[allow(clippy::eq_op)]
    190
    		 
    #[test]
  • bacon-sci-1 0.11.0/src/tests/special/polynomial/mod.rs
    189
    		 
    #[allow(clippy::eq_op)]
    190
    		 
    #[test]
  • bed-reader 0.2.29/src/lib.rs
    662
    		 
        #[allow(clippy::eq_op)]
    663
    		 
        let use_nan = missing != missing; // generic NAN test
    677
    		 
                        for (iid_i, &v0) in column.iter().enumerate() {
    678
    		 
                            #[allow(clippy::eq_op)]
    679
    		 
                            let genotype_byte = if v0 == homozygous_primary_allele {
    5589
    		 
                // x != x is a generic nan check
    5590
    		 
                #[allow(clippy::eq_op)]
    5591
    		 
                let a_nan = *ptr_a != *ptr_a;
    5592
    		 
                #[allow(clippy::eq_op)]
    5593
    		 
                let b_nan = *ptr_b != *ptr_b;
  • bls12_381 0.7.1/src/g1.rs
    1139
    		 
    #[test]
    1140
    		 
    #[allow(clippy::eq_op)]
    1141
    		 
    fn test_affine_point_equality() {
    1151
    		 
    #[test]
    1152
    		 
    #[allow(clippy::eq_op)]
    1153
    		 
    fn test_projective_point_equality() {
    1542
    		 
    #[test]
    1543
    		 
    #[allow(clippy::eq_op)]
    1544
    		 
    fn test_projective_negation_and_subtraction() {
  • bls12_381 0.7.1/src/g2.rs
    1277
    		 
    #[test]
    1278
    		 
    #[allow(clippy::eq_op)]
    1279
    		 
    fn test_affine_point_equality() {
    1289
    		 
    #[test]
    1290
    		 
    #[allow(clippy::eq_op)]
    1291
    		 
    fn test_projective_point_equality() {
    1806
    		 
    #[test]
    1807
    		 
    #[allow(clippy::eq_op)]
    1808
    		 
    fn test_projective_negation_and_subtraction() {
  • bls12_381_plus 0.7.0/src/g1.rs
    1291
    		 
    #[test]
    1292
    		 
    #[allow(clippy::eq_op)]
    1293
    		 
    fn test_affine_point_equality() {
    1303
    		 
    #[test]
    1304
    		 
    #[allow(clippy::eq_op)]
    1305
    		 
    fn test_projective_point_equality() {
    1694
    		 
    #[test]
    1695
    		 
    #[allow(clippy::eq_op)]
    1696
    		 
    fn test_projective_negation_and_subtraction() {
  • bls12_381_plus 0.7.0/src/g2.rs
    1455
    		 
    #[test]
    1456
    		 
    #[allow(clippy::eq_op)]
    1457
    		 
    fn test_affine_point_equality() {
    1467
    		 
    #[test]
    1468
    		 
    #[allow(clippy::eq_op)]
    1469
    		 
    fn test_projective_point_equality() {
    1984
    		 
    #[test]
    1985
    		 
    #[allow(clippy::eq_op)]
    1986
    		 
    fn test_projective_negation_and_subtraction() {
  • Boa 0.13.1/src/value/tests.rs
    128
    		 
    #[test]
    129
    		 
    #[allow(clippy::eq_op)]
    130
    		 
    fn hash_rational() {
    142
    		 
    #[test]
    143
    		 
    #[allow(clippy::eq_op)]
    144
    		 
    fn hash_object() {
  • boa_engine 0.16.0/src/value/tests.rs
    118
    		 
    #[test]
    119
    		 
    #[allow(clippy::eq_op)]
    120
    		 
    fn hash_rational() {
    132
    		 
    #[test]
    133
    		 
    #[allow(clippy::eq_op)]
    134
    		 
    fn hash_object() {
  • capctl 0.2.2/src/caps/mod.rs
    299
    		 
        #[allow(clippy::eq_op)]
    300
    		 
        #[test]
  • com_ptr 0.2.1/src/lib.rs
    235
    		 
        #[test]
    236
    		 
        #[allow(clippy::eq_op)]
    237
    		 
        fn co_create_instance_test() {
  • core_cbc_casper 0.1.0/src/util/weight.rs
    342
    		 
        #[test]
    343
    		 
        #[allow(clippy::eq_op)]
    344
    		 
        fn substraction() {
    363
    		 
        #[test]
    364
    		 
        #[allow(clippy::eq_op)]
    365
    		 
        fn equality() {
    374
    		 
        #[test]
    375
    		 
        #[allow(clippy::eq_op)]
    376
    		 
        fn greater() {
    393
    		 
        #[test]
    394
    		 
        #[allow(clippy::eq_op)]
    395
    		 
        fn smaller() {
  • cosmian_bls12_381 0.4.1/src/g1.rs
    1065
    		 
    #[test]
    1066
    		 
    #[allow(clippy::eq_op)]
    1067
    		 
    fn test_affine_point_equality() {
    1077
    		 
    #[test]
    1078
    		 
    #[allow(clippy::eq_op)]
    1079
    		 
    fn test_projective_point_equality() {
    1468
    		 
    #[test]
    1469
    		 
    #[allow(clippy::eq_op)]
    1470
    		 
    fn test_projective_negation_and_subtraction() {
  • cosmian_bls12_381 0.4.1/src/g2.rs
    1241
    		 
    #[test]
    1242
    		 
    #[allow(clippy::eq_op)]
    1243
    		 
    fn test_affine_point_equality() {
    1253
    		 
    #[test]
    1254
    		 
    #[allow(clippy::eq_op)]
    1255
    		 
    fn test_projective_point_equality() {
    1770
    		 
    #[test]
    1771
    		 
    #[allow(clippy::eq_op)]
    1772
    		 
    fn test_projective_negation_and_subtraction() {
  • cosmwasm-std 1.2.1/src/ibc.rs
    816
    		 
        #[test]
    817
    		 
        #[allow(clippy::eq_op)]
    818
    		 
        fn ibc_timeout_block_ord() {
  • cradle 0.2.2/src/macros.rs
    86
    		 
            #[test]
    87
    		 
            #[allow(clippy::eq_op)]
    88
    		 
            fn one_value() {
  • cryptoxide 0.4.2/src/curve25519/mod.rs
    219
    		 
        #[test]
    220
    		 
        #[allow(clippy::eq_op)]
    221
    		 
        fn mul_commutes() {
  • dashu-int 0.3.1/tests/modular.rs
    115
    		 
    #[test]
    116
    		 
    #[allow(clippy::eq_op)]
    117
    		 
    fn test_different_rings() {
  • decorum 0.3.1/src/cmp.rs
    362
    		 
        #[test]
    363
    		 
        #[allow(clippy::eq_op)]
    364
    		 
        #[allow(clippy::zero_divided_by_zero)]
  • decorum 0.3.1/src/proxy.rs
    1843
    		 
        #[test]
    1844
    		 
        #[allow(clippy::eq_op)]
    1845
    		 
        #[allow(clippy::float_cmp)]
    1863
    		 
        #[allow(clippy::cmp_nan)]
    1864
    		 
        #[allow(clippy::eq_op)]
    1865
    		 
        #[allow(clippy::float_cmp)]
  • discord-indexmap 1.4.0/src/set.rs
    1468
    		 
            // FIXME: #[allow(clippy::eq_op)] in Rust 1.31
    1469
    		 
            #[cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints, eq_op))]
    1470
    		 
            {
  • dqcsim 0.4.1/src/core/common/types/cycle.rs
    131
    		 
        #[allow(clippy::eq_op)]
    132
    		 
        #[test]
  • dusk-pki 0.11.3/tests/tests.rs
    64
    		 
    #[test]
    65
    		 
    #[allow(clippy::eq_op)]
    66
    		 
    fn partial_eq_pk() {
  • efficient-sm2 0.1.5/src/sm2p256.rs
    325
    		 
    #[allow(clippy::eq_op)]
    326
    		 
    #[inline]
  • elektra 0.9.10/src/key.rs
    459
    		 
        #[allow(clippy::eq_op)]
    460
    		 
        #[test]
    471
    		 
        #[allow(clippy::eq_op)]
    472
    		 
        #[test]
  • ethcontract 0.23.1/src/int.rs
    1566
    		 
        #[test]
    1567
    		 
        #[allow(clippy::eq_op)]
    1568
    		 
        fn subtraction() {
  • ethers-core 1.0.2/src/types/i256.rs
    1679
    		 
        #[test]
    1680
    		 
        #[allow(clippy::eq_op)]
    1681
    		 
        fn subtraction() {
  • fleetfs_raft 0.6.0/src/errors.rs
    111
    		 
    #[allow(clippy::eq_op)]
    112
    		 
    #[cfg(test)]
  • fontdue 0.7.2/src/platform/float/sqrt.rs
    28
    		 
            if ix < 0 {
    29
    		 
                #[allow(clippy::eq_op)] // This has special semantics and is not wrong.
    30
    		 
                return (x - x) / (x - x); /* sqrt(-ve) = sNaN */
  • fpdec 0.5.4/src/binops/add_sub.rs
    112
    		 
        #[test]
    113
    		 
        #[allow(clippy::eq_op)]
    114
    		 
        fn test_sub_same_n_frac_digits() {
  • fpdec 0.5.4/src/binops/checked_add_sub.rs
    117
    		 
        #[test]
    118
    		 
        #[allow(clippy::eq_op)]
    119
    		 
        fn test_checked_sub() {
  • fruit-salad 0.0.2/tests/generated_implementations.rs
    16
    		 
    #[test]
    17
    		 
    #[allow(clippy::eq_op)] // Identical args are intentional.
    18
    		 
    fn test_partial_eq() {
  • gazebo 0.8.1/src/cmp.rs
    164
    		 
        #[test]
    165
    		 
        #[allow(clippy::eq_op)]
    166
    		 
        fn always_false_cmp() {
  • gitlab 0.1508.0/src/api/common.rs
    528
    		 
                // We are asserting that `Eq` is implemented.
    529
    		 
                #[allow(clippy::eq_op)]
    530
    		 
                {
  • gitlab 0.1508.0/src/api/projects/protected_branches/protect.rs
    204
    		 
                // We are asserting that `Eq` is implemented.
    205
    		 
                #[allow(clippy::eq_op)]
    206
    		 
                {
  • gluesql-core 0.13.1/src/data/value/mod.rs
    616
    		 
        #[allow(clippy::eq_op)]
    617
    		 
        #[test]
  • gstreamer 0.19.7/src/format/clock_time.rs
    616
    		 
        #[test]
    617
    		 
        #[allow(clippy::eq_op, clippy::op_ref)]
    618
    		 
        fn ops() {
  • gstreamer 0.19.7/src/format/generic.rs
    429
    		 
        #[test]
    430
    		 
        #[allow(clippy::eq_op, clippy::op_ref)]
    431
    		 
        fn other() {
    452
    		 
        #[test]
    453
    		 
        #[allow(clippy::eq_op, clippy::op_ref)]
    454
    		 
        fn generic_other() {
    477
    		 
        #[test]
    478
    		 
        #[allow(clippy::eq_op, clippy::op_ref)]
    479
    		 
        fn generic_signed_other() {
  • heph-rt 0.4.1/src/process/tests.rs
    68
    		 
    #[test]
    69
    		 
    #[allow(clippy::eq_op)] // Need to compare `ProcessData` to itself.
    70
    		 
    fn process_data_equality() {
  • hexx 0.1.1/src/hex.rs
    682
    		 
    #[cfg(test)]
    683
    		 
    #[allow(clippy::eq_op)]
    684
    		 
    mod tests {
  • http-types 2.12.0/src/headers/header_name.rs
    137
    		 
        #[test]
    138
    		 
        #[allow(clippy::eq_op)]
    139
    		 
        fn test_header_name_static_non_static() {
  • ibig 0.3.6/tests/modular.rs
    122
    		 
    #[test]
    123
    		 
    #[allow(clippy::eq_op)]
    124
    		 
    fn test_different_rings() {
  • ic_bls12_381 0.7.1/src/g1.rs
    1119
    		 
    #[test]
    1120
    		 
    #[allow(clippy::eq_op)]
    1121
    		 
    fn test_affine_point_equality() {
    1131
    		 
    #[test]
    1132
    		 
    #[allow(clippy::eq_op)]
    1133
    		 
    fn test_projective_point_equality() {
    1522
    		 
    #[test]
    1523
    		 
    #[allow(clippy::eq_op)]
    1524
    		 
    fn test_projective_negation_and_subtraction() {
  • ic_bls12_381 0.7.1/src/g2.rs
    1257
    		 
    #[test]
    1258
    		 
    #[allow(clippy::eq_op)]
    1259
    		 
    fn test_affine_point_equality() {
    1269
    		 
    #[test]
    1270
    		 
    #[allow(clippy::eq_op)]
    1271
    		 
    fn test_projective_point_equality() {
    1786
    		 
    #[test]
    1787
    		 
    #[allow(clippy::eq_op)]
    1788
    		 
    fn test_projective_negation_and_subtraction() {
  • iced-x86 1.18.0/src/instruction.rs
    3167
    		 
    			0 | 1 => {
    3168
    		 
    				#[allow(clippy::eq_op)]
    3169
    		 
    				const _: () = assert!(ImpliedAccess::Shift_Ib_MASK1FMOD9 as u32 - ImpliedAccess::Shift_Ib_MASK1FMOD9 as u32 == 0);
  • icrate 0.0.1/examples/basic_usage.rs
    7
    		 
        let obj = NSObject::new();
    8
    		 
        #[allow(clippy::eq_op)]
    9
    		 
        {
  • inari 1.0.0/tests/itf1788.rs
    6
    		 
        clippy::approx_constant,
    7
    		 
        clippy::eq_op,
    8
    		 
        clippy::excessive_precision,
  • indexmap 1.9.2/src/set.rs
    1868
    		 
            #[allow(clippy::eq_op)]
    1869
    		 
            {
  • indexmap-amortized 1.6.1/src/set.rs
    1613
    		 
            // FIXME: #[allow(clippy::eq_op)] in Rust 1.31
    1614
    		 
            #[cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints, eq_op))]
    1615
    		 
            {
  • indexmap-rmw 1.6.3/src/set.rs
    1615
    		 
            // FIXME: #[allow(clippy::eq_op)] in Rust 1.31
    1616
    		 
            #[cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints, eq_op))]
    1617
    		 
            {
  • irmaseal-curve 0.1.4/src/g1.rs
    1119
    		 
    #[test]
    1120
    		 
    #[allow(clippy::eq_op)]
    1121
    		 
    fn test_affine_point_equality() {
    1131
    		 
    #[test]
    1132
    		 
    #[allow(clippy::eq_op)]
    1133
    		 
    fn test_projective_point_equality() {
    1522
    		 
    #[test]
    1523
    		 
    #[allow(clippy::eq_op)]
    1524
    		 
    fn test_projective_negation_and_subtraction() {
  • irmaseal-curve 0.1.4/src/g2.rs
    1257
    		 
    #[test]
    1258
    		 
    #[allow(clippy::eq_op)]
    1259
    		 
    fn test_affine_point_equality() {
    1269
    		 
    #[test]
    1270
    		 
    #[allow(clippy::eq_op)]
    1271
    		 
    fn test_projective_point_equality() {
    1786
    		 
    #[test]
    1787
    		 
    #[allow(clippy::eq_op)]
    1788
    		 
    fn test_projective_negation_and_subtraction() {
  • jinko 0.3.0-jinx7/src/instruction/binary_op.rs
    254
    		 
        #[test]
    255
    		 
        #[allow(clippy::eq_op)]
    256
    		 
        fn comparison_simple_int() {
  • jomini 0.21.0/src/data.rs
    280
    		 
    /// it.
    281
    		 
    #[allow(clippy::eq_op, clippy::identity_op)]
    282
    		 
    pub(crate) static CHARACTER_CLASS: [u8; 256] = [
  • jsondata 0.8.1/src/ops_test.rs
    69
    		 
    #[test]
    70
    		 
    #[allow(clippy::eq_op)]
    71
    		 
    fn test_ops_sub() {
    169
    		 
    #[test]
    170
    		 
    #[allow(clippy::eq_op)]
    171
    		 
    fn test_ops_div() {
  • kiam 0.1.1/src/lib.rs
    177
    		 
            // won't work with if/elseif/else
    178
    		 
            #[allow(clippy::eq_op)]
    179
    		 
            let r = when! {
  • lattice-qcd-rs 0.2.1/src/field.rs
    1482
    		 
        #[test]
    1483
    		 
        #[allow(clippy::eq_op)]
    1484
    		 
        #[allow(clippy::op_ref)]
  • lexical-util 0.8.5/src/num.rs
    1245
    		 
    #[allow(clippy::eq_op, clippy::excessive_precision)]
    1246
    		 
    #[cfg(all(not(feature = "std"), feature = "floats"))]
    1317
    		 
    #[allow(clippy::eq_op, clippy::excessive_precision)]
    1318
    		 
    #[cfg(all(not(feature = "std"), feature = "floats"))]
  • li-http-types 2.12.0/src/headers/header_name.rs
    137
    		 
        #[test]
    138
    		 
        #[allow(clippy::eq_op)]
    139
    		 
        fn test_header_name_static_non_static() {
  • libcryptsetup-rs 0.6.0/src/format.rs
    690
    		 
        fn test_encryption_format_partialeq() {
    691
    		 
            #[allow(clippy::eq_op)]
    692
    		 
            {
  • madsim-tokio-postgres 0.2.0/tests/test/types/mod.rs
    382
    		 
    #[allow(clippy::eq_op)]
    383
    		 
    async fn test_nan_param<T>(sql_type: &str)
  • malachite-base 0.3.2/tests/num/float/nice_float/eq.rs
    16
    		 
    #[allow(clippy::eq_op)]
    17
    		 
    fn eq_properties_helper<T: PrimitiveFloat>() {
  • malachite-base 0.3.2/tests/rounding_modes/eq.rs
    12
    		 
    #[test]
    13
    		 
    #[allow(clippy::eq_op)]
    14
    		 
    fn eq_properties() {
  • malachite-nz 0.3.2/tests/integer/arithmetic/div.rs
    431
    		 
    #[allow(clippy::eq_op)]
    432
    		 
    #[test]
  • malachite-nz 0.3.2/tests/integer/arithmetic/sub.rs
    63
    		 
    #[allow(clippy::eq_op)]
    64
    		 
    #[test]
  • malachite-nz 0.3.2/tests/integer/comparison/eq.rs
    19
    		 
    #[allow(clippy::cmp_owned, clippy::eq_op)]
    20
    		 
    #[test]
  • malachite-nz 0.3.2/tests/integer/logic/and.rs
    1089
    		 
    #[allow(clippy::eq_op)]
    1090
    		 
    #[test]
  • malachite-nz 0.3.2/tests/integer/logic/or.rs
    845
    		 
    #[allow(clippy::eq_op)]
    846
    		 
    #[test]
  • malachite-nz 0.3.2/tests/integer/logic/xor.rs
    1141
    		 
    #[allow(clippy::eq_op)]
    1142
    		 
    #[test]
  • malachite-nz 0.3.2/tests/natural/arithmetic/div.rs
    31798
    		 
    #[allow(clippy::eq_op)]
    31799
    		 
    #[test]
  • malachite-nz 0.3.2/tests/natural/comparison/eq.rs
    17
    		 
    #[allow(clippy::cmp_owned, clippy::eq_op)]
    18
    		 
    #[test]
  • malachite-nz 0.3.2/tests/natural/logic/and.rs
    387
    		 
    #[allow(clippy::eq_op)]
    388
    		 
    #[test]
  • malachite-nz 0.3.2/tests/natural/logic/or.rs
    463
    		 
    #[allow(clippy::eq_op)]
    464
    		 
    #[test]
  • malachite-q 0.3.2/tests/arithmetic/div.rs
    115
    		 
    #[allow(clippy::eq_op)]
    116
    		 
    #[test]
  • malachite-q 0.3.2/tests/arithmetic/sub.rs
    70
    		 
    #[allow(clippy::eq_op)]
    71
    		 
    #[test]
  • malachite-q 0.3.2/tests/comparison/eq.rs
    40
    		 
    #[allow(clippy::cmp_owned, clippy::eq_op)]
    41
    		 
    #[test]
  • moscato 0.1.2/src/truetype/hint.rs
    2369
    		 
        #[rustfmt::skip]
    2370
    		 
        #[allow(clippy::eq_op, clippy::identity_op)]
    2371
    		 
        pub const OPCODE_POP_PUSH: [u8; 256] = [
  • mownstr 0.1.3/src/lib.rs
    307
    		 
    #[cfg(test)]
    308
    		 
    #[allow(clippy::eq_op)]
    309
    		 
    mod test {
  • myelin-geometry 2.4.2/src/point.rs
    55
    		 
        #[test]
    56
    		 
        #[allow(clippy::eq_op)]
    57
    		 
        fn is_equal_to_itself() {
    62
    		 
        #[test]
    63
    		 
        #[allow(clippy::eq_op)]
    64
    		 
        fn is_equal_to_itself_when_zero() {
  • myelin-geometry 2.4.2/src/vector.rs
    171
    		 
        #[test]
    172
    		 
        #[allow(clippy::eq_op)]
    173
    		 
        fn is_equal_to_itself() {
    178
    		 
        #[test]
    179
    		 
        #[allow(clippy::eq_op)]
    180
    		 
        fn is_equal_to_itself_when_zero() {
  • nalgebra 0.32.1/src/geometry/quaternion.rs
    398
    		 
        pub fn outer(&self, other: &Self) -> Self {
    399
    		 
            #[allow(clippy::eq_op)]
    400
    		 
            (self * other - other * self).half()
  • ndarray 0.15.6/tests/dimension.rs
    62
    		 
    #[test]
    63
    		 
    #[allow(clippy::eq_op)]
    64
    		 
    fn dyn_dimension() {
  • noindexmap 1.6.1/src/set.rs
    1615
    		 
            // FIXME: #[allow(clippy::eq_op)] in Rust 1.31
    1616
    		 
            #[cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints, eq_op))]
    1617
    		 
            {
  • noodles-bam 0.25.1/src/writer/record.rs
    203
    		 
    // § 5.3 "C source code for computing bin number and overlapping bins" (2021-06-03)
    204
    		 
    #[allow(clippy::eq_op)]
    205
    		 
    pub(crate) fn region_to_bin(alignment_start: Position, alignment_end: Position) -> io::Result<u16> {
  • noodles-tabix 0.15.0/src/index/reference_sequence/builder.rs
    86
    		 
    #[allow(clippy::eq_op)]
    87
    		 
    fn region_to_bin(start: Position, end: Position) -> io::Result<u16> {
  • ntex 0.6.3/src/http/body.rs
    661
    		 
        #[crate::rt_test]
    662
    		 
        #[allow(clippy::eq_op)]
    663
    		 
        async fn test_body_eq() {
  • num-rational 0.4.1/src/lib.rs
    1867
    		 
        #[test]
    1868
    		 
        #[allow(clippy::eq_op)]
    1869
    		 
        fn test_cmp() {
    2525
    		 
            #[test]
    2526
    		 
            #[allow(clippy::eq_op)]
    2527
    		 
            fn test_zero() {
  • nyx-space 1.1.1/src/cosmic/orbitdual.rs
    660
    		 
        /// Returns the right ascension of this orbit in degrees
    661
    		 
        #[allow(clippy::eq_op)]
    662
    		 
        pub fn right_ascension(&self) -> OrbitPartial {
    669
    		 
        /// Returns the declination of this orbit in degrees
    670
    		 
        #[allow(clippy::eq_op)]
    671
    		 
        pub fn declination(&self) -> OrbitPartial {
  • objc2-foundation 0.2.0-alpha.6/examples/basic_usage.rs
    6
    		 
        let obj = NSObject::new();
    7
    		 
        #[allow(clippy::eq_op)]
    8
    		 
        {
  • ord_subset 3.1.1/src/ord_subset_trait.rs
    36
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(float_cmp, eq_op))]
    37
    		 
    impl OrdSubset for f64 {
    45
    		 
    #[cfg_attr(feature = "cargo-clippy", allow(float_cmp, eq_op))]
    46
    		 
    impl OrdSubset for f32 {
  • packed_simd_2 0.3.8/src/testing/utils.rs
    24
    		 
        // than clippy can handle.
    25
    		 
        #[allow(clippy::eq_op)]
    26
    		 
        {
  • paired 0.22.0/src/signum.rs
    67
    		 
        #[test]
    68
    		 
        #[allow(clippy::eq_op)]
    69
    		 
        fn test_sgn0result_xor() {
    88
    		 
        #[test]
    89
    		 
        #[allow(clippy::eq_op)]
    90
    		 
        fn test_sgn0result_and() {
  • pairing-plus 0.19.0/src/signum.rs
    41
    		 
    #[test]
    42
    		 
    #[allow(clippy::eq_op)]
    43
    		 
    fn test_sgn0result_xor() {
  • parquet 32.0.0/src/column/writer/mod.rs
    955
    		 
    #[inline]
    956
    		 
    #[allow(clippy::eq_op)]
    957
    		 
    fn is_nan<T: ParquetValueType>(val: &T) -> bool {
  • plonky2_field 0.1.0/src/field_testing.rs
    106
    		 
    #[allow(clippy::eq_op)]
    107
    		 
    pub(crate) fn test_add_neg_sub_mul<BF: Extendable<D>, const D: usize>() {
  • polars-core 0.26.1/src/chunked_array/arithmetic.rs
    583
    		 
        #[test]
    584
    		 
        #[allow(clippy::eq_op)]
    585
    		 
        fn test_chunk_mismatch() {
  • polars-core 0.26.1/src/chunked_array/ops/compare_inner.rs
    195
    		 
        // without convincing the compiler we deal with floats
    196
    		 
        #[allow(clippy::eq_op)]
    197
    		 
        if a != a {
  • polars-core 0.26.1/src/series/arithmetic/borrowed.rs
    769
    		 
        #[test]
    770
    		 
        #[allow(clippy::eq_op)]
    771
    		 
        fn test_arithmetic_series() {
  • polynomen 1.0.0/src/arithmetic.rs
    857
    		 
        #[test]
    858
    		 
        #[allow(clippy::eq_op)]
    859
    		 
        fn poly_sub() {
  • pretty_assertions 1.3.0/tests/macros.rs
    7
    		 
    #[allow(clippy::eq_op)]
    8
    		 
    mod assert_str_eq {
    86
    		 
    #[allow(clippy::eq_op)]
    87
    		 
    mod assert_eq {
  • pretty_assertions_sorted 1.2.1/tests/macros.rs
    1
    		 
    #[allow(clippy::eq_op)]
    2
    		 
    mod assert_eq {
  • prio 0.10.0/src/field.rs
    819
    		 
        // experimental" https://github.com/rust-lang/rust/issues/15701
    820
    		 
        #[allow(clippy::eq_op)]
    821
    		 
        fn field_element_test<F: FieldElement + Hash>() {
  • prov-cosmwasm-std 1.0.0-provbeta3/src/ibc.rs
    771
    		 
        #[test]
    772
    		 
        #[allow(clippy::eq_op)]
    773
    		 
        fn ibc_timeout_block_ord() {
  • pwn-helper 0.1.0/src/bytes.rs
    87
    		 
        #[test]
    88
    		 
        #[allow(clippy::eq_op)]
    89
    		 
        fn test_mul_bytestr() {
    93
    		 
        #[test]
    94
    		 
        #[allow(clippy::eq_op)]
    95
    		 
        fn test_add_byte() {
    99
    		 
        #[test]
    100
    		 
        #[allow(clippy::eq_op)]
    101
    		 
        fn test_add_bytestr() {
    105
    		 
        #[test]
    106
    		 
        #[allow(clippy::eq_op)]
    107
    		 
        fn test_add_bytestr_byte() {
    111
    		 
        #[test]
    112
    		 
        #[allow(clippy::eq_op)]
    113
    		 
        fn test_add_byte_bytestr() {
  • raft 0.6.0/src/errors.rs
    111
    		 
    #[allow(clippy::eq_op)]
    112
    		 
    #[cfg(test)]
  • reckoner 0.2.0/src/integer/ops.rs
    606
    		 
            #[allow(clippy::eq_op)]
    607
    		 
            let one = &a / &a;
  • reckoner 0.2.0/src/integer.rs
    556
    		 
                    .unwrap();
    557
    		 
            #[allow(clippy::eq_op)]
    558
    		 
            let zero = &int - &int;
  • reckoner 0.2.0/src/rational/ops.rs
    489
    		 
            #[allow(clippy::eq_op)]
    490
    		 
            let one = &a / &a;
  • relearn 0.3.1/src/spaces/test_derive.rs
    940
    		 
            #[test]
    941
    		 
            #[allow(clippy::eq_op)]
    942
    		 
            fn same_interval_eq() {
  • relearn 0.3.1/src/torch/optimizers/coptimizer.rs
    232
    		 
            let mut optimizer = SgdConfig::default().build_optimizer([&x]).unwrap();
    233
    		 
            #[allow(clippy::eq_op)]
    234
    		 
            let _ = optimizer
  • roaring 0.10.1/src/bitmap/proptests.rs
    1
    		 
    #[cfg(test)]
    2
    		 
    #[allow(clippy::eq_op)] // Allow equal expressions as operands
    3
    		 
    mod test {
  • routing 0.37.1/src/lib.rs
    296
    		 
        #[test]
    297
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(eq_op))]
    298
    		 
        fn quorum_check() {
  • routing 0.37.1/src/xor_name.rs
    274
    		 
        #[test]
    275
    		 
        #[cfg_attr(feature = "cargo-clippy", allow(eq_op))]
    276
    		 
        fn xor_name_ord() {
  • rpki 0.15.9/src/repository/resources/chain.rs
    1037
    		 
        #[test]
    1038
    		 
        #[allow(clippy::eq_op)]
    1039
    		 
        fn eq() {
  • rug 1.19.0/src/complex/ord.rs
    166
    		 
    #[allow(clippy::eq_op)]
    167
    		 
    #[cfg(test)]
  • rug 1.19.0/src/float/ord.rs
    193
    		 
    #[allow(clippy::eq_op)]
    194
    		 
    #[cfg(test)]
  • rust-fixed-point-decimal 0.1.2/src/binops/add_sub.rs
    138
    		 
        #[test]
    139
    		 
        #[allow(clippy::eq_op)]
    140
    		 
        fn test_sub_same_prec() {
  • rust-fixed-point-decimal 0.1.2/src/binops/checked_add_sub.rs
    100
    		 
        #[test]
    101
    		 
        #[allow(clippy::eq_op)]
    102
    		 
        fn test_checked_sub() {
  • rusty_v8 0.32.1/tests/test_api.rs
    2458
    		 
    #[test]
    2459
    		 
    #[allow(clippy::eq_op)]
    2460
    		 
    fn equality_edge_cases() {
    2983
    		 
    #[allow(clippy::cognitive_complexity)]
    2984
    		 
    #[allow(clippy::eq_op)]
    2985
    		 
    fn value_checker() {
  • rusty_v8_m 0.4.6/tests/test_api.rs
    2018
    		 
    #[allow(clippy::cognitive_complexity)]
    2019
    		 
    #[allow(clippy::eq_op)]
    2020
    		 
    fn value_checker() {
  • rusty_v8_protryon 3.10.4/tests/test_api.rs
    2049
    		 
    #[allow(clippy::cognitive_complexity)]
    2050
    		 
    #[allow(clippy::eq_op)]
    2051
    		 
    fn value_checker() {
  • sardonyx_core 0.0.3/src/transform/systems.rs
    365
    		 
        #[cfg(debug_assertions)]
    366
    		 
        #[allow(clippy::eq_op, clippy::zero_divided_by_zero)]
    367
    		 
        fn nan_transform() {
  • secret-cosmwasm-std 1.0.0/src/ibc.rs
    819
    		 
        #[test]
    820
    		 
        #[allow(clippy::eq_op)]
    821
    		 
        fn ibc_timeout_block_ord() {
  • smithay 0.3.0/src/wayland/mod.rs
    146
    		 
        #[test]
    147
    		 
        #[allow(clippy::eq_op)]
    148
    		 
        fn serial_equals_self() {
  • snarkvm-curves 0.9.11/src/traits/tests_field.rs
    429
    		 
    #[allow(clippy::eq_op)]
    430
    		 
    pub fn field_test<F: Field>(a: F, b: F, rng: &mut TestRng) {
  • snarkvm-curves 0.9.11/src/traits/tests_group.rs
    21
    		 
    #[allow(clippy::eq_op)]
    22
    		 
    pub fn affine_test<G: AffineCurve>(a: G) {
    37
    		 
    #[allow(clippy::eq_op)]
    38
    		 
    pub fn projective_test<G: ProjectiveCurve>(a: G, mut b: G, rng: &mut TestRng) {
  • snarkvm-gadgets 0.8.0/src/curves/tests_field.rs
    33
    		 
    #[allow(clippy::eq_op)]
    34
    		 
    fn field_test<NativeF: Field, F: Field, FG: FieldGadget<NativeF, F>, CS: ConstraintSystem<F>>(
  • snarkvm-gadgets 0.8.0/src/curves/tests_group.rs
    22
    		 
    #[allow(clippy::eq_op)]
    23
    		 
    pub fn group_test<F: Field, G: Group, GG: GroupGadget<G, F>, CS: ConstraintSystem<F>>(cs: &mut CS, a: GG, b: GG) {
  • snarkvm-models 0.0.6/src/curves/tests_field.rs
    272
    		 
    #[allow(clippy::eq_op)]
    273
    		 
    pub fn field_test<F: Field>(a: F, b: F) {
  • snarkvm-models 0.0.6/src/curves/tests_group.rs
    23
    		 
    #[allow(clippy::eq_op)]
    24
    		 
    pub fn group_test<G: Group>(a: G, mut b: G) {
  • snarkvm-utilities 0.9.11/src/biginteger/tests.rs
    22
    		 
    #[allow(clippy::eq_op)]
    23
    		 
    fn biginteger_arithmetic_test<B: BigInteger>(a: B, b: B, zero: B) {
  • spdx 0.10.0/src/expression.rs
    251
    		 
        #[test]
    252
    		 
        #[allow(clippy::eq_op)]
    253
    		 
        fn eq() {
  • spectrum-analyzer 1.2.6/src/frequency.rs
    151
    		 
            assert!(f1 > f2, "Compare must work");
    152
    		 
            #[allow(clippy::eq_op)]
    153
    		 
            {
  • springql-core 0.18.1/src/stream_engine/autonomous_executor/row/value/sql_value.rs
    265
    		 
        #[allow(clippy::eq_op)]
    266
    		 
        #[test]
  • springql-core-release-test 1.0.0-a6/src/stream_engine/autonomous_executor/row/value/sql_value.rs
    265
    		 
        #[allow(clippy::eq_op)]
    266
    		 
        #[test]
  • srt-protocol 0.3.0/src/packet/time.rs
    276
    		 
        #[test]
    277
    		 
        #[allow(clippy::eq_op)]
    278
    		 
        fn timestamp_operators() {
  • swash 0.1.6/src/scale/glyf/hint.rs
    2369
    		 
        #[rustfmt::skip]
    2370
    		 
        #[allow(clippy::eq_op, clippy::identity_op)]
    2371
    		 
        pub const OPCODE_POP_PUSH: [u8; 256] = [
  • tokio-postgres 0.7.7/tests/test/types/mod.rs
    384
    		 
    #[allow(clippy::eq_op)]
    385
    		 
    async fn test_nan_param<T>(sql_type: &str)
  • trillium-http-types 0.0.3/src/headers/header_name.rs
    145
    		 
        #[test]
    146
    		 
        #[allow(clippy::eq_op)]
    147
    		 
        fn test_header_name_static_non_static() {
  • triomphe 0.1.8/src/thin_arc.rs
    278
    		 
        #[test]
    279
    		 
        #[allow(clippy::redundant_clone, clippy::eq_op)]
    280
    		 
        fn slices_and_thin() {
    295
    		 
        #[test]
    296
    		 
        #[allow(clippy::redundant_clone, clippy::eq_op)]
    297
    		 
        fn iter_and_thin() {
  • ultraviolet 0.9.0/src/rotor.rs
    870
    		 
        #[test]
    871
    		 
        #[allow(clippy::eq_op)]
    872
    		 
        pub fn rotor_equality() {
    923
    		 
        #[test]
    924
    		 
        #[allow(clippy::eq_op)]
    925
    		 
        pub fn drotor_equality() {
  • unid 1.0.1/src/lib.rs
    522
    		 
        #[allow(clippy::eq_op)]
    523
    		 
        #[test]
  • v8 0.62.0/tests/test_api.rs
    3728
    		 
    #[test]
    3729
    		 
    #[allow(clippy::eq_op)]
    3730
    		 
    fn equality_edge_cases() {
    4480
    		 
    #[allow(clippy::cognitive_complexity)]
    4481
    		 
    #[allow(clippy::eq_op)]
    4482
    		 
    fn value_checker() {
  • vecmat 0.7.8/src/complex/tests/quaternion/advanced.rs
    30
    		 
    #[test]
    31
    		 
    #[allow(clippy::eq_op)]
    32
    		 
    fn inversion() {
  • vipers-tests 0.1.0/src/lib.rs
    118
    		 
    #[test]
    119
    		 
    #[allow(clippy::eq_op)]
    120
    		 
    fn test_invariant() {
  • vole 0.1.1/src/datastructures/digraph.rs
    281
    		 
    #[allow(clippy::eq_op, clippy::neg_cmp_op_on_partial_ord)]
    282
    		 
    #[cfg(test)]
  • wgpu 0.15.0/examples/water/main.rs
    696
    		 
        #[allow(clippy::eq_op)]
    697
    		 
        fn render(
  • wita 0.20.0/examples/children.rs
    3
    		 
    impl Application {
    4
    		 
        #[allow(clippy::eq_op)]
    5
    		 
        pub fn new() -> anyhow::Result<Self> {
  • xilinx-dma 0.0.7/src/axi_dma.rs
    13
    		 
    const MM2S_DMACR: isize = 0x0 / 4;
    14
    		 
    #[allow(clippy::eq_op)]
    15
    		 
    const MM2S_DMASR: isize = 0x4 / 4;
  • xilinx-dma 0.0.7/src/axi_dma_async.rs
    14
    		 
    const MM2S_DMACR: isize = 0x0 / 4;
    15
    		 
    #[allow(clippy::eq_op)]
    16
    		 
    const MM2S_DMASR: isize = 0x4 / 4;
  • xor_name 5.0.0/src/lib.rs
    356
    		 
        #[test]
    357
    		 
        #[allow(clippy::eq_op, clippy::nonminimal_bool)]
    358
    		 
        fn xor_name_ord() {
  • yata 0.6.1/src/core/action.rs
    464
    		 
    	#[test]
    465
    		 
    	#[allow(clippy::eq_op)]
    466
    		 
    	fn test_action_eq() {
  • a_r_c_h_e_r_y 0.4.3/src/shared_pointer/test.rs
    6
    		 
    #![allow(clippy::eq_op)]
  • anyhow 1.0.68/tests/test_macros.rs
    2
    		 
        clippy::assertions_on_result_states,
    3
    		 
        clippy::eq_op,
    4
    		 
        clippy::items_after_statements,
  • archery 0.4.0/src/shared_pointer/test.rs
    6
    		 
    #![allow(clippy::eq_op)]
  • ark-algebra-test-templates 0.4.0/src/fields.rs
    1
    		 
    #![allow(unused)]
    2
    		 
    #![allow(clippy::eq_op)]
  • arrow 32.0.0/benches/equal.rs
    18
    		 
    // Allowed because we use `arr == arr` in benchmarks
    19
    		 
    #![allow(clippy::eq_op)]
  • assert2 0.3.8/tests/check.rs
    1
    		 
    #![allow(clippy::eq_op)]
    2
    		 
    #![allow(clippy::nonminimal_bool)]
  • assert2ify 0.1.0-alpha1/tests/logic/mod.rs
    5
    		 
    #![allow(clippy::eq_op)]
    6
    		 
    #![allow(clippy::op_ref)]
  • blstrs 0.6.1/src/g1.rs
    849
    		 
    mod tests {
    850
    		 
        #![allow(clippy::eq_op)]
  • blstrs 0.6.1/src/g2.rs
    824
    		 
    mod tests {
    825
    		 
        #![allow(clippy::eq_op)]
  • concrete 0.2.1/src/lib.rs
    6
    		 
    #![allow(clippy::assign_op_pattern)]
    7
    		 
    #![allow(clippy::eq_op)]
    8
    		 
    #![allow(clippy::assign_op_pattern)]
  • cw-semver 1.0.14/tests/test_identifier.rs
    1
    		 
    #![allow(
    2
    		 
        clippy::eq_op,
    3
    		 
        clippy::needless_pass_by_value,
  • derivative 2.2.0/tests/derive-eq-packed.rs
    1
    		 
    #![allow(clippy::eq_op)]
  • derivative 2.2.0/tests/derive-eq.rs
    1
    		 
    #![allow(clippy::eq_op)]
  • derivative 2.2.0/tests/derive-partial-eq-packed.rs
    1
    		 
    #![allow(clippy::eq_op, clippy::trivially_copy_pass_by_ref)]
  • derivative 2.2.0/tests/derive-partial-eq.rs
    1
    		 
    #![allow(clippy::eq_op, clippy::trivially_copy_pass_by_ref, dead_code)]
  • derivative 2.2.0/tests/rustc-deriving-meta-multiple.rs
    13
    		 
    #![allow(clippy::eq_op, clippy::redundant_clone)]
  • derivative 2.2.0/tests/rustc-deriving-meta.rs
    13
    		 
    #![allow(clippy::eq_op, clippy::redundant_clone)]
  • easytime 0.2.4/tests/instant.rs
    2
    		 
    #![warn(rust_2018_idioms, single_use_lifetimes)]
    3
    		 
    #![allow(clippy::eq_op)]
  • ed25519-compact 2.0.4/src/sha512.rs
    6
    		 
        clippy::cast_lossless,
    7
    		 
        clippy::eq_op,
    8
    		 
        clippy::identity_op,
  • egui_winit_vulkano 0.22.0/examples/minimal.rs
    10
    		 
    #![allow(clippy::eq_op)]
  • egui_winit_vulkano 0.22.0/examples/subpass.rs
    10
    		 
    #![allow(clippy::eq_op)]
  • egui_winit_vulkano 0.22.0/examples/wholesome/main.rs
    10
    		 
    #![allow(clippy::eq_op)]
  • encode_unicode 1.0.0/tests/oks.rs
    13
    		 
    #![allow(
    14
    		 
        clippy::eq_op, // testing the comparison
    15
    		 
    )]
  • evalexpr 8.1.0/tests/integration.rs
    1645
    		 
    fn test_same_operator_chains() {
    1646
    		 
        #![allow(clippy::eq_op)]
    1647
    		 
        assert_eq!(
  • exocore-core 0.1.24/src/cell/node.rs
    460
    		 
        fn node_equality() {
    461
    		 
            #![allow(clippy::eq_op)]
    462
    		 
            let node1 = LocalNode::generate();
  • expected 0.0.1/tests/sketch.rs
    1
    		 
    #![allow(clippy::assertions_on_constants, clippy::eq_op, clippy::identity_op)]
  • eyre 0.6.8/tests/test_macros.rs
    1
    		 
    #![allow(clippy::eq_op)]
    2
    		 
    mod common;
  • hmac-sha1-compact 1.1.3/src/lib.rs
    7
    		 
        clippy::cast_lossless,
    8
    		 
        clippy::eq_op,
    9
    		 
        clippy::identity_op,
  • hmac-sha256 1.1.6/src/lib.rs
    7
    		 
        clippy::cast_lossless,
    8
    		 
        clippy::eq_op,
    9
    		 
        clippy::identity_op,
  • hmac-sha512 1.1.4/src/lib.rs
    7
    		 
        clippy::cast_lossless,
    8
    		 
        clippy::eq_op,
    9
    		 
        clippy::identity_op,
  • index_vec 0.1.3/tests/test.rs
    1
    		 
    #![allow(clippy::assertions_on_constants, clippy::eq_op)]
  • ink_macro 4.0.0-beta.1/src/storage/tests/storable.rs
    19
    		 
    #![allow(clippy::identity_op)]
    20
    		 
    #![allow(clippy::eq_op)]
    21
    		 
    #![allow(clippy::match_single_binding)]
  • ink_storage_derive 4.0.0-alpha.1/src/tests/spread_layout.rs
    19
    		 
    #![allow(clippy::identity_op)]
    20
    		 
    #![allow(clippy::eq_op)]
    21
    		 
    #![allow(clippy::match_single_binding)]
  • libm 0.2.6/src/lib.rs
    11
    		 
    #![allow(clippy::float_cmp)]
    12
    		 
    #![allow(clippy::eq_op)]
    13
    		 
    #![allow(clippy::assign_op_pattern)]
  • liquid-core 0.26.0/src/model/scalar/mod.rs
    3
    		 
    #![allow(clippy::eq_op)]
  • liquid-core 0.26.0/src/model/value/values.rs
    1
    		 
    #![allow(clippy::eq_op)]
  • minisign 0.7.2/src/crypto/sha512.rs
    6
    		 
        clippy::cast_lossless,
    7
    		 
        clippy::eq_op,
    8
    		 
        clippy::identity_op,
  • minisign-verify 0.2.1/src/crypto/sha512.rs
    6
    		 
        clippy::cast_lossless,
    7
    		 
        clippy::eq_op,
    8
    		 
        clippy::identity_op,
  • minivec 0.4.0/tests/vec.rs
    13
    		 
      clippy::unnecessary_filter_map,
    14
    		 
      clippy::eq_op,
    15
    		 
      clippy::redundant_slicing,
  • ordered-float 3.4.0/tests/test.rs
    1
    		 
    #![allow(clippy::float_cmp, clippy::eq_op, clippy::op_ref)]
  • oxiri 0.2.2/tests/lib.rs
    1
    		 
    #![allow(clippy::eq_op)]
    2
    		 
    use oxiri::{Iri, IriRef};
  • rypt 0.8.0/src/shamir/gf256.rs
    171
    		 
    mod tests {
    172
    		 
        #![allow(clippy::eq_op)]
    173
    		 
        use super::*;
  • semver 1.0.16/tests/test_identifier.rs
    1
    		 
    #![allow(
    2
    		 
        clippy::eq_op,
    3
    		 
        clippy::needless_pass_by_value,
  • serde_yaml 0.9.17/tests/test_value.rs
    2
    		 
        clippy::derive_partial_eq_without_eq,
    3
    		 
        clippy::eq_op,
    4
    		 
        clippy::uninlined_format_args
  • serde_yaml_with_quirks 0.8.24/tests/test_value.rs
    1
    		 
    #![allow(clippy::derive_partial_eq_without_eq, clippy::eq_op)]
  • threshold_crypto 0.4.0/src/mock/ms8.rs
    429
    		 
        // otherwise unusual expressions, so the lint is disabled.
    430
    		 
        #![allow(clippy::eq_op)]
    431
    		 
        // Some test functions contain long lists of assertions. Clippy thinks they are too complex.
  • tiny-skia-path 0.8.2/src/lib.rs
    20
    		 
    #![allow(clippy::collapsible_if)]
    21
    		 
    #![allow(clippy::eq_op)]
    22
    		 
    #![allow(clippy::excessive_precision)]
  • tor-circmgr 0.7.0/src/timeouts/pareto.rs
    665
    		 
        fn ms_partial_cmp() {
    666
    		 
            #![allow(clippy::eq_op)]
    667
    		 
            let myriad: MsecDuration = 10_000.into();
  • tulip-derivative 2.2.1/tests/derive-eq-packed.rs
    1
    		 
    #![allow(clippy::eq_op)]
  • tulip-derivative 2.2.1/tests/derive-eq.rs
    1
    		 
    #![allow(clippy::eq_op)]
  • tulip-derivative 2.2.1/tests/derive-partial-eq-packed.rs
    1
    		 
    #![allow(clippy::eq_op, clippy::trivially_copy_pass_by_ref)]
  • tulip-derivative 2.2.1/tests/derive-partial-eq.rs
    1
    		 
    #![allow(clippy::eq_op, clippy::trivially_copy_pass_by_ref, dead_code)]
  • tulip-derivative 2.2.1/tests/rustc-deriving-meta-multiple.rs
    13
    		 
    #![allow(clippy::eq_op, clippy::redundant_clone)]
  • tulip-derivative 2.2.1/tests/rustc-deriving-meta.rs
    13
    		 
    #![allow(clippy::eq_op, clippy::redundant_clone)]
  • ux-dx 0.2.1/src/lib.rs
    63
    		 
        clippy::deprecated_cfg_attr,
    64
    		 
        clippy::eq_op,
    65
    		 
        clippy::approx_constant,
  • wide 0.7.5/src/lib.rs
    3
    		 
    #![warn(clippy::missing_inline_in_public_items)]
    4
    		 
    #![allow(clippy::eq_op)]
    5
    		 
    #![allow(clippy::excessive_precision)]