[INFO] cloning repository https://github.com/ZzaizZ/rust_course_practice_6
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/ZzaizZ/rust_course_practice_6" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FZzaizZ%2Frust_course_practice_6", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FZzaizZ%2Frust_course_practice_6'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 34961b56817ea45ddb0921096403803bac2d5356
[INFO] checking ZzaizZ/rust_course_practice_6 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FZzaizZ%2Frust_course_practice_6" "/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/ZzaizZ/rust_course_practice_6
[INFO] finished tweaking git repo https://github.com/ZzaizZ/rust_course_practice_6
[INFO] tweaked toml for git repo https://github.com/ZzaizZ/rust_course_practice_6 written to /workspace/builds/worker-2-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/ZzaizZ/rust_course_practice_6 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/ZzaizZ/rust_course_practice_6 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] 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] 1dbc2e6380df0257c9aae969cabe143787a645ed7b0991f2c10fde875258a5e2
[INFO] running `Command { std: "docker" "start" "1dbc2e6380df0257c9aae969cabe143787a645ed7b0991f2c10fde875258a5e2", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1dbc2e6380df0257c9aae969cabe143787a645ed7b0991f2c10fde875258a5e2", 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" "1dbc2e6380df0257c9aae969cabe143787a645ed7b0991f2c10fde875258a5e2" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1dbc2e6380df0257c9aae969cabe143787a645ed7b0991f2c10fde875258a5e2", 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" "1dbc2e6380df0257c9aae969cabe143787a645ed7b0991f2c10fde875258a5e2" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]     Checking analysis v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1131:36
[INFO] [stdout]      |
[INFO] [stdout] 1131 |         assert_eq!(stdp::U32.parse("411".into()), Ok(("".into(), NonZeroU32::new(411).unwrap())));
[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] 1131 -         assert_eq!(stdp::U32.parse("411".into()), Ok(("".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout] 1131 +         assert_eq!(stdp::U32.parse("411"), Ok(("".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1131 -         assert_eq!(stdp::U32.parse("411".into()), Ok(("".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout] 1131 +         assert_eq!(stdp::U32.parse(<&str as Into<_>>::into("411")), Ok(("".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1131:55
[INFO] [stdout]      |
[INFO] [stdout] 1131 |         assert_eq!(stdp::U32.parse("411".into()), Ok(("".into(), NonZeroU32::new(411).unwrap())));
[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] 1131 -         assert_eq!(stdp::U32.parse("411".into()), Ok(("".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout] 1131 +         assert_eq!(stdp::U32.parse("411".into()), Ok(("", NonZeroU32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1131 -         assert_eq!(stdp::U32.parse("411".into()), Ok(("".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout] 1131 +         assert_eq!(stdp::U32.parse("411".into()), Ok((<&str as Into<_>>::into(""), NonZeroU32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1132:36
[INFO] [stdout]      |
[INFO] [stdout] 1132 |         assert_eq!(stdp::U32.parse("411ab".into()), Ok(("ab".into(), NonZeroU32::new(411).unwrap())));
[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] 1132 -         assert_eq!(stdp::U32.parse("411ab".into()), Ok(("ab".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout] 1132 +         assert_eq!(stdp::U32.parse("411ab"), Ok(("ab".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1132 -         assert_eq!(stdp::U32.parse("411ab".into()), Ok(("ab".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout] 1132 +         assert_eq!(stdp::U32.parse(<&str as Into<_>>::into("411ab")), Ok(("ab".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1132:57
[INFO] [stdout]      |
[INFO] [stdout] 1132 |         assert_eq!(stdp::U32.parse("411ab".into()), Ok(("ab".into(), NonZeroU32::new(411).unwrap())));
[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] 1132 -         assert_eq!(stdp::U32.parse("411ab".into()), Ok(("ab".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout] 1132 +         assert_eq!(stdp::U32.parse("411ab".into()), Ok(("ab", NonZeroU32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1132 -         assert_eq!(stdp::U32.parse("411ab".into()), Ok(("ab".into(), NonZeroU32::new(411).unwrap())));
[INFO] [stdout] 1132 +         assert_eq!(stdp::U32.parse("411ab".into()), Ok((<&str as Into<_>>::into("ab"), NonZeroU32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1133:36
[INFO] [stdout]      |
[INFO] [stdout] 1133 |         assert_eq!(stdp::U32.parse("".into()), Err(()));
[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] 1133 -         assert_eq!(stdp::U32.parse("".into()), Err(()));
[INFO] [stdout] 1133 +         assert_eq!(stdp::U32.parse(""), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1133 -         assert_eq!(stdp::U32.parse("".into()), Err(()));
[INFO] [stdout] 1133 +         assert_eq!(stdp::U32.parse(<&str as Into<_>>::into("")), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1134:36
[INFO] [stdout]      |
[INFO] [stdout] 1134 |         assert_eq!(stdp::U32.parse("-3".into()), Err(()));
[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 -         assert_eq!(stdp::U32.parse("-3".into()), Err(()));
[INFO] [stdout] 1134 +         assert_eq!(stdp::U32.parse("-3"), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1134 -         assert_eq!(stdp::U32.parse("-3".into()), Err(()));
[INFO] [stdout] 1134 +         assert_eq!(stdp::U32.parse(<&str as Into<_>>::into("-3")), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1135:36
[INFO] [stdout]      |
[INFO] [stdout] 1135 |         assert_eq!(stdp::U32.parse("0x03".into()), Ok(("".into(), NonZeroU32::new(0x3).unwrap())));
[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] 1135 -         assert_eq!(stdp::U32.parse("0x03".into()), Ok(("".into(), NonZeroU32::new(0x3).unwrap())));
[INFO] [stdout] 1135 +         assert_eq!(stdp::U32.parse("0x03"), Ok(("".into(), NonZeroU32::new(0x3).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1135 -         assert_eq!(stdp::U32.parse("0x03".into()), Ok(("".into(), NonZeroU32::new(0x3).unwrap())));
[INFO] [stdout] 1135 +         assert_eq!(stdp::U32.parse(<&str as Into<_>>::into("0x03")), Ok(("".into(), NonZeroU32::new(0x3).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1135:56
[INFO] [stdout]      |
[INFO] [stdout] 1135 |         assert_eq!(stdp::U32.parse("0x03".into()), Ok(("".into(), NonZeroU32::new(0x3).unwrap())));
[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] 1135 -         assert_eq!(stdp::U32.parse("0x03".into()), Ok(("".into(), NonZeroU32::new(0x3).unwrap())));
[INFO] [stdout] 1135 +         assert_eq!(stdp::U32.parse("0x03".into()), Ok(("", NonZeroU32::new(0x3).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1135 -         assert_eq!(stdp::U32.parse("0x03".into()), Ok(("".into(), NonZeroU32::new(0x3).unwrap())));
[INFO] [stdout] 1135 +         assert_eq!(stdp::U32.parse("0x03".into()), Ok((<&str as Into<_>>::into(""), NonZeroU32::new(0x3).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1136:36
[INFO] [stdout]      |
[INFO] [stdout] 1136 |         assert_eq!(stdp::U32.parse("0x03abg".into()), Ok(("g".into(), NonZeroU32::new(0x3ab).unwrap())));
[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] 1136 -         assert_eq!(stdp::U32.parse("0x03abg".into()), Ok(("g".into(), NonZeroU32::new(0x3ab).unwrap())));
[INFO] [stdout] 1136 +         assert_eq!(stdp::U32.parse("0x03abg"), Ok(("g".into(), NonZeroU32::new(0x3ab).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1136 -         assert_eq!(stdp::U32.parse("0x03abg".into()), Ok(("g".into(), NonZeroU32::new(0x3ab).unwrap())));
[INFO] [stdout] 1136 +         assert_eq!(stdp::U32.parse(<&str as Into<_>>::into("0x03abg")), Ok(("g".into(), NonZeroU32::new(0x3ab).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1136:59
[INFO] [stdout]      |
[INFO] [stdout] 1136 |         assert_eq!(stdp::U32.parse("0x03abg".into()), Ok(("g".into(), NonZeroU32::new(0x3ab).unwrap())));
[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] 1136 -         assert_eq!(stdp::U32.parse("0x03abg".into()), Ok(("g".into(), NonZeroU32::new(0x3ab).unwrap())));
[INFO] [stdout] 1136 +         assert_eq!(stdp::U32.parse("0x03abg".into()), Ok(("g", NonZeroU32::new(0x3ab).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1136 -         assert_eq!(stdp::U32.parse("0x03abg".into()), Ok(("g".into(), NonZeroU32::new(0x3ab).unwrap())));
[INFO] [stdout] 1136 +         assert_eq!(stdp::U32.parse("0x03abg".into()), Ok((<&str as Into<_>>::into("g"), NonZeroU32::new(0x3ab).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1137:36
[INFO] [stdout]      |
[INFO] [stdout] 1137 |         assert_eq!(stdp::U32.parse("0x".into()), Err(()));
[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] 1137 -         assert_eq!(stdp::U32.parse("0x".into()), Err(()));
[INFO] [stdout] 1137 +         assert_eq!(stdp::U32.parse("0x"), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1137 -         assert_eq!(stdp::U32.parse("0x".into()), Err(()));
[INFO] [stdout] 1137 +         assert_eq!(stdp::U32.parse(<&str as Into<_>>::into("0x")), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1142:36
[INFO] [stdout]      |
[INFO] [stdout] 1142 |         assert_eq!(stdp::I32.parse("411".into()), Ok(("".into(), NonZeroI32::new(411).unwrap())));
[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] 1142 -         assert_eq!(stdp::I32.parse("411".into()), Ok(("".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout] 1142 +         assert_eq!(stdp::I32.parse("411"), Ok(("".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1142 -         assert_eq!(stdp::I32.parse("411".into()), Ok(("".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout] 1142 +         assert_eq!(stdp::I32.parse(<&str as Into<_>>::into("411")), Ok(("".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1142:55
[INFO] [stdout]      |
[INFO] [stdout] 1142 |         assert_eq!(stdp::I32.parse("411".into()), Ok(("".into(), NonZeroI32::new(411).unwrap())));
[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] 1142 -         assert_eq!(stdp::I32.parse("411".into()), Ok(("".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout] 1142 +         assert_eq!(stdp::I32.parse("411".into()), Ok(("", NonZeroI32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1142 -         assert_eq!(stdp::I32.parse("411".into()), Ok(("".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout] 1142 +         assert_eq!(stdp::I32.parse("411".into()), Ok((<&str as Into<_>>::into(""), NonZeroI32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1143:36
[INFO] [stdout]      |
[INFO] [stdout] 1143 |         assert_eq!(stdp::I32.parse("411ab".into()), Ok(("ab".into(), NonZeroI32::new(411).unwrap())));
[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] 1143 -         assert_eq!(stdp::I32.parse("411ab".into()), Ok(("ab".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout] 1143 +         assert_eq!(stdp::I32.parse("411ab"), Ok(("ab".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1143 -         assert_eq!(stdp::I32.parse("411ab".into()), Ok(("ab".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout] 1143 +         assert_eq!(stdp::I32.parse(<&str as Into<_>>::into("411ab")), Ok(("ab".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1143:57
[INFO] [stdout]      |
[INFO] [stdout] 1143 |         assert_eq!(stdp::I32.parse("411ab".into()), Ok(("ab".into(), NonZeroI32::new(411).unwrap())));
[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] 1143 -         assert_eq!(stdp::I32.parse("411ab".into()), Ok(("ab".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout] 1143 +         assert_eq!(stdp::I32.parse("411ab".into()), Ok(("ab", NonZeroI32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1143 -         assert_eq!(stdp::I32.parse("411ab".into()), Ok(("ab".into(), NonZeroI32::new(411).unwrap())));
[INFO] [stdout] 1143 +         assert_eq!(stdp::I32.parse("411ab".into()), Ok((<&str as Into<_>>::into("ab"), NonZeroI32::new(411).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1144:36
[INFO] [stdout]      |
[INFO] [stdout] 1144 |         assert_eq!(stdp::I32.parse("".into()), Err(()));
[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] 1144 -         assert_eq!(stdp::I32.parse("".into()), Err(()));
[INFO] [stdout] 1144 +         assert_eq!(stdp::I32.parse(""), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1144 -         assert_eq!(stdp::I32.parse("".into()), Err(()));
[INFO] [stdout] 1144 +         assert_eq!(stdp::I32.parse(<&str as Into<_>>::into("")), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1145:36
[INFO] [stdout]      |
[INFO] [stdout] 1145 |         assert_eq!(stdp::I32.parse("-3".into()), Ok(("".into(), NonZeroI32::new(-3).unwrap())));
[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] 1145 -         assert_eq!(stdp::I32.parse("-3".into()), Ok(("".into(), NonZeroI32::new(-3).unwrap())));
[INFO] [stdout] 1145 +         assert_eq!(stdp::I32.parse("-3"), Ok(("".into(), NonZeroI32::new(-3).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1145 -         assert_eq!(stdp::I32.parse("-3".into()), Ok(("".into(), NonZeroI32::new(-3).unwrap())));
[INFO] [stdout] 1145 +         assert_eq!(stdp::I32.parse(<&str as Into<_>>::into("-3")), Ok(("".into(), NonZeroI32::new(-3).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1145:54
[INFO] [stdout]      |
[INFO] [stdout] 1145 |         assert_eq!(stdp::I32.parse("-3".into()), Ok(("".into(), NonZeroI32::new(-3).unwrap())));
[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] 1145 -         assert_eq!(stdp::I32.parse("-3".into()), Ok(("".into(), NonZeroI32::new(-3).unwrap())));
[INFO] [stdout] 1145 +         assert_eq!(stdp::I32.parse("-3".into()), Ok(("", NonZeroI32::new(-3).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1145 -         assert_eq!(stdp::I32.parse("-3".into()), Ok(("".into(), NonZeroI32::new(-3).unwrap())));
[INFO] [stdout] 1145 +         assert_eq!(stdp::I32.parse("-3".into()), Ok((<&str as Into<_>>::into(""), NonZeroI32::new(-3).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1146:36
[INFO] [stdout]      |
[INFO] [stdout] 1146 |         assert_eq!(stdp::I32.parse("0x03".into()), Err(()));
[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 -         assert_eq!(stdp::I32.parse("0x03".into()), Err(()));
[INFO] [stdout] 1146 +         assert_eq!(stdp::I32.parse("0x03"), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1146 -         assert_eq!(stdp::I32.parse("0x03".into()), Err(()));
[INFO] [stdout] 1146 +         assert_eq!(stdp::I32.parse(<&str as Into<_>>::into("0x03")), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1147:36
[INFO] [stdout]      |
[INFO] [stdout] 1147 |         assert_eq!(stdp::I32.parse("-".into()), Err(()));
[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] 1147 -         assert_eq!(stdp::I32.parse("-".into()), Err(()));
[INFO] [stdout] 1147 +         assert_eq!(stdp::I32.parse("-"), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1147 -         assert_eq!(stdp::I32.parse("-".into()), Err(()));
[INFO] [stdout] 1147 +         assert_eq!(stdp::I32.parse(<&str as Into<_>>::into("-")), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1158:43
[INFO] [stdout]      |
[INFO] [stdout] 1158 |         assert_eq!(do_unquote_non_escaped(r#""411""#.into()), Ok(("".into(), "411".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] 1158 -         assert_eq!(do_unquote_non_escaped(r#""411""#.into()), Ok(("".into(), "411".into())));
[INFO] [stdout] 1158 +         assert_eq!(do_unquote_non_escaped(r#""411""#), Ok(("".into(), "411".into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1158 -         assert_eq!(do_unquote_non_escaped(r#""411""#.into()), Ok(("".into(), "411".into())));
[INFO] [stdout] 1158 +         assert_eq!(do_unquote_non_escaped(<&str as Into<_>>::into(r#""411""#)), Ok(("".into(), "411".into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1158:67
[INFO] [stdout]      |
[INFO] [stdout] 1158 |         assert_eq!(do_unquote_non_escaped(r#""411""#.into()), Ok(("".into(), "411".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] 1158 -         assert_eq!(do_unquote_non_escaped(r#""411""#.into()), Ok(("".into(), "411".into())));
[INFO] [stdout] 1158 +         assert_eq!(do_unquote_non_escaped(r#""411""#.into()), Ok(("", "411".into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1158 -         assert_eq!(do_unquote_non_escaped(r#""411""#.into()), Ok(("".into(), "411".into())));
[INFO] [stdout] 1158 +         assert_eq!(do_unquote_non_escaped(r#""411""#.into()), Ok((<&str as Into<_>>::into(""), "411".into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1159:43
[INFO] [stdout]      |
[INFO] [stdout] 1159 |         assert_eq!(do_unquote_non_escaped(r#" "411""#.into()), Err(()));
[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] 1159 -         assert_eq!(do_unquote_non_escaped(r#" "411""#.into()), Err(()));
[INFO] [stdout] 1159 +         assert_eq!(do_unquote_non_escaped(r#" "411""#), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1159 -         assert_eq!(do_unquote_non_escaped(r#" "411""#.into()), Err(()));
[INFO] [stdout] 1159 +         assert_eq!(do_unquote_non_escaped(<&str as Into<_>>::into(r#" "411""#)), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1160:43
[INFO] [stdout]      |
[INFO] [stdout] 1160 |         assert_eq!(do_unquote_non_escaped(r#"411"#.into()), Err(()));
[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] 1160 -         assert_eq!(do_unquote_non_escaped(r#"411"#.into()), Err(()));
[INFO] [stdout] 1160 +         assert_eq!(do_unquote_non_escaped(r#"411"#), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1160 -         assert_eq!(do_unquote_non_escaped(r#"411"#.into()), Err(()));
[INFO] [stdout] 1160 +         assert_eq!(do_unquote_non_escaped(<&str as Into<_>>::into(r#"411"#)), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1165:34
[INFO] [stdout]      |
[INFO] [stdout] 1165 |         assert_eq!(Unquote.parse(r#""411""#.into()), Ok(("".into(), "411".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] 1165 -         assert_eq!(Unquote.parse(r#""411""#.into()), Ok(("".into(), "411".into())));
[INFO] [stdout] 1165 +         assert_eq!(Unquote.parse(r#""411""#), Ok(("".into(), "411".into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1165 -         assert_eq!(Unquote.parse(r#""411""#.into()), Ok(("".into(), "411".into())));
[INFO] [stdout] 1165 +         assert_eq!(Unquote.parse(<&str as Into<_>>::into(r#""411""#)), Ok(("".into(), "411".into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1165:58
[INFO] [stdout]      |
[INFO] [stdout] 1165 |         assert_eq!(Unquote.parse(r#""411""#.into()), Ok(("".into(), "411".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] 1165 -         assert_eq!(Unquote.parse(r#""411""#.into()), Ok(("".into(), "411".into())));
[INFO] [stdout] 1165 +         assert_eq!(Unquote.parse(r#""411""#.into()), Ok(("", "411".into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1165 -         assert_eq!(Unquote.parse(r#""411""#.into()), Ok(("".into(), "411".into())));
[INFO] [stdout] 1165 +         assert_eq!(Unquote.parse(r#""411""#.into()), Ok((<&str as Into<_>>::into(""), "411".into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1166:34
[INFO] [stdout]      |
[INFO] [stdout] 1166 |         assert_eq!(Unquote.parse(r#" "411""#.into()), Err(()));
[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 -         assert_eq!(Unquote.parse(r#" "411""#.into()), Err(()));
[INFO] [stdout] 1166 +         assert_eq!(Unquote.parse(r#" "411""#), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1166 -         assert_eq!(Unquote.parse(r#" "411""#.into()), Err(()));
[INFO] [stdout] 1166 +         assert_eq!(Unquote.parse(<&str as Into<_>>::into(r#" "411""#)), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1167:34
[INFO] [stdout]      |
[INFO] [stdout] 1167 |         assert_eq!(Unquote.parse(r#"411"#.into()), Err(()));
[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] 1167 -         assert_eq!(Unquote.parse(r#"411"#.into()), Err(()));
[INFO] [stdout] 1167 +         assert_eq!(Unquote.parse(r#"411"#), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1167 -         assert_eq!(Unquote.parse(r#"411"#.into()), Err(()));
[INFO] [stdout] 1167 +         assert_eq!(Unquote.parse(<&str as Into<_>>::into(r#"411"#)), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1169:34
[INFO] [stdout]      |
[INFO] [stdout] 1169 |         assert_eq!(Unquote.parse(r#""ni\\c\"e""#.into()), Ok(("".into(), r#"ni\c"e"#.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 -         assert_eq!(Unquote.parse(r#""ni\\c\"e""#.into()), Ok(("".into(), r#"ni\c"e"#.into())));
[INFO] [stdout] 1169 +         assert_eq!(Unquote.parse(r#""ni\\c\"e""#), Ok(("".into(), r#"ni\c"e"#.into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         assert_eq!(Unquote.parse(r#""ni\\c\"e""#.into()), Ok(("".into(), r#"ni\c"e"#.into())));
[INFO] [stdout] 1169 +         assert_eq!(Unquote.parse(<&str as Into<_>>::into(r#""ni\\c\"e""#)), Ok(("".into(), r#"ni\c"e"#.into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1169:63
[INFO] [stdout]      |
[INFO] [stdout] 1169 |         assert_eq!(Unquote.parse(r#""ni\\c\"e""#.into()), Ok(("".into(), r#"ni\c"e"#.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 -         assert_eq!(Unquote.parse(r#""ni\\c\"e""#.into()), Ok(("".into(), r#"ni\c"e"#.into())));
[INFO] [stdout] 1169 +         assert_eq!(Unquote.parse(r#""ni\\c\"e""#.into()), Ok(("", r#"ni\c"e"#.into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1169 -         assert_eq!(Unquote.parse(r#""ni\\c\"e""#.into()), Ok(("".into(), r#"ni\c"e"#.into())));
[INFO] [stdout] 1169 +         assert_eq!(Unquote.parse(r#""ni\\c\"e""#.into()), Ok((<&str as Into<_>>::into(""), r#"ni\c"e"#.into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1174:38
[INFO] [stdout]      |
[INFO] [stdout] 1174 |         assert_eq!(tag("key=").parse("key=value".into()), Ok(("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] 1174 -         assert_eq!(tag("key=").parse("key=value".into()), Ok(("value".into(), ())));
[INFO] [stdout] 1174 +         assert_eq!(tag("key=").parse("key=value"), Ok(("value".into(), ())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1174 -         assert_eq!(tag("key=").parse("key=value".into()), Ok(("value".into(), ())));
[INFO] [stdout] 1174 +         assert_eq!(tag("key=").parse(<&str as Into<_>>::into("key=value")), Ok(("value".into(), ())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1174:63
[INFO] [stdout]      |
[INFO] [stdout] 1174 |         assert_eq!(tag("key=").parse("key=value".into()), Ok(("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] 1174 -         assert_eq!(tag("key=").parse("key=value".into()), Ok(("value".into(), ())));
[INFO] [stdout] 1174 +         assert_eq!(tag("key=").parse("key=value".into()), Ok(("value", ())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1174 -         assert_eq!(tag("key=").parse("key=value".into()), Ok(("value".into(), ())));
[INFO] [stdout] 1174 +         assert_eq!(tag("key=").parse("key=value".into()), Ok((<&str as Into<_>>::into("value"), ())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1175:38
[INFO] [stdout]      |
[INFO] [stdout] 1175 |         assert_eq!(tag("key=").parse("key:value".into()), Err(()));
[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] 1175 -         assert_eq!(tag("key=").parse("key:value".into()), Err(()));
[INFO] [stdout] 1175 +         assert_eq!(tag("key=").parse("key:value"), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1175 -         assert_eq!(tag("key=").parse("key:value".into()), Err(()));
[INFO] [stdout] 1175 +         assert_eq!(tag("key=").parse(<&str as Into<_>>::into("key:value")), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1180:44
[INFO] [stdout]      |
[INFO] [stdout] 1180 |         assert_eq!(quoted_tag("key").parse(r#""key"=value"#.into()), Ok(("=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] 1180 -         assert_eq!(quoted_tag("key").parse(r#""key"=value"#.into()), Ok(("=value".into(), ())));
[INFO] [stdout] 1180 +         assert_eq!(quoted_tag("key").parse(r#""key"=value"#), Ok(("=value".into(), ())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1180 -         assert_eq!(quoted_tag("key").parse(r#""key"=value"#.into()), Ok(("=value".into(), ())));
[INFO] [stdout] 1180 +         assert_eq!(quoted_tag("key").parse(<&str as Into<_>>::into(r#""key"=value"#)), Ok(("=value".into(), ())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1180:74
[INFO] [stdout]      |
[INFO] [stdout] 1180 |         assert_eq!(quoted_tag("key").parse(r#""key"=value"#.into()), Ok(("=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] 1180 -         assert_eq!(quoted_tag("key").parse(r#""key"=value"#.into()), Ok(("=value".into(), ())));
[INFO] [stdout] 1180 +         assert_eq!(quoted_tag("key").parse(r#""key"=value"#.into()), Ok(("=value", ())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1180 -         assert_eq!(quoted_tag("key").parse(r#""key"=value"#.into()), Ok(("=value".into(), ())));
[INFO] [stdout] 1180 +         assert_eq!(quoted_tag("key").parse(r#""key"=value"#.into()), Ok((<&str as Into<_>>::into("=value"), ())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1181:44
[INFO] [stdout]      |
[INFO] [stdout] 1181 |         assert_eq!(quoted_tag("key").parse(r#""key:"value"#.into()), Err(()));
[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] 1181 -         assert_eq!(quoted_tag("key").parse(r#""key:"value"#.into()), Err(()));
[INFO] [stdout] 1181 +         assert_eq!(quoted_tag("key").parse(r#""key:"value"#), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1181 -         assert_eq!(quoted_tag("key").parse(r#""key:"value"#.into()), Err(()));
[INFO] [stdout] 1181 +         assert_eq!(quoted_tag("key").parse(<&str as Into<_>>::into(r#""key:"value"#)), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1182:44
[INFO] [stdout]      |
[INFO] [stdout] 1182 |         assert_eq!(quoted_tag("key").parse(r#"key=value"#.into()), Err(()));
[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] 1182 -         assert_eq!(quoted_tag("key").parse(r#"key=value"#.into()), Err(()));
[INFO] [stdout] 1182 +         assert_eq!(quoted_tag("key").parse(r#"key=value"#), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1182 -         assert_eq!(quoted_tag("key").parse(r#"key=value"#.into()), Err(()));
[INFO] [stdout] 1182 +         assert_eq!(quoted_tag("key").parse(<&str as Into<_>>::into(r#"key=value"#)), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1187:57
[INFO] [stdout]      |
[INFO] [stdout] 1187 |         assert_eq!(strip_whitespace(tag("hello")).parse(" hello world".into()), Ok(("world".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] 1187 -         assert_eq!(strip_whitespace(tag("hello")).parse(" hello world".into()), Ok(("world".into(), ())));
[INFO] [stdout] 1187 +         assert_eq!(strip_whitespace(tag("hello")).parse(" hello world"), Ok(("world".into(), ())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1187 -         assert_eq!(strip_whitespace(tag("hello")).parse(" hello world".into()), Ok(("world".into(), ())));
[INFO] [stdout] 1187 +         assert_eq!(strip_whitespace(tag("hello")).parse(<&str as Into<_>>::into(" hello world")), Ok(("world".into(), ())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1187:85
[INFO] [stdout]      |
[INFO] [stdout] 1187 |         assert_eq!(strip_whitespace(tag("hello")).parse(" hello world".into()), Ok(("world".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] 1187 -         assert_eq!(strip_whitespace(tag("hello")).parse(" hello world".into()), Ok(("world".into(), ())));
[INFO] [stdout] 1187 +         assert_eq!(strip_whitespace(tag("hello")).parse(" hello world".into()), Ok(("world", ())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1187 -         assert_eq!(strip_whitespace(tag("hello")).parse(" hello world".into()), Ok(("world".into(), ())));
[INFO] [stdout] 1187 +         assert_eq!(strip_whitespace(tag("hello")).parse(" hello world".into()), Ok((<&str as Into<_>>::into("world"), ())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1188:57
[INFO] [stdout]      |
[INFO] [stdout] 1188 |         assert_eq!(strip_whitespace(tag("hello")).parse("hello".into()), Ok(("".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] 1188 -         assert_eq!(strip_whitespace(tag("hello")).parse("hello".into()), Ok(("".into(), ())));
[INFO] [stdout] 1188 +         assert_eq!(strip_whitespace(tag("hello")).parse("hello"), Ok(("".into(), ())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1188 -         assert_eq!(strip_whitespace(tag("hello")).parse("hello".into()), Ok(("".into(), ())));
[INFO] [stdout] 1188 +         assert_eq!(strip_whitespace(tag("hello")).parse(<&str as Into<_>>::into("hello")), Ok(("".into(), ())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1188:78
[INFO] [stdout]      |
[INFO] [stdout] 1188 |         assert_eq!(strip_whitespace(tag("hello")).parse("hello".into()), Ok(("".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] 1188 -         assert_eq!(strip_whitespace(tag("hello")).parse("hello".into()), Ok(("".into(), ())));
[INFO] [stdout] 1188 +         assert_eq!(strip_whitespace(tag("hello")).parse("hello".into()), Ok(("", ())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1188 -         assert_eq!(strip_whitespace(tag("hello")).parse("hello".into()), Ok(("".into(), ())));
[INFO] [stdout] 1188 +         assert_eq!(strip_whitespace(tag("hello")).parse("hello".into()), Ok((<&str as Into<_>>::into(""), ())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1189:54
[INFO] [stdout]      |
[INFO] [stdout] 1189 |         assert_eq!(strip_whitespace(stdp::U32).parse(" 42 answer".into()), Ok(("answer".into(), NonZeroU32::new(42).unwrap())));
[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] 1189 -         assert_eq!(strip_whitespace(stdp::U32).parse(" 42 answer".into()), Ok(("answer".into(), NonZeroU32::new(42).unwrap())));
[INFO] [stdout] 1189 +         assert_eq!(strip_whitespace(stdp::U32).parse(" 42 answer"), Ok(("answer".into(), NonZeroU32::new(42).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1189 -         assert_eq!(strip_whitespace(stdp::U32).parse(" 42 answer".into()), Ok(("answer".into(), NonZeroU32::new(42).unwrap())));
[INFO] [stdout] 1189 +         assert_eq!(strip_whitespace(stdp::U32).parse(<&str as Into<_>>::into(" 42 answer")), Ok(("answer".into(), NonZeroU32::new(42).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1189:80
[INFO] [stdout]      |
[INFO] [stdout] 1189 |         assert_eq!(strip_whitespace(stdp::U32).parse(" 42 answer".into()), Ok(("answer".into(), NonZeroU32::new(42).unwrap())));
[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] 1189 -         assert_eq!(strip_whitespace(stdp::U32).parse(" 42 answer".into()), Ok(("answer".into(), NonZeroU32::new(42).unwrap())));
[INFO] [stdout] 1189 +         assert_eq!(strip_whitespace(stdp::U32).parse(" 42 answer".into()), Ok(("answer", NonZeroU32::new(42).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1189 -         assert_eq!(strip_whitespace(stdp::U32).parse(" 42 answer".into()), Ok(("answer".into(), NonZeroU32::new(42).unwrap())));
[INFO] [stdout] 1189 +         assert_eq!(strip_whitespace(stdp::U32).parse(" 42 answer".into()), Ok((<&str as Into<_>>::into("answer"), NonZeroU32::new(42).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1194:67
[INFO] [stdout]      |
[INFO] [stdout] 1194 |         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse("[0x32]".into()), Ok(("".into(), NonZeroU32::new(0x32).unwrap())));
[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] 1194 -         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse("[0x32]".into()), Ok(("".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1194 +         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse("[0x32]"), Ok(("".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1194 -         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse("[0x32]".into()), Ok(("".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1194 +         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse(<&str as Into<_>>::into("[0x32]")), Ok(("".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1194:89
[INFO] [stdout]      |
[INFO] [stdout] 1194 |         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse("[0x32]".into()), Ok(("".into(), NonZeroU32::new(0x32).unwrap())));
[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] 1194 -         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse("[0x32]".into()), Ok(("".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1194 +         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse("[0x32]".into()), Ok(("", NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1194 -         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse("[0x32]".into()), Ok(("".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1194 +         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse("[0x32]".into()), Ok((<&str as Into<_>>::into(""), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1195:34
[INFO] [stdout]      |
[INFO] [stdout] 1195 | ...   assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU3...
[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] 1195 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1195 +         assert_eq!(delimited(tag("["), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1195 +         assert_eq!(delimited(tag(<&str as Into<_>>::into("[")), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1195:62
[INFO] [stdout]      |
[INFO] [stdout] 1195 | ...   assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU3...
[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] 1195 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1195 +         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1195 +         assert_eq!(delimited(tag("[".into()), stdp::U32, tag(<&str as Into<_>>::into("]"))).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1195:81
[INFO] [stdout]      |
[INFO] [stdout] 1195 | ...   assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU3...
[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] 1195 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1195 +         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice"), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1195 +         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse(<&str as Into<_>>::into("[0x32] nice")), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1195:108
[INFO] [stdout]      |
[INFO] [stdout] 1195 | ...   assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU3...
[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] 1195 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1195 +         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice", NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((" nice".into(), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout] 1195 +         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]".into())).parse("[0x32] nice".into()), Ok((<&str as Into<_>>::into(" nice"), NonZeroU32::new(0x32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1196:34
[INFO] [stdout]      |
[INFO] [stdout] 1196 |         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("0x32]".into()), Err(()));
[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] 1196 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("0x32]".into()), Err(()));
[INFO] [stdout] 1196 +         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse("0x32]".into()), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1196 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("0x32]".into()), Err(()));
[INFO] [stdout] 1196 +         assert_eq!(delimited(tag(<&str as Into<_>>::into("[")), stdp::U32, tag("]")).parse("0x32]".into()), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1196:74
[INFO] [stdout]      |
[INFO] [stdout] 1196 |         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("0x32]".into()), Err(()));
[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] 1196 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("0x32]".into()), Err(()));
[INFO] [stdout] 1196 +         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("0x32]"), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1196 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("0x32]".into()), Err(()));
[INFO] [stdout] 1196 +         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse(<&str as Into<_>>::into("0x32]")), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1197:34
[INFO] [stdout]      |
[INFO] [stdout] 1197 |         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("[0x32".into()), Err(()));
[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 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("[0x32".into()), Err(()));
[INFO] [stdout] 1197 +         assert_eq!(delimited(tag("["), stdp::U32, tag("]")).parse("[0x32".into()), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1197 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("[0x32".into()), Err(()));
[INFO] [stdout] 1197 +         assert_eq!(delimited(tag(<&str as Into<_>>::into("[")), stdp::U32, tag("]")).parse("[0x32".into()), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1197:74
[INFO] [stdout]      |
[INFO] [stdout] 1197 |         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("[0x32".into()), Err(()));
[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 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("[0x32".into()), Err(()));
[INFO] [stdout] 1197 +         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("[0x32"), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1197 -         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse("[0x32".into()), Err(()));
[INFO] [stdout] 1197 +         assert_eq!(delimited(tag("[".into()), stdp::U32, tag("]")).parse(<&str as Into<_>>::into("[0x32")), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1202:54
[INFO] [stdout]      |
[INFO] [stdout] 1202 |         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32,"#.into()), Ok(("".into(), NonZeroU32::new(32).unwrap())));
[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] 1202 -         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32,"#.into()), Ok(("".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout] 1202 +         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32,"#), Ok(("".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1202 -         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32,"#.into()), Ok(("".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout] 1202 +         assert_eq!(key_value("key", stdp::U32).parse(<&str as Into<_>>::into(r#""key":32,"#)), Ok(("".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1202:82
[INFO] [stdout]      |
[INFO] [stdout] 1202 |         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32,"#.into()), Ok(("".into(), NonZeroU32::new(32).unwrap())));
[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] 1202 -         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32,"#.into()), Ok(("".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout] 1202 +         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32,"#.into()), Ok(("", NonZeroU32::new(32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1202 -         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32,"#.into()), Ok(("".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout] 1202 +         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32,"#.into()), Ok((<&str as Into<_>>::into(""), NonZeroU32::new(32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1203:54
[INFO] [stdout]      |
[INFO] [stdout] 1203 |         assert_eq!(key_value("key", stdp::U32).parse(r#"key:32,"#.into()), Err(()));
[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 -         assert_eq!(key_value("key", stdp::U32).parse(r#"key:32,"#.into()), Err(()));
[INFO] [stdout] 1203 +         assert_eq!(key_value("key", stdp::U32).parse(r#"key:32,"#), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1203 -         assert_eq!(key_value("key", stdp::U32).parse(r#"key:32,"#.into()), Err(()));
[INFO] [stdout] 1203 +         assert_eq!(key_value("key", stdp::U32).parse(<&str as Into<_>>::into(r#"key:32,"#)), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1204:54
[INFO] [stdout]      |
[INFO] [stdout] 1204 |         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32"#.into()), Err(()));
[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] 1204 -         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32"#.into()), Err(()));
[INFO] [stdout] 1204 +         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32"#), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1204 -         assert_eq!(key_value("key", stdp::U32).parse(r#""key":32"#.into()), Err(()));
[INFO] [stdout] 1204 +         assert_eq!(key_value("key", stdp::U32).parse(<&str as Into<_>>::into(r#""key":32"#)), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1205:54
[INFO] [stdout]      |
[INFO] [stdout] 1205 | ...   assert_eq!(key_value("key", stdp::U32).parse(r#" "key" : 32 , nice"#.into()), Ok(("nice".into(), NonZeroU32::new(32).unwrap(...
[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] 1205 -         assert_eq!(key_value("key", stdp::U32).parse(r#" "key" : 32 , nice"#.into()), Ok(("nice".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout] 1205 +         assert_eq!(key_value("key", stdp::U32).parse(r#" "key" : 32 , nice"#), Ok(("nice".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1205 -         assert_eq!(key_value("key", stdp::U32).parse(r#" "key" : 32 , nice"#.into()), Ok(("nice".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout] 1205 +         assert_eq!(key_value("key", stdp::U32).parse(<&str as Into<_>>::into(r#" "key" : 32 , nice"#)), Ok(("nice".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1205:91
[INFO] [stdout]      |
[INFO] [stdout] 1205 | ...   assert_eq!(key_value("key", stdp::U32).parse(r#" "key" : 32 , nice"#.into()), Ok(("nice".into(), NonZeroU32::new(32).unwrap(...
[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] 1205 -         assert_eq!(key_value("key", stdp::U32).parse(r#" "key" : 32 , nice"#.into()), Ok(("nice".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout] 1205 +         assert_eq!(key_value("key", stdp::U32).parse(r#" "key" : 32 , nice"#.into()), Ok(("nice", NonZeroU32::new(32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1205 -         assert_eq!(key_value("key", stdp::U32).parse(r#" "key" : 32 , nice"#.into()), Ok(("nice".into(), NonZeroU32::new(32).unwrap())));
[INFO] [stdout] 1205 +         assert_eq!(key_value("key", stdp::U32).parse(r#" "key" : 32 , nice"#.into()), Ok((<&str as Into<_>>::into("nice"), NonZeroU32::new(32).unwrap())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1210:42
[INFO] [stdout]      |
[INFO] [stdout] 1210 | ...   assert_eq!(list(stdp::U32).parse("[1,2,3,4,]".into()), Ok(("".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).u...
[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] 1210 -         assert_eq!(list(stdp::U32).parse("[1,2,3,4,]".into()), Ok(("".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout] 1210 +         assert_eq!(list(stdp::U32).parse("[1,2,3,4,]"), Ok(("".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1210 -         assert_eq!(list(stdp::U32).parse("[1,2,3,4,]".into()), Ok(("".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout] 1210 +         assert_eq!(list(stdp::U32).parse(<&str as Into<_>>::into("[1,2,3,4,]")), Ok(("".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1210:68
[INFO] [stdout]      |
[INFO] [stdout] 1210 | ...   assert_eq!(list(stdp::U32).parse("[1,2,3,4,]".into()), Ok(("".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).u...
[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] 1210 -         assert_eq!(list(stdp::U32).parse("[1,2,3,4,]".into()), Ok(("".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout] 1210 +         assert_eq!(list(stdp::U32).parse("[1,2,3,4,]".into()), Ok(("", vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1210 -         assert_eq!(list(stdp::U32).parse("[1,2,3,4,]".into()), Ok(("".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout] 1210 +         assert_eq!(list(stdp::U32).parse("[1,2,3,4,]".into()), Ok((<&str as Into<_>>::into(""), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1211:42
[INFO] [stdout]      |
[INFO] [stdout] 1211 | ...   assert_eq!(list(stdp::U32).parse(" [ 1 , 2 , 3 , 4 , ] nice".into()), Ok(("nice".into(), vec![NonZeroU32::new(1).unwrap(), N...
[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 -         assert_eq!(list(stdp::U32).parse(" [ 1 , 2 , 3 , 4 , ] nice".into()), Ok(("nice".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout] 1211 +         assert_eq!(list(stdp::U32).parse(" [ 1 , 2 , 3 , 4 , ] nice"), Ok(("nice".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1211 -         assert_eq!(list(stdp::U32).parse(" [ 1 , 2 , 3 , 4 , ] nice".into()), Ok(("nice".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout] 1211 +         assert_eq!(list(stdp::U32).parse(<&str as Into<_>>::into(" [ 1 , 2 , 3 , 4 , ] nice")), Ok(("nice".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1211:83
[INFO] [stdout]      |
[INFO] [stdout] 1211 | ...   assert_eq!(list(stdp::U32).parse(" [ 1 , 2 , 3 , 4 , ] nice".into()), Ok(("nice".into(), vec![NonZeroU32::new(1).unwrap(), N...
[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 -         assert_eq!(list(stdp::U32).parse(" [ 1 , 2 , 3 , 4 , ] nice".into()), Ok(("nice".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout] 1211 +         assert_eq!(list(stdp::U32).parse(" [ 1 , 2 , 3 , 4 , ] nice".into()), Ok(("nice", vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1211 -         assert_eq!(list(stdp::U32).parse(" [ 1 , 2 , 3 , 4 , ] nice".into()), Ok(("nice".into(), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout] 1211 +         assert_eq!(list(stdp::U32).parse(" [ 1 , 2 , 3 , 4 , ] nice".into()), Ok((<&str as Into<_>>::into("nice"), vec![NonZeroU32::new(1).unwrap(), NonZeroU32::new(2).unwrap(), NonZeroU32::new(3).unwrap(), NonZeroU32::new(4).unwrap()])));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1212:42
[INFO] [stdout]      |
[INFO] [stdout] 1212 |         assert_eq!(list(stdp::U32).parse("1,2,3,4,".into()), Err(()));
[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] 1212 -         assert_eq!(list(stdp::U32).parse("1,2,3,4,".into()), Err(()));
[INFO] [stdout] 1212 +         assert_eq!(list(stdp::U32).parse("1,2,3,4,"), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1212 -         assert_eq!(list(stdp::U32).parse("1,2,3,4,".into()), Err(()));
[INFO] [stdout] 1212 +         assert_eq!(list(stdp::U32).parse(<&str as Into<_>>::into("1,2,3,4,")), Err(()));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1213:42
[INFO] [stdout]      |
[INFO] [stdout] 1213 |         assert_eq!(list(stdp::U32).parse("[]".into()), Ok(("".into(), vec![])));
[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] 1213 -         assert_eq!(list(stdp::U32).parse("[]".into()), Ok(("".into(), vec![])));
[INFO] [stdout] 1213 +         assert_eq!(list(stdp::U32).parse("[]"), Ok(("".into(), vec![])));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1213 -         assert_eq!(list(stdp::U32).parse("[]".into()), Ok(("".into(), vec![])));
[INFO] [stdout] 1213 +         assert_eq!(list(stdp::U32).parse(<&str as Into<_>>::into("[]")), Ok(("".into(), vec![])));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1213:60
[INFO] [stdout]      |
[INFO] [stdout] 1213 |         assert_eq!(list(stdp::U32).parse("[]".into()), Ok(("".into(), vec![])));
[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] 1213 -         assert_eq!(list(stdp::U32).parse("[]".into()), Ok(("".into(), vec![])));
[INFO] [stdout] 1213 +         assert_eq!(list(stdp::U32).parse("[]".into()), Ok(("", vec![])));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1213 -         assert_eq!(list(stdp::U32).parse("[]".into()), Ok(("".into(), vec![])));
[INFO] [stdout] 1213 +         assert_eq!(list(stdp::U32).parse("[]".into()), Ok((<&str as Into<_>>::into(""), vec![])));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1226:93
[INFO] [stdout]      |
[INFO] [stdout] 1226 | ...   assert_eq!(all2(strip_whitespace(tag("AssetDsc")),strip_whitespace(tag("{"))).parse(" AssetDsc { ".into()), Ok(("".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] 1226 -         assert_eq!(all2(strip_whitespace(tag("AssetDsc")),strip_whitespace(tag("{"))).parse(" AssetDsc { ".into()), Ok(("".into(), ((),()))));
[INFO] [stdout] 1226 +         assert_eq!(all2(strip_whitespace(tag("AssetDsc")),strip_whitespace(tag("{"))).parse(" AssetDsc { "), Ok(("".into(), ((),()))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1226 -         assert_eq!(all2(strip_whitespace(tag("AssetDsc")),strip_whitespace(tag("{"))).parse(" AssetDsc { ".into()), Ok(("".into(), ((),()))));
[INFO] [stdout] 1226 +         assert_eq!(all2(strip_whitespace(tag("AssetDsc")),strip_whitespace(tag("{"))).parse(<&str as Into<_>>::into(" AssetDsc { ")), Ok(("".into(), ((),()))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1226:121
[INFO] [stdout]      |
[INFO] [stdout] 1226 | ...   assert_eq!(all2(strip_whitespace(tag("AssetDsc")),strip_whitespace(tag("{"))).parse(" AssetDsc { ".into()), Ok(("".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] 1226 -         assert_eq!(all2(strip_whitespace(tag("AssetDsc")),strip_whitespace(tag("{"))).parse(" AssetDsc { ".into()), Ok(("".into(), ((),()))));
[INFO] [stdout] 1226 +         assert_eq!(all2(strip_whitespace(tag("AssetDsc")),strip_whitespace(tag("{"))).parse(" AssetDsc { ".into()), Ok(("", ((),()))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1226 -         assert_eq!(all2(strip_whitespace(tag("AssetDsc")),strip_whitespace(tag("{"))).parse(" AssetDsc { ".into()), Ok(("".into(), ((),()))));
[INFO] [stdout] 1226 +         assert_eq!(all2(strip_whitespace(tag("AssetDsc")),strip_whitespace(tag("{"))).parse(" AssetDsc { ".into()), Ok((<&str as Into<_>>::into(""), ((),()))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1228:45
[INFO] [stdout]      |
[INFO] [stdout] 1228 | ...   assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"id":"usd","dsc":"USA dollar",}"#.into()), Ok(("".into(), AssetDsc{id: "usd"...
[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] 1228 -         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"id":"usd","dsc":"USA dollar",}"#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1228 +         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"id":"usd","dsc":"USA dollar",}"#), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1228 -         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"id":"usd","dsc":"USA dollar",}"#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1228 +         assert_eq!(AssetDsc::parser().parse(<&str as Into<_>>::into(r#"AssetDsc{"id":"usd","dsc":"USA dollar",}"#)), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1228:104
[INFO] [stdout]      |
[INFO] [stdout] 1228 | ...   assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"id":"usd","dsc":"USA dollar",}"#.into()), Ok(("".into(), AssetDsc{id: "usd"...
[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] 1228 -         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"id":"usd","dsc":"USA dollar",}"#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1228 +         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"id":"usd","dsc":"USA dollar",}"#.into()), Ok(("", AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1228 -         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"id":"usd","dsc":"USA dollar",}"#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1228 +         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"id":"usd","dsc":"USA dollar",}"#.into()), Ok((<&str as Into<_>>::into(""), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1229:45
[INFO] [stdout]      |
[INFO] [stdout] 1229 | ...   assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } "#.into()), Ok(("".into(), AssetD...
[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] 1229 -         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } "#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1229 +         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } "#), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1229 -         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } "#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1229 +         assert_eq!(AssetDsc::parser().parse(<&str as Into<_>>::into(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } "#)), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1229:116
[INFO] [stdout]      |
[INFO] [stdout] 1229 | ...   assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } "#.into()), Ok(("".into(), AssetD...
[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] 1229 -         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } "#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1229 +         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } "#.into()), Ok(("", AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1229 -         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } "#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1229 +         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } "#.into()), Ok((<&str as Into<_>>::into(""), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1230:45
[INFO] [stdout]      |
[INFO] [stdout] 1230 | ...   assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } nice "#.into()), Ok(("nice ".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] 1230 -         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } nice "#.into()), Ok(("nice ".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1230 +         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } nice "#), Ok(("nice ".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1230 -         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } nice "#.into()), Ok(("nice ".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1230 +         assert_eq!(AssetDsc::parser().parse(<&str as Into<_>>::into(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } nice "#)), Ok(("nice ".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1230:121
[INFO] [stdout]      |
[INFO] [stdout] 1230 | ...: "usd" , "dsc" : "USA dollar" , } nice "#.into()), Ok(("nice ".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".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] 1230 -         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } nice "#.into()), Ok(("nice ".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1230 +         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } nice "#.into()), Ok(("nice ", AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1230 -         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } nice "#.into()), Ok(("nice ".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1230 +         assert_eq!(AssetDsc::parser().parse(r#" AssetDsc { "id" : "usd" , "dsc" : "USA dollar" , } nice "#.into()), Ok((<&str as Into<_>>::into("nice "), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1232:45
[INFO] [stdout]      |
[INFO] [stdout] 1232 | ...   assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"dsc":"USA dollar","id":"usd",}"#.into()), Ok(("".into(), AssetDsc{id: "usd"...
[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] 1232 -         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"dsc":"USA dollar","id":"usd",}"#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1232 +         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"dsc":"USA dollar","id":"usd",}"#), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1232 -         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"dsc":"USA dollar","id":"usd",}"#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1232 +         assert_eq!(AssetDsc::parser().parse(<&str as Into<_>>::into(r#"AssetDsc{"dsc":"USA dollar","id":"usd",}"#)), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1232:104
[INFO] [stdout]      |
[INFO] [stdout] 1232 | ...   assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"dsc":"USA dollar","id":"usd",}"#.into()), Ok(("".into(), AssetDsc{id: "usd"...
[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] 1232 -         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"dsc":"USA dollar","id":"usd",}"#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1232 +         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"dsc":"USA dollar","id":"usd",}"#.into()), Ok(("", AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1232 -         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"dsc":"USA dollar","id":"usd",}"#.into()), Ok(("".into(), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout] 1232 +         assert_eq!(AssetDsc::parser().parse(r#"AssetDsc{"dsc":"USA dollar","id":"usd",}"#.into()), Ok((<&str as Into<_>>::into(""), AssetDsc{id: "usd".into(), dsc: "USA dollar".into()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1237:43
[INFO] [stdout]      |
[INFO] [stdout] 1237 | ...   assert_eq!(Backet::parser().parse(r#"Backet{"asset_id":"usd","count":42,}"#.into()), Ok(("".into(), Backet{asset_id: "usd".i...
[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] 1237 -         assert_eq!(Backet::parser().parse(r#"Backet{"asset_id":"usd","count":42,}"#.into()), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout] 1237 +         assert_eq!(Backet::parser().parse(r#"Backet{"asset_id":"usd","count":42,}"#), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1237 -         assert_eq!(Backet::parser().parse(r#"Backet{"asset_id":"usd","count":42,}"#.into()), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout] 1237 +         assert_eq!(Backet::parser().parse(<&str as Into<_>>::into(r#"Backet{"asset_id":"usd","count":42,}"#)), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1237:98
[INFO] [stdout]      |
[INFO] [stdout] 1237 | ...   assert_eq!(Backet::parser().parse(r#"Backet{"asset_id":"usd","count":42,}"#.into()), Ok(("".into(), Backet{asset_id: "usd".i...
[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] 1237 -         assert_eq!(Backet::parser().parse(r#"Backet{"asset_id":"usd","count":42,}"#.into()), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout] 1237 +         assert_eq!(Backet::parser().parse(r#"Backet{"asset_id":"usd","count":42,}"#.into()), Ok(("", Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1237 -         assert_eq!(Backet::parser().parse(r#"Backet{"asset_id":"usd","count":42,}"#.into()), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout] 1237 +         assert_eq!(Backet::parser().parse(r#"Backet{"asset_id":"usd","count":42,}"#.into()), Ok((<&str as Into<_>>::into(""), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1238:43
[INFO] [stdout]      |
[INFO] [stdout] 1238 | ...   assert_eq!(Backet::parser().parse(r#"Backet{"count":42,"asset_id":"usd",}"#.into()), Ok(("".into(), Backet{asset_id: "usd".i...
[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] 1238 -         assert_eq!(Backet::parser().parse(r#"Backet{"count":42,"asset_id":"usd",}"#.into()), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout] 1238 +         assert_eq!(Backet::parser().parse(r#"Backet{"count":42,"asset_id":"usd",}"#), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1238 -         assert_eq!(Backet::parser().parse(r#"Backet{"count":42,"asset_id":"usd",}"#.into()), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout] 1238 +         assert_eq!(Backet::parser().parse(<&str as Into<_>>::into(r#"Backet{"count":42,"asset_id":"usd",}"#)), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1238:98
[INFO] [stdout]      |
[INFO] [stdout] 1238 | ...   assert_eq!(Backet::parser().parse(r#"Backet{"count":42,"asset_id":"usd",}"#.into()), Ok(("".into(), Backet{asset_id: "usd".i...
[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] 1238 -         assert_eq!(Backet::parser().parse(r#"Backet{"count":42,"asset_id":"usd",}"#.into()), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout] 1238 +         assert_eq!(Backet::parser().parse(r#"Backet{"count":42,"asset_id":"usd",}"#.into()), Ok(("", Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1238 -         assert_eq!(Backet::parser().parse(r#"Backet{"count":42,"asset_id":"usd",}"#.into()), Ok(("".into(), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout] 1238 +         assert_eq!(Backet::parser().parse(r#"Backet{"count":42,"asset_id":"usd",}"#.into()), Ok((<&str as Into<_>>::into(""), Backet{asset_id: "usd".into(), count: NonZeroU32::new(42).unwrap()})));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1243:103
[INFO] [stdout]      |
[INFO] [stdout] 1243 | ...rror")), strip_whitespace(unquote())).parse(r#"NetworkError "url unknown""#.into()), Ok(("".into(), "url unknown".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] 1243 -         assert_eq!(preceded(strip_whitespace(tag("NetworkError")), strip_whitespace(unquote())).parse(r#"NetworkError "url unknown""#.into()), Ok(("".into(), "url unknown".into())));
[INFO] [stdout] 1243 +         assert_eq!(preceded(strip_whitespace(tag("NetworkError")), strip_whitespace(unquote())).parse(r#"NetworkError "url unknown""#), Ok(("".into(), "url unknown".into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1243 -         assert_eq!(preceded(strip_whitespace(tag("NetworkError")), strip_whitespace(unquote())).parse(r#"NetworkError "url unknown""#.into()), Ok(("".into(), "url unknown".into())));
[INFO] [stdout] 1243 +         assert_eq!(preceded(strip_whitespace(tag("NetworkError")), strip_whitespace(unquote())).parse(<&str as Into<_>>::into(r#"NetworkError "url unknown""#)), Ok(("".into(), "url unknown".into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1243:148
[INFO] [stdout]      |
[INFO] [stdout] 1243 | ...ote())).parse(r#"NetworkError "url unknown""#.into()), Ok(("".into(), "url unknown".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] 1243 -         assert_eq!(preceded(strip_whitespace(tag("NetworkError")), strip_whitespace(unquote())).parse(r#"NetworkError "url unknown""#.into()), Ok(("".into(), "url unknown".into())));
[INFO] [stdout] 1243 +         assert_eq!(preceded(strip_whitespace(tag("NetworkError")), strip_whitespace(unquote())).parse(r#"NetworkError "url unknown""#.into()), Ok(("", "url unknown".into())));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1243 -         assert_eq!(preceded(strip_whitespace(tag("NetworkError")), strip_whitespace(unquote())).parse(r#"NetworkError "url unknown""#.into()), Ok(("".into(), "url unknown".into())));
[INFO] [stdout] 1243 +         assert_eq!(preceded(strip_whitespace(tag("NetworkError")), strip_whitespace(unquote())).parse(r#"NetworkError "url unknown""#.into()), Ok((<&str as Into<_>>::into(""), "url unknown".into())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1245:44
[INFO] [stdout]      |
[INFO] [stdout] 1245 | ...   assert_eq!(LogKind::parser().parse(r#"System::Error NetworkError "url unknown""#.into()), Ok(("".into(), LogKind::System(Sys...
[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] 1245 -         assert_eq!(LogKind::parser().parse(r#"System::Error NetworkError "url unknown""#.into()), Ok(("".into(), LogKind::System(SystemLogKind::Error(SystemLogErrorKind::NetworkError("url unknown".into()))))));
[INFO] [stdout] 1245 +         assert_eq!(LogKind::parser().parse(r#"System::Error NetworkError "url unknown""#), Ok(("".into(), LogKind::System(SystemLogKind::Error(SystemLogErrorKind::NetworkError("url unknown".into()))))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1245 -         assert_eq!(LogKind::parser().parse(r#"System::Error NetworkError "url unknown""#.into()), Ok(("".into(), LogKind::System(SystemLogKind::Error(SystemLogErrorKind::NetworkError("url unknown".into()))))));
[INFO] [stdout] 1245 +         assert_eq!(LogKind::parser().parse(<&str as Into<_>>::into(r#"System::Error NetworkError "url unknown""#)), Ok(("".into(), LogKind::System(SystemLogKind::Error(SystemLogErrorKind::NetworkError("url unknown".into()))))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1245:103
[INFO] [stdout]      |
[INFO] [stdout] 1245 | ...   assert_eq!(LogKind::parser().parse(r#"System::Error NetworkError "url unknown""#.into()), Ok(("".into(), LogKind::System(Sys...
[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] 1245 -         assert_eq!(LogKind::parser().parse(r#"System::Error NetworkError "url unknown""#.into()), Ok(("".into(), LogKind::System(SystemLogKind::Error(SystemLogErrorKind::NetworkError("url unknown".into()))))));
[INFO] [stdout] 1245 +         assert_eq!(LogKind::parser().parse(r#"System::Error NetworkError "url unknown""#.into()), Ok(("", LogKind::System(SystemLogKind::Error(SystemLogErrorKind::NetworkError("url unknown".into()))))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1245 -         assert_eq!(LogKind::parser().parse(r#"System::Error NetworkError "url unknown""#.into()), Ok(("".into(), LogKind::System(SystemLogKind::Error(SystemLogErrorKind::NetworkError("url unknown".into()))))));
[INFO] [stdout] 1245 +         assert_eq!(LogKind::parser().parse(r#"System::Error NetworkError "url unknown""#.into()), Ok((<&str as Into<_>>::into(""), LogKind::System(SystemLogKind::Error(SystemLogErrorKind::NetworkError("url unknown".into()))))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1246:44
[INFO] [stdout]      |
[INFO] [stdout] 1246 | ...se(r#"App::Trace Connect 30c305825b900077ae7f82...d50d656456ea6c361b76508357714079424"#.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] 1246 -         assert_eq!(LogKind::parser().parse(r#"App::Trace Connect 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"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Trace(AppLogTraceKind::Connect(AuthData([0x30,0xc3,0x05,0x82,0x5b,0x90,0x00,0x77,0xae,0x7f,0x82,0x59,0xc1,0xc3,0x28,0xaa,0x3e,0x12,0x4a,0x07,0xf3,0xbf,0xbb,0xf2,0x16,0xdf,0xc6,0xe3,0x08,0xbe,0xea,0x6e,0x47,0x4b,0x9a,0x7e,0xa6,0xc2,0x4d,0x00,0x3a,0x6a,0xe4,0xfc,0xf0,0x4a,0x9e,0x6e,0xf7,0xc7,0xf1,0x7c,0xda,0xa0,0x29,0x6f,0x66,0xa8,0x80,0x36,0xba,0xdc,0xf0,0x1f,0x05,0x3d,0xa8,0x06,0xfa,0xd3,0x56,0x54,0x63,0x49,0xde,0xce,0xff,0x24,0x62,0x1b,0x89,0x54,0x40,0xd0,0x5a,0x71,0x5b,0x22,0x1a,0xf8,0xe9,0xe0,0x68,0x07,0x3d,0x6d,0xec,0x04,0xf1,0x48,0x17,0x57,0x17,0xd3,0xc2,0xd1,0xb6,0xaf,0x84,0xe2,0x37,0x57,0x18,0xab,0x4a,0x1e,0xba,0x7e,0x03,0x7c,0x1c,0x1d,0x43,0xb4,0xcf,0x42,0x2d,0x6f,0x2a,0xa9,0x19,0x42,0x66,0xf0,0xa7,0x54,0x4e,0xae,0xff,0x81,0x67,0xf0,0xe9,0x93,0xd0,0xea,0x6a,0x8d,0xdb,0x98,0xbf,0xeb,0x88,0x05,0x63,0x5d,0x5e,0xa9,0xf6,0x59,0x2f,0xd5,0x29,0x7e,0x6f,0x83,0xb6,0x83,0x41,0x90,0xf9,0x94,0x49,0x72,0x2c,0xd0,0xde,0x87,0xa4,0xc1,0x22,0xf0,0x8b,0xbe,0x83,0x6f,0xd3,0x09,0x2e,0x5f,0x0d,0x37,0xa3,0x05,0x7e,0x90,0xf3,0xdd,0x41,0x04,0x8d,0xa6,0x6c,0xad,0x3e,0x8f,0xd3,0xef,0x72,0xa9,0xd8,0x6e,0xcd,0x90,0x09,0xc2,0xdb,0x99,0x6a,0xf2,0x9d,0xc6,0x2a,0xf5,0xef,0x5e,0xb0,0x4d,0x0e,0x16,0xce,0x8f,0xce,0xcb,0xa9,0x2a,0x4a,0x98,0x88,0xf5,0x2d,0x5d,0x57,0x5e,0x7d,0xbc,0x30,0x2e,0xd9,0x7d,0xbf,0x69,0xdf,0x15,0xbb,0x4f,0x5c,0x56,0x01,0xd3,0x8f,0xbe,0x3b,0xd8,0x9d,0x88,0x76,0x8a,0x6a,0xed,0x11,0xce,0x2f,0x95,0xa6,0xad,0x30,0xbb,0x72,0xe7,0x87,0xbf,0xb7,0x34,0x70,0x1c,0xea,0x1f,0x38,0x16,0x8b,0xe4,0x4e,0xa1,0x9d,0x3e,0x98,0xdd,0x3c,0x95,0x3f,0xdb,0x99,0x51,0xac,0x9c,0x6e,0x22,0x1b,0xb0,0xf9,0x80,0xd8,0xf0,0x95,0x2a,0xc8,0x12,0x7d,0xa5,0xbd,0xa7,0x07,0x7d,0xd2,0x5f,0xfc,0x8e,0x15,0x15,0xc5,0x29,0xf2,0x95,0x16,0xda,0xce,0xc6,0xbe,0x9c,0x08,0x4e,0x6c,0x91,0x69,0x82,0x67,0xb2,0xae,0xd9,0x03,0x8e,0xca,0x5e,0xba,0xfa,0xd4,0x79,0xc5,0xfb,0x17,0x65,0x2e,0x25,0xbb,0x5b,0x85,0x58,0x6f,0xae,0x64,0x5b,0xd7,0xc3,0x25,0x3d,0x99,0x16,0xc0,0xaf,0x65,0xa2,0x02,0x53,0x41,0x2d,0x54,0x84,0xac,0x15,0xd2,0x88,0xc6,0xca,0x88,0x23,0x46,0x90,0x90,0xde,0xd5,0xce,0x09,0x75,0xda,0xda,0x63,0x65,0x37,0x97,0x12,0x9f,0x0e,0x92,0x6a,0xf6,0x24,0x7b,0x45,0x7b,0x06,0x7d,0xb6,0x83,0xe3,0x7d,0x84,0x8e,0x0a,0xcf,0x30,0xe5,0x60,0x2b,0x78,0xf1,0x84,0x8e,0x8d,0xa4,0xb6,0x40,0xed,0x08,0xb7,0x5f,0x35,0x19,0xa4,0x0e,0xc9,0x6b,0x2b,0xe9,0x64,0x23,0x4b,0xea,0xb3,0x77,0x59,0x50,0x43,0x76,0xc6,0xe5,0xeb,0xfa,0xcd,0xc5,0x7e,0x4c,0x7a,0x22,0xcf,0x1e,0x87,0x9d,0x7b,0xde,0x29,0xa2,0xdc,0xa5,0xfe,0x20,0x42,0x02,0x15,0xb5,0x9d,0x10,0x2f,0xd0,0x16,0x60,0x6c,0x53,0x3e,0x8e,0x36,0xf7,0xda,0x11,0x49,0x10,0x66,0x4b,0xad,0xe9,0xb2,0x95,0xd9,0x04,0x3a,0x01,0xbc,0x0d,0xc4,0xd8,0xab,0xbc,0x16,0xb1,0xce,0xc7,0x78,0x9d,0x89,0xe6,0x99,0xad,0x99,0xda,0xe5,0x97,0xc7,0xf1,0x0d,0x6f,0x04,0x7e,0xfc,0x01,0x1d,0x67,0x44,0x46,0x95,0xcb,0x8e,0x6e,0x8b,0x3d,0xba,0x17,0xcc,0xc6,0x93,0x72,0x9d,0x01,0x31,0x2d,0x0f,0x12,0xa3,0xfc,0x76,0xe1,0x2c,0x2e,0x49,0x84,0xaf,0x5c,0xb3,0x04,0x9b,0x9d,0x8a,0x13,0x12,0x4a,0x1f,0x77,0x0e,0x96,0xba,0xe1,0xfb,0x15,0x3b,0xa4,0xc9,0x1b,0xea,0x4f,0xae,0x6f,0x03,0x01,0x02,0x75,0xd5,0xa9,0xb1,0x40,0x12,0xbd,0xd6,0x78,0xe0,0x37,0x93,0x4d,0xc6,0x76,0x20,0x05,0xde,0x54,0xb3,0x2a,0x76,0x84,0xe0,0x30,0x60,0xd5,0xcc,0x80,0x37,0x8e,0x9b,0xef,0x05,0xb8,0xf0,0x69,0x22,0x02,0x94,0x44,0x01,0xbd,0x06,0xe4,0x55,0x3e,0x44,0x90,0xa0,0xe5,0x7c,0x5a,0x72,0xfc,0x8a,0xbb,0x1f,0x71,0x4e,0x22,0xea,0x95,0x0f,0xb2,0xf1,0xde,0x28,0x4d,0x6f,0xf3,0xda,0x43,0x59,0x54,0xde,0x35,0x5c,0x67,0x7f,0x60,0xdb,0x42,0x52,0xa5,0x10,0x91,0x9c,0xbe,0x7d,0xad,0xfe,0xd0,0x44,0x1c,0xf1,0x25,0xfd,0x88,0x94,0x75,0x3a,0xf8,0x11,0x4f,0x2d,0xda,0xcb,0x75,0xc3,0xda,0xa4,0x60,0x92,0x0f,0xc4,0x7d,0x28,0x5e,0x59,0xfe,0x91,0x10,0xe4,0x15,0x1f,0xce,0xf0,0x3f,0xa2,0x46,0xcd,0x2d,0xd9,0xa4,0xd5,0x73,0xe1,0xdb,0xbd,0xa1,0xc6,0x96,0x8c,0xf4,0xf5,0x46,0x28,0x9b,0x95,0xce,0x1b,0xf0,0xa5,0x5e,0xea,0x65,0x31,0x38,0x28,0x26,0xd4,0x00,0x2b,0xc4,0x6b,0xf4,0x41,0xce,0x16,0x05,0x6d,0x42,0xb5,0xa2,0x07,0x9e,0x29,0x9e,0x31,0x91,0xc2,0x3a,0x76,0x04,0xcd,0xe0,0x3d,0xe6,0x08,0x1e,0x06,0xf9,0x3c,0xfe,0x63,0x2c,0x9a,0x60,0x88,0xcd,0x32,0x86,0x62,0xd4,0x7a,0x49,0x54,0x93,0x48,0x32,0xdf,0x5b,0x5f,0x37,0x65,0xdb,0xe1,0x36,0x11,0x4c,0x73,0xc5,0x5c,0xb7,0xce,0x63,0x9e,0x5d,0x40,0xd1,0xd1,0xd8,0xf5,0x40,0xd3,0xc8,0xe1,0xbc,0x74,0x23,0xf0,0x32,0xc0,0xda,0x52,0x64,0x35,0x34,0x68,0xf0,0x09,0xc9,0x73,0xee,0xc0,0x44,0x8e,0x41,0xf9,0x28,0x9e,0x8d,0x9d,0xad,0xc6,0x8d,0xa7,0x7d,0x3c,0x3a,0xb3,0xa6,0x47,0x7d,0x44,0x02,0x4f,0x21,0xfb,0xa0,0xbd,0x44,0x77,0xd8,0x1c,0x60,0x27,0x65,0x75,0x27,0xaa,0x04,0x13,0xb4,0x5f,0x41,0x7c,0xb7,0xb3,0xbe,0xea,0x83,0x5a,0x1d,0x5d,0x79,0x54,0x14,0xd3,0x81,0x56,0x32,0x4c,0xb5,0xc1,0x30,0x3e,0x99,0x24,0xdb,0xe4,0x0c,0xd4,0x97,0xc4,0xc2,0x3c,0x22,0x1c,0xb9,0x12,0x05,0x8c,0x93,0x9b,0xea,0x8b,0x79,0xb3,0xfe,0xa3,0x60,0xfe,0xca,0xa8,0x33,0x75,0xa9,0xa8,0x4e,0x33,0x8d,0x9e,0x86,0x3e,0x80,0x21,0xad,0x2d,0xf4,0x43,0x0b,0x8d,0xea,0x0c,0x17,0x14,0xe1,0xbd,0xc4,0x78,0xf5,0x59,0x70,0x55,0x49,0xad,0x73,0x84,0x53,0xab,0x65,0xc0,0xff,0xcc,0x8c,0xf0,0xe3,0xba,0xfa,0xf4,0xaf,0xad,0x75,0xec,0xc4,0xdf,0xad,0x0d,0xe0,0xcf,0xe2,0x7d,0x50,0xd6,0x56,0x45,0x6e,0xa6,0xc3,0x61,0xb7,0x65,0x08,0x35,0x77,0x14,0x07,0x94,0x24].to_vec())))))));
[INFO] [stdout] 1246 +         assert_eq!(LogKind::parser().parse(r#"App::Trace Connect 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"#), Ok(("".into(), LogKind::App(AppLogKind::Trace(AppLogTraceKind::Connect(AuthData([0x30,0xc3,0x05,0x82,0x5b,0x90,0x00,0x77,0xae,0x7f,0x82,0x59,0xc1,0xc3,0x28,0xaa,0x3e,0x12,0x4a,0x07,0xf3,0xbf,0xbb,0xf2,0x16,0xdf,0xc6,0xe3,0x08,0xbe,0xea,0x6e,0x47,0x4b,0x9a,0x7e,0xa6,0xc2,0x4d,0x00,0x3a,0x6a,0xe4,0xfc,0xf0,0x4a,0x9e,0x6e,0xf7,0xc7,0xf1,0x7c,0xda,0xa0,0x29,0x6f,0x66,0xa8,0x80,0x36,0xba,0xdc,0xf0,0x1f,0x05,0x3d,0xa8,0x06,0xfa,0xd3,0x56,0x54,0x63,0x49,0xde,0xce,0xff,0x24,0x62,0x1b,0x89,0x54,0x40,0xd0,0x5a,0x71,0x5b,0x22,0x1a,0xf8,0xe9,0xe0,0x68,0x07,0x3d,0x6d,0xec,0x04,0xf1,0x48,0x17,0x57,0x17,0xd3,0xc2,0xd1,0xb6,0xaf,0x84,0xe2,0x37,0x57,0x18,0xab,0x4a,0x1e,0xba,0x7e,0x03,0x7c,0x1c,0x1d,0x43,0xb4,0xcf,0x42,0x2d,0x6f,0x2a,0xa9,0x19,0x42,0x66,0xf0,0xa7,0x54,0x4e,0xae,0xff,0x81,0x67,0xf0,0xe9,0x93,0xd0,0xea,0x6a,0x8d,0xdb,0x98,0xbf,0xeb,0x88,0x05,0x63,0x5d,0x5e,0xa9,0xf6,0x59,0x2f,0xd5,0x29,0x7e,0x6f,0x83,0xb6,0x83,0x41,0x90,0xf9,0x94,0x49,0x72,0x2c,0xd0,0xde,0x87,0xa4,0xc1,0x22,0xf0,0x8b,0xbe,0x83,0x6f,0xd3,0x09,0x2e,0x5f,0x0d,0x37,0xa3,0x05,0x7e,0x90,0xf3,0xdd,0x41,0x04,0x8d,0xa6,0x6c,0xad,0x3e,0x8f,0xd3,0xef,0x72,0xa9,0xd8,0x6e,0xcd,0x90,0x09,0xc2,0xdb,0x99,0x6a,0xf2,0x9d,0xc6,0x2a,0xf5,0xef,0x5e,0xb0,0x4d,0x0e,0x16,0xce,0x8f,0xce,0xcb,0xa9,0x2a,0x4a,0x98,0x88,0xf5,0x2d,0x5d,0x57,0x5e,0x7d,0xbc,0x30,0x2e,0xd9,0x7d,0xbf,0x69,0xdf,0x15,0xbb,0x4f,0x5c,0x56,0x01,0xd3,0x8f,0xbe,0x3b,0xd8,0x9d,0x88,0x76,0x8a,0x6a,0xed,0x11,0xce,0x2f,0x95,0xa6,0xad,0x30,0xbb,0x72,0xe7,0x87,0xbf,0xb7,0x34,0x70,0x1c,0xea,0x1f,0x38,0x16,0x8b,0xe4,0x4e,0xa1,0x9d,0x3e,0x98,0xdd,0x3c,0x95,0x3f,0xdb,0x99,0x51,0xac,0x9c,0x6e,0x22,0x1b,0xb0,0xf9,0x80,0xd8,0xf0,0x95,0x2a,0xc8,0x12,0x7d,0xa5,0xbd,0xa7,0x07,0x7d,0xd2,0x5f,0xfc,0x8e,0x15,0x15,0xc5,0x29,0xf2,0x95,0x16,0xda,0xce,0xc6,0xbe,0x9c,0x08,0x4e,0x6c,0x91,0x69,0x82,0x67,0xb2,0xae,0xd9,0x03,0x8e,0xca,0x5e,0xba,0xfa,0xd4,0x79,0xc5,0xfb,0x17,0x65,0x2e,0x25,0xbb,0x5b,0x85,0x58,0x6f,0xae,0x64,0x5b,0xd7,0xc3,0x25,0x3d,0x99,0x16,0xc0,0xaf,0x65,0xa2,0x02,0x53,0x41,0x2d,0x54,0x84,0xac,0x15,0xd2,0x88,0xc6,0xca,0x88,0x23,0x46,0x90,0x90,0xde,0xd5,0xce,0x09,0x75,0xda,0xda,0x63,0x65,0x37,0x97,0x12,0x9f,0x0e,0x92,0x6a,0xf6,0x24,0x7b,0x45,0x7b,0x06,0x7d,0xb6,0x83,0xe3,0x7d,0x84,0x8e,0x0a,0xcf,0x30,0xe5,0x60,0x2b,0x78,0xf1,0x84,0x8e,0x8d,0xa4,0xb6,0x40,0xed,0x08,0xb7,0x5f,0x35,0x19,0xa4,0x0e,0xc9,0x6b,0x2b,0xe9,0x64,0x23,0x4b,0xea,0xb3,0x77,0x59,0x50,0x43,0x76,0xc6,0xe5,0xeb,0xfa,0xcd,0xc5,0x7e,0x4c,0x7a,0x22,0xcf,0x1e,0x87,0x9d,0x7b,0xde,0x29,0xa2,0xdc,0xa5,0xfe,0x20,0x42,0x02,0x15,0xb5,0x9d,0x10,0x2f,0xd0,0x16,0x60,0x6c,0x53,0x3e,0x8e,0x36,0xf7,0xda,0x11,0x49,0x10,0x66,0x4b,0xad,0xe9,0xb2,0x95,0xd9,0x04,0x3a,0x01,0xbc,0x0d,0xc4,0xd8,0xab,0xbc,0x16,0xb1,0xce,0xc7,0x78,0x9d,0x89,0xe6,0x99,0xad,0x99,0xda,0xe5,0x97,0xc7,0xf1,0x0d,0x6f,0x04,0x7e,0xfc,0x01,0x1d,0x67,0x44,0x46,0x95,0xcb,0x8e,0x6e,0x8b,0x3d,0xba,0x17,0xcc,0xc6,0x93,0x72,0x9d,0x01,0x31,0x2d,0x0f,0x12,0xa3,0xfc,0x76,0xe1,0x2c,0x2e,0x49,0x84,0xaf,0x5c,0xb3,0x04,0x9b,0x9d,0x8a,0x13,0x12,0x4a,0x1f,0x77,0x0e,0x96,0xba,0xe1,0xfb,0x15,0x3b,0xa4,0xc9,0x1b,0xea,0x4f,0xae,0x6f,0x03,0x01,0x02,0x75,0xd5,0xa9,0xb1,0x40,0x12,0xbd,0xd6,0x78,0xe0,0x37,0x93,0x4d,0xc6,0x76,0x20,0x05,0xde,0x54,0xb3,0x2a,0x76,0x84,0xe0,0x30,0x60,0xd5,0xcc,0x80,0x37,0x8e,0x9b,0xef,0x05,0xb8,0xf0,0x69,0x22,0x02,0x94,0x44,0x01,0xbd,0x06,0xe4,0x55,0x3e,0x44,0x90,0xa0,0xe5,0x7c,0x5a,0x72,0xfc,0x8a,0xbb,0x1f,0x71,0x4e,0x22,0xea,0x95,0x0f,0xb2,0xf1,0xde,0x28,0x4d,0x6f,0xf3,0xda,0x43,0x59,0x54,0xde,0x35,0x5c,0x67,0x7f,0x60,0xdb,0x42,0x52,0xa5,0x10,0x91,0x9c,0xbe,0x7d,0xad,0xfe,0xd0,0x44,0x1c,0xf1,0x25,0xfd,0x88,0x94,0x75,0x3a,0xf8,0x11,0x4f,0x2d,0xda,0xcb,0x75,0xc3,0xda,0xa4,0x60,0x92,0x0f,0xc4,0x7d,0x28,0x5e,0x59,0xfe,0x91,0x10,0xe4,0x15,0x1f,0xce,0xf0,0x3f,0xa2,0x46,0xcd,0x2d,0xd9,0xa4,0xd5,0x73,0xe1,0xdb,0xbd,0xa1,0xc6,0x96,0x8c,0xf4,0xf5,0x46,0x28,0x9b,0x95,0xce,0x1b,0xf0,0xa5,0x5e,0xea,0x65,0x31,0x38,0x28,0x26,0xd4,0x00,0x2b,0xc4,0x6b,0xf4,0x41,0xce,0x16,0x05,0x6d,0x42,0xb5,0xa2,0x07,0x9e,0x29,0x9e,0x31,0x91,0xc2,0x3a,0x76,0x04,0xcd,0xe0,0x3d,0xe6,0x08,0x1e,0x06,0xf9,0x3c,0xfe,0x63,0x2c,0x9a,0x60,0x88,0xcd,0x32,0x86,0x62,0xd4,0x7a,0x49,0x54,0x93,0x48,0x32,0xdf,0x5b,0x5f,0x37,0x65,0xdb,0xe1,0x36,0x11,0x4c,0x73,0xc5,0x5c,0xb7,0xce,0x63,0x9e,0x5d,0x40,0xd1,0xd1,0xd8,0xf5,0x40,0xd3,0xc8,0xe1,0xbc,0x74,0x23,0xf0,0x32,0xc0,0xda,0x52,0x64,0x35,0x34,0x68,0xf0,0x09,0xc9,0x73,0xee,0xc0,0x44,0x8e,0x41,0xf9,0x28,0x9e,0x8d,0x9d,0xad,0xc6,0x8d,0xa7,0x7d,0x3c,0x3a,0xb3,0xa6,0x47,0x7d,0x44,0x02,0x4f,0x21,0xfb,0xa0,0xbd,0x44,0x77,0xd8,0x1c,0x60,0x27,0x65,0x75,0x27,0xaa,0x04,0x13,0xb4,0x5f,0x41,0x7c,0xb7,0xb3,0xbe,0xea,0x83,0x5a,0x1d,0x5d,0x79,0x54,0x14,0xd3,0x81,0x56,0x32,0x4c,0xb5,0xc1,0x30,0x3e,0x99,0x24,0xdb,0xe4,0x0c,0xd4,0x97,0xc4,0xc2,0x3c,0x22,0x1c,0xb9,0x12,0x05,0x8c,0x93,0x9b,0xea,0x8b,0x79,0xb3,0xfe,0xa3,0x60,0xfe,0xca,0xa8,0x33,0x75,0xa9,0xa8,0x4e,0x33,0x8d,0x9e,0x86,0x3e,0x80,0x21,0xad,0x2d,0xf4,0x43,0x0b,0x8d,0xea,0x0c,0x17,0x14,0xe1,0xbd,0xc4,0x78,0xf5,0x59,0x70,0x55,0x49,0xad,0x73,0x84,0x53,0xab,0x65,0xc0,0xff,0xcc,0x8c,0xf0,0xe3,0xba,0xfa,0xf4,0xaf,0xad,0x75,0xec,0xc4,0xdf,0xad,0x0d,0xe0,0xcf,0xe2,0x7d,0x50,0xd6,0x56,0x45,0x6e,0xa6,0xc3,0x61,0xb7,0x65,0x08,0x35,0x77,0x14,0x07,0x94,0x24].to_vec())))))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1246 -         assert_eq!(LogKind::parser().parse(r#"App::Trace Connect 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"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Trace(AppLogTraceKind::Connect(AuthData([0x30,0xc3,0x05,0x82,0x5b,0x90,0x00,0x77,0xae,0x7f,0x82,0x59,0xc1,0xc3,0x28,0xaa,0x3e,0x12,0x4a,0x07,0xf3,0xbf,0xbb,0xf2,0x16,0xdf,0xc6,0xe3,0x08,0xbe,0xea,0x6e,0x47,0x4b,0x9a,0x7e,0xa6,0xc2,0x4d,0x00,0x3a,0x6a,0xe4,0xfc,0xf0,0x4a,0x9e,0x6e,0xf7,0xc7,0xf1,0x7c,0xda,0xa0,0x29,0x6f,0x66,0xa8,0x80,0x36,0xba,0xdc,0xf0,0x1f,0x05,0x3d,0xa8,0x06,0xfa,0xd3,0x56,0x54,0x63,0x49,0xde,0xce,0xff,0x24,0x62,0x1b,0x89,0x54,0x40,0xd0,0x5a,0x71,0x5b,0x22,0x1a,0xf8,0xe9,0xe0,0x68,0x07,0x3d,0x6d,0xec,0x04,0xf1,0x48,0x17,0x57,0x17,0xd3,0xc2,0xd1,0xb6,0xaf,0x84,0xe2,0x37,0x57,0x18,0xab,0x4a,0x1e,0xba,0x7e,0x03,0x7c,0x1c,0x1d,0x43,0xb4,0xcf,0x42,0x2d,0x6f,0x2a,0xa9,0x19,0x42,0x66,0xf0,0xa7,0x54,0x4e,0xae,0xff,0x81,0x67,0xf0,0xe9,0x93,0xd0,0xea,0x6a,0x8d,0xdb,0x98,0xbf,0xeb,0x88,0x05,0x63,0x5d,0x5e,0xa9,0xf6,0x59,0x2f,0xd5,0x29,0x7e,0x6f,0x83,0xb6,0x83,0x41,0x90,0xf9,0x94,0x49,0x72,0x2c,0xd0,0xde,0x87,0xa4,0xc1,0x22,0xf0,0x8b,0xbe,0x83,0x6f,0xd3,0x09,0x2e,0x5f,0x0d,0x37,0xa3,0x05,0x7e,0x90,0xf3,0xdd,0x41,0x04,0x8d,0xa6,0x6c,0xad,0x3e,0x8f,0xd3,0xef,0x72,0xa9,0xd8,0x6e,0xcd,0x90,0x09,0xc2,0xdb,0x99,0x6a,0xf2,0x9d,0xc6,0x2a,0xf5,0xef,0x5e,0xb0,0x4d,0x0e,0x16,0xce,0x8f,0xce,0xcb,0xa9,0x2a,0x4a,0x98,0x88,0xf5,0x2d,0x5d,0x57,0x5e,0x7d,0xbc,0x30,0x2e,0xd9,0x7d,0xbf,0x69,0xdf,0x15,0xbb,0x4f,0x5c,0x56,0x01,0xd3,0x8f,0xbe,0x3b,0xd8,0x9d,0x88,0x76,0x8a,0x6a,0xed,0x11,0xce,0x2f,0x95,0xa6,0xad,0x30,0xbb,0x72,0xe7,0x87,0xbf,0xb7,0x34,0x70,0x1c,0xea,0x1f,0x38,0x16,0x8b,0xe4,0x4e,0xa1,0x9d,0x3e,0x98,0xdd,0x3c,0x95,0x3f,0xdb,0x99,0x51,0xac,0x9c,0x6e,0x22,0x1b,0xb0,0xf9,0x80,0xd8,0xf0,0x95,0x2a,0xc8,0x12,0x7d,0xa5,0xbd,0xa7,0x07,0x7d,0xd2,0x5f,0xfc,0x8e,0x15,0x15,0xc5,0x29,0xf2,0x95,0x16,0xda,0xce,0xc6,0xbe,0x9c,0x08,0x4e,0x6c,0x91,0x69,0x82,0x67,0xb2,0xae,0xd9,0x03,0x8e,0xca,0x5e,0xba,0xfa,0xd4,0x79,0xc5,0xfb,0x17,0x65,0x2e,0x25,0xbb,0x5b,0x85,0x58,0x6f,0xae,0x64,0x5b,0xd7,0xc3,0x25,0x3d,0x99,0x16,0xc0,0xaf,0x65,0xa2,0x02,0x53,0x41,0x2d,0x54,0x84,0xac,0x15,0xd2,0x88,0xc6,0xca,0x88,0x23,0x46,0x90,0x90,0xde,0xd5,0xce,0x09,0x75,0xda,0xda,0x63,0x65,0x37,0x97,0x12,0x9f,0x0e,0x92,0x6a,0xf6,0x24,0x7b,0x45,0x7b,0x06,0x7d,0xb6,0x83,0xe3,0x7d,0x84,0x8e,0x0a,0xcf,0x30,0xe5,0x60,0x2b,0x78,0xf1,0x84,0x8e,0x8d,0xa4,0xb6,0x40,0xed,0x08,0xb7,0x5f,0x35,0x19,0xa4,0x0e,0xc9,0x6b,0x2b,0xe9,0x64,0x23,0x4b,0xea,0xb3,0x77,0x59,0x50,0x43,0x76,0xc6,0xe5,0xeb,0xfa,0xcd,0xc5,0x7e,0x4c,0x7a,0x22,0xcf,0x1e,0x87,0x9d,0x7b,0xde,0x29,0xa2,0xdc,0xa5,0xfe,0x20,0x42,0x02,0x15,0xb5,0x9d,0x10,0x2f,0xd0,0x16,0x60,0x6c,0x53,0x3e,0x8e,0x36,0xf7,0xda,0x11,0x49,0x10,0x66,0x4b,0xad,0xe9,0xb2,0x95,0xd9,0x04,0x3a,0x01,0xbc,0x0d,0xc4,0xd8,0xab,0xbc,0x16,0xb1,0xce,0xc7,0x78,0x9d,0x89,0xe6,0x99,0xad,0x99,0xda,0xe5,0x97,0xc7,0xf1,0x0d,0x6f,0x04,0x7e,0xfc,0x01,0x1d,0x67,0x44,0x46,0x95,0xcb,0x8e,0x6e,0x8b,0x3d,0xba,0x17,0xcc,0xc6,0x93,0x72,0x9d,0x01,0x31,0x2d,0x0f,0x12,0xa3,0xfc,0x76,0xe1,0x2c,0x2e,0x49,0x84,0xaf,0x5c,0xb3,0x04,0x9b,0x9d,0x8a,0x13,0x12,0x4a,0x1f,0x77,0x0e,0x96,0xba,0xe1,0xfb,0x15,0x3b,0xa4,0xc9,0x1b,0xea,0x4f,0xae,0x6f,0x03,0x01,0x02,0x75,0xd5,0xa9,0xb1,0x40,0x12,0xbd,0xd6,0x78,0xe0,0x37,0x93,0x4d,0xc6,0x76,0x20,0x05,0xde,0x54,0xb3,0x2a,0x76,0x84,0xe0,0x30,0x60,0xd5,0xcc,0x80,0x37,0x8e,0x9b,0xef,0x05,0xb8,0xf0,0x69,0x22,0x02,0x94,0x44,0x01,0xbd,0x06,0xe4,0x55,0x3e,0x44,0x90,0xa0,0xe5,0x7c,0x5a,0x72,0xfc,0x8a,0xbb,0x1f,0x71,0x4e,0x22,0xea,0x95,0x0f,0xb2,0xf1,0xde,0x28,0x4d,0x6f,0xf3,0xda,0x43,0x59,0x54,0xde,0x35,0x5c,0x67,0x7f,0x60,0xdb,0x42,0x52,0xa5,0x10,0x91,0x9c,0xbe,0x7d,0xad,0xfe,0xd0,0x44,0x1c,0xf1,0x25,0xfd,0x88,0x94,0x75,0x3a,0xf8,0x11,0x4f,0x2d,0xda,0xcb,0x75,0xc3,0xda,0xa4,0x60,0x92,0x0f,0xc4,0x7d,0x28,0x5e,0x59,0xfe,0x91,0x10,0xe4,0x15,0x1f,0xce,0xf0,0x3f,0xa2,0x46,0xcd,0x2d,0xd9,0xa4,0xd5,0x73,0xe1,0xdb,0xbd,0xa1,0xc6,0x96,0x8c,0xf4,0xf5,0x46,0x28,0x9b,0x95,0xce,0x1b,0xf0,0xa5,0x5e,0xea,0x65,0x31,0x38,0x28,0x26,0xd4,0x00,0x2b,0xc4,0x6b,0xf4,0x41,0xce,0x16,0x05,0x6d,0x42,0xb5,0xa2,0x07,0x9e,0x29,0x9e,0x31,0x91,0xc2,0x3a,0x76,0x04,0xcd,0xe0,0x3d,0xe6,0x08,0x1e,0x06,0xf9,0x3c,0xfe,0x63,0x2c,0x9a,0x60,0x88,0xcd,0x32,0x86,0x62,0xd4,0x7a,0x49,0x54,0x93,0x48,0x32,0xdf,0x5b,0x5f,0x37,0x65,0xdb,0xe1,0x36,0x11,0x4c,0x73,0xc5,0x5c,0xb7,0xce,0x63,0x9e,0x5d,0x40,0xd1,0xd1,0xd8,0xf5,0x40,0xd3,0xc8,0xe1,0xbc,0x74,0x23,0xf0,0x32,0xc0,0xda,0x52,0x64,0x35,0x34,0x68,0xf0,0x09,0xc9,0x73,0xee,0xc0,0x44,0x8e,0x41,0xf9,0x28,0x9e,0x8d,0x9d,0xad,0xc6,0x8d,0xa7,0x7d,0x3c,0x3a,0xb3,0xa6,0x47,0x7d,0x44,0x02,0x4f,0x21,0xfb,0xa0,0xbd,0x44,0x77,0xd8,0x1c,0x60,0x27,0x65,0x75,0x27,0xaa,0x04,0x13,0xb4,0x5f,0x41,0x7c,0xb7,0xb3,0xbe,0xea,0x83,0x5a,0x1d,0x5d,0x79,0x54,0x14,0xd3,0x81,0x56,0x32,0x4c,0xb5,0xc1,0x30,0x3e,0x99,0x24,0xdb,0xe4,0x0c,0xd4,0x97,0xc4,0xc2,0x3c,0x22,0x1c,0xb9,0x12,0x05,0x8c,0x93,0x9b,0xea,0x8b,0x79,0xb3,0xfe,0xa3,0x60,0xfe,0xca,0xa8,0x33,0x75,0xa9,0xa8,0x4e,0x33,0x8d,0x9e,0x86,0x3e,0x80,0x21,0xad,0x2d,0xf4,0x43,0x0b,0x8d,0xea,0x0c,0x17,0x14,0xe1,0xbd,0xc4,0x78,0xf5,0x59,0x70,0x55,0x49,0xad,0x73,0x84,0x53,0xab,0x65,0xc0,0xff,0xcc,0x8c,0xf0,0xe3,0xba,0xfa,0xf4,0xaf,0xad,0x75,0xec,0xc4,0xdf,0xad,0x0d,0xe0,0xcf,0xe2,0x7d,0x50,0xd6,0x56,0x45,0x6e,0xa6,0xc3,0x61,0xb7,0x65,0x08,0x35,0x77,0x14,0x07,0x94,0x24].to_vec())))))));
[INFO] [stdout] 1246 +         assert_eq!(LogKind::parser().parse(<&str as Into<_>>::into(r#"App::Trace Connect 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"#)), Ok(("".into(), LogKind::App(AppLogKind::Trace(AppLogTraceKind::Connect(AuthData([0x30,0xc3,0x05,0x82,0x5b,0x90,0x00,0x77,0xae,0x7f,0x82,0x59,0xc1,0xc3,0x28,0xaa,0x3e,0x12,0x4a,0x07,0xf3,0xbf,0xbb,0xf2,0x16,0xdf,0xc6,0xe3,0x08,0xbe,0xea,0x6e,0x47,0x4b,0x9a,0x7e,0xa6,0xc2,0x4d,0x00,0x3a,0x6a,0xe4,0xfc,0xf0,0x4a,0x9e,0x6e,0xf7,0xc7,0xf1,0x7c,0xda,0xa0,0x29,0x6f,0x66,0xa8,0x80,0x36,0xba,0xdc,0xf0,0x1f,0x05,0x3d,0xa8,0x06,0xfa,0xd3,0x56,0x54,0x63,0x49,0xde,0xce,0xff,0x24,0x62,0x1b,0x89,0x54,0x40,0xd0,0x5a,0x71,0x5b,0x22,0x1a,0xf8,0xe9,0xe0,0x68,0x07,0x3d,0x6d,0xec,0x04,0xf1,0x48,0x17,0x57,0x17,0xd3,0xc2,0xd1,0xb6,0xaf,0x84,0xe2,0x37,0x57,0x18,0xab,0x4a,0x1e,0xba,0x7e,0x03,0x7c,0x1c,0x1d,0x43,0xb4,0xcf,0x42,0x2d,0x6f,0x2a,0xa9,0x19,0x42,0x66,0xf0,0xa7,0x54,0x4e,0xae,0xff,0x81,0x67,0xf0,0xe9,0x93,0xd0,0xea,0x6a,0x8d,0xdb,0x98,0xbf,0xeb,0x88,0x05,0x63,0x5d,0x5e,0xa9,0xf6,0x59,0x2f,0xd5,0x29,0x7e,0x6f,0x83,0xb6,0x83,0x41,0x90,0xf9,0x94,0x49,0x72,0x2c,0xd0,0xde,0x87,0xa4,0xc1,0x22,0xf0,0x8b,0xbe,0x83,0x6f,0xd3,0x09,0x2e,0x5f,0x0d,0x37,0xa3,0x05,0x7e,0x90,0xf3,0xdd,0x41,0x04,0x8d,0xa6,0x6c,0xad,0x3e,0x8f,0xd3,0xef,0x72,0xa9,0xd8,0x6e,0xcd,0x90,0x09,0xc2,0xdb,0x99,0x6a,0xf2,0x9d,0xc6,0x2a,0xf5,0xef,0x5e,0xb0,0x4d,0x0e,0x16,0xce,0x8f,0xce,0xcb,0xa9,0x2a,0x4a,0x98,0x88,0xf5,0x2d,0x5d,0x57,0x5e,0x7d,0xbc,0x30,0x2e,0xd9,0x7d,0xbf,0x69,0xdf,0x15,0xbb,0x4f,0x5c,0x56,0x01,0xd3,0x8f,0xbe,0x3b,0xd8,0x9d,0x88,0x76,0x8a,0x6a,0xed,0x11,0xce,0x2f,0x95,0xa6,0xad,0x30,0xbb,0x72,0xe7,0x87,0xbf,0xb7,0x34,0x70,0x1c,0xea,0x1f,0x38,0x16,0x8b,0xe4,0x4e,0xa1,0x9d,0x3e,0x98,0xdd,0x3c,0x95,0x3f,0xdb,0x99,0x51,0xac,0x9c,0x6e,0x22,0x1b,0xb0,0xf9,0x80,0xd8,0xf0,0x95,0x2a,0xc8,0x12,0x7d,0xa5,0xbd,0xa7,0x07,0x7d,0xd2,0x5f,0xfc,0x8e,0x15,0x15,0xc5,0x29,0xf2,0x95,0x16,0xda,0xce,0xc6,0xbe,0x9c,0x08,0x4e,0x6c,0x91,0x69,0x82,0x67,0xb2,0xae,0xd9,0x03,0x8e,0xca,0x5e,0xba,0xfa,0xd4,0x79,0xc5,0xfb,0x17,0x65,0x2e,0x25,0xbb,0x5b,0x85,0x58,0x6f,0xae,0x64,0x5b,0xd7,0xc3,0x25,0x3d,0x99,0x16,0xc0,0xaf,0x65,0xa2,0x02,0x53,0x41,0x2d,0x54,0x84,0xac,0x15,0xd2,0x88,0xc6,0xca,0x88,0x23,0x46,0x90,0x90,0xde,0xd5,0xce,0x09,0x75,0xda,0xda,0x63,0x65,0x37,0x97,0x12,0x9f,0x0e,0x92,0x6a,0xf6,0x24,0x7b,0x45,0x7b,0x06,0x7d,0xb6,0x83,0xe3,0x7d,0x84,0x8e,0x0a,0xcf,0x30,0xe5,0x60,0x2b,0x78,0xf1,0x84,0x8e,0x8d,0xa4,0xb6,0x40,0xed,0x08,0xb7,0x5f,0x35,0x19,0xa4,0x0e,0xc9,0x6b,0x2b,0xe9,0x64,0x23,0x4b,0xea,0xb3,0x77,0x59,0x50,0x43,0x76,0xc6,0xe5,0xeb,0xfa,0xcd,0xc5,0x7e,0x4c,0x7a,0x22,0xcf,0x1e,0x87,0x9d,0x7b,0xde,0x29,0xa2,0xdc,0xa5,0xfe,0x20,0x42,0x02,0x15,0xb5,0x9d,0x10,0x2f,0xd0,0x16,0x60,0x6c,0x53,0x3e,0x8e,0x36,0xf7,0xda,0x11,0x49,0x10,0x66,0x4b,0xad,0xe9,0xb2,0x95,0xd9,0x04,0x3a,0x01,0xbc,0x0d,0xc4,0xd8,0xab,0xbc,0x16,0xb1,0xce,0xc7,0x78,0x9d,0x89,0xe6,0x99,0xad,0x99,0xda,0xe5,0x97,0xc7,0xf1,0x0d,0x6f,0x04,0x7e,0xfc,0x01,0x1d,0x67,0x44,0x46,0x95,0xcb,0x8e,0x6e,0x8b,0x3d,0xba,0x17,0xcc,0xc6,0x93,0x72,0x9d,0x01,0x31,0x2d,0x0f,0x12,0xa3,0xfc,0x76,0xe1,0x2c,0x2e,0x49,0x84,0xaf,0x5c,0xb3,0x04,0x9b,0x9d,0x8a,0x13,0x12,0x4a,0x1f,0x77,0x0e,0x96,0xba,0xe1,0xfb,0x15,0x3b,0xa4,0xc9,0x1b,0xea,0x4f,0xae,0x6f,0x03,0x01,0x02,0x75,0xd5,0xa9,0xb1,0x40,0x12,0xbd,0xd6,0x78,0xe0,0x37,0x93,0x4d,0xc6,0x76,0x20,0x05,0xde,0x54,0xb3,0x2a,0x76,0x84,0xe0,0x30,0x60,0xd5,0xcc,0x80,0x37,0x8e,0x9b,0xef,0x05,0xb8,0xf0,0x69,0x22,0x02,0x94,0x44,0x01,0xbd,0x06,0xe4,0x55,0x3e,0x44,0x90,0xa0,0xe5,0x7c,0x5a,0x72,0xfc,0x8a,0xbb,0x1f,0x71,0x4e,0x22,0xea,0x95,0x0f,0xb2,0xf1,0xde,0x28,0x4d,0x6f,0xf3,0xda,0x43,0x59,0x54,0xde,0x35,0x5c,0x67,0x7f,0x60,0xdb,0x42,0x52,0xa5,0x10,0x91,0x9c,0xbe,0x7d,0xad,0xfe,0xd0,0x44,0x1c,0xf1,0x25,0xfd,0x88,0x94,0x75,0x3a,0xf8,0x11,0x4f,0x2d,0xda,0xcb,0x75,0xc3,0xda,0xa4,0x60,0x92,0x0f,0xc4,0x7d,0x28,0x5e,0x59,0xfe,0x91,0x10,0xe4,0x15,0x1f,0xce,0xf0,0x3f,0xa2,0x46,0xcd,0x2d,0xd9,0xa4,0xd5,0x73,0xe1,0xdb,0xbd,0xa1,0xc6,0x96,0x8c,0xf4,0xf5,0x46,0x28,0x9b,0x95,0xce,0x1b,0xf0,0xa5,0x5e,0xea,0x65,0x31,0x38,0x28,0x26,0xd4,0x00,0x2b,0xc4,0x6b,0xf4,0x41,0xce,0x16,0x05,0x6d,0x42,0xb5,0xa2,0x07,0x9e,0x29,0x9e,0x31,0x91,0xc2,0x3a,0x76,0x04,0xcd,0xe0,0x3d,0xe6,0x08,0x1e,0x06,0xf9,0x3c,0xfe,0x63,0x2c,0x9a,0x60,0x88,0xcd,0x32,0x86,0x62,0xd4,0x7a,0x49,0x54,0x93,0x48,0x32,0xdf,0x5b,0x5f,0x37,0x65,0xdb,0xe1,0x36,0x11,0x4c,0x73,0xc5,0x5c,0xb7,0xce,0x63,0x9e,0x5d,0x40,0xd1,0xd1,0xd8,0xf5,0x40,0xd3,0xc8,0xe1,0xbc,0x74,0x23,0xf0,0x32,0xc0,0xda,0x52,0x64,0x35,0x34,0x68,0xf0,0x09,0xc9,0x73,0xee,0xc0,0x44,0x8e,0x41,0xf9,0x28,0x9e,0x8d,0x9d,0xad,0xc6,0x8d,0xa7,0x7d,0x3c,0x3a,0xb3,0xa6,0x47,0x7d,0x44,0x02,0x4f,0x21,0xfb,0xa0,0xbd,0x44,0x77,0xd8,0x1c,0x60,0x27,0x65,0x75,0x27,0xaa,0x04,0x13,0xb4,0x5f,0x41,0x7c,0xb7,0xb3,0xbe,0xea,0x83,0x5a,0x1d,0x5d,0x79,0x54,0x14,0xd3,0x81,0x56,0x32,0x4c,0xb5,0xc1,0x30,0x3e,0x99,0x24,0xdb,0xe4,0x0c,0xd4,0x97,0xc4,0xc2,0x3c,0x22,0x1c,0xb9,0x12,0x05,0x8c,0x93,0x9b,0xea,0x8b,0x79,0xb3,0xfe,0xa3,0x60,0xfe,0xca,0xa8,0x33,0x75,0xa9,0xa8,0x4e,0x33,0x8d,0x9e,0x86,0x3e,0x80,0x21,0xad,0x2d,0xf4,0x43,0x0b,0x8d,0xea,0x0c,0x17,0x14,0xe1,0xbd,0xc4,0x78,0xf5,0x59,0x70,0x55,0x49,0xad,0x73,0x84,0x53,0xab,0x65,0xc0,0xff,0xcc,0x8c,0xf0,0xe3,0xba,0xfa,0xf4,0xaf,0xad,0x75,0xec,0xc4,0xdf,0xad,0x0d,0xe0,0xcf,0xe2,0x7d,0x50,0xd6,0x56,0x45,0x6e,0xa6,0xc3,0x61,0xb7,0x65,0x08,0x35,0x77,0x14,0x07,0x94,0x24].to_vec())))))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `analysis` (lib test) due to 96 previous errors
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1246:2130
[INFO] [stdout]      |
[INFO] [stdout] 1246 | ...de0cfe27d50d656456ea6c361b76508357714079424"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Trace(AppLogTraceKind::Connect(A...
[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] 1246 -         assert_eq!(LogKind::parser().parse(r#"App::Trace Connect 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"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Trace(AppLogTraceKind::Connect(AuthData([0x30,0xc3,0x05,0x82,0x5b,0x90,0x00,0x77,0xae,0x7f,0x82,0x59,0xc1,0xc3,0x28,0xaa,0x3e,0x12,0x4a,0x07,0xf3,0xbf,0xbb,0xf2,0x16,0xdf,0xc6,0xe3,0x08,0xbe,0xea,0x6e,0x47,0x4b,0x9a,0x7e,0xa6,0xc2,0x4d,0x00,0x3a,0x6a,0xe4,0xfc,0xf0,0x4a,0x9e,0x6e,0xf7,0xc7,0xf1,0x7c,0xda,0xa0,0x29,0x6f,0x66,0xa8,0x80,0x36,0xba,0xdc,0xf0,0x1f,0x05,0x3d,0xa8,0x06,0xfa,0xd3,0x56,0x54,0x63,0x49,0xde,0xce,0xff,0x24,0x62,0x1b,0x89,0x54,0x40,0xd0,0x5a,0x71,0x5b,0x22,0x1a,0xf8,0xe9,0xe0,0x68,0x07,0x3d,0x6d,0xec,0x04,0xf1,0x48,0x17,0x57,0x17,0xd3,0xc2,0xd1,0xb6,0xaf,0x84,0xe2,0x37,0x57,0x18,0xab,0x4a,0x1e,0xba,0x7e,0x03,0x7c,0x1c,0x1d,0x43,0xb4,0xcf,0x42,0x2d,0x6f,0x2a,0xa9,0x19,0x42,0x66,0xf0,0xa7,0x54,0x4e,0xae,0xff,0x81,0x67,0xf0,0xe9,0x93,0xd0,0xea,0x6a,0x8d,0xdb,0x98,0xbf,0xeb,0x88,0x05,0x63,0x5d,0x5e,0xa9,0xf6,0x59,0x2f,0xd5,0x29,0x7e,0x6f,0x83,0xb6,0x83,0x41,0x90,0xf9,0x94,0x49,0x72,0x2c,0xd0,0xde,0x87,0xa4,0xc1,0x22,0xf0,0x8b,0xbe,0x83,0x6f,0xd3,0x09,0x2e,0x5f,0x0d,0x37,0xa3,0x05,0x7e,0x90,0xf3,0xdd,0x41,0x04,0x8d,0xa6,0x6c,0xad,0x3e,0x8f,0xd3,0xef,0x72,0xa9,0xd8,0x6e,0xcd,0x90,0x09,0xc2,0xdb,0x99,0x6a,0xf2,0x9d,0xc6,0x2a,0xf5,0xef,0x5e,0xb0,0x4d,0x0e,0x16,0xce,0x8f,0xce,0xcb,0xa9,0x2a,0x4a,0x98,0x88,0xf5,0x2d,0x5d,0x57,0x5e,0x7d,0xbc,0x30,0x2e,0xd9,0x7d,0xbf,0x69,0xdf,0x15,0xbb,0x4f,0x5c,0x56,0x01,0xd3,0x8f,0xbe,0x3b,0xd8,0x9d,0x88,0x76,0x8a,0x6a,0xed,0x11,0xce,0x2f,0x95,0xa6,0xad,0x30,0xbb,0x72,0xe7,0x87,0xbf,0xb7,0x34,0x70,0x1c,0xea,0x1f,0x38,0x16,0x8b,0xe4,0x4e,0xa1,0x9d,0x3e,0x98,0xdd,0x3c,0x95,0x3f,0xdb,0x99,0x51,0xac,0x9c,0x6e,0x22,0x1b,0xb0,0xf9,0x80,0xd8,0xf0,0x95,0x2a,0xc8,0x12,0x7d,0xa5,0xbd,0xa7,0x07,0x7d,0xd2,0x5f,0xfc,0x8e,0x15,0x15,0xc5,0x29,0xf2,0x95,0x16,0xda,0xce,0xc6,0xbe,0x9c,0x08,0x4e,0x6c,0x91,0x69,0x82,0x67,0xb2,0xae,0xd9,0x03,0x8e,0xca,0x5e,0xba,0xfa,0xd4,0x79,0xc5,0xfb,0x17,0x65,0x2e,0x25,0xbb,0x5b,0x85,0x58,0x6f,0xae,0x64,0x5b,0xd7,0xc3,0x25,0x3d,0x99,0x16,0xc0,0xaf,0x65,0xa2,0x02,0x53,0x41,0x2d,0x54,0x84,0xac,0x15,0xd2,0x88,0xc6,0xca,0x88,0x23,0x46,0x90,0x90,0xde,0xd5,0xce,0x09,0x75,0xda,0xda,0x63,0x65,0x37,0x97,0x12,0x9f,0x0e,0x92,0x6a,0xf6,0x24,0x7b,0x45,0x7b,0x06,0x7d,0xb6,0x83,0xe3,0x7d,0x84,0x8e,0x0a,0xcf,0x30,0xe5,0x60,0x2b,0x78,0xf1,0x84,0x8e,0x8d,0xa4,0xb6,0x40,0xed,0x08,0xb7,0x5f,0x35,0x19,0xa4,0x0e,0xc9,0x6b,0x2b,0xe9,0x64,0x23,0x4b,0xea,0xb3,0x77,0x59,0x50,0x43,0x76,0xc6,0xe5,0xeb,0xfa,0xcd,0xc5,0x7e,0x4c,0x7a,0x22,0xcf,0x1e,0x87,0x9d,0x7b,0xde,0x29,0xa2,0xdc,0xa5,0xfe,0x20,0x42,0x02,0x15,0xb5,0x9d,0x10,0x2f,0xd0,0x16,0x60,0x6c,0x53,0x3e,0x8e,0x36,0xf7,0xda,0x11,0x49,0x10,0x66,0x4b,0xad,0xe9,0xb2,0x95,0xd9,0x04,0x3a,0x01,0xbc,0x0d,0xc4,0xd8,0xab,0xbc,0x16,0xb1,0xce,0xc7,0x78,0x9d,0x89,0xe6,0x99,0xad,0x99,0xda,0xe5,0x97,0xc7,0xf1,0x0d,0x6f,0x04,0x7e,0xfc,0x01,0x1d,0x67,0x44,0x46,0x95,0xcb,0x8e,0x6e,0x8b,0x3d,0xba,0x17,0xcc,0xc6,0x93,0x72,0x9d,0x01,0x31,0x2d,0x0f,0x12,0xa3,0xfc,0x76,0xe1,0x2c,0x2e,0x49,0x84,0xaf,0x5c,0xb3,0x04,0x9b,0x9d,0x8a,0x13,0x12,0x4a,0x1f,0x77,0x0e,0x96,0xba,0xe1,0xfb,0x15,0x3b,0xa4,0xc9,0x1b,0xea,0x4f,0xae,0x6f,0x03,0x01,0x02,0x75,0xd5,0xa9,0xb1,0x40,0x12,0xbd,0xd6,0x78,0xe0,0x37,0x93,0x4d,0xc6,0x76,0x20,0x05,0xde,0x54,0xb3,0x2a,0x76,0x84,0xe0,0x30,0x60,0xd5,0xcc,0x80,0x37,0x8e,0x9b,0xef,0x05,0xb8,0xf0,0x69,0x22,0x02,0x94,0x44,0x01,0xbd,0x06,0xe4,0x55,0x3e,0x44,0x90,0xa0,0xe5,0x7c,0x5a,0x72,0xfc,0x8a,0xbb,0x1f,0x71,0x4e,0x22,0xea,0x95,0x0f,0xb2,0xf1,0xde,0x28,0x4d,0x6f,0xf3,0xda,0x43,0x59,0x54,0xde,0x35,0x5c,0x67,0x7f,0x60,0xdb,0x42,0x52,0xa5,0x10,0x91,0x9c,0xbe,0x7d,0xad,0xfe,0xd0,0x44,0x1c,0xf1,0x25,0xfd,0x88,0x94,0x75,0x3a,0xf8,0x11,0x4f,0x2d,0xda,0xcb,0x75,0xc3,0xda,0xa4,0x60,0x92,0x0f,0xc4,0x7d,0x28,0x5e,0x59,0xfe,0x91,0x10,0xe4,0x15,0x1f,0xce,0xf0,0x3f,0xa2,0x46,0xcd,0x2d,0xd9,0xa4,0xd5,0x73,0xe1,0xdb,0xbd,0xa1,0xc6,0x96,0x8c,0xf4,0xf5,0x46,0x28,0x9b,0x95,0xce,0x1b,0xf0,0xa5,0x5e,0xea,0x65,0x31,0x38,0x28,0x26,0xd4,0x00,0x2b,0xc4,0x6b,0xf4,0x41,0xce,0x16,0x05,0x6d,0x42,0xb5,0xa2,0x07,0x9e,0x29,0x9e,0x31,0x91,0xc2,0x3a,0x76,0x04,0xcd,0xe0,0x3d,0xe6,0x08,0x1e,0x06,0xf9,0x3c,0xfe,0x63,0x2c,0x9a,0x60,0x88,0xcd,0x32,0x86,0x62,0xd4,0x7a,0x49,0x54,0x93,0x48,0x32,0xdf,0x5b,0x5f,0x37,0x65,0xdb,0xe1,0x36,0x11,0x4c,0x73,0xc5,0x5c,0xb7,0xce,0x63,0x9e,0x5d,0x40,0xd1,0xd1,0xd8,0xf5,0x40,0xd3,0xc8,0xe1,0xbc,0x74,0x23,0xf0,0x32,0xc0,0xda,0x52,0x64,0x35,0x34,0x68,0xf0,0x09,0xc9,0x73,0xee,0xc0,0x44,0x8e,0x41,0xf9,0x28,0x9e,0x8d,0x9d,0xad,0xc6,0x8d,0xa7,0x7d,0x3c,0x3a,0xb3,0xa6,0x47,0x7d,0x44,0x02,0x4f,0x21,0xfb,0xa0,0xbd,0x44,0x77,0xd8,0x1c,0x60,0x27,0x65,0x75,0x27,0xaa,0x04,0x13,0xb4,0x5f,0x41,0x7c,0xb7,0xb3,0xbe,0xea,0x83,0x5a,0x1d,0x5d,0x79,0x54,0x14,0xd3,0x81,0x56,0x32,0x4c,0xb5,0xc1,0x30,0x3e,0x99,0x24,0xdb,0xe4,0x0c,0xd4,0x97,0xc4,0xc2,0x3c,0x22,0x1c,0xb9,0x12,0x05,0x8c,0x93,0x9b,0xea,0x8b,0x79,0xb3,0xfe,0xa3,0x60,0xfe,0xca,0xa8,0x33,0x75,0xa9,0xa8,0x4e,0x33,0x8d,0x9e,0x86,0x3e,0x80,0x21,0xad,0x2d,0xf4,0x43,0x0b,0x8d,0xea,0x0c,0x17,0x14,0xe1,0xbd,0xc4,0x78,0xf5,0x59,0x70,0x55,0x49,0xad,0x73,0x84,0x53,0xab,0x65,0xc0,0xff,0xcc,0x8c,0xf0,0xe3,0xba,0xfa,0xf4,0xaf,0xad,0x75,0xec,0xc4,0xdf,0xad,0x0d,0xe0,0xcf,0xe2,0x7d,0x50,0xd6,0x56,0x45,0x6e,0xa6,0xc3,0x61,0xb7,0x65,0x08,0x35,0x77,0x14,0x07,0x94,0x24].to_vec())))))));
[INFO] [stdout] 1246 +         assert_eq!(LogKind::parser().parse(r#"App::Trace Connect 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"#.into()), Ok(("", LogKind::App(AppLogKind::Trace(AppLogTraceKind::Connect(AuthData([0x30,0xc3,0x05,0x82,0x5b,0x90,0x00,0x77,0xae,0x7f,0x82,0x59,0xc1,0xc3,0x28,0xaa,0x3e,0x12,0x4a,0x07,0xf3,0xbf,0xbb,0xf2,0x16,0xdf,0xc6,0xe3,0x08,0xbe,0xea,0x6e,0x47,0x4b,0x9a,0x7e,0xa6,0xc2,0x4d,0x00,0x3a,0x6a,0xe4,0xfc,0xf0,0x4a,0x9e,0x6e,0xf7,0xc7,0xf1,0x7c,0xda,0xa0,0x29,0x6f,0x66,0xa8,0x80,0x36,0xba,0xdc,0xf0,0x1f,0x05,0x3d,0xa8,0x06,0xfa,0xd3,0x56,0x54,0x63,0x49,0xde,0xce,0xff,0x24,0x62,0x1b,0x89,0x54,0x40,0xd0,0x5a,0x71,0x5b,0x22,0x1a,0xf8,0xe9,0xe0,0x68,0x07,0x3d,0x6d,0xec,0x04,0xf1,0x48,0x17,0x57,0x17,0xd3,0xc2,0xd1,0xb6,0xaf,0x84,0xe2,0x37,0x57,0x18,0xab,0x4a,0x1e,0xba,0x7e,0x03,0x7c,0x1c,0x1d,0x43,0xb4,0xcf,0x42,0x2d,0x6f,0x2a,0xa9,0x19,0x42,0x66,0xf0,0xa7,0x54,0x4e,0xae,0xff,0x81,0x67,0xf0,0xe9,0x93,0xd0,0xea,0x6a,0x8d,0xdb,0x98,0xbf,0xeb,0x88,0x05,0x63,0x5d,0x5e,0xa9,0xf6,0x59,0x2f,0xd5,0x29,0x7e,0x6f,0x83,0xb6,0x83,0x41,0x90,0xf9,0x94,0x49,0x72,0x2c,0xd0,0xde,0x87,0xa4,0xc1,0x22,0xf0,0x8b,0xbe,0x83,0x6f,0xd3,0x09,0x2e,0x5f,0x0d,0x37,0xa3,0x05,0x7e,0x90,0xf3,0xdd,0x41,0x04,0x8d,0xa6,0x6c,0xad,0x3e,0x8f,0xd3,0xef,0x72,0xa9,0xd8,0x6e,0xcd,0x90,0x09,0xc2,0xdb,0x99,0x6a,0xf2,0x9d,0xc6,0x2a,0xf5,0xef,0x5e,0xb0,0x4d,0x0e,0x16,0xce,0x8f,0xce,0xcb,0xa9,0x2a,0x4a,0x98,0x88,0xf5,0x2d,0x5d,0x57,0x5e,0x7d,0xbc,0x30,0x2e,0xd9,0x7d,0xbf,0x69,0xdf,0x15,0xbb,0x4f,0x5c,0x56,0x01,0xd3,0x8f,0xbe,0x3b,0xd8,0x9d,0x88,0x76,0x8a,0x6a,0xed,0x11,0xce,0x2f,0x95,0xa6,0xad,0x30,0xbb,0x72,0xe7,0x87,0xbf,0xb7,0x34,0x70,0x1c,0xea,0x1f,0x38,0x16,0x8b,0xe4,0x4e,0xa1,0x9d,0x3e,0x98,0xdd,0x3c,0x95,0x3f,0xdb,0x99,0x51,0xac,0x9c,0x6e,0x22,0x1b,0xb0,0xf9,0x80,0xd8,0xf0,0x95,0x2a,0xc8,0x12,0x7d,0xa5,0xbd,0xa7,0x07,0x7d,0xd2,0x5f,0xfc,0x8e,0x15,0x15,0xc5,0x29,0xf2,0x95,0x16,0xda,0xce,0xc6,0xbe,0x9c,0x08,0x4e,0x6c,0x91,0x69,0x82,0x67,0xb2,0xae,0xd9,0x03,0x8e,0xca,0x5e,0xba,0xfa,0xd4,0x79,0xc5,0xfb,0x17,0x65,0x2e,0x25,0xbb,0x5b,0x85,0x58,0x6f,0xae,0x64,0x5b,0xd7,0xc3,0x25,0x3d,0x99,0x16,0xc0,0xaf,0x65,0xa2,0x02,0x53,0x41,0x2d,0x54,0x84,0xac,0x15,0xd2,0x88,0xc6,0xca,0x88,0x23,0x46,0x90,0x90,0xde,0xd5,0xce,0x09,0x75,0xda,0xda,0x63,0x65,0x37,0x97,0x12,0x9f,0x0e,0x92,0x6a,0xf6,0x24,0x7b,0x45,0x7b,0x06,0x7d,0xb6,0x83,0xe3,0x7d,0x84,0x8e,0x0a,0xcf,0x30,0xe5,0x60,0x2b,0x78,0xf1,0x84,0x8e,0x8d,0xa4,0xb6,0x40,0xed,0x08,0xb7,0x5f,0x35,0x19,0xa4,0x0e,0xc9,0x6b,0x2b,0xe9,0x64,0x23,0x4b,0xea,0xb3,0x77,0x59,0x50,0x43,0x76,0xc6,0xe5,0xeb,0xfa,0xcd,0xc5,0x7e,0x4c,0x7a,0x22,0xcf,0x1e,0x87,0x9d,0x7b,0xde,0x29,0xa2,0xdc,0xa5,0xfe,0x20,0x42,0x02,0x15,0xb5,0x9d,0x10,0x2f,0xd0,0x16,0x60,0x6c,0x53,0x3e,0x8e,0x36,0xf7,0xda,0x11,0x49,0x10,0x66,0x4b,0xad,0xe9,0xb2,0x95,0xd9,0x04,0x3a,0x01,0xbc,0x0d,0xc4,0xd8,0xab,0xbc,0x16,0xb1,0xce,0xc7,0x78,0x9d,0x89,0xe6,0x99,0xad,0x99,0xda,0xe5,0x97,0xc7,0xf1,0x0d,0x6f,0x04,0x7e,0xfc,0x01,0x1d,0x67,0x44,0x46,0x95,0xcb,0x8e,0x6e,0x8b,0x3d,0xba,0x17,0xcc,0xc6,0x93,0x72,0x9d,0x01,0x31,0x2d,0x0f,0x12,0xa3,0xfc,0x76,0xe1,0x2c,0x2e,0x49,0x84,0xaf,0x5c,0xb3,0x04,0x9b,0x9d,0x8a,0x13,0x12,0x4a,0x1f,0x77,0x0e,0x96,0xba,0xe1,0xfb,0x15,0x3b,0xa4,0xc9,0x1b,0xea,0x4f,0xae,0x6f,0x03,0x01,0x02,0x75,0xd5,0xa9,0xb1,0x40,0x12,0xbd,0xd6,0x78,0xe0,0x37,0x93,0x4d,0xc6,0x76,0x20,0x05,0xde,0x54,0xb3,0x2a,0x76,0x84,0xe0,0x30,0x60,0xd5,0xcc,0x80,0x37,0x8e,0x9b,0xef,0x05,0xb8,0xf0,0x69,0x22,0x02,0x94,0x44,0x01,0xbd,0x06,0xe4,0x55,0x3e,0x44,0x90,0xa0,0xe5,0x7c,0x5a,0x72,0xfc,0x8a,0xbb,0x1f,0x71,0x4e,0x22,0xea,0x95,0x0f,0xb2,0xf1,0xde,0x28,0x4d,0x6f,0xf3,0xda,0x43,0x59,0x54,0xde,0x35,0x5c,0x67,0x7f,0x60,0xdb,0x42,0x52,0xa5,0x10,0x91,0x9c,0xbe,0x7d,0xad,0xfe,0xd0,0x44,0x1c,0xf1,0x25,0xfd,0x88,0x94,0x75,0x3a,0xf8,0x11,0x4f,0x2d,0xda,0xcb,0x75,0xc3,0xda,0xa4,0x60,0x92,0x0f,0xc4,0x7d,0x28,0x5e,0x59,0xfe,0x91,0x10,0xe4,0x15,0x1f,0xce,0xf0,0x3f,0xa2,0x46,0xcd,0x2d,0xd9,0xa4,0xd5,0x73,0xe1,0xdb,0xbd,0xa1,0xc6,0x96,0x8c,0xf4,0xf5,0x46,0x28,0x9b,0x95,0xce,0x1b,0xf0,0xa5,0x5e,0xea,0x65,0x31,0x38,0x28,0x26,0xd4,0x00,0x2b,0xc4,0x6b,0xf4,0x41,0xce,0x16,0x05,0x6d,0x42,0xb5,0xa2,0x07,0x9e,0x29,0x9e,0x31,0x91,0xc2,0x3a,0x76,0x04,0xcd,0xe0,0x3d,0xe6,0x08,0x1e,0x06,0xf9,0x3c,0xfe,0x63,0x2c,0x9a,0x60,0x88,0xcd,0x32,0x86,0x62,0xd4,0x7a,0x49,0x54,0x93,0x48,0x32,0xdf,0x5b,0x5f,0x37,0x65,0xdb,0xe1,0x36,0x11,0x4c,0x73,0xc5,0x5c,0xb7,0xce,0x63,0x9e,0x5d,0x40,0xd1,0xd1,0xd8,0xf5,0x40,0xd3,0xc8,0xe1,0xbc,0x74,0x23,0xf0,0x32,0xc0,0xda,0x52,0x64,0x35,0x34,0x68,0xf0,0x09,0xc9,0x73,0xee,0xc0,0x44,0x8e,0x41,0xf9,0x28,0x9e,0x8d,0x9d,0xad,0xc6,0x8d,0xa7,0x7d,0x3c,0x3a,0xb3,0xa6,0x47,0x7d,0x44,0x02,0x4f,0x21,0xfb,0xa0,0xbd,0x44,0x77,0xd8,0x1c,0x60,0x27,0x65,0x75,0x27,0xaa,0x04,0x13,0xb4,0x5f,0x41,0x7c,0xb7,0xb3,0xbe,0xea,0x83,0x5a,0x1d,0x5d,0x79,0x54,0x14,0xd3,0x81,0x56,0x32,0x4c,0xb5,0xc1,0x30,0x3e,0x99,0x24,0xdb,0xe4,0x0c,0xd4,0x97,0xc4,0xc2,0x3c,0x22,0x1c,0xb9,0x12,0x05,0x8c,0x93,0x9b,0xea,0x8b,0x79,0xb3,0xfe,0xa3,0x60,0xfe,0xca,0xa8,0x33,0x75,0xa9,0xa8,0x4e,0x33,0x8d,0x9e,0x86,0x3e,0x80,0x21,0xad,0x2d,0xf4,0x43,0x0b,0x8d,0xea,0x0c,0x17,0x14,0xe1,0xbd,0xc4,0x78,0xf5,0x59,0x70,0x55,0x49,0xad,0x73,0x84,0x53,0xab,0x65,0xc0,0xff,0xcc,0x8c,0xf0,0xe3,0xba,0xfa,0xf4,0xaf,0xad,0x75,0xec,0xc4,0xdf,0xad,0x0d,0xe0,0xcf,0xe2,0x7d,0x50,0xd6,0x56,0x45,0x6e,0xa6,0xc3,0x61,0xb7,0x65,0x08,0x35,0x77,0x14,0x07,0x94,0x24].to_vec())))))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1246 -         assert_eq!(LogKind::parser().parse(r#"App::Trace Connect 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"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Trace(AppLogTraceKind::Connect(AuthData([0x30,0xc3,0x05,0x82,0x5b,0x90,0x00,0x77,0xae,0x7f,0x82,0x59,0xc1,0xc3,0x28,0xaa,0x3e,0x12,0x4a,0x07,0xf3,0xbf,0xbb,0xf2,0x16,0xdf,0xc6,0xe3,0x08,0xbe,0xea,0x6e,0x47,0x4b,0x9a,0x7e,0xa6,0xc2,0x4d,0x00,0x3a,0x6a,0xe4,0xfc,0xf0,0x4a,0x9e,0x6e,0xf7,0xc7,0xf1,0x7c,0xda,0xa0,0x29,0x6f,0x66,0xa8,0x80,0x36,0xba,0xdc,0xf0,0x1f,0x05,0x3d,0xa8,0x06,0xfa,0xd3,0x56,0x54,0x63,0x49,0xde,0xce,0xff,0x24,0x62,0x1b,0x89,0x54,0x40,0xd0,0x5a,0x71,0x5b,0x22,0x1a,0xf8,0xe9,0xe0,0x68,0x07,0x3d,0x6d,0xec,0x04,0xf1,0x48,0x17,0x57,0x17,0xd3,0xc2,0xd1,0xb6,0xaf,0x84,0xe2,0x37,0x57,0x18,0xab,0x4a,0x1e,0xba,0x7e,0x03,0x7c,0x1c,0x1d,0x43,0xb4,0xcf,0x42,0x2d,0x6f,0x2a,0xa9,0x19,0x42,0x66,0xf0,0xa7,0x54,0x4e,0xae,0xff,0x81,0x67,0xf0,0xe9,0x93,0xd0,0xea,0x6a,0x8d,0xdb,0x98,0xbf,0xeb,0x88,0x05,0x63,0x5d,0x5e,0xa9,0xf6,0x59,0x2f,0xd5,0x29,0x7e,0x6f,0x83,0xb6,0x83,0x41,0x90,0xf9,0x94,0x49,0x72,0x2c,0xd0,0xde,0x87,0xa4,0xc1,0x22,0xf0,0x8b,0xbe,0x83,0x6f,0xd3,0x09,0x2e,0x5f,0x0d,0x37,0xa3,0x05,0x7e,0x90,0xf3,0xdd,0x41,0x04,0x8d,0xa6,0x6c,0xad,0x3e,0x8f,0xd3,0xef,0x72,0xa9,0xd8,0x6e,0xcd,0x90,0x09,0xc2,0xdb,0x99,0x6a,0xf2,0x9d,0xc6,0x2a,0xf5,0xef,0x5e,0xb0,0x4d,0x0e,0x16,0xce,0x8f,0xce,0xcb,0xa9,0x2a,0x4a,0x98,0x88,0xf5,0x2d,0x5d,0x57,0x5e,0x7d,0xbc,0x30,0x2e,0xd9,0x7d,0xbf,0x69,0xdf,0x15,0xbb,0x4f,0x5c,0x56,0x01,0xd3,0x8f,0xbe,0x3b,0xd8,0x9d,0x88,0x76,0x8a,0x6a,0xed,0x11,0xce,0x2f,0x95,0xa6,0xad,0x30,0xbb,0x72,0xe7,0x87,0xbf,0xb7,0x34,0x70,0x1c,0xea,0x1f,0x38,0x16,0x8b,0xe4,0x4e,0xa1,0x9d,0x3e,0x98,0xdd,0x3c,0x95,0x3f,0xdb,0x99,0x51,0xac,0x9c,0x6e,0x22,0x1b,0xb0,0xf9,0x80,0xd8,0xf0,0x95,0x2a,0xc8,0x12,0x7d,0xa5,0xbd,0xa7,0x07,0x7d,0xd2,0x5f,0xfc,0x8e,0x15,0x15,0xc5,0x29,0xf2,0x95,0x16,0xda,0xce,0xc6,0xbe,0x9c,0x08,0x4e,0x6c,0x91,0x69,0x82,0x67,0xb2,0xae,0xd9,0x03,0x8e,0xca,0x5e,0xba,0xfa,0xd4,0x79,0xc5,0xfb,0x17,0x65,0x2e,0x25,0xbb,0x5b,0x85,0x58,0x6f,0xae,0x64,0x5b,0xd7,0xc3,0x25,0x3d,0x99,0x16,0xc0,0xaf,0x65,0xa2,0x02,0x53,0x41,0x2d,0x54,0x84,0xac,0x15,0xd2,0x88,0xc6,0xca,0x88,0x23,0x46,0x90,0x90,0xde,0xd5,0xce,0x09,0x75,0xda,0xda,0x63,0x65,0x37,0x97,0x12,0x9f,0x0e,0x92,0x6a,0xf6,0x24,0x7b,0x45,0x7b,0x06,0x7d,0xb6,0x83,0xe3,0x7d,0x84,0x8e,0x0a,0xcf,0x30,0xe5,0x60,0x2b,0x78,0xf1,0x84,0x8e,0x8d,0xa4,0xb6,0x40,0xed,0x08,0xb7,0x5f,0x35,0x19,0xa4,0x0e,0xc9,0x6b,0x2b,0xe9,0x64,0x23,0x4b,0xea,0xb3,0x77,0x59,0x50,0x43,0x76,0xc6,0xe5,0xeb,0xfa,0xcd,0xc5,0x7e,0x4c,0x7a,0x22,0xcf,0x1e,0x87,0x9d,0x7b,0xde,0x29,0xa2,0xdc,0xa5,0xfe,0x20,0x42,0x02,0x15,0xb5,0x9d,0x10,0x2f,0xd0,0x16,0x60,0x6c,0x53,0x3e,0x8e,0x36,0xf7,0xda,0x11,0x49,0x10,0x66,0x4b,0xad,0xe9,0xb2,0x95,0xd9,0x04,0x3a,0x01,0xbc,0x0d,0xc4,0xd8,0xab,0xbc,0x16,0xb1,0xce,0xc7,0x78,0x9d,0x89,0xe6,0x99,0xad,0x99,0xda,0xe5,0x97,0xc7,0xf1,0x0d,0x6f,0x04,0x7e,0xfc,0x01,0x1d,0x67,0x44,0x46,0x95,0xcb,0x8e,0x6e,0x8b,0x3d,0xba,0x17,0xcc,0xc6,0x93,0x72,0x9d,0x01,0x31,0x2d,0x0f,0x12,0xa3,0xfc,0x76,0xe1,0x2c,0x2e,0x49,0x84,0xaf,0x5c,0xb3,0x04,0x9b,0x9d,0x8a,0x13,0x12,0x4a,0x1f,0x77,0x0e,0x96,0xba,0xe1,0xfb,0x15,0x3b,0xa4,0xc9,0x1b,0xea,0x4f,0xae,0x6f,0x03,0x01,0x02,0x75,0xd5,0xa9,0xb1,0x40,0x12,0xbd,0xd6,0x78,0xe0,0x37,0x93,0x4d,0xc6,0x76,0x20,0x05,0xde,0x54,0xb3,0x2a,0x76,0x84,0xe0,0x30,0x60,0xd5,0xcc,0x80,0x37,0x8e,0x9b,0xef,0x05,0xb8,0xf0,0x69,0x22,0x02,0x94,0x44,0x01,0xbd,0x06,0xe4,0x55,0x3e,0x44,0x90,0xa0,0xe5,0x7c,0x5a,0x72,0xfc,0x8a,0xbb,0x1f,0x71,0x4e,0x22,0xea,0x95,0x0f,0xb2,0xf1,0xde,0x28,0x4d,0x6f,0xf3,0xda,0x43,0x59,0x54,0xde,0x35,0x5c,0x67,0x7f,0x60,0xdb,0x42,0x52,0xa5,0x10,0x91,0x9c,0xbe,0x7d,0xad,0xfe,0xd0,0x44,0x1c,0xf1,0x25,0xfd,0x88,0x94,0x75,0x3a,0xf8,0x11,0x4f,0x2d,0xda,0xcb,0x75,0xc3,0xda,0xa4,0x60,0x92,0x0f,0xc4,0x7d,0x28,0x5e,0x59,0xfe,0x91,0x10,0xe4,0x15,0x1f,0xce,0xf0,0x3f,0xa2,0x46,0xcd,0x2d,0xd9,0xa4,0xd5,0x73,0xe1,0xdb,0xbd,0xa1,0xc6,0x96,0x8c,0xf4,0xf5,0x46,0x28,0x9b,0x95,0xce,0x1b,0xf0,0xa5,0x5e,0xea,0x65,0x31,0x38,0x28,0x26,0xd4,0x00,0x2b,0xc4,0x6b,0xf4,0x41,0xce,0x16,0x05,0x6d,0x42,0xb5,0xa2,0x07,0x9e,0x29,0x9e,0x31,0x91,0xc2,0x3a,0x76,0x04,0xcd,0xe0,0x3d,0xe6,0x08,0x1e,0x06,0xf9,0x3c,0xfe,0x63,0x2c,0x9a,0x60,0x88,0xcd,0x32,0x86,0x62,0xd4,0x7a,0x49,0x54,0x93,0x48,0x32,0xdf,0x5b,0x5f,0x37,0x65,0xdb,0xe1,0x36,0x11,0x4c,0x73,0xc5,0x5c,0xb7,0xce,0x63,0x9e,0x5d,0x40,0xd1,0xd1,0xd8,0xf5,0x40,0xd3,0xc8,0xe1,0xbc,0x74,0x23,0xf0,0x32,0xc0,0xda,0x52,0x64,0x35,0x34,0x68,0xf0,0x09,0xc9,0x73,0xee,0xc0,0x44,0x8e,0x41,0xf9,0x28,0x9e,0x8d,0x9d,0xad,0xc6,0x8d,0xa7,0x7d,0x3c,0x3a,0xb3,0xa6,0x47,0x7d,0x44,0x02,0x4f,0x21,0xfb,0xa0,0xbd,0x44,0x77,0xd8,0x1c,0x60,0x27,0x65,0x75,0x27,0xaa,0x04,0x13,0xb4,0x5f,0x41,0x7c,0xb7,0xb3,0xbe,0xea,0x83,0x5a,0x1d,0x5d,0x79,0x54,0x14,0xd3,0x81,0x56,0x32,0x4c,0xb5,0xc1,0x30,0x3e,0x99,0x24,0xdb,0xe4,0x0c,0xd4,0x97,0xc4,0xc2,0x3c,0x22,0x1c,0xb9,0x12,0x05,0x8c,0x93,0x9b,0xea,0x8b,0x79,0xb3,0xfe,0xa3,0x60,0xfe,0xca,0xa8,0x33,0x75,0xa9,0xa8,0x4e,0x33,0x8d,0x9e,0x86,0x3e,0x80,0x21,0xad,0x2d,0xf4,0x43,0x0b,0x8d,0xea,0x0c,0x17,0x14,0xe1,0xbd,0xc4,0x78,0xf5,0x59,0x70,0x55,0x49,0xad,0x73,0x84,0x53,0xab,0x65,0xc0,0xff,0xcc,0x8c,0xf0,0xe3,0xba,0xfa,0xf4,0xaf,0xad,0x75,0xec,0xc4,0xdf,0xad,0x0d,0xe0,0xcf,0xe2,0x7d,0x50,0xd6,0x56,0x45,0x6e,0xa6,0xc3,0x61,0xb7,0x65,0x08,0x35,0x77,0x14,0x07,0x94,0x24].to_vec())))))));
[INFO] [stdout] 1246 +         assert_eq!(LogKind::parser().parse(r#"App::Trace Connect 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"#.into()), Ok((<&str as Into<_>>::into(""), LogKind::App(AppLogKind::Trace(AppLogTraceKind::Connect(AuthData([0x30,0xc3,0x05,0x82,0x5b,0x90,0x00,0x77,0xae,0x7f,0x82,0x59,0xc1,0xc3,0x28,0xaa,0x3e,0x12,0x4a,0x07,0xf3,0xbf,0xbb,0xf2,0x16,0xdf,0xc6,0xe3,0x08,0xbe,0xea,0x6e,0x47,0x4b,0x9a,0x7e,0xa6,0xc2,0x4d,0x00,0x3a,0x6a,0xe4,0xfc,0xf0,0x4a,0x9e,0x6e,0xf7,0xc7,0xf1,0x7c,0xda,0xa0,0x29,0x6f,0x66,0xa8,0x80,0x36,0xba,0xdc,0xf0,0x1f,0x05,0x3d,0xa8,0x06,0xfa,0xd3,0x56,0x54,0x63,0x49,0xde,0xce,0xff,0x24,0x62,0x1b,0x89,0x54,0x40,0xd0,0x5a,0x71,0x5b,0x22,0x1a,0xf8,0xe9,0xe0,0x68,0x07,0x3d,0x6d,0xec,0x04,0xf1,0x48,0x17,0x57,0x17,0xd3,0xc2,0xd1,0xb6,0xaf,0x84,0xe2,0x37,0x57,0x18,0xab,0x4a,0x1e,0xba,0x7e,0x03,0x7c,0x1c,0x1d,0x43,0xb4,0xcf,0x42,0x2d,0x6f,0x2a,0xa9,0x19,0x42,0x66,0xf0,0xa7,0x54,0x4e,0xae,0xff,0x81,0x67,0xf0,0xe9,0x93,0xd0,0xea,0x6a,0x8d,0xdb,0x98,0xbf,0xeb,0x88,0x05,0x63,0x5d,0x5e,0xa9,0xf6,0x59,0x2f,0xd5,0x29,0x7e,0x6f,0x83,0xb6,0x83,0x41,0x90,0xf9,0x94,0x49,0x72,0x2c,0xd0,0xde,0x87,0xa4,0xc1,0x22,0xf0,0x8b,0xbe,0x83,0x6f,0xd3,0x09,0x2e,0x5f,0x0d,0x37,0xa3,0x05,0x7e,0x90,0xf3,0xdd,0x41,0x04,0x8d,0xa6,0x6c,0xad,0x3e,0x8f,0xd3,0xef,0x72,0xa9,0xd8,0x6e,0xcd,0x90,0x09,0xc2,0xdb,0x99,0x6a,0xf2,0x9d,0xc6,0x2a,0xf5,0xef,0x5e,0xb0,0x4d,0x0e,0x16,0xce,0x8f,0xce,0xcb,0xa9,0x2a,0x4a,0x98,0x88,0xf5,0x2d,0x5d,0x57,0x5e,0x7d,0xbc,0x30,0x2e,0xd9,0x7d,0xbf,0x69,0xdf,0x15,0xbb,0x4f,0x5c,0x56,0x01,0xd3,0x8f,0xbe,0x3b,0xd8,0x9d,0x88,0x76,0x8a,0x6a,0xed,0x11,0xce,0x2f,0x95,0xa6,0xad,0x30,0xbb,0x72,0xe7,0x87,0xbf,0xb7,0x34,0x70,0x1c,0xea,0x1f,0x38,0x16,0x8b,0xe4,0x4e,0xa1,0x9d,0x3e,0x98,0xdd,0x3c,0x95,0x3f,0xdb,0x99,0x51,0xac,0x9c,0x6e,0x22,0x1b,0xb0,0xf9,0x80,0xd8,0xf0,0x95,0x2a,0xc8,0x12,0x7d,0xa5,0xbd,0xa7,0x07,0x7d,0xd2,0x5f,0xfc,0x8e,0x15,0x15,0xc5,0x29,0xf2,0x95,0x16,0xda,0xce,0xc6,0xbe,0x9c,0x08,0x4e,0x6c,0x91,0x69,0x82,0x67,0xb2,0xae,0xd9,0x03,0x8e,0xca,0x5e,0xba,0xfa,0xd4,0x79,0xc5,0xfb,0x17,0x65,0x2e,0x25,0xbb,0x5b,0x85,0x58,0x6f,0xae,0x64,0x5b,0xd7,0xc3,0x25,0x3d,0x99,0x16,0xc0,0xaf,0x65,0xa2,0x02,0x53,0x41,0x2d,0x54,0x84,0xac,0x15,0xd2,0x88,0xc6,0xca,0x88,0x23,0x46,0x90,0x90,0xde,0xd5,0xce,0x09,0x75,0xda,0xda,0x63,0x65,0x37,0x97,0x12,0x9f,0x0e,0x92,0x6a,0xf6,0x24,0x7b,0x45,0x7b,0x06,0x7d,0xb6,0x83,0xe3,0x7d,0x84,0x8e,0x0a,0xcf,0x30,0xe5,0x60,0x2b,0x78,0xf1,0x84,0x8e,0x8d,0xa4,0xb6,0x40,0xed,0x08,0xb7,0x5f,0x35,0x19,0xa4,0x0e,0xc9,0x6b,0x2b,0xe9,0x64,0x23,0x4b,0xea,0xb3,0x77,0x59,0x50,0x43,0x76,0xc6,0xe5,0xeb,0xfa,0xcd,0xc5,0x7e,0x4c,0x7a,0x22,0xcf,0x1e,0x87,0x9d,0x7b,0xde,0x29,0xa2,0xdc,0xa5,0xfe,0x20,0x42,0x02,0x15,0xb5,0x9d,0x10,0x2f,0xd0,0x16,0x60,0x6c,0x53,0x3e,0x8e,0x36,0xf7,0xda,0x11,0x49,0x10,0x66,0x4b,0xad,0xe9,0xb2,0x95,0xd9,0x04,0x3a,0x01,0xbc,0x0d,0xc4,0xd8,0xab,0xbc,0x16,0xb1,0xce,0xc7,0x78,0x9d,0x89,0xe6,0x99,0xad,0x99,0xda,0xe5,0x97,0xc7,0xf1,0x0d,0x6f,0x04,0x7e,0xfc,0x01,0x1d,0x67,0x44,0x46,0x95,0xcb,0x8e,0x6e,0x8b,0x3d,0xba,0x17,0xcc,0xc6,0x93,0x72,0x9d,0x01,0x31,0x2d,0x0f,0x12,0xa3,0xfc,0x76,0xe1,0x2c,0x2e,0x49,0x84,0xaf,0x5c,0xb3,0x04,0x9b,0x9d,0x8a,0x13,0x12,0x4a,0x1f,0x77,0x0e,0x96,0xba,0xe1,0xfb,0x15,0x3b,0xa4,0xc9,0x1b,0xea,0x4f,0xae,0x6f,0x03,0x01,0x02,0x75,0xd5,0xa9,0xb1,0x40,0x12,0xbd,0xd6,0x78,0xe0,0x37,0x93,0x4d,0xc6,0x76,0x20,0x05,0xde,0x54,0xb3,0x2a,0x76,0x84,0xe0,0x30,0x60,0xd5,0xcc,0x80,0x37,0x8e,0x9b,0xef,0x05,0xb8,0xf0,0x69,0x22,0x02,0x94,0x44,0x01,0xbd,0x06,0xe4,0x55,0x3e,0x44,0x90,0xa0,0xe5,0x7c,0x5a,0x72,0xfc,0x8a,0xbb,0x1f,0x71,0x4e,0x22,0xea,0x95,0x0f,0xb2,0xf1,0xde,0x28,0x4d,0x6f,0xf3,0xda,0x43,0x59,0x54,0xde,0x35,0x5c,0x67,0x7f,0x60,0xdb,0x42,0x52,0xa5,0x10,0x91,0x9c,0xbe,0x7d,0xad,0xfe,0xd0,0x44,0x1c,0xf1,0x25,0xfd,0x88,0x94,0x75,0x3a,0xf8,0x11,0x4f,0x2d,0xda,0xcb,0x75,0xc3,0xda,0xa4,0x60,0x92,0x0f,0xc4,0x7d,0x28,0x5e,0x59,0xfe,0x91,0x10,0xe4,0x15,0x1f,0xce,0xf0,0x3f,0xa2,0x46,0xcd,0x2d,0xd9,0xa4,0xd5,0x73,0xe1,0xdb,0xbd,0xa1,0xc6,0x96,0x8c,0xf4,0xf5,0x46,0x28,0x9b,0x95,0xce,0x1b,0xf0,0xa5,0x5e,0xea,0x65,0x31,0x38,0x28,0x26,0xd4,0x00,0x2b,0xc4,0x6b,0xf4,0x41,0xce,0x16,0x05,0x6d,0x42,0xb5,0xa2,0x07,0x9e,0x29,0x9e,0x31,0x91,0xc2,0x3a,0x76,0x04,0xcd,0xe0,0x3d,0xe6,0x08,0x1e,0x06,0xf9,0x3c,0xfe,0x63,0x2c,0x9a,0x60,0x88,0xcd,0x32,0x86,0x62,0xd4,0x7a,0x49,0x54,0x93,0x48,0x32,0xdf,0x5b,0x5f,0x37,0x65,0xdb,0xe1,0x36,0x11,0x4c,0x73,0xc5,0x5c,0xb7,0xce,0x63,0x9e,0x5d,0x40,0xd1,0xd1,0xd8,0xf5,0x40,0xd3,0xc8,0xe1,0xbc,0x74,0x23,0xf0,0x32,0xc0,0xda,0x52,0x64,0x35,0x34,0x68,0xf0,0x09,0xc9,0x73,0xee,0xc0,0x44,0x8e,0x41,0xf9,0x28,0x9e,0x8d,0x9d,0xad,0xc6,0x8d,0xa7,0x7d,0x3c,0x3a,0xb3,0xa6,0x47,0x7d,0x44,0x02,0x4f,0x21,0xfb,0xa0,0xbd,0x44,0x77,0xd8,0x1c,0x60,0x27,0x65,0x75,0x27,0xaa,0x04,0x13,0xb4,0x5f,0x41,0x7c,0xb7,0xb3,0xbe,0xea,0x83,0x5a,0x1d,0x5d,0x79,0x54,0x14,0xd3,0x81,0x56,0x32,0x4c,0xb5,0xc1,0x30,0x3e,0x99,0x24,0xdb,0xe4,0x0c,0xd4,0x97,0xc4,0xc2,0x3c,0x22,0x1c,0xb9,0x12,0x05,0x8c,0x93,0x9b,0xea,0x8b,0x79,0xb3,0xfe,0xa3,0x60,0xfe,0xca,0xa8,0x33,0x75,0xa9,0xa8,0x4e,0x33,0x8d,0x9e,0x86,0x3e,0x80,0x21,0xad,0x2d,0xf4,0x43,0x0b,0x8d,0xea,0x0c,0x17,0x14,0xe1,0xbd,0xc4,0x78,0xf5,0x59,0x70,0x55,0x49,0xad,0x73,0x84,0x53,0xab,0x65,0xc0,0xff,0xcc,0x8c,0xf0,0xe3,0xba,0xfa,0xf4,0xaf,0xad,0x75,0xec,0xc4,0xdf,0xad,0x0d,0xe0,0xcf,0xe2,0x7d,0x50,0xd6,0x56,0x45,0x6e,0xa6,0xc3,0x61,0xb7,0x65,0x08,0x35,0x77,0x14,0x07,0x94,0x24].to_vec())))))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1247:44
[INFO] [stdout]      |
[INFO] [stdout] 1247 | ...ind::parser().parse(r#"App::Journal CreateUser {"user_id": "Steeve", "authorized_capital": 10000,}"#.into()), Ok(("".into(), Lo...
[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] 1247 -         assert_eq!(LogKind::parser().parse(r#"App::Journal CreateUser {"user_id": "Steeve", "authorized_capital": 10000,}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::CreateUser{user_id: "Steeve".into(), authorized_capital: NonZeroU32::new(10_000).unwrap()})))));
[INFO] [stdout] 1247 +         assert_eq!(LogKind::parser().parse(r#"App::Journal CreateUser {"user_id": "Steeve", "authorized_capital": 10000,}"#), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::CreateUser{user_id: "Steeve".into(), authorized_capital: NonZeroU32::new(10_000).unwrap()})))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1247 -         assert_eq!(LogKind::parser().parse(r#"App::Journal CreateUser {"user_id": "Steeve", "authorized_capital": 10000,}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::CreateUser{user_id: "Steeve".into(), authorized_capital: NonZeroU32::new(10_000).unwrap()})))));
[INFO] [stdout] 1247 +         assert_eq!(LogKind::parser().parse(<&str as Into<_>>::into(r#"App::Journal CreateUser {"user_id": "Steeve", "authorized_capital": 10000,}"#)), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::CreateUser{user_id: "Steeve".into(), authorized_capital: NonZeroU32::new(10_000).unwrap()})))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1247:138
[INFO] [stdout]      |
[INFO] [stdout] 1247 | ...d": "Steeve", "authorized_capital": 10000,}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::Creat...
[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] 1247 -         assert_eq!(LogKind::parser().parse(r#"App::Journal CreateUser {"user_id": "Steeve", "authorized_capital": 10000,}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::CreateUser{user_id: "Steeve".into(), authorized_capital: NonZeroU32::new(10_000).unwrap()})))));
[INFO] [stdout] 1247 +         assert_eq!(LogKind::parser().parse(r#"App::Journal CreateUser {"user_id": "Steeve", "authorized_capital": 10000,}"#.into()), Ok(("", LogKind::App(AppLogKind::Journal(AppLogJournalKind::CreateUser{user_id: "Steeve".into(), authorized_capital: NonZeroU32::new(10_000).unwrap()})))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1247 -         assert_eq!(LogKind::parser().parse(r#"App::Journal CreateUser {"user_id": "Steeve", "authorized_capital": 10000,}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::CreateUser{user_id: "Steeve".into(), authorized_capital: NonZeroU32::new(10_000).unwrap()})))));
[INFO] [stdout] 1247 +         assert_eq!(LogKind::parser().parse(r#"App::Journal CreateUser {"user_id": "Steeve", "authorized_capital": 10000,}"#.into()), Ok((<&str as Into<_>>::into(""), LogKind::App(AppLogKind::Journal(AppLogJournalKind::CreateUser{user_id: "Steeve".into(), authorized_capital: NonZeroU32::new(10_000).unwrap()})))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1248:44
[INFO] [stdout]      |
[INFO] [stdout] 1248 | ...   assert_eq!(LogKind::parser().parse(r#"App::Journal DeleteUser {"user_id": "Steeve",}"#.into()), Ok(("".into(), LogKind::App(...
[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] 1248 -         assert_eq!(LogKind::parser().parse(r#"App::Journal DeleteUser {"user_id": "Steeve",}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DeleteUser{user_id: "Steeve".into()})))));
[INFO] [stdout] 1248 +         assert_eq!(LogKind::parser().parse(r#"App::Journal DeleteUser {"user_id": "Steeve",}"#), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DeleteUser{user_id: "Steeve".into()})))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1248 -         assert_eq!(LogKind::parser().parse(r#"App::Journal DeleteUser {"user_id": "Steeve",}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DeleteUser{user_id: "Steeve".into()})))));
[INFO] [stdout] 1248 +         assert_eq!(LogKind::parser().parse(<&str as Into<_>>::into(r#"App::Journal DeleteUser {"user_id": "Steeve",}"#)), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DeleteUser{user_id: "Steeve".into()})))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1248:109
[INFO] [stdout]      |
[INFO] [stdout] 1248 | ...   assert_eq!(LogKind::parser().parse(r#"App::Journal DeleteUser {"user_id": "Steeve",}"#.into()), Ok(("".into(), LogKind::App(...
[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] 1248 -         assert_eq!(LogKind::parser().parse(r#"App::Journal DeleteUser {"user_id": "Steeve",}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DeleteUser{user_id: "Steeve".into()})))));
[INFO] [stdout] 1248 +         assert_eq!(LogKind::parser().parse(r#"App::Journal DeleteUser {"user_id": "Steeve",}"#.into()), Ok(("", LogKind::App(AppLogKind::Journal(AppLogJournalKind::DeleteUser{user_id: "Steeve".into()})))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1248 -         assert_eq!(LogKind::parser().parse(r#"App::Journal DeleteUser {"user_id": "Steeve",}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DeleteUser{user_id: "Steeve".into()})))));
[INFO] [stdout] 1248 +         assert_eq!(LogKind::parser().parse(r#"App::Journal DeleteUser {"user_id": "Steeve",}"#.into()), Ok((<&str as Into<_>>::into(""), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DeleteUser{user_id: "Steeve".into()})))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1249:44
[INFO] [stdout]      |
[INFO] [stdout] 1249 | ...er().parse(r#"App::Journal RegisterAsset {"asset_id": "bayc", "liquidity": 100000000, "user_id": "Steeve",}"#.into()), Ok(("".i...
[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] 1249 -         assert_eq!(LogKind::parser().parse(r#"App::Journal RegisterAsset {"asset_id": "bayc", "liquidity": 100000000, "user_id": "Steeve",}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::RegisterAsset{asset_id: "bayc".into(), user_id: "Steeve".into(), liquidity: NonZeroU32::new(100_000_000).unwrap()})))));
[INFO] [stdout] 1249 +         assert_eq!(LogKind::parser().parse(r#"App::Journal RegisterAsset {"asset_id": "bayc", "liquidity": 100000000, "user_id": "Steeve",}"#), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::RegisterAsset{asset_id: "bayc".into(), user_id: "Steeve".into(), liquidity: NonZeroU32::new(100_000_000).unwrap()})))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1249 -         assert_eq!(LogKind::parser().parse(r#"App::Journal RegisterAsset {"asset_id": "bayc", "liquidity": 100000000, "user_id": "Steeve",}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::RegisterAsset{asset_id: "bayc".into(), user_id: "Steeve".into(), liquidity: NonZeroU32::new(100_000_000).unwrap()})))));
[INFO] [stdout] 1249 +         assert_eq!(LogKind::parser().parse(<&str as Into<_>>::into(r#"App::Journal RegisterAsset {"asset_id": "bayc", "liquidity": 100000000, "user_id": "Steeve",}"#)), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::RegisterAsset{asset_id: "bayc".into(), user_id: "Steeve".into(), liquidity: NonZeroU32::new(100_000_000).unwrap()})))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1249:156
[INFO] [stdout]      |
[INFO] [stdout] 1249 | ...iquidity": 100000000, "user_id": "Steeve",}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::Regis...
[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] 1249 -         assert_eq!(LogKind::parser().parse(r#"App::Journal RegisterAsset {"asset_id": "bayc", "liquidity": 100000000, "user_id": "Steeve",}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::RegisterAsset{asset_id: "bayc".into(), user_id: "Steeve".into(), liquidity: NonZeroU32::new(100_000_000).unwrap()})))));
[INFO] [stdout] 1249 +         assert_eq!(LogKind::parser().parse(r#"App::Journal RegisterAsset {"asset_id": "bayc", "liquidity": 100000000, "user_id": "Steeve",}"#.into()), Ok(("", LogKind::App(AppLogKind::Journal(AppLogJournalKind::RegisterAsset{asset_id: "bayc".into(), user_id: "Steeve".into(), liquidity: NonZeroU32::new(100_000_000).unwrap()})))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1249 -         assert_eq!(LogKind::parser().parse(r#"App::Journal RegisterAsset {"asset_id": "bayc", "liquidity": 100000000, "user_id": "Steeve",}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::RegisterAsset{asset_id: "bayc".into(), user_id: "Steeve".into(), liquidity: NonZeroU32::new(100_000_000).unwrap()})))));
[INFO] [stdout] 1249 +         assert_eq!(LogKind::parser().parse(r#"App::Journal RegisterAsset {"asset_id": "bayc", "liquidity": 100000000, "user_id": "Steeve",}"#.into()), Ok((<&str as Into<_>>::into(""), LogKind::App(AppLogKind::Journal(AppLogJournalKind::RegisterAsset{asset_id: "bayc".into(), user_id: "Steeve".into(), liquidity: NonZeroU32::new(100_000_000).unwrap()})))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1250:44
[INFO] [stdout]      |
[INFO] [stdout] 1250 | ...   assert_eq!(LogKind::parser().parse(r#"App::Journal DepositCash UserCash{"user_id": "Steeve", "count": 10,}"#.into()), Ok((""...
[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] 1250 -         assert_eq!(LogKind::parser().parse(r#"App::Journal DepositCash UserCash{"user_id": "Steeve", "count": 10,}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DepositCash(UserCash{user_id: "Steeve".into(), count: NonZeroU32::new(10).unwrap()}))))));
[INFO] [stdout] 1250 +         assert_eq!(LogKind::parser().parse(r#"App::Journal DepositCash UserCash{"user_id": "Steeve", "count": 10,}"#), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DepositCash(UserCash{user_id: "Steeve".into(), count: NonZeroU32::new(10).unwrap()}))))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1250 -         assert_eq!(LogKind::parser().parse(r#"App::Journal DepositCash UserCash{"user_id": "Steeve", "count": 10,}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DepositCash(UserCash{user_id: "Steeve".into(), count: NonZeroU32::new(10).unwrap()}))))));
[INFO] [stdout] 1250 +         assert_eq!(LogKind::parser().parse(<&str as Into<_>>::into(r#"App::Journal DepositCash UserCash{"user_id": "Steeve", "count": 10,}"#)), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DepositCash(UserCash{user_id: "Steeve".into(), count: NonZeroU32::new(10).unwrap()}))))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1250:131
[INFO] [stdout]      |
[INFO] [stdout] 1250 | ...UserCash{"user_id": "Steeve", "count": 10,}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::Depos...
[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] 1250 -         assert_eq!(LogKind::parser().parse(r#"App::Journal DepositCash UserCash{"user_id": "Steeve", "count": 10,}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DepositCash(UserCash{user_id: "Steeve".into(), count: NonZeroU32::new(10).unwrap()}))))));
[INFO] [stdout] 1250 +         assert_eq!(LogKind::parser().parse(r#"App::Journal DepositCash UserCash{"user_id": "Steeve", "count": 10,}"#.into()), Ok(("", LogKind::App(AppLogKind::Journal(AppLogJournalKind::DepositCash(UserCash{user_id: "Steeve".into(), count: NonZeroU32::new(10).unwrap()}))))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1250 -         assert_eq!(LogKind::parser().parse(r#"App::Journal DepositCash UserCash{"user_id": "Steeve", "count": 10,}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DepositCash(UserCash{user_id: "Steeve".into(), count: NonZeroU32::new(10).unwrap()}))))));
[INFO] [stdout] 1250 +         assert_eq!(LogKind::parser().parse(r#"App::Journal DepositCash UserCash{"user_id": "Steeve", "count": 10,}"#.into()), Ok((<&str as Into<_>>::into(""), LogKind::App(AppLogKind::Journal(AppLogJournalKind::DepositCash(UserCash{user_id: "Steeve".into(), count: NonZeroU32::new(10).unwrap()}))))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1251:44
[INFO] [stdout]      |
[INFO] [stdout] 1251 | ...parse(r#"App::Journal BuyAsset UserBacket{"user_id": "Steeve", "backet": Backet{"asset_id":"bayc","count":1,},}"#.into()), Ok((...
[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] 1251 -         assert_eq!(LogKind::parser().parse(r#"App::Journal BuyAsset UserBacket{"user_id": "Steeve", "backet": Backet{"asset_id":"bayc","count":1,},}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::BuyAsset(UserBacket{user_id: "Steeve".into(), backet: Backet{asset_id: "bayc".into(), count: NonZeroU32::new(1).unwrap()}}))))));
[INFO] [stdout] 1251 +         assert_eq!(LogKind::parser().parse(r#"App::Journal BuyAsset UserBacket{"user_id": "Steeve", "backet": Backet{"asset_id":"bayc","count":1,},}"#), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::BuyAsset(UserBacket{user_id: "Steeve".into(), backet: Backet{asset_id: "bayc".into(), count: NonZeroU32::new(1).unwrap()}}))))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1251 -         assert_eq!(LogKind::parser().parse(r#"App::Journal BuyAsset UserBacket{"user_id": "Steeve", "backet": Backet{"asset_id":"bayc","count":1,},}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::BuyAsset(UserBacket{user_id: "Steeve".into(), backet: Backet{asset_id: "bayc".into(), count: NonZeroU32::new(1).unwrap()}}))))));
[INFO] [stdout] 1251 +         assert_eq!(LogKind::parser().parse(<&str as Into<_>>::into(r#"App::Journal BuyAsset UserBacket{"user_id": "Steeve", "backet": Backet{"asset_id":"bayc","count":1,},}"#)), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::BuyAsset(UserBacket{user_id: "Steeve".into(), backet: Backet{asset_id: "bayc".into(), count: NonZeroU32::new(1).unwrap()}}))))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/parse.rs:1251:165
[INFO] [stdout]      |
[INFO] [stdout] 1251 | ...et": Backet{"asset_id":"bayc","count":1,},}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::BuyAs...
[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] 1251 -         assert_eq!(LogKind::parser().parse(r#"App::Journal BuyAsset UserBacket{"user_id": "Steeve", "backet": Backet{"asset_id":"bayc","count":1,},}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::BuyAsset(UserBacket{user_id: "Steeve".into(), backet: Backet{asset_id: "bayc".into(), count: NonZeroU32::new(1).unwrap()}}))))));
[INFO] [stdout] 1251 +         assert_eq!(LogKind::parser().parse(r#"App::Journal BuyAsset UserBacket{"user_id": "Steeve", "backet": Backet{"asset_id":"bayc","count":1,},}"#.into()), Ok(("", LogKind::App(AppLogKind::Journal(AppLogJournalKind::BuyAsset(UserBacket{user_id: "Steeve".into(), backet: Backet{asset_id: "bayc".into(), count: NonZeroU32::new(1).unwrap()}}))))));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1251 -         assert_eq!(LogKind::parser().parse(r#"App::Journal BuyAsset UserBacket{"user_id": "Steeve", "backet": Backet{"asset_id":"bayc","count":1,},}"#.into()), Ok(("".into(), LogKind::App(AppLogKind::Journal(AppLogJournalKind::BuyAsset(UserBacket{user_id: "Steeve".into(), backet: Backet{asset_id: "bayc".into(), count: NonZeroU32::new(1).unwrap()}}))))));
[INFO] [stdout] 1251 +         assert_eq!(LogKind::parser().parse(r#"App::Journal BuyAsset UserBacket{"user_id": "Steeve", "backet": Backet{"asset_id":"bayc","count":1,},}"#.into()), Ok((<&str as Into<_>>::into(""), LogKind::App(AppLogKind::Journal(AppLogJournalKind::BuyAsset(UserBacket{user_id: "Steeve".into(), backet: Backet{asset_id: "bayc".into(), count: NonZeroU32::new(1).unwrap()}}))))));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] running `Command { std: "docker" "inspect" "1dbc2e6380df0257c9aae969cabe143787a645ed7b0991f2c10fde875258a5e2", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "1dbc2e6380df0257c9aae969cabe143787a645ed7b0991f2c10fde875258a5e2", kill_on_drop: false }`
[INFO] [stdout] 1dbc2e6380df0257c9aae969cabe143787a645ed7b0991f2c10fde875258a5e2
