Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 650bd6b1 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "Fix clippy lints for new EPSILON/INFINITY/MAX/MIN/NAN" into main

parents 5a206588 be8acf7f

libs/binder/rust/src/parcel/parcelable.rs

+20 −20
Original line number Diff line number Diff line
@@ -1333,7 +1333,7 @@ mod tests { 
        let vec = Vec::<u8>::deserialize(parcel.borrowed_ref()).unwrap();

        assert_eq!(vec, [-128i8 as u8, 127, 42, -117i8 as u8]);



        let u16s = [u16::max_value(), 12_345, 42, 117];

        let u16s = [u16::MAX, 12_345, 42, 117];



        // SAFETY: start is less than the current size of the parcel data buffer, because we haven't

        // made it any shorter since we got the position.
@@ -1348,7 +1348,7 @@ mod tests { 
        }



        assert_eq!(parcel.read::<u32>().unwrap(), 4); // 4 items

        assert_eq!(parcel.read::<u32>().unwrap(), 0xffff); // u16::max_value()

        assert_eq!(parcel.read::<u32>().unwrap(), 0xffff); // u16::MAX

        assert_eq!(parcel.read::<u32>().unwrap(), 12345); // 12,345

        assert_eq!(parcel.read::<u32>().unwrap(), 42); // 42

        assert_eq!(parcel.read::<u32>().unwrap(), 117); // 117
@@ -1361,9 +1361,9 @@ mod tests { 


        let vec = Vec::<u16>::deserialize(parcel.borrowed_ref()).unwrap();



        assert_eq!(vec, [u16::max_value(), 12_345, 42, 117]);

        assert_eq!(vec, [u16::MAX, 12_345, 42, 117]);



        let i16s = [i16::max_value(), i16::min_value(), 42, -117];

        let i16s = [i16::MAX, i16::MIN, 42, -117];



        // SAFETY: start is less than the current size of the parcel data buffer, because we haven't

        // made it any shorter since we got the position.
@@ -1378,8 +1378,8 @@ mod tests { 
        }



        assert_eq!(parcel.read::<u32>().unwrap(), 4); // 4 items

        assert_eq!(parcel.read::<u32>().unwrap(), 0x7fff); // i16::max_value()

        assert_eq!(parcel.read::<u32>().unwrap(), 0x8000); // i16::min_value()

        assert_eq!(parcel.read::<u32>().unwrap(), 0x7fff); // i16::MAX

        assert_eq!(parcel.read::<u32>().unwrap(), 0x8000); // i16::MIN

        assert_eq!(parcel.read::<u32>().unwrap(), 42); // 42

        assert_eq!(parcel.read::<u32>().unwrap(), 0xff8b); // -117
@@ -1391,9 +1391,9 @@ mod tests { 


        let vec = Vec::<i16>::deserialize(parcel.borrowed_ref()).unwrap();



        assert_eq!(vec, [i16::max_value(), i16::min_value(), 42, -117]);

        assert_eq!(vec, [i16::MAX, i16::MIN, 42, -117]);



        let u32s = [u32::max_value(), 12_345, 42, 117];

        let u32s = [u32::MAX, 12_345, 42, 117];



        // SAFETY: start is less than the current size of the parcel data buffer, because we haven't

        // made it any shorter since we got the position.
@@ -1408,7 +1408,7 @@ mod tests { 
        }



        assert_eq!(parcel.read::<u32>().unwrap(), 4); // 4 items

        assert_eq!(parcel.read::<u32>().unwrap(), 0xffffffff); // u32::max_value()

        assert_eq!(parcel.read::<u32>().unwrap(), 0xffffffff); // u32::MAX

        assert_eq!(parcel.read::<u32>().unwrap(), 12345); // 12,345

        assert_eq!(parcel.read::<u32>().unwrap(), 42); // 42

        assert_eq!(parcel.read::<u32>().unwrap(), 117); // 117
@@ -1421,9 +1421,9 @@ mod tests { 


        let vec = Vec::<u32>::deserialize(parcel.borrowed_ref()).unwrap();



        assert_eq!(vec, [u32::max_value(), 12_345, 42, 117]);

        assert_eq!(vec, [u32::MAX, 12_345, 42, 117]);



        let i32s = [i32::max_value(), i32::min_value(), 42, -117];

        let i32s = [i32::MAX, i32::MIN, 42, -117];



        // SAFETY: start is less than the current size of the parcel data buffer, because we haven't

        // made it any shorter since we got the position.
@@ -1438,8 +1438,8 @@ mod tests { 
        }



        assert_eq!(parcel.read::<u32>().unwrap(), 4); // 4 items

        assert_eq!(parcel.read::<u32>().unwrap(), 0x7fffffff); // i32::max_value()

        assert_eq!(parcel.read::<u32>().unwrap(), 0x80000000); // i32::min_value()

        assert_eq!(parcel.read::<u32>().unwrap(), 0x7fffffff); // i32::MAX

        assert_eq!(parcel.read::<u32>().unwrap(), 0x80000000); // i32::MIN

        assert_eq!(parcel.read::<u32>().unwrap(), 42); // 42

        assert_eq!(parcel.read::<u32>().unwrap(), 0xffffff8b); // -117
@@ -1451,9 +1451,9 @@ mod tests { 


        let vec = Vec::<i32>::deserialize(parcel.borrowed_ref()).unwrap();



        assert_eq!(vec, [i32::max_value(), i32::min_value(), 42, -117]);

        assert_eq!(vec, [i32::MAX, i32::MIN, 42, -117]);



        let u64s = [u64::max_value(), 12_345, 42, 117];

        let u64s = [u64::MAX, 12_345, 42, 117];



        // SAFETY: start is less than the current size of the parcel data buffer, because we haven't

        // made it any shorter since we got the position.
@@ -1469,9 +1469,9 @@ mod tests { 


        let vec = Vec::<u64>::deserialize(parcel.borrowed_ref()).unwrap();



        assert_eq!(vec, [u64::max_value(), 12_345, 42, 117]);

        assert_eq!(vec, [u64::MAX, 12_345, 42, 117]);



        let i64s = [i64::max_value(), i64::min_value(), 42, -117];

        let i64s = [i64::MAX, i64::MIN, 42, -117];



        // SAFETY: start is less than the current size of the parcel data buffer, because we haven't

        // made it any shorter since we got the position.
@@ -1487,9 +1487,9 @@ mod tests { 


        let vec = Vec::<i64>::deserialize(parcel.borrowed_ref()).unwrap();



        assert_eq!(vec, [i64::max_value(), i64::min_value(), 42, -117]);

        assert_eq!(vec, [i64::MAX, i64::MIN, 42, -117]);



        let f32s = [std::f32::NAN, std::f32::INFINITY, 1.23456789, std::f32::EPSILON];

        let f32s = [f32::NAN, f32::INFINITY, 1.23456789, f32::EPSILON];



        // SAFETY: start is less than the current size of the parcel data buffer, because we haven't

        // made it any shorter since we got the position.
@@ -1509,7 +1509,7 @@ mod tests { 
        assert!(vec[0].is_nan());

        assert_eq!(vec[1..], f32s[1..]);



        let f64s = [std::f64::NAN, std::f64::INFINITY, 1.234567890123456789, std::f64::EPSILON];

        let f64s = [f64::NAN, f64::INFINITY, 1.234567890123456789, f64::EPSILON];



        // SAFETY: start is less than the current size of the parcel data buffer, because we haven't

        // made it any shorter since we got the position.

libs/binder/rust/tests/serialization.rs

+10 −10
Original line number Diff line number Diff line
@@ -124,7 +124,7 @@ fn on_transact( 
        bindings::Transaction_TEST_BYTE => {

            assert_eq!(parcel.read::<i8>()?, 0);

            assert_eq!(parcel.read::<i8>()?, 1);

            assert_eq!(parcel.read::<i8>()?, i8::max_value());

            assert_eq!(parcel.read::<i8>()?, i8::MAX);

            // SAFETY: Just reading an extern constant.

            assert_eq!(parcel.read::<Vec<i8>>()?, unsafe { bindings::TESTDATA_I8 });

            // SAFETY: Just reading an extern constant.
@@ -133,7 +133,7 @@ fn on_transact( 


            reply.write(&0i8)?;

            reply.write(&1i8)?;

            reply.write(&i8::max_value())?;

            reply.write(&i8::MAX)?;

            // SAFETY: Just reading an extern constant.

            reply.write(&unsafe { bindings::TESTDATA_I8 }[..])?;

            // SAFETY: Just reading an extern constant.
@@ -143,14 +143,14 @@ fn on_transact( 
        bindings::Transaction_TEST_U16 => {

            assert_eq!(parcel.read::<u16>()?, 0);

            assert_eq!(parcel.read::<u16>()?, 1);

            assert_eq!(parcel.read::<u16>()?, u16::max_value());

            assert_eq!(parcel.read::<u16>()?, u16::MAX);

            // SAFETY: Just reading an extern constant.

            assert_eq!(parcel.read::<Vec<u16>>()?, unsafe { bindings::TESTDATA_CHARS });

            assert_eq!(parcel.read::<Option<Vec<u16>>>()?, None);



            reply.write(&0u16)?;

            reply.write(&1u16)?;

            reply.write(&u16::max_value())?;

            reply.write(&u16::MAX)?;

            // SAFETY: Just reading an extern constant.

            reply.write(&unsafe { bindings::TESTDATA_CHARS }[..])?;

            reply.write(&(None as Option<Vec<u16>>))?;
@@ -158,14 +158,14 @@ fn on_transact( 
        bindings::Transaction_TEST_I32 => {

            assert_eq!(parcel.read::<i32>()?, 0);

            assert_eq!(parcel.read::<i32>()?, 1);

            assert_eq!(parcel.read::<i32>()?, i32::max_value());

            assert_eq!(parcel.read::<i32>()?, i32::MAX);

            // SAFETY: Just reading an extern constant.

            assert_eq!(parcel.read::<Vec<i32>>()?, unsafe { bindings::TESTDATA_I32 });

            assert_eq!(parcel.read::<Option<Vec<i32>>>()?, None);



            reply.write(&0i32)?;

            reply.write(&1i32)?;

            reply.write(&i32::max_value())?;

            reply.write(&i32::MAX)?;

            // SAFETY: Just reading an extern constant.

            reply.write(&unsafe { bindings::TESTDATA_I32 }[..])?;

            reply.write(&(None as Option<Vec<i32>>))?;
@@ -173,14 +173,14 @@ fn on_transact( 
        bindings::Transaction_TEST_I64 => {

            assert_eq!(parcel.read::<i64>()?, 0);

            assert_eq!(parcel.read::<i64>()?, 1);

            assert_eq!(parcel.read::<i64>()?, i64::max_value());

            assert_eq!(parcel.read::<i64>()?, i64::MAX);

            // SAFETY: Just reading an extern constant.

            assert_eq!(parcel.read::<Vec<i64>>()?, unsafe { bindings::TESTDATA_I64 });

            assert_eq!(parcel.read::<Option<Vec<i64>>>()?, None);



            reply.write(&0i64)?;

            reply.write(&1i64)?;

            reply.write(&i64::max_value())?;

            reply.write(&i64::MAX)?;

            // SAFETY: Just reading an extern constant.

            reply.write(&unsafe { bindings::TESTDATA_I64 }[..])?;

            reply.write(&(None as Option<Vec<i64>>))?;
@@ -188,14 +188,14 @@ fn on_transact( 
        bindings::Transaction_TEST_U64 => {

            assert_eq!(parcel.read::<u64>()?, 0);

            assert_eq!(parcel.read::<u64>()?, 1);

            assert_eq!(parcel.read::<u64>()?, u64::max_value());

            assert_eq!(parcel.read::<u64>()?, u64::MAX);

            // SAFETY: Just reading an extern constant.

            assert_eq!(parcel.read::<Vec<u64>>()?, unsafe { bindings::TESTDATA_U64 });

            assert_eq!(parcel.read::<Option<Vec<u64>>>()?, None);



            reply.write(&0u64)?;

            reply.write(&1u64)?;

            reply.write(&u64::max_value())?;

            reply.write(&u64::MAX)?;

            // SAFETY: Just reading an extern constant.

            reply.write(&unsafe { bindings::TESTDATA_U64 }[..])?;

            reply.write(&(None as Option<Vec<u64>>))?;