[INFO] cloning repository https://github.com/faronov/zigbee-rs
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/faronov/zigbee-rs" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Ffaronov%2Fzigbee-rs", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Ffaronov%2Fzigbee-rs'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 14ba6df7309602cc31a08e97667c732d61b9580d
[INFO] checking faronov/zigbee-rs against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Ffaronov%2Fzigbee-rs" "/workspace/builds/worker-2-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-2-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/faronov/zigbee-rs
[INFO] finished tweaking git repo https://github.com/faronov/zigbee-rs
[INFO] tweaked toml for git repo https://github.com/faronov/zigbee-rs written to /workspace/builds/worker-2-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/faronov/zigbee-rs on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/faronov/zigbee-rs already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr] warning: unused workspace dependency `heapless`
[INFO] [stderr]   --> Cargo.toml:14:1
[INFO] [stderr]    |
[INFO] [stderr] 14 | heapless = "0.9"
[INFO] [stderr]    | ^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_workspace_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the workspace dependency `heapless`
[INFO] [stderr] warning: unused workspace dependency `log`
[INFO] [stderr]   --> Cargo.toml:15:1
[INFO] [stderr]    |
[INFO] [stderr] 15 | log = "0.4"
[INFO] [stderr]    | ^^^
[INFO] [stderr]    |
[INFO] [stderr] help: consider removing the workspace dependency `log`
[INFO] [stderr] warning: workspace (manifest) generated 2 warnings
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] b8380001fc6d2e38e35cf50eba434aac7533f6ae30ac9918d503e27f31ecc6a8
[INFO] running `Command { std: "docker" "start" "b8380001fc6d2e38e35cf50eba434aac7533f6ae30ac9918d503e27f31ecc6a8", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b8380001fc6d2e38e35cf50eba434aac7533f6ae30ac9918d503e27f31ecc6a8", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "b8380001fc6d2e38e35cf50eba434aac7533f6ae30ac9918d503e27f31ecc6a8" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b8380001fc6d2e38e35cf50eba434aac7533f6ae30ac9918d503e27f31ecc6a8", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-w" "/opt/rustwide/workdir" "--user" "0:0" "b8380001fc6d2e38e35cf50eba434aac7533f6ae30ac9918d503e27f31ecc6a8" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] warning: unused workspace dependency `heapless`
[INFO] [stderr]   --> Cargo.toml:14:1
[INFO] [stderr]    |
[INFO] [stderr] 14 | heapless = "0.9"
[INFO] [stderr]    | ^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_workspace_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the workspace dependency `heapless`
[INFO] [stderr] warning: unused workspace dependency `log`
[INFO] [stderr]   --> Cargo.toml:15:1
[INFO] [stderr]    |
[INFO] [stderr] 15 | log = "0.4"
[INFO] [stderr]    | ^^^
[INFO] [stderr]    |
[INFO] [stderr] help: consider removing the workspace dependency `log`
[INFO] [stderr] warning: workspace (manifest) generated 2 warnings
[INFO] [stderr]    Compiling heapless v0.9.2
[INFO] [stderr]     Checking byteorder v1.5.0
[INFO] [stderr]     Checking zigbee-types v0.1.0 (/opt/rustwide/workdir/zigbee-types)
[INFO] [stderr]    Compiling zigbee-mac v0.1.0 (/opt/rustwide/workdir/zigbee-mac)
[INFO] [stderr]     Checking embedded-storage v0.3.1
[INFO] [stderr]    Compiling embedded-hal-async v1.0.0
[INFO] [stderr]     Checking embedded-hal v1.0.0
[INFO] [stderr]     Checking inout v0.1.4
[INFO] [stderr]     Checking crypto-common v0.1.7
[INFO] [stderr]     Checking pollster v0.4.0
[INFO] [stderr]    Compiling syn v2.0.117
[INFO] [stderr]     Checking cipher v0.4.4
[INFO] [stderr]     Checking phy62x2-image v0.1.0 (/opt/rustwide/workdir/tools/phy62x2-image)
[INFO] [stderr]     Checking hash32 v0.3.1
[INFO] [stderr]     Checking aes v0.8.4
[INFO] [stderr]     Checking zigbee-sht4x v0.1.0 (/opt/rustwide/workdir/drivers/sht4x)
[INFO] [stderr]     Checking zigbee-scd4x v0.1.0 (/opt/rustwide/workdir/drivers/scd4x)
[INFO] [stderr]     Checking zigbee-bme280 v0.1.0 (/opt/rustwide/workdir/drivers/bme280)
[INFO] [stderr]     Checking zigbee-sht3x v0.1.0 (/opt/rustwide/workdir/drivers/sht3x)
[INFO] [stderr]     Checking zigbee-bh1750 v0.1.0 (/opt/rustwide/workdir/drivers/bh1750)
[INFO] [stderr]     Checking zigbee-bme680 v0.1.0 (/opt/rustwide/workdir/drivers/bme680)
[INFO] [stderr]     Checking zigbee-crypto v0.1.0 (/opt/rustwide/workdir/zigbee-crypto)
[INFO] [stderr]     Checking zigbee-zcl v0.1.0 (/opt/rustwide/workdir/zigbee-zcl)
[INFO] [stderr]     Checking zigbee-nwk v0.1.0 (/opt/rustwide/workdir/zigbee-nwk)
[INFO] [stderr]     Checking zigbee-aps v0.1.0 (/opt/rustwide/workdir/zigbee-aps)
[INFO] [stderr]    Compiling tokio-macros v2.6.1
[INFO] [stderr]     Checking tokio v1.50.0
[INFO] [stderr]     Checking zigbee-zdo v0.1.0 (/opt/rustwide/workdir/zigbee-zdo)
[INFO] [stderr]     Checking zigbee-bdb v0.1.0 (/opt/rustwide/workdir/zigbee-bdb)
[INFO] [stderr]     Checking zigbee-runtime v0.1.0 (/opt/rustwide/workdir/zigbee-runtime)
[INFO] [stderr]     Checking sensor-sed-app v0.1.0 (/opt/rustwide/workdir/apps/sensor-sed)
[INFO] [stderr]     Checking router-app v0.1.0 (/opt/rustwide/workdir/apps/router)
[INFO] [stderr]     Checking zigbee v0.1.0 (/opt/rustwide/workdir/zigbee)
[INFO] [stderr]     Checking zigbee-tests v0.1.0 (/opt/rustwide/workdir/tests)
[INFO] [stderr]     Checking mock-sleepy-sensor v0.1.0 (/opt/rustwide/workdir/examples/mock-sleepy-sensor)
[INFO] [stderr]     Checking mock-sensor v0.1.0 (/opt/rustwide/workdir/examples/mock-sensor)
[INFO] [stderr]     Checking mock-light v0.1.0 (/opt/rustwide/workdir/examples/mock-light)
[INFO] [stderr]     Checking mock-coordinator v0.1.0 (/opt/rustwide/workdir/examples/mock-coordinator)
[INFO] [stdout] warning: enum `InterruptibleSleep` is never used
[INFO] [stdout]   --> tests/src/../../efr32mg1-hal/src/pm.rs:84:10
[INFO] [stdout]    |
[INFO] [stdout] 84 | pub enum InterruptibleSleep {
[INFO] [stdout]    |          ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:247:60
[INFO] [stdout]     |
[INFO] [stdout] 247 |         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_IDENTIFY_TIME.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 247 -         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_IDENTIFY_TIME.into()) {
[INFO] [stdout] 247 +         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_IDENTIFY_TIME) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 247 -         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_IDENTIFY_TIME.into()) {
[INFO] [stdout] 247 +         if let Some(ZclValue::U16(t)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_IDENTIFY_TIME)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:389:60
[INFO] [stdout]     |
[INFO] [stdout] 389 |         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_REMAINING_TIME.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 389 -         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_REMAINING_TIME.into()) {
[INFO] [stdout] 389 +         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_REMAINING_TIME) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 389 -         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_REMAINING_TIME.into()) {
[INFO] [stdout] 389 +         if let Some(ZclValue::U16(t)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_REMAINING_TIME)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:442:61
[INFO] [stdout]     |
[INFO] [stdout] 442 |         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_GLOBAL_SCENE_CONTROL.into()) {
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 442 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_GLOBAL_SCENE_CONTROL.into()) {
[INFO] [stdout] 442 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_GLOBAL_SCENE_CONTROL) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 442 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_GLOBAL_SCENE_CONTROL.into()) {
[INFO] [stdout] 442 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_GLOBAL_SCENE_CONTROL)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:457:61
[INFO] [stdout]     |
[INFO] [stdout] 457 |         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_GLOBAL_SCENE_CONTROL.into()) {
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 457 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_GLOBAL_SCENE_CONTROL.into()) {
[INFO] [stdout] 457 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_GLOBAL_SCENE_CONTROL) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 457 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_GLOBAL_SCENE_CONTROL.into()) {
[INFO] [stdout] 457 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_GLOBAL_SCENE_CONTROL)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:472:60
[INFO] [stdout]     |
[INFO] [stdout] 472 |         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_ON_TIME.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 472 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_ON_TIME.into()) {
[INFO] [stdout] 472 +         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_ON_TIME) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 472 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_ON_TIME.into()) {
[INFO] [stdout] 472 +         if let Some(ZclValue::U16(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_ON_TIME)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:475:60
[INFO] [stdout]     |
[INFO] [stdout] 475 |         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_OFF_WAIT_TIME.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 475 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_OFF_WAIT_TIME.into()) {
[INFO] [stdout] 475 +         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_OFF_WAIT_TIME) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 475 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_OFF_WAIT_TIME.into()) {
[INFO] [stdout] 475 +         if let Some(ZclValue::U16(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_OFF_WAIT_TIME)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:505:60
[INFO] [stdout]     |
[INFO] [stdout] 505 |         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_ON_TIME.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 505 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_ON_TIME.into()) {
[INFO] [stdout] 505 +         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_ON_TIME) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 505 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_ON_TIME.into()) {
[INFO] [stdout] 505 +         if let Some(ZclValue::U16(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_ON_TIME)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:551:60
[INFO] [stdout]     |
[INFO] [stdout] 551 |         if let Some(ZclValue::U16(x)) = c.attributes().get(ATTR_CURRENT_X.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 551 -         if let Some(ZclValue::U16(x)) = c.attributes().get(ATTR_CURRENT_X.into()) {
[INFO] [stdout] 551 +         if let Some(ZclValue::U16(x)) = c.attributes().get(ATTR_CURRENT_X) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 551 -         if let Some(ZclValue::U16(x)) = c.attributes().get(ATTR_CURRENT_X.into()) {
[INFO] [stdout] 551 +         if let Some(ZclValue::U16(x)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_CURRENT_X)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:554:62
[INFO] [stdout]     |
[INFO] [stdout] 554 |         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout]     |                                                              ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 554 -         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout] 554 +         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 554 -         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout] 554 +         if let Some(ZclValue::Enum8(m)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_COLOR_MODE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:564:59
[INFO] [stdout]     |
[INFO] [stdout] 564 |         if let Some(ZclValue::U8(h)) = c.attributes().get(ATTR_CURRENT_HUE.into()) {
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 564 -         if let Some(ZclValue::U8(h)) = c.attributes().get(ATTR_CURRENT_HUE.into()) {
[INFO] [stdout] 564 +         if let Some(ZclValue::U8(h)) = c.attributes().get(ATTR_CURRENT_HUE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 564 -         if let Some(ZclValue::U8(h)) = c.attributes().get(ATTR_CURRENT_HUE.into()) {
[INFO] [stdout] 564 +         if let Some(ZclValue::U8(h)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_CURRENT_HUE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:567:62
[INFO] [stdout]     |
[INFO] [stdout] 567 |         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout]     |                                                              ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 567 -         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout] 567 +         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 567 -         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout] 567 +         if let Some(ZclValue::Enum8(m)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_COLOR_MODE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:577:59
[INFO] [stdout]     |
[INFO] [stdout] 577 |         if let Some(ZclValue::U8(s)) = c.attributes().get(ATTR_CURRENT_SATURATION.into()) {
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 577 -         if let Some(ZclValue::U8(s)) = c.attributes().get(ATTR_CURRENT_SATURATION.into()) {
[INFO] [stdout] 577 +         if let Some(ZclValue::U8(s)) = c.attributes().get(ATTR_CURRENT_SATURATION) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 577 -         if let Some(ZclValue::U8(s)) = c.attributes().get(ATTR_CURRENT_SATURATION.into()) {
[INFO] [stdout] 577 +         if let Some(ZclValue::U8(s)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_CURRENT_SATURATION)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:587:59
[INFO] [stdout]     |
[INFO] [stdout] 587 |         if let Some(ZclValue::U8(h)) = c.attributes().get(ATTR_CURRENT_HUE.into()) {
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 587 -         if let Some(ZclValue::U8(h)) = c.attributes().get(ATTR_CURRENT_HUE.into()) {
[INFO] [stdout] 587 +         if let Some(ZclValue::U8(h)) = c.attributes().get(ATTR_CURRENT_HUE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 587 -         if let Some(ZclValue::U8(h)) = c.attributes().get(ATTR_CURRENT_HUE.into()) {
[INFO] [stdout] 587 +         if let Some(ZclValue::U8(h)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_CURRENT_HUE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:590:59
[INFO] [stdout]     |
[INFO] [stdout] 590 |         if let Some(ZclValue::U8(s)) = c.attributes().get(ATTR_CURRENT_SATURATION.into()) {
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 590 -         if let Some(ZclValue::U8(s)) = c.attributes().get(ATTR_CURRENT_SATURATION.into()) {
[INFO] [stdout] 590 +         if let Some(ZclValue::U8(s)) = c.attributes().get(ATTR_CURRENT_SATURATION) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 590 -         if let Some(ZclValue::U8(s)) = c.attributes().get(ATTR_CURRENT_SATURATION.into()) {
[INFO] [stdout] 590 +         if let Some(ZclValue::U8(s)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_CURRENT_SATURATION)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:606:61
[INFO] [stdout]     |
[INFO] [stdout] 606 |         if let Some(ZclValue::U16(vx)) = c.attributes().get(ATTR_CURRENT_X.into()) {
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 606 -         if let Some(ZclValue::U16(vx)) = c.attributes().get(ATTR_CURRENT_X.into()) {
[INFO] [stdout] 606 +         if let Some(ZclValue::U16(vx)) = c.attributes().get(ATTR_CURRENT_X) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 606 -         if let Some(ZclValue::U16(vx)) = c.attributes().get(ATTR_CURRENT_X.into()) {
[INFO] [stdout] 606 +         if let Some(ZclValue::U16(vx)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_CURRENT_X)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:609:61
[INFO] [stdout]     |
[INFO] [stdout] 609 |         if let Some(ZclValue::U16(vy)) = c.attributes().get(ATTR_CURRENT_Y.into()) {
[INFO] [stdout]     |                                                             ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 609 -         if let Some(ZclValue::U16(vy)) = c.attributes().get(ATTR_CURRENT_Y.into()) {
[INFO] [stdout] 609 +         if let Some(ZclValue::U16(vy)) = c.attributes().get(ATTR_CURRENT_Y) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 609 -         if let Some(ZclValue::U16(vy)) = c.attributes().get(ATTR_CURRENT_Y.into()) {
[INFO] [stdout] 609 +         if let Some(ZclValue::U16(vy)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_CURRENT_Y)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:612:62
[INFO] [stdout]     |
[INFO] [stdout] 612 |         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout]     |                                                              ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 612 -         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout] 612 +         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 612 -         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout] 612 +         if let Some(ZclValue::Enum8(m)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_COLOR_MODE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:627:60
[INFO] [stdout]     |
[INFO] [stdout] 627 |         if let Some(ZclValue::U16(m)) = c.attributes().get(ATTR_COLOR_TEMPERATURE_MIREDS.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 627 -         if let Some(ZclValue::U16(m)) = c.attributes().get(ATTR_COLOR_TEMPERATURE_MIREDS.into()) {
[INFO] [stdout] 627 +         if let Some(ZclValue::U16(m)) = c.attributes().get(ATTR_COLOR_TEMPERATURE_MIREDS) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 627 -         if let Some(ZclValue::U16(m)) = c.attributes().get(ATTR_COLOR_TEMPERATURE_MIREDS.into()) {
[INFO] [stdout] 627 +         if let Some(ZclValue::U16(m)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_COLOR_TEMPERATURE_MIREDS)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:630:62
[INFO] [stdout]     |
[INFO] [stdout] 630 |         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout]     |                                                              ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 630 -         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout] 630 +         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 630 -         if let Some(ZclValue::Enum8(m)) = c.attributes().get(ATTR_COLOR_MODE.into()) {
[INFO] [stdout] 630 +         if let Some(ZclValue::Enum8(m)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_COLOR_MODE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:646:60
[INFO] [stdout]     |
[INFO] [stdout] 646 |         if let Some(ZclValue::U16(h)) = c.attributes().get(ATTR_ENHANCED_CURRENT_HUE.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 646 -         if let Some(ZclValue::U16(h)) = c.attributes().get(ATTR_ENHANCED_CURRENT_HUE.into()) {
[INFO] [stdout] 646 +         if let Some(ZclValue::U16(h)) = c.attributes().get(ATTR_ENHANCED_CURRENT_HUE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 646 -         if let Some(ZclValue::U16(h)) = c.attributes().get(ATTR_ENHANCED_CURRENT_HUE.into()) {
[INFO] [stdout] 646 +         if let Some(ZclValue::U16(h)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_ENHANCED_CURRENT_HUE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:658:59
[INFO] [stdout]     |
[INFO] [stdout] 658 |         if let Some(ZclValue::U8(a)) = c.attributes().get(ATTR_COLOR_LOOP_ACTIVE.into()) {
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 658 -         if let Some(ZclValue::U8(a)) = c.attributes().get(ATTR_COLOR_LOOP_ACTIVE.into()) {
[INFO] [stdout] 658 +         if let Some(ZclValue::U8(a)) = c.attributes().get(ATTR_COLOR_LOOP_ACTIVE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 658 -         if let Some(ZclValue::U8(a)) = c.attributes().get(ATTR_COLOR_LOOP_ACTIVE.into()) {
[INFO] [stdout] 658 +         if let Some(ZclValue::U8(a)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_COLOR_LOOP_ACTIVE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:661:59
[INFO] [stdout]     |
[INFO] [stdout] 661 |         if let Some(ZclValue::U8(d)) = c.attributes().get(ATTR_COLOR_LOOP_DIRECTION.into()) {
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 661 -         if let Some(ZclValue::U8(d)) = c.attributes().get(ATTR_COLOR_LOOP_DIRECTION.into()) {
[INFO] [stdout] 661 +         if let Some(ZclValue::U8(d)) = c.attributes().get(ATTR_COLOR_LOOP_DIRECTION) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 661 -         if let Some(ZclValue::U8(d)) = c.attributes().get(ATTR_COLOR_LOOP_DIRECTION.into()) {
[INFO] [stdout] 661 +         if let Some(ZclValue::U8(d)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_COLOR_LOOP_DIRECTION)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:664:60
[INFO] [stdout]     |
[INFO] [stdout] 664 |         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_COLOR_LOOP_TIME.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 664 -         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_COLOR_LOOP_TIME.into()) {
[INFO] [stdout] 664 +         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_COLOR_LOOP_TIME) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 664 -         if let Some(ZclValue::U16(t)) = c.attributes().get(ATTR_COLOR_LOOP_TIME.into()) {
[INFO] [stdout] 664 +         if let Some(ZclValue::U16(t)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_COLOR_LOOP_TIME)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:677:59
[INFO] [stdout]     |
[INFO] [stdout] 677 |         if let Some(ZclValue::U8(a)) = c.attributes().get(ATTR_COLOR_LOOP_ACTIVE.into()) {
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 677 -         if let Some(ZclValue::U8(a)) = c.attributes().get(ATTR_COLOR_LOOP_ACTIVE.into()) {
[INFO] [stdout] 677 +         if let Some(ZclValue::U8(a)) = c.attributes().get(ATTR_COLOR_LOOP_ACTIVE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 677 -         if let Some(ZclValue::U8(a)) = c.attributes().get(ATTR_COLOR_LOOP_ACTIVE.into()) {
[INFO] [stdout] 677 +         if let Some(ZclValue::U8(a)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_COLOR_LOOP_ACTIVE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:680:59
[INFO] [stdout]     |
[INFO] [stdout] 680 |         if let Some(ZclValue::U8(d)) = c.attributes().get(ATTR_COLOR_LOOP_DIRECTION.into()) {
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 680 -         if let Some(ZclValue::U8(d)) = c.attributes().get(ATTR_COLOR_LOOP_DIRECTION.into()) {
[INFO] [stdout] 680 +         if let Some(ZclValue::U8(d)) = c.attributes().get(ATTR_COLOR_LOOP_DIRECTION) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 680 -         if let Some(ZclValue::U8(d)) = c.attributes().get(ATTR_COLOR_LOOP_DIRECTION.into()) {
[INFO] [stdout] 680 +         if let Some(ZclValue::U8(d)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_COLOR_LOOP_DIRECTION)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:733:67
[INFO] [stdout]     |
[INFO] [stdout] 733 |         if let Some(ZclValue::CharString(s)) = c.attributes().get(ATTR_MANUFACTURER_NAME.into()) {
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 733 -         if let Some(ZclValue::CharString(s)) = c.attributes().get(ATTR_MANUFACTURER_NAME.into()) {
[INFO] [stdout] 733 +         if let Some(ZclValue::CharString(s)) = c.attributes().get(ATTR_MANUFACTURER_NAME) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 733 -         if let Some(ZclValue::CharString(s)) = c.attributes().get(ATTR_MANUFACTURER_NAME.into()) {
[INFO] [stdout] 733 +         if let Some(ZclValue::CharString(s)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MANUFACTURER_NAME)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:738:67
[INFO] [stdout]     |
[INFO] [stdout] 738 |         if let Some(ZclValue::CharString(s)) = c.attributes().get(ATTR_MODEL_IDENTIFIER.into()) {
[INFO] [stdout]     |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 738 -         if let Some(ZclValue::CharString(s)) = c.attributes().get(ATTR_MODEL_IDENTIFIER.into()) {
[INFO] [stdout] 738 +         if let Some(ZclValue::CharString(s)) = c.attributes().get(ATTR_MODEL_IDENTIFIER) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 738 -         if let Some(ZclValue::CharString(s)) = c.attributes().get(ATTR_MODEL_IDENTIFIER.into()) {
[INFO] [stdout] 738 +         if let Some(ZclValue::CharString(s)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MODEL_IDENTIFIER)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:741:59
[INFO] [stdout]     |
[INFO] [stdout] 741 |         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_ZCL_VERSION.into()) {
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 741 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_ZCL_VERSION.into()) {
[INFO] [stdout] 741 +         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_ZCL_VERSION) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 741 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_ZCL_VERSION.into()) {
[INFO] [stdout] 741 +         if let Some(ZclValue::U8(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_ZCL_VERSION)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:766:62
[INFO] [stdout]     |
[INFO] [stdout] 766 |         if let Some(ZclValue::Enum8(v)) = c.attributes().get(ATTR_POWER_SOURCE.into()) {
[INFO] [stdout]     |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 766 -         if let Some(ZclValue::Enum8(v)) = c.attributes().get(ATTR_POWER_SOURCE.into()) {
[INFO] [stdout] 766 +         if let Some(ZclValue::Enum8(v)) = c.attributes().get(ATTR_POWER_SOURCE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 766 -         if let Some(ZclValue::Enum8(v)) = c.attributes().get(ATTR_POWER_SOURCE.into()) {
[INFO] [stdout] 766 +         if let Some(ZclValue::Enum8(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_POWER_SOURCE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:832:60
[INFO] [stdout]     |
[INFO] [stdout] 832 |         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 832 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout] 832 +         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MEASURED_VALUE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 832 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout] 832 +         if let Some(ZclValue::U16(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MEASURED_VALUE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:848:60
[INFO] [stdout]     |
[INFO] [stdout] 848 |         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MIN_MEASURED_VALUE.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 848 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MIN_MEASURED_VALUE.into()) {
[INFO] [stdout] 848 +         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MIN_MEASURED_VALUE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 848 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MIN_MEASURED_VALUE.into()) {
[INFO] [stdout] 848 +         if let Some(ZclValue::U16(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MIN_MEASURED_VALUE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:851:60
[INFO] [stdout]     |
[INFO] [stdout] 851 |         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MAX_MEASURED_VALUE.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 851 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MAX_MEASURED_VALUE.into()) {
[INFO] [stdout] 851 +         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MAX_MEASURED_VALUE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 851 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MAX_MEASURED_VALUE.into()) {
[INFO] [stdout] 851 +         if let Some(ZclValue::U16(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MAX_MEASURED_VALUE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:861:60
[INFO] [stdout]     |
[INFO] [stdout] 861 |         if let Some(ZclValue::I16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 861 -         if let Some(ZclValue::I16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout] 861 +         if let Some(ZclValue::I16(v)) = c.attributes().get(ATTR_MEASURED_VALUE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 861 -         if let Some(ZclValue::I16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout] 861 +         if let Some(ZclValue::I16(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MEASURED_VALUE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:882:60
[INFO] [stdout]     |
[INFO] [stdout] 882 |         if let Some(ZclValue::I16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 882 -         if let Some(ZclValue::I16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout] 882 +         if let Some(ZclValue::I16(v)) = c.attributes().get(ATTR_MEASURED_VALUE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 882 -         if let Some(ZclValue::I16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout] 882 +         if let Some(ZclValue::I16(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MEASURED_VALUE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:901:59
[INFO] [stdout]     |
[INFO] [stdout] 901 |         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_VOLTAGE.into()) {
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 901 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_VOLTAGE.into()) {
[INFO] [stdout] 901 +         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_VOLTAGE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 901 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_VOLTAGE.into()) {
[INFO] [stdout] 901 +         if let Some(ZclValue::U8(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_BATTERY_VOLTAGE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:904:59
[INFO] [stdout]     |
[INFO] [stdout] 904 |         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_PERCENTAGE_REMAINING.into())
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 904 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_PERCENTAGE_REMAINING.into())
[INFO] [stdout] 904 +         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_PERCENTAGE_REMAINING)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 904 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_PERCENTAGE_REMAINING.into())
[INFO] [stdout] 904 +         if let Some(ZclValue::U8(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_BATTERY_PERCENTAGE_REMAINING))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:908:62
[INFO] [stdout]     |
[INFO] [stdout] 908 |         if let Some(ZclValue::Enum8(v)) = c.attributes().get(ATTR_BATTERY_SIZE.into()) {
[INFO] [stdout]     |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 908 -         if let Some(ZclValue::Enum8(v)) = c.attributes().get(ATTR_BATTERY_SIZE.into()) {
[INFO] [stdout] 908 +         if let Some(ZclValue::Enum8(v)) = c.attributes().get(ATTR_BATTERY_SIZE) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 908 -         if let Some(ZclValue::Enum8(v)) = c.attributes().get(ATTR_BATTERY_SIZE.into()) {
[INFO] [stdout] 908 +         if let Some(ZclValue::Enum8(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_BATTERY_SIZE)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]    --> tests/src/cluster_tests.rs:911:59
[INFO] [stdout]     |
[INFO] [stdout] 911 |         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_QUANTITY.into()) {
[INFO] [stdout]     |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 911 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_QUANTITY.into()) {
[INFO] [stdout] 911 +         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_QUANTITY) {
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 911 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_BATTERY_QUANTITY.into()) {
[INFO] [stdout] 911 +         if let Some(ZclValue::U8(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_BATTERY_QUANTITY)) {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1016:61
[INFO] [stdout]      |
[INFO] [stdout] 1016 |         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1016 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout] 1016 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1016 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout] 1016 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_PRESENT_VALUE)) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1021:61
[INFO] [stdout]      |
[INFO] [stdout] 1021 |         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1021 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout] 1021 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1021 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout] 1021 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_PRESENT_VALUE)) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1056:61
[INFO] [stdout]      |
[INFO] [stdout] 1056 |         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1056 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout] 1056 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1056 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout] 1056 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_PRESENT_VALUE)) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1061:61
[INFO] [stdout]      |
[INFO] [stdout] 1061 |         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1061 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout] 1061 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1061 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout] 1061 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_PRESENT_VALUE)) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1085:61
[INFO] [stdout]      |
[INFO] [stdout] 1085 |         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1085 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout] 1085 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1085 -         if let Some(ZclValue::Bool(v)) = c.attributes().get(ATTR_PRESENT_VALUE.into()) {
[INFO] [stdout] 1085 +         if let Some(ZclValue::Bool(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_PRESENT_VALUE)) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1134:60
[INFO] [stdout]      |
[INFO] [stdout] 1134 |         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1134 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout] 1134 +         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MEASURED_VALUE) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1134 -         if let Some(ZclValue::U16(v)) = c.attributes().get(ATTR_MEASURED_VALUE.into()) {
[INFO] [stdout] 1134 +         if let Some(ZclValue::U16(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MEASURED_VALUE)) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1146:59
[INFO] [stdout]      |
[INFO] [stdout] 1146 |         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_LEVEL_STATUS.into()) {
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1146 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_LEVEL_STATUS.into()) {
[INFO] [stdout] 1146 +         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_LEVEL_STATUS) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1146 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_LEVEL_STATUS.into()) {
[INFO] [stdout] 1146 +         if let Some(ZclValue::U8(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_LEVEL_STATUS)) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1166:59
[INFO] [stdout]      |
[INFO] [stdout] 1166 |         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_PHYSICAL_MIN_LEVEL.into()) {
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1166 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_PHYSICAL_MIN_LEVEL.into()) {
[INFO] [stdout] 1166 +         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_PHYSICAL_MIN_LEVEL) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1166 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_PHYSICAL_MIN_LEVEL.into()) {
[INFO] [stdout] 1166 +         if let Some(ZclValue::U8(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_PHYSICAL_MIN_LEVEL)) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1169:59
[INFO] [stdout]      |
[INFO] [stdout] 1169 |         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_PHYSICAL_MAX_LEVEL.into()) {
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_PHYSICAL_MAX_LEVEL.into()) {
[INFO] [stdout] 1169 +         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_PHYSICAL_MAX_LEVEL) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         if let Some(ZclValue::U8(v)) = c.attributes().get(ATTR_PHYSICAL_MAX_LEVEL.into()) {
[INFO] [stdout] 1169 +         if let Some(ZclValue::U8(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_PHYSICAL_MAX_LEVEL)) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1174:60
[INFO] [stdout]      |
[INFO] [stdout] 1174 |         if let Some(ZclValue::U32(v)) = c.attributes().get(ATTR_LAMP_BURN_HOURS.into()) {
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1174 -         if let Some(ZclValue::U32(v)) = c.attributes().get(ATTR_LAMP_BURN_HOURS.into()) {
[INFO] [stdout] 1174 +         if let Some(ZclValue::U32(v)) = c.attributes().get(ATTR_LAMP_BURN_HOURS) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1174 -         if let Some(ZclValue::U32(v)) = c.attributes().get(ATTR_LAMP_BURN_HOURS.into()) {
[INFO] [stdout] 1174 +         if let Some(ZclValue::U32(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_LAMP_BURN_HOURS)) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1180:60
[INFO] [stdout]      |
[INFO] [stdout] 1180 |         if let Some(ZclValue::U32(v)) = c.attributes().get(ATTR_LAMP_BURN_HOURS.into()) {
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1180 -         if let Some(ZclValue::U32(v)) = c.attributes().get(ATTR_LAMP_BURN_HOURS.into()) {
[INFO] [stdout] 1180 +         if let Some(ZclValue::U32(v)) = c.attributes().get(ATTR_LAMP_BURN_HOURS) {
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1180 -         if let Some(ZclValue::U32(v)) = c.attributes().get(ATTR_LAMP_BURN_HOURS.into()) {
[INFO] [stdout] 1180 +         if let Some(ZclValue::U32(v)) = c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_LAMP_BURN_HOURS)) {
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1197:32
[INFO] [stdout]      |
[INFO] [stdout] 1197 |             c.attributes().get(ATTR_CURRENT_TEMPERATURE.into()),
[INFO] [stdout]      |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1197 -             c.attributes().get(ATTR_CURRENT_TEMPERATURE.into()),
[INFO] [stdout] 1197 +             c.attributes().get(ATTR_CURRENT_TEMPERATURE),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1197 -             c.attributes().get(ATTR_CURRENT_TEMPERATURE.into()),
[INFO] [stdout] 1197 +             c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_CURRENT_TEMPERATURE)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1203:32
[INFO] [stdout]      |
[INFO] [stdout] 1203 |             c.attributes().get(ATTR_CURRENT_TEMPERATURE.into()),
[INFO] [stdout]      |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1203 -             c.attributes().get(ATTR_CURRENT_TEMPERATURE.into()),
[INFO] [stdout] 1203 +             c.attributes().get(ATTR_CURRENT_TEMPERATURE),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1203 -             c.attributes().get(ATTR_CURRENT_TEMPERATURE.into()),
[INFO] [stdout] 1203 +             c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_CURRENT_TEMPERATURE)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1207:32
[INFO] [stdout]      |
[INFO] [stdout] 1207 |             c.attributes().get(ATTR_MIN_TEMP_EXPERIENCED.into()),
[INFO] [stdout]      |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1207 -             c.attributes().get(ATTR_MIN_TEMP_EXPERIENCED.into()),
[INFO] [stdout] 1207 +             c.attributes().get(ATTR_MIN_TEMP_EXPERIENCED),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1207 -             c.attributes().get(ATTR_MIN_TEMP_EXPERIENCED.into()),
[INFO] [stdout] 1207 +             c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MIN_TEMP_EXPERIENCED)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1211:32
[INFO] [stdout]      |
[INFO] [stdout] 1211 |             c.attributes().get(ATTR_MAX_TEMP_EXPERIENCED.into()),
[INFO] [stdout]      |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1211 -             c.attributes().get(ATTR_MAX_TEMP_EXPERIENCED.into()),
[INFO] [stdout] 1211 +             c.attributes().get(ATTR_MAX_TEMP_EXPERIENCED),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1211 -             c.attributes().get(ATTR_MAX_TEMP_EXPERIENCED.into()),
[INFO] [stdout] 1211 +             c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MAX_TEMP_EXPERIENCED)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1218:32
[INFO] [stdout]      |
[INFO] [stdout] 1218 |             c.attributes().get(ATTR_MIN_TEMP_EXPERIENCED.into()),
[INFO] [stdout]      |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1218 -             c.attributes().get(ATTR_MIN_TEMP_EXPERIENCED.into()),
[INFO] [stdout] 1218 +             c.attributes().get(ATTR_MIN_TEMP_EXPERIENCED),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1218 -             c.attributes().get(ATTR_MIN_TEMP_EXPERIENCED.into()),
[INFO] [stdout] 1218 +             c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MIN_TEMP_EXPERIENCED)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zigbee_zcl::AttributeId`
[INFO] [stdout]     --> tests/src/cluster_tests.rs:1222:32
[INFO] [stdout]      |
[INFO] [stdout] 1222 |             c.attributes().get(ATTR_MAX_TEMP_EXPERIENCED.into()),
[INFO] [stdout]      |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1222 -             c.attributes().get(ATTR_MAX_TEMP_EXPERIENCED.into()),
[INFO] [stdout] 1222 +             c.attributes().get(ATTR_MAX_TEMP_EXPERIENCED),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1222 -             c.attributes().get(ATTR_MAX_TEMP_EXPERIENCED.into()),
[INFO] [stdout] 1222 +             c.attributes().get(<zigbee_zcl::AttributeId as Into<_>>::into(ATTR_MAX_TEMP_EXPERIENCED)),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `zigbee-tests` (lib test) due to 55 previous errors; 1 warning emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stderr] warning: unused dependency `log`
[INFO] [stderr]   --> zigbee-mac/Cargo.toml:47:1
[INFO] [stderr]    |
[INFO] [stderr] 47 | log = "0.4"
[INFO] [stderr]    | ^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `log`
[INFO] [stderr] warning: `zigbee-mac` (manifest) generated 1 warning
[INFO] [stderr] warning: unused dependency `pollster`
[INFO] [stderr]   --> tests/Cargo.toml:19:1
[INFO] [stderr]    |
[INFO] [stderr] 19 | pollster = "0.4"
[INFO] [stderr]    | ^^^^^^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `pollster`
[INFO] [stderr] warning: `zigbee-tests` (manifest) generated 1 warning
[INFO] [stderr] warning: unused dependency `zigbee-types`
[INFO] [stderr]  --> zigbee-zcl/Cargo.toml:9:1
[INFO] [stderr]   |
[INFO] [stderr] 9 | zigbee-types = { version = "0.1.0", path = "../zigbee-types" }
[INFO] [stderr]   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `zigbee-types`
[INFO] [stderr] warning: `zigbee-zcl` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "inspect" "b8380001fc6d2e38e35cf50eba434aac7533f6ae30ac9918d503e27f31ecc6a8", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "b8380001fc6d2e38e35cf50eba434aac7533f6ae30ac9918d503e27f31ecc6a8", kill_on_drop: false }`
[INFO] [stdout] b8380001fc6d2e38e35cf50eba434aac7533f6ae30ac9918d503e27f31ecc6a8
