Dec 02 19:46:13.383 INFO testing rs6502-0.3.4 against 1.30.1 for beta-1.31-5
Dec 02 19:46:13.383 INFO running `"docker" "create" "-v" "/mnt/big/crater/work/local/target-dirs/beta-1.31-5/worker-7/1.30.1:/target:rw,Z" "-v" "/mnt/big/crater/work/local/test-source/worker-7/beta-1.31-5/1.30.1:/source:ro,Z" "-v" "/mnt/big/crater/work/local/cargo-home:/cargo-home:ro,Z" "-v" "/mnt/big/crater/work/local/rustup-home:/rustup-home:ro,Z" "-e" "USER_ID=1000" "-e" "SOURCE_DIR=/source" "-e" "USER_ID=1000" "-e" "CMD=cargo +1.30.1 build --frozen" "-e" "CARGO_TARGET_DIR=/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/cargo-home" "-e" "RUSTUP_HOME=/rustup-home" "-m" "1536M" "--network" "none" "crater"`
Dec 02 19:46:13.699 INFO [stdout] 1c2e1f7ee6aaa41ed9ee2503777676563b2fb5a04021f6030c0360fff0337311
Dec 02 19:46:13.705 INFO running `"docker" "start" "-a" "1c2e1f7ee6aaa41ed9ee2503777676563b2fb5a04021f6030c0360fff0337311"`
Dec 02 19:46:14.663 INFO [stderr] usermod: no changes
Dec 02 19:46:14.740 INFO [stderr]    Compiling rs6502 v0.3.4 (/source)
Dec 02 19:46:15.491 INFO [stderr] warning: unused import: `OpCode`
Dec 02 19:46:15.491 INFO [stderr]  --> src/assembler/assembler.rs:7:33
Dec 02 19:46:15.491 INFO [stderr]   |
Dec 02 19:46:15.491 INFO [stderr] 7 | use ::opcodes::{AddressingMode, OpCode};
Dec 02 19:46:15.491 INFO [stderr]   |                                 ^^^^^^
Dec 02 19:46:15.491 INFO [stderr]   |
Dec 02 19:46:15.491 INFO [stderr]   = note: #[warn(unused_imports)] on by default
Dec 02 19:46:15.491 INFO [stderr] 
Dec 02 19:46:15.491 INFO [stderr] warning: unused import: `LexerToken`
Dec 02 19:46:15.491 INFO [stderr]   --> src/assembler/assembler.rs:10:24
Dec 02 19:46:15.491 INFO [stderr]    |
Dec 02 19:46:15.491 INFO [stderr] 10 | use assembler::token::{LexerToken, ParserToken};
Dec 02 19:46:15.491 INFO [stderr]    |                        ^^^^^^^^^^
Dec 02 19:46:15.491 INFO [stderr] 
Dec 02 19:46:15.491 INFO [stderr] warning: unused import: `AddressingMode`
Dec 02 19:46:15.491 INFO [stderr]  --> src/assembler/token.rs:1:17
Dec 02 19:46:15.491 INFO [stderr]   |
Dec 02 19:46:15.491 INFO [stderr] 1 | use ::opcodes::{AddressingMode, OpCode};
Dec 02 19:46:15.491 INFO [stderr]   |                 ^^^^^^^^^^^^^^
Dec 02 19:46:15.491 INFO [stderr] 
Dec 02 19:46:15.491 INFO [stderr] warning: unused import: `::opcodes::OpCode`
Dec 02 19:46:15.491 INFO [stderr]   --> src/assembler/lexer.rs:12:5
Dec 02 19:46:15.491 INFO [stderr]    |
Dec 02 19:46:15.491 INFO [stderr] 12 | use ::opcodes::OpCode;
Dec 02 19:46:15.491 INFO [stderr]    |     ^^^^^^^^^^^^^^^^^
Dec 02 19:46:15.491 INFO [stderr] 
Dec 02 19:46:15.491 INFO [stderr] warning: unused import: `AddressingMode`
Dec 02 19:46:15.491 INFO [stderr]  --> src/cpu/cpu.rs:3:17
Dec 02 19:46:15.491 INFO [stderr]   |
Dec 02 19:46:15.491 INFO [stderr] 3 | use ::opcodes::{AddressingMode, OpCode};
Dec 02 19:46:15.491 INFO [stderr]   |                 ^^^^^^^^^^^^^^
Dec 02 19:46:15.491 INFO [stderr] 
Dec 02 19:46:15.711 INFO [stderr] warning: unreachable statement
Dec 02 19:46:15.711 INFO [stderr]    --> src/assembler/parser.rs:327:21
Dec 02 19:46:15.711 INFO [stderr]     |
Dec 02 19:46:15.711 INFO [stderr] 327 |                     let next = *peeker.peek().unwrap();
Dec 02 19:46:15.711 INFO [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:15.711 INFO [stderr]     |
Dec 02 19:46:15.711 INFO [stderr]     = note: #[warn(unreachable_code)] on by default
Dec 02 19:46:15.711 INFO [stderr] 
Dec 02 19:46:15.723 INFO [stderr] warning: unreachable statement
Dec 02 19:46:15.723 INFO [stderr]    --> src/assembler/parser.rs:490:9
Dec 02 19:46:15.723 INFO [stderr]     |
Dec 02 19:46:15.723 INFO [stderr] 490 |         unreachable!();
Dec 02 19:46:15.723 INFO [stderr]     |         ^^^^^^^^^^^^^^^
Dec 02 19:46:15.723 INFO [stderr]     |
Dec 02 19:46:15.723 INFO [stderr]     = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
Dec 02 19:46:15.723 INFO [stderr] 
Dec 02 19:46:15.923 INFO [stderr] warning: variable `last_addressing_mode` is assigned to, but never used
Dec 02 19:46:15.923 INFO [stderr]    --> src/assembler/assembler.rs:181:17
Dec 02 19:46:15.923 INFO [stderr]     |
Dec 02 19:46:15.923 INFO [stderr] 181 |         let mut last_addressing_mode = AddressingMode::Absolute;
Dec 02 19:46:15.923 INFO [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:15.923 INFO [stderr]     |
Dec 02 19:46:15.923 INFO [stderr]     = note: #[warn(unused_variables)] on by default
Dec 02 19:46:15.923 INFO [stderr]     = note: consider using `_last_addressing_mode` instead
Dec 02 19:46:15.923 INFO [stderr] 
Dec 02 19:46:15.923 INFO [stderr] warning: value assigned to `last_addressing_mode` is never read
Dec 02 19:46:15.923 INFO [stderr]    --> src/assembler/assembler.rs:192:17
Dec 02 19:46:15.923 INFO [stderr]     |
Dec 02 19:46:15.923 INFO [stderr] 192 |                 last_addressing_mode = opcode.mode;
Dec 02 19:46:15.923 INFO [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:15.923 INFO [stderr]     |
Dec 02 19:46:15.923 INFO [stderr]     = note: #[warn(unused_assignments)] on by default
Dec 02 19:46:15.923 INFO [stderr] 
Dec 02 19:46:15.923 INFO [stderr] warning: unused variable: `added_label`
Dec 02 19:46:15.923 INFO [stderr]   --> src/assembler/parser.rs:94:21
Dec 02 19:46:15.923 INFO [stderr]    |
Dec 02 19:46:15.923 INFO [stderr] 94 |             let mut added_label = false;
Dec 02 19:46:15.923 INFO [stderr]    |                     ^^^^^^^^^^^ help: consider using `_added_label` instead
Dec 02 19:46:15.923 INFO [stderr] 
Dec 02 19:46:15.923 INFO [stderr] warning: unused variable: `opcode`
Dec 02 19:46:15.923 INFO [stderr]    --> src/assembler/parser.rs:192:21
Dec 02 19:46:15.923 INFO [stderr]     |
Dec 02 19:46:15.923 INFO [stderr] 192 |         if let Some(opcode) = OpCode::from_mnemonic(mnemonic) {
Dec 02 19:46:15.923 INFO [stderr]     |                     ^^^^^^ help: consider using `_opcode` instead
Dec 02 19:46:15.923 INFO [stderr] 
Dec 02 19:46:15.923 INFO [stderr] warning: unused variable: `next`
Dec 02 19:46:15.923 INFO [stderr]    --> src/assembler/parser.rs:327:25
Dec 02 19:46:15.923 INFO [stderr]     |
Dec 02 19:46:15.923 INFO [stderr] 327 |                     let next = *peeker.peek().unwrap();
Dec 02 19:46:15.923 INFO [stderr]     |                         ^^^^ help: consider using `_next` instead
Dec 02 19:46:15.923 INFO [stderr] 
Dec 02 19:46:15.923 INFO [stderr] warning: unused variable: `addressing_mode`
Dec 02 19:46:15.923 INFO [stderr]    --> src/assembler/parser.rs:334:21
Dec 02 19:46:15.923 INFO [stderr]     |
Dec 02 19:46:15.923 INFO [stderr] 334 |                 let addressing_mode = AddressingMode::Indirect;
Dec 02 19:46:15.923 INFO [stderr]     |                     ^^^^^^^^^^^^^^^ help: consider using `_addressing_mode` instead
Dec 02 19:46:15.923 INFO [stderr] 
Dec 02 19:46:15.923 INFO [stderr] warning: unused variable: `addressing_mode`
Dec 02 19:46:15.923 INFO [stderr]    --> src/assembler/parser.rs:406:29
Dec 02 19:46:15.923 INFO [stderr]     |
Dec 02 19:46:15.923 INFO [stderr] 406 |                         let addressing_mode = AddressingMode::IndirectY;
Dec 02 19:46:15.923 INFO [stderr]     |                             ^^^^^^^^^^^^^^^ help: consider using `_addressing_mode` instead
Dec 02 19:46:15.923 INFO [stderr] 
Dec 02 19:46:15.960 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:15.960 INFO [stderr]    --> src/assembler/lexer.rs:109:30
Dec 02 19:46:15.960 INFO [stderr]     |
Dec 02 19:46:15.960 INFO [stderr] 109 |     fn advance<I>(&mut self, mut peeker: &mut Peekable<I>)
Dec 02 19:46:15.960 INFO [stderr]     |                              ----^^^^^^
Dec 02 19:46:15.960 INFO [stderr]     |                              |
Dec 02 19:46:15.960 INFO [stderr]     |                              help: remove this `mut`
Dec 02 19:46:15.960 INFO [stderr]     |
Dec 02 19:46:15.960 INFO [stderr]     = note: #[warn(unused_mut)] on by default
Dec 02 19:46:15.960 INFO [stderr] 
Dec 02 19:46:16.007 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:16.007 INFO [stderr]    --> src/assembler/parser.rs:200:33
Dec 02 19:46:16.007 INFO [stderr]     |
Dec 02 19:46:16.007 INFO [stderr] 200 |                                 mut peeker: &mut Peekable<I>,
Dec 02 19:46:16.007 INFO [stderr]     |                                 ----^^^^^^
Dec 02 19:46:16.007 INFO [stderr]     |                                 |
Dec 02 19:46:16.007 INFO [stderr]     |                                 help: remove this `mut`
Dec 02 19:46:16.007 INFO [stderr] 
Dec 02 19:46:16.007 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:16.007 INFO [stderr]    --> src/assembler/parser.rs:494:37
Dec 02 19:46:16.007 INFO [stderr]     |
Dec 02 19:46:16.007 INFO [stderr] 494 |                                     mut peeker: &mut Peekable<I>)
Dec 02 19:46:16.007 INFO [stderr]     |                                     ----^^^^^^
Dec 02 19:46:16.007 INFO [stderr]     |                                     |
Dec 02 19:46:16.007 INFO [stderr]     |                                     help: remove this `mut`
Dec 02 19:46:16.007 INFO [stderr] 
Dec 02 19:46:16.007 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:16.007 INFO [stderr]    --> src/assembler/parser.rs:515:38
Dec 02 19:46:16.007 INFO [stderr]     |
Dec 02 19:46:16.007 INFO [stderr] 515 |                                      mut peeker: &mut Peekable<I>)
Dec 02 19:46:16.007 INFO [stderr]     |                                      ----^^^^^^
Dec 02 19:46:16.007 INFO [stderr]     |                                      |
Dec 02 19:46:16.007 INFO [stderr]     |                                      help: remove this `mut`
Dec 02 19:46:16.007 INFO [stderr] 
Dec 02 19:46:16.007 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:16.007 INFO [stderr]    --> src/assembler/parser.rs:528:17
Dec 02 19:46:16.007 INFO [stderr]     |
Dec 02 19:46:16.007 INFO [stderr] 528 |             let mut next = peeker.next().unwrap();
Dec 02 19:46:16.007 INFO [stderr]     |                 ----^^^^
Dec 02 19:46:16.007 INFO [stderr]     |                 |
Dec 02 19:46:16.007 INFO [stderr]     |                 help: remove this `mut`
Dec 02 19:46:16.007 INFO [stderr] 
Dec 02 19:46:16.063 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:16.063 INFO [stderr]    --> src/cpu/cpu.rs:530:13
Dec 02 19:46:16.063 INFO [stderr]     |
Dec 02 19:46:16.063 INFO [stderr] 530 |         let mut mem = &mut self.memory[STACK_START..STACK_END + 0x01];
Dec 02 19:46:16.063 INFO [stderr]     |             ----^^^
Dec 02 19:46:16.063 INFO [stderr]     |             |
Dec 02 19:46:16.063 INFO [stderr]     |             help: remove this `mut`
Dec 02 19:46:16.063 INFO [stderr] 
Dec 02 19:46:16.063 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:16.063 INFO [stderr]    --> src/cpu/cpu.rs:598:13
Dec 02 19:46:16.063 INFO [stderr]     |
Dec 02 19:46:16.063 INFO [stderr] 598 |         let mut mem = &mut self.memory[STACK_START..STACK_END + 0x01];
Dec 02 19:46:16.063 INFO [stderr]     |             ----^^^
Dec 02 19:46:16.063 INFO [stderr]     |             |
Dec 02 19:46:16.063 INFO [stderr]     |             help: remove this `mut`
Dec 02 19:46:16.063 INFO [stderr] 
Dec 02 19:46:16.063 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:16.063 INFO [stderr]    --> src/cpu/cpu.rs:604:13
Dec 02 19:46:16.063 INFO [stderr]     |
Dec 02 19:46:16.063 INFO [stderr] 604 |         let mut mem = &mut self.memory[STACK_START..STACK_END + 0x01];
Dec 02 19:46:16.063 INFO [stderr]     |             ----^^^
Dec 02 19:46:16.063 INFO [stderr]     |             |
Dec 02 19:46:16.063 INFO [stderr]     |             help: remove this `mut`
Dec 02 19:46:16.063 INFO [stderr] 
Dec 02 19:46:16.063 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:16.063 INFO [stderr]    --> src/cpu/cpu.rs:626:13
Dec 02 19:46:16.063 INFO [stderr]     |
Dec 02 19:46:16.063 INFO [stderr] 626 |         let mut mem = &mut self.memory[STACK_START..STACK_END + 0x01];
Dec 02 19:46:16.063 INFO [stderr]     |             ----^^^
Dec 02 19:46:16.063 INFO [stderr]     |             |
Dec 02 19:46:16.063 INFO [stderr]     |             help: remove this `mut`
Dec 02 19:46:16.063 INFO [stderr] 
Dec 02 19:46:16.087 INFO [stderr] warning: variant is never constructed: `Absolute`
Dec 02 19:46:16.087 INFO [stderr]   --> src/assembler/token.rs:27:5
Dec 02 19:46:16.087 INFO [stderr]    |
Dec 02 19:46:16.087 INFO [stderr] 27 |     Absolute(String),
Dec 02 19:46:16.087 INFO [stderr]    |     ^^^^^^^^^^^^^^^^
Dec 02 19:46:16.087 INFO [stderr]    |
Dec 02 19:46:16.087 INFO [stderr]    = note: #[warn(dead_code)] on by default
Dec 02 19:46:16.087 INFO [stderr] 
Dec 02 19:46:16.087 INFO [stderr] warning: method is never used: `unexpected_ident`
Dec 02 19:46:16.087 INFO [stderr]   --> src/assembler/lexer.rs:20:5
Dec 02 19:46:16.087 INFO [stderr]    |
Dec 02 19:46:16.087 INFO [stderr] 20 | /     fn unexpected_ident<A, B>(expected: A, found: B, line: u32, column: u32) -> LexerError
Dec 02 19:46:16.087 INFO [stderr] 21 | |         where A: std::fmt::Display,
Dec 02 19:46:16.087 INFO [stderr] 22 | |               B: std::fmt::Display
Dec 02 19:46:16.087 INFO [stderr] 23 | |     {
Dec 02 19:46:16.087 INFO [stderr] ...  |
Dec 02 19:46:16.087 INFO [stderr] 30 | |         }
Dec 02 19:46:16.087 INFO [stderr] 31 | |     }
Dec 02 19:46:16.087 INFO [stderr]    | |_____^
Dec 02 19:46:16.087 INFO [stderr] 
Dec 02 19:46:16.087 INFO [stderr] warning: method is never used: `expected_eol`
Dec 02 19:46:16.087 INFO [stderr]   --> src/assembler/parser.rs:32:5
Dec 02 19:46:16.087 INFO [stderr]    |
Dec 02 19:46:16.087 INFO [stderr] 32 |     fn expected_eol(line: u32) -> ParserError {
Dec 02 19:46:16.087 INFO [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:16.087 INFO [stderr] 
Dec 02 19:46:16.089 INFO [stderr] warning: comparison is useless due to type limits
Dec 02 19:46:16.089 INFO [stderr]    --> src/assembler/assembler.rs:155:51
Dec 02 19:46:16.089 INFO [stderr]     |
Dec 02 19:46:16.089 INFO [stderr] 155 |                             if distance < -128 || distance > 127 {
Dec 02 19:46:16.089 INFO [stderr]     |                                                   ^^^^^^^^^^^^^^
Dec 02 19:46:16.089 INFO [stderr]     |
Dec 02 19:46:16.089 INFO [stderr]     = note: #[warn(unused_comparisons)] on by default
Dec 02 19:46:16.093 INFO [stderr] 
Dec 02 19:46:16.099 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:16.099 INFO [stderr]    --> src/cpu/cpu.rs:253:9
Dec 02 19:46:16.099 INFO [stderr]     |
Dec 02 19:46:16.099 INFO [stderr] 253 |         self.stack.push_u16(mem, self.registers.PC);
Dec 02 19:46:16.099 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:16.099 INFO [stderr]     |
Dec 02 19:46:16.099 INFO [stderr]     = note: #[warn(unused_must_use)] on by default
Dec 02 19:46:16.099 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:16.099 INFO [stderr] 
Dec 02 19:46:16.099 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:16.099 INFO [stderr]    --> src/cpu/cpu.rs:254:9
Dec 02 19:46:16.099 INFO [stderr]     |
Dec 02 19:46:16.099 INFO [stderr] 254 |         self.stack.push(mem, self.flags.to_u8());
Dec 02 19:46:16.099 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:16.099 INFO [stderr]     |
Dec 02 19:46:16.099 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:16.099 INFO [stderr] 
Dec 02 19:46:16.099 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:16.099 INFO [stderr]    --> src/cpu/cpu.rs:276:9
Dec 02 19:46:16.099 INFO [stderr]     |
Dec 02 19:46:16.099 INFO [stderr] 276 |         self.stack.push_u16(mem, self.registers.PC);
Dec 02 19:46:16.099 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:16.099 INFO [stderr]     |
Dec 02 19:46:16.099 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:16.099 INFO [stderr] 
Dec 02 19:46:16.099 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:16.099 INFO [stderr]    --> src/cpu/cpu.rs:277:9
Dec 02 19:46:16.099 INFO [stderr]     |
Dec 02 19:46:16.099 INFO [stderr] 277 |         self.stack.push(mem, self.flags.to_u8());
Dec 02 19:46:16.099 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:16.099 INFO [stderr]     |
Dec 02 19:46:16.099 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:16.099 INFO [stderr] 
Dec 02 19:46:16.099 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:16.099 INFO [stderr]    --> src/cpu/cpu.rs:532:9
Dec 02 19:46:16.099 INFO [stderr]     |
Dec 02 19:46:16.099 INFO [stderr] 532 |         self.stack.push_u16(mem, self.registers.PC);
Dec 02 19:46:16.099 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:16.099 INFO [stderr]     |
Dec 02 19:46:16.099 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:16.099 INFO [stderr] 
Dec 02 19:46:16.103 INFO [stderr] warning: static variable `OpCodes` should have an upper case name such as `OP_CODES`
Dec 02 19:46:16.103 INFO [stderr]     --> src/opcodes.rs:53:1
Dec 02 19:46:16.103 INFO [stderr]      |
Dec 02 19:46:16.103 INFO [stderr] 53   | / static OpCodes: [OpCode; 151] = [OpCode {
Dec 02 19:46:16.103 INFO [stderr] 54   | |                                      code: 0x69,
Dec 02 19:46:16.103 INFO [stderr] 55   | |                                      mnemonic: "ADC",
Dec 02 19:46:16.103 INFO [stderr] 56   | |                                      length: 2,
Dec 02 19:46:16.103 INFO [stderr] ...    |
Dec 02 19:46:16.103 INFO [stderr] 1108 | |                                      mode: AddressingMode::Absolute,
Dec 02 19:46:16.103 INFO [stderr] 1109 | |                                  }];
Dec 02 19:46:16.103 INFO [stderr]      | |____________________________________^
Dec 02 19:46:16.103 INFO [stderr]      |
Dec 02 19:46:16.103 INFO [stderr]      = note: #[warn(non_upper_case_globals)] on by default
Dec 02 19:46:16.103 INFO [stderr] 
Dec 02 19:46:17.775 INFO [stderr]     Finished dev [unoptimized + debuginfo] target(s) in 3.07s
Dec 02 19:46:17.775 INFO [stderr] su: No module specific data is present
Dec 02 19:46:18.481 INFO running `"docker" "inspect" "1c2e1f7ee6aaa41ed9ee2503777676563b2fb5a04021f6030c0360fff0337311"`
Dec 02 19:46:18.760 INFO running `"docker" "rm" "-f" "1c2e1f7ee6aaa41ed9ee2503777676563b2fb5a04021f6030c0360fff0337311"`
Dec 02 19:46:19.151 INFO [stdout] 1c2e1f7ee6aaa41ed9ee2503777676563b2fb5a04021f6030c0360fff0337311
Dec 02 19:46:19.159 INFO running `"docker" "create" "-v" "/mnt/big/crater/work/local/target-dirs/beta-1.31-5/worker-7/1.30.1:/target:rw,Z" "-v" "/mnt/big/crater/work/local/test-source/worker-7/beta-1.31-5/1.30.1:/source:ro,Z" "-v" "/mnt/big/crater/work/local/cargo-home:/cargo-home:ro,Z" "-v" "/mnt/big/crater/work/local/rustup-home:/rustup-home:ro,Z" "-e" "USER_ID=1000" "-e" "SOURCE_DIR=/source" "-e" "USER_ID=1000" "-e" "CMD=cargo +1.30.1 test --frozen --no-run" "-e" "CARGO_TARGET_DIR=/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/cargo-home" "-e" "RUSTUP_HOME=/rustup-home" "-m" "1536M" "--network" "none" "crater"`
Dec 02 19:46:19.632 INFO [stdout] 3a656ca38ef8582bb44650262065c1ee371b1d6a126885a90b3924b274b5dc23
Dec 02 19:46:19.634 INFO running `"docker" "start" "-a" "3a656ca38ef8582bb44650262065c1ee371b1d6a126885a90b3924b274b5dc23"`
Dec 02 19:46:20.799 INFO [stderr] usermod: no changes
Dec 02 19:46:20.881 INFO [stderr]    Compiling rs6502 v0.3.4 (/source)
Dec 02 19:46:23.615 INFO [stderr] warning: function `INTEGRATION_CPU_can_add_basic_numbers_in_accumulator` should have a snake case name such as `integration_cpu_can_add_basic_numbers_in_accumulator`
Dec 02 19:46:23.615 INFO [stderr]   --> tests/cpu_integration.rs:5:1
Dec 02 19:46:23.615 INFO [stderr]    |
Dec 02 19:46:23.615 INFO [stderr] 5  | / fn INTEGRATION_CPU_can_add_basic_numbers_in_accumulator() {
Dec 02 19:46:23.615 INFO [stderr] 6  | |     let asm = "
Dec 02 19:46:23.615 INFO [stderr] 7  | |         LDA #$20
Dec 02 19:46:23.615 INFO [stderr] 8  | |         ADC #$10    ; A register should equal 48
Dec 02 19:46:23.615 INFO [stderr] ...  |
Dec 02 19:46:23.615 INFO [stderr] 20 | |     assert_eq!(0x30, cpu.registers.A);
Dec 02 19:46:23.615 INFO [stderr] 21 | | }
Dec 02 19:46:23.615 INFO [stderr]    | |_^
Dec 02 19:46:23.615 INFO [stderr]    |
Dec 02 19:46:23.615 INFO [stderr]    = note: #[warn(non_snake_case)] on by default
Dec 02 19:46:23.615 INFO [stderr] 
Dec 02 19:46:23.615 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.615 INFO [stderr]   --> tests/cpu_integration.rs:15:5
Dec 02 19:46:23.615 INFO [stderr]    |
Dec 02 19:46:23.615 INFO [stderr] 15 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.615 INFO [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.616 INFO [stderr]    |
Dec 02 19:46:23.616 INFO [stderr]    = note: #[warn(unused_must_use)] on by default
Dec 02 19:46:23.616 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.616 INFO [stderr] 
Dec 02 19:46:23.616 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.616 INFO [stderr]   --> tests/cpu_integration.rs:18:5
Dec 02 19:46:23.616 INFO [stderr]    |
Dec 02 19:46:23.616 INFO [stderr] 18 |     cpu.step_n(2);
Dec 02 19:46:23.616 INFO [stderr]    |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.616 INFO [stderr]    |
Dec 02 19:46:23.616 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.616 INFO [stderr] 
Dec 02 19:46:23.617 INFO [stderr] warning: function `INTEGRATION_CPU_can_add_binary_coded_decimal_numbers_in_accumulator` should have a snake case name such as `integration_cpu_can_add_binary_coded_decimal_numbers_in_accumulator`
Dec 02 19:46:23.617 INFO [stderr]   --> tests/cpu_integration.rs:24:1
Dec 02 19:46:23.617 INFO [stderr]    |
Dec 02 19:46:23.617 INFO [stderr] 24 | / fn INTEGRATION_CPU_can_add_binary_coded_decimal_numbers_in_accumulator() {
Dec 02 19:46:23.617 INFO [stderr] 25 | |     let asm = "
Dec 02 19:46:23.617 INFO [stderr] 26 | |         SED
Dec 02 19:46:23.617 INFO [stderr] 27 | |         LDA #$20
Dec 02 19:46:23.617 INFO [stderr] ...  |
Dec 02 19:46:23.617 INFO [stderr] 40 | |     assert_eq!(0x25, cpu.registers.A);
Dec 02 19:46:23.617 INFO [stderr] 41 | | }
Dec 02 19:46:23.617 INFO [stderr]    | |_^
Dec 02 19:46:23.617 INFO [stderr] 
Dec 02 19:46:23.617 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.617 INFO [stderr]   --> tests/cpu_integration.rs:35:5
Dec 02 19:46:23.617 INFO [stderr]    |
Dec 02 19:46:23.617 INFO [stderr] 35 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.617 INFO [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.617 INFO [stderr]    |
Dec 02 19:46:23.617 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.617 INFO [stderr] 
Dec 02 19:46:23.617 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.617 INFO [stderr]   --> tests/cpu_integration.rs:38:5
Dec 02 19:46:23.617 INFO [stderr]    |
Dec 02 19:46:23.617 INFO [stderr] 38 |     cpu.step_n(3);
Dec 02 19:46:23.617 INFO [stderr]    |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.617 INFO [stderr]    |
Dec 02 19:46:23.617 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.617 INFO [stderr] 
Dec 02 19:46:23.618 INFO [stderr] warning: function `INTEGRATION_CPU_can_add_mixed_mode_numbers_in_accumulator` should have a snake case name such as `integration_cpu_can_add_mixed_mode_numbers_in_accumulator`
Dec 02 19:46:23.618 INFO [stderr]   --> tests/cpu_integration.rs:44:1
Dec 02 19:46:23.618 INFO [stderr]    |
Dec 02 19:46:23.618 INFO [stderr] 44 | / fn INTEGRATION_CPU_can_add_mixed_mode_numbers_in_accumulator() {
Dec 02 19:46:23.618 INFO [stderr] 45 | |     let asm = "
Dec 02 19:46:23.618 INFO [stderr] 46 | |         LDA #$20
Dec 02 19:46:23.618 INFO [stderr] 47 | |         ADC #10    ; A register should equal 0x2A
Dec 02 19:46:23.618 INFO [stderr] ...  |
Dec 02 19:46:23.618 INFO [stderr] 59 | |     assert_eq!(0x2A, cpu.registers.A);
Dec 02 19:46:23.618 INFO [stderr] 60 | | }
Dec 02 19:46:23.618 INFO [stderr]    | |_^
Dec 02 19:46:23.618 INFO [stderr] 
Dec 02 19:46:23.618 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.618 INFO [stderr]   --> tests/cpu_integration.rs:54:5
Dec 02 19:46:23.618 INFO [stderr]    |
Dec 02 19:46:23.618 INFO [stderr] 54 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.618 INFO [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.618 INFO [stderr]    |
Dec 02 19:46:23.618 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.619 INFO [stderr] 
Dec 02 19:46:23.619 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.630 INFO [stderr]   --> tests/cpu_integration.rs:57:5
Dec 02 19:46:23.630 INFO [stderr]    |
Dec 02 19:46:23.630 INFO [stderr] 57 |     cpu.step_n(2);
Dec 02 19:46:23.630 INFO [stderr]    |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.630 INFO [stderr]    |
Dec 02 19:46:23.630 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.630 INFO [stderr] 
Dec 02 19:46:23.630 INFO [stderr] warning: function `INTEGRATION_CPU_can_store_bytes_in_memory` should have a snake case name such as `integration_cpu_can_store_bytes_in_memory`
Dec 02 19:46:23.630 INFO [stderr]   --> tests/cpu_integration.rs:63:1
Dec 02 19:46:23.630 INFO [stderr]    |
Dec 02 19:46:23.630 INFO [stderr] 63 | / fn INTEGRATION_CPU_can_store_bytes_in_memory() {
Dec 02 19:46:23.630 INFO [stderr] 64 | |     let asm = "
Dec 02 19:46:23.630 INFO [stderr] 65 | |         LDA #$20
Dec 02 19:46:23.630 INFO [stderr] 66 | |         STA $2000
Dec 02 19:46:23.630 INFO [stderr] ...  |
Dec 02 19:46:23.630 INFO [stderr] 82 | |     assert_eq!(0x00, cpu.memory[0x2002]);
Dec 02 19:46:23.630 INFO [stderr] 83 | | }
Dec 02 19:46:23.630 INFO [stderr]    | |_^
Dec 02 19:46:23.630 INFO [stderr] 
Dec 02 19:46:23.630 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.630 INFO [stderr]   --> tests/cpu_integration.rs:75:5
Dec 02 19:46:23.630 INFO [stderr]    |
Dec 02 19:46:23.630 INFO [stderr] 75 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.630 INFO [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.630 INFO [stderr]    |
Dec 02 19:46:23.630 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.630 INFO [stderr] 
Dec 02 19:46:23.630 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.630 INFO [stderr]   --> tests/cpu_integration.rs:78:5
Dec 02 19:46:23.630 INFO [stderr]    |
Dec 02 19:46:23.630 INFO [stderr] 78 |     cpu.step_n(4);
Dec 02 19:46:23.630 INFO [stderr]    |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.630 INFO [stderr]    |
Dec 02 19:46:23.630 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.630 INFO [stderr] 
Dec 02 19:46:23.630 INFO [stderr] warning: function `INTEGRATION_CPU_can_overwrite_own_memory` should have a snake case name such as `integration_cpu_can_overwrite_own_memory`
Dec 02 19:46:23.630 INFO [stderr]    --> tests/cpu_integration.rs:86:1
Dec 02 19:46:23.630 INFO [stderr]     |
Dec 02 19:46:23.630 INFO [stderr] 86  | / fn INTEGRATION_CPU_can_overwrite_own_memory() {
Dec 02 19:46:23.630 INFO [stderr] 87  | |     let asm = "
Dec 02 19:46:23.630 INFO [stderr] 88  | |         LDA #$20
Dec 02 19:46:23.630 INFO [stderr] 89  | |         STA $C006
Dec 02 19:46:23.630 INFO [stderr] ...   |
Dec 02 19:46:23.630 INFO [stderr] 103 | |     assert_eq!(0x20, cpu.memory[0x2000]);
Dec 02 19:46:23.630 INFO [stderr] 104 | | }
Dec 02 19:46:23.630 INFO [stderr]     | |_^
Dec 02 19:46:23.630 INFO [stderr] 
Dec 02 19:46:23.630 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.630 INFO [stderr]   --> tests/cpu_integration.rs:98:5
Dec 02 19:46:23.630 INFO [stderr]    |
Dec 02 19:46:23.631 INFO [stderr] 98 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.631 INFO [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.631 INFO [stderr]    |
Dec 02 19:46:23.631 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.631 INFO [stderr] 
Dec 02 19:46:23.631 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.631 INFO [stderr]    --> tests/cpu_integration.rs:101:5
Dec 02 19:46:23.631 INFO [stderr]     |
Dec 02 19:46:23.631 INFO [stderr] 101 |     cpu.step_n(4);
Dec 02 19:46:23.631 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.631 INFO [stderr]     |
Dec 02 19:46:23.631 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.631 INFO [stderr] 
Dec 02 19:46:23.639 INFO [stderr] warning: function `INTEGRATION_CPU_can_load_byte_into_memory_and_logical_AND_it_with_A_register` should have a snake case name such as `integration_cpu_can_load_byte_into_memory_and_logical_and_it_with_a_register`
Dec 02 19:46:23.639 INFO [stderr]    --> tests/cpu_integration.rs:107:1
Dec 02 19:46:23.639 INFO [stderr]     |
Dec 02 19:46:23.639 INFO [stderr] 107 | / fn INTEGRATION_CPU_can_load_byte_into_memory_and_logical_AND_it_with_A_register() {
Dec 02 19:46:23.639 INFO [stderr] 108 | |     let asm = "
Dec 02 19:46:23.639 INFO [stderr] 109 | |         LDA #$0F
Dec 02 19:46:23.639 INFO [stderr] 110 | |         STA $2000   ; Load the mask 0x0F into $2000
Dec 02 19:46:23.639 INFO [stderr] ...   |
Dec 02 19:46:23.639 INFO [stderr] 124 | |     assert_eq!(0x0F, cpu.memory[0x2000]);
Dec 02 19:46:23.639 INFO [stderr] 125 | | }
Dec 02 19:46:23.639 INFO [stderr]     | |_^
Dec 02 19:46:23.639 INFO [stderr] 
Dec 02 19:46:23.639 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.639 INFO [stderr]    --> tests/cpu_integration.rs:119:5
Dec 02 19:46:23.639 INFO [stderr]     |
Dec 02 19:46:23.639 INFO [stderr] 119 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.639 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.639 INFO [stderr]     |
Dec 02 19:46:23.639 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.639 INFO [stderr] 
Dec 02 19:46:23.639 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.639 INFO [stderr]    --> tests/cpu_integration.rs:122:5
Dec 02 19:46:23.639 INFO [stderr]     |
Dec 02 19:46:23.639 INFO [stderr] 122 |     cpu.step_n(4);
Dec 02 19:46:23.639 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.639 INFO [stderr]     |
Dec 02 19:46:23.639 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.639 INFO [stderr] 
Dec 02 19:46:23.639 INFO [stderr] warning: function `INTEGRATION_CPU_can_load_byte_into_memory_and_logical_AND_it_with_A_register_using_a_variable` should have a snake case name such as `integration_cpu_can_load_byte_into_memory_and_logical_and_it_with_a_register_using_a_variable`
Dec 02 19:46:23.639 INFO [stderr]    --> tests/cpu_integration.rs:128:1
Dec 02 19:46:23.639 INFO [stderr]     |
Dec 02 19:46:23.639 INFO [stderr] 128 | / fn INTEGRATION_CPU_can_load_byte_into_memory_and_logical_AND_it_with_A_register_using_a_variable
Dec 02 19:46:23.639 INFO [stderr] 129 | |     () {
Dec 02 19:46:23.639 INFO [stderr] 130 | |     let asm = "
Dec 02 19:46:23.639 INFO [stderr] 131 | |         MEMORY_LOCATION = $2000
Dec 02 19:46:23.639 INFO [stderr] ...   |
Dec 02 19:46:23.639 INFO [stderr] 148 | |     assert_eq!(0x0F, cpu.memory[0x2000]);
Dec 02 19:46:23.639 INFO [stderr] 149 | | }
Dec 02 19:46:23.639 INFO [stderr]     | |_^
Dec 02 19:46:23.639 INFO [stderr] 
Dec 02 19:46:23.639 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.639 INFO [stderr]    --> tests/cpu_integration.rs:143:5
Dec 02 19:46:23.639 INFO [stderr]     |
Dec 02 19:46:23.639 INFO [stderr] 143 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.639 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.639 INFO [stderr]     |
Dec 02 19:46:23.639 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.639 INFO [stderr] 
Dec 02 19:46:23.640 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.640 INFO [stderr]    --> tests/cpu_integration.rs:146:5
Dec 02 19:46:23.640 INFO [stderr]     |
Dec 02 19:46:23.640 INFO [stderr] 146 |     cpu.step_n(4);
Dec 02 19:46:23.640 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.640 INFO [stderr]     |
Dec 02 19:46:23.640 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.640 INFO [stderr] 
Dec 02 19:46:23.640 INFO [stderr] warning: function `INTEGRATION_CPU_does_not_branch_on_clear_carry_flag` should have a snake case name such as `integration_cpu_does_not_branch_on_clear_carry_flag`
Dec 02 19:46:23.640 INFO [stderr]    --> tests/cpu_integration.rs:152:1
Dec 02 19:46:23.640 INFO [stderr]     |
Dec 02 19:46:23.640 INFO [stderr] 152 | / fn INTEGRATION_CPU_does_not_branch_on_clear_carry_flag() {
Dec 02 19:46:23.640 INFO [stderr] 153 | |     let asm = "
Dec 02 19:46:23.640 INFO [stderr] 154 | |         LDA #$FE
Dec 02 19:46:23.640 INFO [stderr] 155 | |         ADC #1      ; This won't cause a carry
Dec 02 19:46:23.640 INFO [stderr] ...   |
Dec 02 19:46:23.640 INFO [stderr] 170 | |     assert_eq!(0xFF, cpu.registers.A);
Dec 02 19:46:23.640 INFO [stderr] 171 | | }
Dec 02 19:46:23.640 INFO [stderr]     | |_^
Dec 02 19:46:23.640 INFO [stderr] 
Dec 02 19:46:23.640 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.640 INFO [stderr]    --> tests/cpu_integration.rs:165:5
Dec 02 19:46:23.640 INFO [stderr]     |
Dec 02 19:46:23.640 INFO [stderr] 165 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.640 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.641 INFO [stderr]     |
Dec 02 19:46:23.641 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.641 INFO [stderr] 
Dec 02 19:46:23.641 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.641 INFO [stderr]    --> tests/cpu_integration.rs:168:5
Dec 02 19:46:23.641 INFO [stderr]     |
Dec 02 19:46:23.641 INFO [stderr] 168 |     cpu.step_n(3);
Dec 02 19:46:23.641 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.641 INFO [stderr]     |
Dec 02 19:46:23.641 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.641 INFO [stderr] 
Dec 02 19:46:23.642 INFO [stderr] warning: function `INTEGRATION_CPU_can_branch_on_carry_flag` should have a snake case name such as `integration_cpu_can_branch_on_carry_flag`
Dec 02 19:46:23.642 INFO [stderr]    --> tests/cpu_integration.rs:174:1
Dec 02 19:46:23.642 INFO [stderr]     |
Dec 02 19:46:23.642 INFO [stderr] 174 | / fn INTEGRATION_CPU_can_branch_on_carry_flag() {
Dec 02 19:46:23.642 INFO [stderr] 175 | |     let asm = "
Dec 02 19:46:23.643 INFO [stderr] 176 | |         LDA #$FE
Dec 02 19:46:23.643 INFO [stderr] 177 | |         ADC #10     ; This will cause a carry
Dec 02 19:46:23.643 INFO [stderr] ...   |
Dec 02 19:46:23.643 INFO [stderr] 192 | |     assert_eq!(0x00, cpu.registers.A);
Dec 02 19:46:23.643 INFO [stderr] 193 | | }
Dec 02 19:46:23.643 INFO [stderr]     | |_^
Dec 02 19:46:23.643 INFO [stderr] 
Dec 02 19:46:23.643 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.643 INFO [stderr]    --> tests/cpu_integration.rs:187:5
Dec 02 19:46:23.643 INFO [stderr]     |
Dec 02 19:46:23.643 INFO [stderr] 187 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.643 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.643 INFO [stderr]     |
Dec 02 19:46:23.643 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.643 INFO [stderr] 
Dec 02 19:46:23.643 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.643 INFO [stderr]    --> tests/cpu_integration.rs:190:5
Dec 02 19:46:23.643 INFO [stderr]     |
Dec 02 19:46:23.643 INFO [stderr] 190 |     cpu.step_n(4);
Dec 02 19:46:23.643 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.643 INFO [stderr]     |
Dec 02 19:46:23.643 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.643 INFO [stderr] 
Dec 02 19:46:23.647 INFO [stderr] warning: function `INTEGRATION_CPU_can_branch_on_carry_flag_to_correct_offset` should have a snake case name such as `integration_cpu_can_branch_on_carry_flag_to_correct_offset`
Dec 02 19:46:23.647 INFO [stderr]    --> tests/cpu_integration.rs:196:1
Dec 02 19:46:23.647 INFO [stderr]     |
Dec 02 19:46:23.647 INFO [stderr] 196 | / fn INTEGRATION_CPU_can_branch_on_carry_flag_to_correct_offset() {
Dec 02 19:46:23.647 INFO [stderr] 197 | |     let asm = "
Dec 02 19:46:23.647 INFO [stderr] 198 | |         LDA #$FE
Dec 02 19:46:23.647 INFO [stderr] 199 | |         ADC #1      ; This will not cause a carry, and execution
Dec 02 19:46:23.647 INFO [stderr] ...   |
Dec 02 19:46:23.647 INFO [stderr] 219 | |     assert_eq!(0xAA, cpu.registers.A);
Dec 02 19:46:23.647 INFO [stderr] 220 | | }
Dec 02 19:46:23.647 INFO [stderr]     | |_^
Dec 02 19:46:23.654 INFO [stderr] 
Dec 02 19:46:23.655 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.655 INFO [stderr]    --> tests/cpu_integration.rs:214:5
Dec 02 19:46:23.655 INFO [stderr]     |
Dec 02 19:46:23.655 INFO [stderr] 214 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.655 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.655 INFO [stderr]     |
Dec 02 19:46:23.655 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.655 INFO [stderr] 
Dec 02 19:46:23.656 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.656 INFO [stderr]    --> tests/cpu_integration.rs:217:5
Dec 02 19:46:23.656 INFO [stderr]     |
Dec 02 19:46:23.656 INFO [stderr] 217 |     cpu.step_n(5);
Dec 02 19:46:23.656 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.656 INFO [stderr]     |
Dec 02 19:46:23.656 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.656 INFO [stderr] 
Dec 02 19:46:23.656 INFO [stderr] warning: function `INTEGRATION_CPU_can_loop_on_bcc` should have a snake case name such as `integration_cpu_can_loop_on_bcc`
Dec 02 19:46:23.656 INFO [stderr]    --> tests/cpu_integration.rs:223:1
Dec 02 19:46:23.656 INFO [stderr]     |
Dec 02 19:46:23.656 INFO [stderr] 223 | / fn INTEGRATION_CPU_can_loop_on_bcc() {
Dec 02 19:46:23.656 INFO [stderr] 224 | |     let asm = "
Dec 02 19:46:23.656 INFO [stderr] 225 | |         LDA #$F0
Dec 02 19:46:23.656 INFO [stderr] 226 | |     ADDER:
Dec 02 19:46:23.657 INFO [stderr] ...   |
Dec 02 19:46:23.657 INFO [stderr] 240 | |     assert_eq!(0xFF, cpu.registers.A);
Dec 02 19:46:23.657 INFO [stderr] 241 | | }
Dec 02 19:46:23.657 INFO [stderr]     | |_^
Dec 02 19:46:23.657 INFO [stderr] 
Dec 02 19:46:23.657 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.657 INFO [stderr]    --> tests/cpu_integration.rs:235:5
Dec 02 19:46:23.657 INFO [stderr]     |
Dec 02 19:46:23.657 INFO [stderr] 235 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.657 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.657 INFO [stderr]     |
Dec 02 19:46:23.657 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.657 INFO [stderr] 
Dec 02 19:46:23.657 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.657 INFO [stderr]    --> tests/cpu_integration.rs:238:5
Dec 02 19:46:23.657 INFO [stderr]     |
Dec 02 19:46:23.657 INFO [stderr] 238 |     cpu.step_n(30);
Dec 02 19:46:23.657 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.657 INFO [stderr]     |
Dec 02 19:46:23.657 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.657 INFO [stderr] 
Dec 02 19:46:23.657 INFO [stderr] warning: function `INTEGRATION_CPU_can_branch_on_bcs` should have a snake case name such as `integration_cpu_can_branch_on_bcs`
Dec 02 19:46:23.657 INFO [stderr]    --> tests/cpu_integration.rs:244:1
Dec 02 19:46:23.657 INFO [stderr]     |
Dec 02 19:46:23.657 INFO [stderr] 244 | / fn INTEGRATION_CPU_can_branch_on_bcs() {
Dec 02 19:46:23.657 INFO [stderr] 245 | |     let asm = "
Dec 02 19:46:23.657 INFO [stderr] 246 | |         LDA #$FE
Dec 02 19:46:23.657 INFO [stderr] 247 | |         ADC #$05    ; This will carry
Dec 02 19:46:23.657 INFO [stderr] ...   |
Dec 02 19:46:23.657 INFO [stderr] 262 | |     assert_eq!(0x03, cpu.registers.A);
Dec 02 19:46:23.657 INFO [stderr] 263 | | }
Dec 02 19:46:23.657 INFO [stderr]     | |_^
Dec 02 19:46:23.657 INFO [stderr] 
Dec 02 19:46:23.657 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.657 INFO [stderr]    --> tests/cpu_integration.rs:257:5
Dec 02 19:46:23.657 INFO [stderr]     |
Dec 02 19:46:23.657 INFO [stderr] 257 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.657 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.657 INFO [stderr]     |
Dec 02 19:46:23.657 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.657 INFO [stderr] 
Dec 02 19:46:23.657 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.657 INFO [stderr]    --> tests/cpu_integration.rs:260:5
Dec 02 19:46:23.657 INFO [stderr]     |
Dec 02 19:46:23.657 INFO [stderr] 260 |     cpu.step_n(30);
Dec 02 19:46:23.657 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.657 INFO [stderr]     |
Dec 02 19:46:23.657 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.657 INFO [stderr] 
Dec 02 19:46:23.657 INFO [stderr] warning: function `INTEGRATION_CPU_can_branch_on_beq` should have a snake case name such as `integration_cpu_can_branch_on_beq`
Dec 02 19:46:23.658 INFO [stderr]    --> tests/cpu_integration.rs:266:1
Dec 02 19:46:23.658 INFO [stderr]     |
Dec 02 19:46:23.658 INFO [stderr] 266 | / fn INTEGRATION_CPU_can_branch_on_beq() {
Dec 02 19:46:23.658 INFO [stderr] 267 | |     let asm = "
Dec 02 19:46:23.658 INFO [stderr] 268 | |         LDA #$FF
Dec 02 19:46:23.658 INFO [stderr] 269 | |         ADC #$01    ; This will result in a zero result
Dec 02 19:46:23.658 INFO [stderr] ...   |
Dec 02 19:46:23.658 INFO [stderr] 284 | |     assert_eq!(0x00, cpu.registers.A);
Dec 02 19:46:23.658 INFO [stderr] 285 | | }
Dec 02 19:46:23.658 INFO [stderr]     | |_^
Dec 02 19:46:23.658 INFO [stderr] 
Dec 02 19:46:23.658 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.658 INFO [stderr]    --> tests/cpu_integration.rs:279:5
Dec 02 19:46:23.658 INFO [stderr]     |
Dec 02 19:46:23.658 INFO [stderr] 279 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.658 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.658 INFO [stderr]     |
Dec 02 19:46:23.658 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.659 INFO [stderr] 
Dec 02 19:46:23.659 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.659 INFO [stderr]    --> tests/cpu_integration.rs:282:5
Dec 02 19:46:23.659 INFO [stderr]     |
Dec 02 19:46:23.659 INFO [stderr] 282 |     cpu.step_n(30);
Dec 02 19:46:23.659 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.659 INFO [stderr]     |
Dec 02 19:46:23.659 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.659 INFO [stderr] 
Dec 02 19:46:23.659 INFO [stderr] warning: function `INTEGRATION_CPU_does_not_branch_on_beq` should have a snake case name such as `integration_cpu_does_not_branch_on_beq`
Dec 02 19:46:23.659 INFO [stderr]    --> tests/cpu_integration.rs:288:1
Dec 02 19:46:23.659 INFO [stderr]     |
Dec 02 19:46:23.659 INFO [stderr] 288 | / fn INTEGRATION_CPU_does_not_branch_on_beq() {
Dec 02 19:46:23.659 INFO [stderr] 289 | |     let asm = "
Dec 02 19:46:23.659 INFO [stderr] 290 | |         LDA #$F0
Dec 02 19:46:23.659 INFO [stderr] 291 | |         ADC #$01
Dec 02 19:46:23.659 INFO [stderr] ...   |
Dec 02 19:46:23.659 INFO [stderr] 306 | |     assert_eq!(0xFF, cpu.registers.A);
Dec 02 19:46:23.659 INFO [stderr] 307 | | }
Dec 02 19:46:23.659 INFO [stderr]     | |_^
Dec 02 19:46:23.659 INFO [stderr] 
Dec 02 19:46:23.659 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.659 INFO [stderr]    --> tests/cpu_integration.rs:301:5
Dec 02 19:46:23.659 INFO [stderr]     |
Dec 02 19:46:23.659 INFO [stderr] 301 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.659 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.659 INFO [stderr]     |
Dec 02 19:46:23.659 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.659 INFO [stderr] 
Dec 02 19:46:23.659 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.659 INFO [stderr]    --> tests/cpu_integration.rs:304:5
Dec 02 19:46:23.659 INFO [stderr]     |
Dec 02 19:46:23.659 INFO [stderr] 304 |     cpu.step_n(30);
Dec 02 19:46:23.660 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.660 INFO [stderr]     |
Dec 02 19:46:23.660 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.660 INFO [stderr] 
Dec 02 19:46:23.661 INFO [stderr] warning: function `INTEGRATION_CPU_preserves_flags_on_bit` should have a snake case name such as `integration_cpu_preserves_flags_on_bit`
Dec 02 19:46:23.661 INFO [stderr]    --> tests/cpu_integration.rs:310:1
Dec 02 19:46:23.661 INFO [stderr]     |
Dec 02 19:46:23.661 INFO [stderr] 310 | / fn INTEGRATION_CPU_preserves_flags_on_bit() {
Dec 02 19:46:23.661 INFO [stderr] 311 | |     let asm = "
Dec 02 19:46:23.661 INFO [stderr] 312 | |         LDA #$0F
Dec 02 19:46:23.661 INFO [stderr] 313 | |         STA $44
Dec 02 19:46:23.661 INFO [stderr] ...   |
Dec 02 19:46:23.661 INFO [stderr] 330 | |     assert_eq!(0xF0, cpu.registers.A);
Dec 02 19:46:23.661 INFO [stderr] 331 | | }
Dec 02 19:46:23.661 INFO [stderr]     | |_^
Dec 02 19:46:23.667 INFO [stderr] 
Dec 02 19:46:23.667 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.667 INFO [stderr]    --> tests/cpu_integration.rs:325:5
Dec 02 19:46:23.667 INFO [stderr]     |
Dec 02 19:46:23.667 INFO [stderr] 325 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.667 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.667 INFO [stderr]     |
Dec 02 19:46:23.667 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.667 INFO [stderr] 
Dec 02 19:46:23.667 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.667 INFO [stderr]    --> tests/cpu_integration.rs:328:5
Dec 02 19:46:23.667 INFO [stderr]     |
Dec 02 19:46:23.667 INFO [stderr] 328 |     cpu.step_n(30);
Dec 02 19:46:23.667 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.667 INFO [stderr]     |
Dec 02 19:46:23.667 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.667 INFO [stderr] 
Dec 02 19:46:23.667 INFO [stderr] warning: function `INTEGRATION_CPU_bmi_branches_on_sign_bit_set` should have a snake case name such as `integration_cpu_bmi_branches_on_sign_bit_set`
Dec 02 19:46:23.667 INFO [stderr]    --> tests/cpu_integration.rs:334:1
Dec 02 19:46:23.667 INFO [stderr]     |
Dec 02 19:46:23.667 INFO [stderr] 334 | / fn INTEGRATION_CPU_bmi_branches_on_sign_bit_set() {
Dec 02 19:46:23.667 INFO [stderr] 335 | |     let asm = "
Dec 02 19:46:23.667 INFO [stderr] 336 | |         LDA #$7F
Dec 02 19:46:23.667 INFO [stderr] 337 | |         ADC #1
Dec 02 19:46:23.667 INFO [stderr] ...   |
Dec 02 19:46:23.667 INFO [stderr] 353 | |     assert_eq!(true, cpu.flags.sign);
Dec 02 19:46:23.667 INFO [stderr] 354 | | }
Dec 02 19:46:23.667 INFO [stderr]     | |_^
Dec 02 19:46:23.670 INFO [stderr] 
Dec 02 19:46:23.671 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.671 INFO [stderr]    --> tests/cpu_integration.rs:347:5
Dec 02 19:46:23.671 INFO [stderr]     |
Dec 02 19:46:23.671 INFO [stderr] 347 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.671 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.671 INFO [stderr]     |
Dec 02 19:46:23.671 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.671 INFO [stderr] 
Dec 02 19:46:23.671 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.671 INFO [stderr]    --> tests/cpu_integration.rs:350:5
Dec 02 19:46:23.671 INFO [stderr]     |
Dec 02 19:46:23.671 INFO [stderr] 350 |     cpu.step_n(30);
Dec 02 19:46:23.671 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.671 INFO [stderr]     |
Dec 02 19:46:23.671 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.671 INFO [stderr] 
Dec 02 19:46:23.674 INFO [stderr] warning: function `INTEGRATION_CPU_bne_branches_on_zero_clear` should have a snake case name such as `integration_cpu_bne_branches_on_zero_clear`
Dec 02 19:46:23.675 INFO [stderr]    --> tests/cpu_integration.rs:357:1
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr] 357 | / fn INTEGRATION_CPU_bne_branches_on_zero_clear() {
Dec 02 19:46:23.675 INFO [stderr] 358 | |     let asm = "
Dec 02 19:46:23.675 INFO [stderr] 359 | |         LDA #$F0
Dec 02 19:46:23.675 INFO [stderr] 360 | |     MAIN:
Dec 02 19:46:23.675 INFO [stderr] ...   |
Dec 02 19:46:23.675 INFO [stderr] 375 | |     assert_eq!(true, cpu.flags.zero);
Dec 02 19:46:23.675 INFO [stderr] 376 | | }
Dec 02 19:46:23.675 INFO [stderr]     | |_^
Dec 02 19:46:23.675 INFO [stderr] 
Dec 02 19:46:23.675 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.675 INFO [stderr]    --> tests/cpu_integration.rs:369:5
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr] 369 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.675 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.675 INFO [stderr] 
Dec 02 19:46:23.675 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.675 INFO [stderr]    --> tests/cpu_integration.rs:372:5
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr] 372 |     cpu.step_n(50);
Dec 02 19:46:23.675 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.675 INFO [stderr] 
Dec 02 19:46:23.675 INFO [stderr] warning: function `INTEGRATION_CPU_bpl_branches_on_sign_clear` should have a snake case name such as `integration_cpu_bpl_branches_on_sign_clear`
Dec 02 19:46:23.675 INFO [stderr]    --> tests/cpu_integration.rs:379:1
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr] 379 | / fn INTEGRATION_CPU_bpl_branches_on_sign_clear() {
Dec 02 19:46:23.675 INFO [stderr] 380 | |     let asm = "
Dec 02 19:46:23.675 INFO [stderr] 381 | |         LDA #$0A
Dec 02 19:46:23.675 INFO [stderr] 382 | |         BPL END
Dec 02 19:46:23.675 INFO [stderr] ...   |
Dec 02 19:46:23.675 INFO [stderr] 397 | |     assert_eq!(false, cpu.flags.sign);
Dec 02 19:46:23.675 INFO [stderr] 398 | | }
Dec 02 19:46:23.675 INFO [stderr]     | |_^
Dec 02 19:46:23.675 INFO [stderr] 
Dec 02 19:46:23.675 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.675 INFO [stderr]    --> tests/cpu_integration.rs:391:5
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr] 391 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.675 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.675 INFO [stderr] 
Dec 02 19:46:23.675 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.675 INFO [stderr]    --> tests/cpu_integration.rs:394:5
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr] 394 |     cpu.step_n(50);
Dec 02 19:46:23.675 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.675 INFO [stderr] 
Dec 02 19:46:23.675 INFO [stderr] warning: function `INTEGRATION_CPU_bpl_does_not_branch_on_sign_set` should have a snake case name such as `integration_cpu_bpl_does_not_branch_on_sign_set`
Dec 02 19:46:23.675 INFO [stderr]    --> tests/cpu_integration.rs:401:1
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr] 401 | / fn INTEGRATION_CPU_bpl_does_not_branch_on_sign_set() {
Dec 02 19:46:23.675 INFO [stderr] 402 | |     let asm = "
Dec 02 19:46:23.675 INFO [stderr] 403 | |         LDA #$F0
Dec 02 19:46:23.675 INFO [stderr] 404 | |         BPL END
Dec 02 19:46:23.675 INFO [stderr] ...   |
Dec 02 19:46:23.675 INFO [stderr] 419 | |     assert_eq!(true, cpu.flags.sign);
Dec 02 19:46:23.675 INFO [stderr] 420 | | }
Dec 02 19:46:23.675 INFO [stderr]     | |_^
Dec 02 19:46:23.675 INFO [stderr] 
Dec 02 19:46:23.675 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.675 INFO [stderr]    --> tests/cpu_integration.rs:413:5
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr] 413 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.675 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.675 INFO [stderr] 
Dec 02 19:46:23.675 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.675 INFO [stderr]    --> tests/cpu_integration.rs:416:5
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr] 416 |     cpu.step_n(50);
Dec 02 19:46:23.675 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.675 INFO [stderr]     |
Dec 02 19:46:23.675 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.675 INFO [stderr] 
Dec 02 19:46:23.682 INFO [stderr] warning: function `INTEGRATION_CPU_cmp_does_branch_on_accumulator_less_than_memory_bcc` should have a snake case name such as `integration_cpu_cmp_does_branch_on_accumulator_less_than_memory_bcc`
Dec 02 19:46:23.682 INFO [stderr]    --> tests/cpu_integration.rs:423:1
Dec 02 19:46:23.683 INFO [stderr]     |
Dec 02 19:46:23.683 INFO [stderr] 423 | / fn INTEGRATION_CPU_cmp_does_branch_on_accumulator_less_than_memory_bcc() {
Dec 02 19:46:23.683 INFO [stderr] 424 | |     let asm = "
Dec 02 19:46:23.683 INFO [stderr] 425 | |         LDA #$0F
Dec 02 19:46:23.683 INFO [stderr] 426 | |         CMP #$FF
Dec 02 19:46:23.683 INFO [stderr] ...   |
Dec 02 19:46:23.683 INFO [stderr] 444 | |     assert_eq!(0x01, cpu.registers.A);
Dec 02 19:46:23.683 INFO [stderr] 445 | | }
Dec 02 19:46:23.683 INFO [stderr]     | |_^
Dec 02 19:46:23.683 INFO [stderr] 
Dec 02 19:46:23.683 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.683 INFO [stderr]    --> tests/cpu_integration.rs:439:5
Dec 02 19:46:23.683 INFO [stderr]     |
Dec 02 19:46:23.683 INFO [stderr] 439 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.683 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.683 INFO [stderr]     |
Dec 02 19:46:23.686 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.686 INFO [stderr] 
Dec 02 19:46:23.687 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.687 INFO [stderr]    --> tests/cpu_integration.rs:442:5
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr] 442 |     cpu.step_n(50);
Dec 02 19:46:23.687 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.687 INFO [stderr] 
Dec 02 19:46:23.687 INFO [stderr] warning: function `INTEGRATION_CPU_cmp_does_branch_on_accumulator_greater_than_memory_bcs` should have a snake case name such as `integration_cpu_cmp_does_branch_on_accumulator_greater_than_memory_bcs`
Dec 02 19:46:23.687 INFO [stderr]    --> tests/cpu_integration.rs:448:1
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr] 448 | / fn INTEGRATION_CPU_cmp_does_branch_on_accumulator_greater_than_memory_bcs() {
Dec 02 19:46:23.687 INFO [stderr] 449 | |     let asm = "
Dec 02 19:46:23.687 INFO [stderr] 450 | |         LDA #$FF
Dec 02 19:46:23.687 INFO [stderr] 451 | |         CMP #$FE
Dec 02 19:46:23.687 INFO [stderr] ...   |
Dec 02 19:46:23.687 INFO [stderr] 469 | |     assert_eq!(0x02, cpu.registers.A);
Dec 02 19:46:23.687 INFO [stderr] 470 | | }
Dec 02 19:46:23.687 INFO [stderr]     | |_^
Dec 02 19:46:23.687 INFO [stderr] 
Dec 02 19:46:23.687 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.687 INFO [stderr]    --> tests/cpu_integration.rs:464:5
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr] 464 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.687 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.687 INFO [stderr] 
Dec 02 19:46:23.687 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.687 INFO [stderr]    --> tests/cpu_integration.rs:467:5
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr] 467 |     cpu.step_n(50);
Dec 02 19:46:23.687 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.687 INFO [stderr] 
Dec 02 19:46:23.687 INFO [stderr] warning: function `INTEGRATION_CPU_cmp_does_branch_on_accumulator_less_than_equal_to_bcc` should have a snake case name such as `integration_cpu_cmp_does_branch_on_accumulator_less_than_equal_to_bcc`
Dec 02 19:46:23.687 INFO [stderr]    --> tests/cpu_integration.rs:473:1
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr] 473 | / fn INTEGRATION_CPU_cmp_does_branch_on_accumulator_less_than_equal_to_bcc() {
Dec 02 19:46:23.687 INFO [stderr] 474 | |     let asm = "
Dec 02 19:46:23.687 INFO [stderr] 475 | |         LDA #$FF
Dec 02 19:46:23.687 INFO [stderr] 476 | |         CMP #$FF
Dec 02 19:46:23.687 INFO [stderr] ...   |
Dec 02 19:46:23.687 INFO [stderr] 494 | |     assert_eq!(0x03, cpu.registers.A);
Dec 02 19:46:23.687 INFO [stderr] 495 | | }
Dec 02 19:46:23.687 INFO [stderr]     | |_^
Dec 02 19:46:23.687 INFO [stderr] 
Dec 02 19:46:23.687 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.687 INFO [stderr]    --> tests/cpu_integration.rs:489:5
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr] 489 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.687 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.687 INFO [stderr] 
Dec 02 19:46:23.687 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.687 INFO [stderr]    --> tests/cpu_integration.rs:492:5
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr] 492 |     cpu.step_n(50);
Dec 02 19:46:23.687 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.687 INFO [stderr] 
Dec 02 19:46:23.687 INFO [stderr] warning: function `INTEGRATION_CPU_dec_decrements` should have a snake case name such as `integration_cpu_dec_decrements`
Dec 02 19:46:23.687 INFO [stderr]    --> tests/cpu_integration.rs:498:1
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr] 498 | / fn INTEGRATION_CPU_dec_decrements() {
Dec 02 19:46:23.687 INFO [stderr] 499 | |     let asm = "
Dec 02 19:46:23.687 INFO [stderr] 500 | |         LDA #$FF
Dec 02 19:46:23.687 INFO [stderr] 501 | |         STA $0100
Dec 02 19:46:23.687 INFO [stderr] ...   |
Dec 02 19:46:23.687 INFO [stderr] 514 | |     assert_eq!(0xFE, cpu.memory[0x100]);
Dec 02 19:46:23.687 INFO [stderr] 515 | | }
Dec 02 19:46:23.687 INFO [stderr]     | |_^
Dec 02 19:46:23.687 INFO [stderr] 
Dec 02 19:46:23.687 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.687 INFO [stderr]    --> tests/cpu_integration.rs:509:5
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr] 509 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.687 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.687 INFO [stderr]     |
Dec 02 19:46:23.687 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.687 INFO [stderr] 
Dec 02 19:46:23.687 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.687 INFO [stderr]    --> tests/cpu_integration.rs:512:5
Dec 02 19:46:23.688 INFO [stderr]     |
Dec 02 19:46:23.688 INFO [stderr] 512 |     cpu.step_n(3);
Dec 02 19:46:23.688 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.688 INFO [stderr]     |
Dec 02 19:46:23.688 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.688 INFO [stderr] 
Dec 02 19:46:23.688 INFO [stderr] warning: function `INTEGRATION_CPU_dex_decrements` should have a snake case name such as `integration_cpu_dex_decrements`
Dec 02 19:46:23.688 INFO [stderr]    --> tests/cpu_integration.rs:518:1
Dec 02 19:46:23.688 INFO [stderr]     |
Dec 02 19:46:23.688 INFO [stderr] 518 | / fn INTEGRATION_CPU_dex_decrements() {
Dec 02 19:46:23.688 INFO [stderr] 519 | |     let asm = "
Dec 02 19:46:23.688 INFO [stderr] 520 | |         LDX #$05
Dec 02 19:46:23.688 INFO [stderr] 521 | |         LDA #$FF
Dec 02 19:46:23.688 INFO [stderr] ...   |
Dec 02 19:46:23.688 INFO [stderr] 538 | |     assert_eq!(0xFA, cpu.memory[0x100]);
Dec 02 19:46:23.688 INFO [stderr] 539 | | }
Dec 02 19:46:23.688 INFO [stderr]     | |_^
Dec 02 19:46:23.688 INFO [stderr] 
Dec 02 19:46:23.688 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.688 INFO [stderr]    --> tests/cpu_integration.rs:533:5
Dec 02 19:46:23.688 INFO [stderr]     |
Dec 02 19:46:23.688 INFO [stderr] 533 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.688 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.688 INFO [stderr]     |
Dec 02 19:46:23.688 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.688 INFO [stderr] 
Dec 02 19:46:23.688 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.688 INFO [stderr]    --> tests/cpu_integration.rs:536:5
Dec 02 19:46:23.688 INFO [stderr]     |
Dec 02 19:46:23.688 INFO [stderr] 536 |     cpu.step_n(20);
Dec 02 19:46:23.688 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.688 INFO [stderr]     |
Dec 02 19:46:23.688 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.688 INFO [stderr] 
Dec 02 19:46:23.690 INFO [stderr] warning: function `INTEGRATION_CPU_jsr_rts_combination_works` should have a snake case name such as `integration_cpu_jsr_rts_combination_works`
Dec 02 19:46:23.691 INFO [stderr]    --> tests/cpu_integration.rs:542:1
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr] 542 | / fn INTEGRATION_CPU_jsr_rts_combination_works() {
Dec 02 19:46:23.691 INFO [stderr] 543 | |     let asm = "
Dec 02 19:46:23.691 INFO [stderr] 544 | |         LDA #$FF
Dec 02 19:46:23.691 INFO [stderr] 545 | |         LDA #$FE
Dec 02 19:46:23.691 INFO [stderr] ...   |
Dec 02 19:46:23.691 INFO [stderr] 565 | |     assert_eq!(0x0A, cpu.registers.A);
Dec 02 19:46:23.691 INFO [stderr] 566 | | }
Dec 02 19:46:23.691 INFO [stderr]     | |_^
Dec 02 19:46:23.691 INFO [stderr] 
Dec 02 19:46:23.691 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.691 INFO [stderr]    --> tests/cpu_integration.rs:560:5
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr] 560 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.691 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.691 INFO [stderr] 
Dec 02 19:46:23.691 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.691 INFO [stderr]    --> tests/cpu_integration.rs:563:5
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr] 563 |     cpu.step_n(20);
Dec 02 19:46:23.691 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.691 INFO [stderr] 
Dec 02 19:46:23.691 INFO [stderr] warning: function `INTEGRATION_CPU_jsr_rts_combination_works_when_code_segment_loaded_at_weird_address` should have a snake case name such as `integration_cpu_jsr_rts_combination_works_when_code_segment_loaded_at_weird_address`
Dec 02 19:46:23.691 INFO [stderr]    --> tests/cpu_integration.rs:569:1
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr] 569 | / fn INTEGRATION_CPU_jsr_rts_combination_works_when_code_segment_loaded_at_weird_address() {
Dec 02 19:46:23.691 INFO [stderr] 570 | |     let asm = "
Dec 02 19:46:23.691 INFO [stderr] 571 | |         LDA #$FF
Dec 02 19:46:23.691 INFO [stderr] 572 | |         LDA #$FE
Dec 02 19:46:23.691 INFO [stderr] ...   |
Dec 02 19:46:23.691 INFO [stderr] 592 | |     assert_eq!(0x0A, cpu.registers.A);
Dec 02 19:46:23.691 INFO [stderr] 593 | | }
Dec 02 19:46:23.691 INFO [stderr]     | |_^
Dec 02 19:46:23.691 INFO [stderr] 
Dec 02 19:46:23.691 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.691 INFO [stderr]    --> tests/cpu_integration.rs:587:5
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr] 587 |     cpu.load(&segments[0].code[..], 0xABCD);  // Load it at a weird address
Dec 02 19:46:23.691 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.691 INFO [stderr] 
Dec 02 19:46:23.691 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.691 INFO [stderr]    --> tests/cpu_integration.rs:590:5
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr] 590 |     cpu.step_n(20);
Dec 02 19:46:23.691 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.691 INFO [stderr] 
Dec 02 19:46:23.691 INFO [stderr] warning: function `INTEGRATION_CPU_lsr_can_halve_a_number` should have a snake case name such as `integration_cpu_lsr_can_halve_a_number`
Dec 02 19:46:23.691 INFO [stderr]    --> tests/cpu_integration.rs:596:1
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr] 596 | / fn INTEGRATION_CPU_lsr_can_halve_a_number() {
Dec 02 19:46:23.691 INFO [stderr] 597 | |     let asm = "
Dec 02 19:46:23.691 INFO [stderr] 598 | |         ; Halve the value at $1000
Dec 02 19:46:23.691 INFO [stderr] 599 | |         LDA #$56
Dec 02 19:46:23.691 INFO [stderr] ...   |
Dec 02 19:46:23.691 INFO [stderr] 618 | |     assert_eq!(0x2B, cpu.memory[0x1000]);
Dec 02 19:46:23.691 INFO [stderr] 619 | | }
Dec 02 19:46:23.691 INFO [stderr]     | |_^
Dec 02 19:46:23.691 INFO [stderr] 
Dec 02 19:46:23.691 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.691 INFO [stderr]    --> tests/cpu_integration.rs:612:5
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr] 612 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.691 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.691 INFO [stderr] 
Dec 02 19:46:23.691 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.691 INFO [stderr]    --> tests/cpu_integration.rs:615:5
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr] 615 |     cpu.step_n(20);
Dec 02 19:46:23.691 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.691 INFO [stderr]     |
Dec 02 19:46:23.691 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.691 INFO [stderr] 
Dec 02 19:46:23.698 INFO [stderr] warning: function `INTEGRATION_CPU_ora_ors_against_accumulator` should have a snake case name such as `integration_cpu_ora_ors_against_accumulator`
Dec 02 19:46:23.699 INFO [stderr]    --> tests/cpu_integration.rs:622:1
Dec 02 19:46:23.699 INFO [stderr]     |
Dec 02 19:46:23.699 INFO [stderr] 622 | / fn INTEGRATION_CPU_ora_ors_against_accumulator() {
Dec 02 19:46:23.699 INFO [stderr] 623 | |     let asm = "
Dec 02 19:46:23.699 INFO [stderr] 624 | |         LDA #$E7    ; 1110 0111
Dec 02 19:46:23.699 INFO [stderr] 625 | |         ORA #$18
Dec 02 19:46:23.699 INFO [stderr] ...   |
Dec 02 19:46:23.699 INFO [stderr] 637 | |     assert_eq!(0xFF, cpu.registers.A);
Dec 02 19:46:23.699 INFO [stderr] 638 | | }
Dec 02 19:46:23.699 INFO [stderr]     | |_^
Dec 02 19:46:23.706 INFO [stderr] 
Dec 02 19:46:23.707 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.707 INFO [stderr]    --> tests/cpu_integration.rs:632:5
Dec 02 19:46:23.707 INFO [stderr]     |
Dec 02 19:46:23.707 INFO [stderr] 632 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.707 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.707 INFO [stderr]     |
Dec 02 19:46:23.707 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.707 INFO [stderr] 
Dec 02 19:46:23.707 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.707 INFO [stderr]    --> tests/cpu_integration.rs:635:5
Dec 02 19:46:23.707 INFO [stderr]     |
Dec 02 19:46:23.707 INFO [stderr] 635 |     cpu.step_n(10);
Dec 02 19:46:23.707 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.707 INFO [stderr]     |
Dec 02 19:46:23.707 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.707 INFO [stderr] 
Dec 02 19:46:23.707 INFO [stderr] warning: function `INTEGRATION_CPU_pha_pla` should have a snake case name such as `integration_cpu_pha_pla`
Dec 02 19:46:23.707 INFO [stderr]    --> tests/cpu_integration.rs:641:1
Dec 02 19:46:23.707 INFO [stderr]     |
Dec 02 19:46:23.707 INFO [stderr] 641 | / fn INTEGRATION_CPU_pha_pla() {
Dec 02 19:46:23.707 INFO [stderr] 642 | |     let asm = "
Dec 02 19:46:23.707 INFO [stderr] 643 | |         LDA #$55
Dec 02 19:46:23.707 INFO [stderr] 644 | |         PHA
Dec 02 19:46:23.707 INFO [stderr] ...   |
Dec 02 19:46:23.707 INFO [stderr] 662 | |     assert_eq!(0x55, cpu.registers.A);
Dec 02 19:46:23.707 INFO [stderr] 663 | | }
Dec 02 19:46:23.707 INFO [stderr]     | |_^
Dec 02 19:46:23.707 INFO [stderr] 
Dec 02 19:46:23.707 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.707 INFO [stderr]    --> tests/cpu_integration.rs:653:5
Dec 02 19:46:23.707 INFO [stderr]     |
Dec 02 19:46:23.707 INFO [stderr] 653 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.707 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.707 INFO [stderr]     |
Dec 02 19:46:23.707 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.707 INFO [stderr] 
Dec 02 19:46:23.707 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.707 INFO [stderr]    --> tests/cpu_integration.rs:656:5
Dec 02 19:46:23.707 INFO [stderr]     |
Dec 02 19:46:23.707 INFO [stderr] 656 |     cpu.step_n(3);
Dec 02 19:46:23.707 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.707 INFO [stderr]     |
Dec 02 19:46:23.707 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.707 INFO [stderr] 
Dec 02 19:46:23.707 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.707 INFO [stderr]    --> tests/cpu_integration.rs:660:5
Dec 02 19:46:23.707 INFO [stderr]     |
Dec 02 19:46:23.707 INFO [stderr] 660 |     cpu.step();
Dec 02 19:46:23.707 INFO [stderr]     |     ^^^^^^^^^^^
Dec 02 19:46:23.707 INFO [stderr]     |
Dec 02 19:46:23.707 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.707 INFO [stderr] 
Dec 02 19:46:23.710 INFO [stderr] warning: function `INTEGRATION_CPU_rol` should have a snake case name such as `integration_cpu_rol`
Dec 02 19:46:23.710 INFO [stderr]    --> tests/cpu_integration.rs:666:1
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr] 666 | / fn INTEGRATION_CPU_rol() {
Dec 02 19:46:23.711 INFO [stderr] 667 | |     let asm = "
Dec 02 19:46:23.711 INFO [stderr] 668 | |         ; To explain this: 0xFF + 0x0A will wrap to
Dec 02 19:46:23.711 INFO [stderr] 669 | |         ; 0x09 + Carry. 0x09 << 1 is 0x12 + 1 for the
Dec 02 19:46:23.711 INFO [stderr] ...   |
Dec 02 19:46:23.711 INFO [stderr] 685 | |     assert_eq!(0x13, cpu.registers.A);
Dec 02 19:46:23.711 INFO [stderr] 686 | | }
Dec 02 19:46:23.711 INFO [stderr]     | |_^
Dec 02 19:46:23.711 INFO [stderr] 
Dec 02 19:46:23.711 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.711 INFO [stderr]    --> tests/cpu_integration.rs:680:5
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr] 680 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.711 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.711 INFO [stderr] 
Dec 02 19:46:23.711 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.711 INFO [stderr]    --> tests/cpu_integration.rs:683:5
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr] 683 |     cpu.step_n(3);
Dec 02 19:46:23.711 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.711 INFO [stderr] 
Dec 02 19:46:23.711 INFO [stderr] warning: function `INTEGRATION_CPU_ror` should have a snake case name such as `integration_cpu_ror`
Dec 02 19:46:23.711 INFO [stderr]    --> tests/cpu_integration.rs:689:1
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr] 689 | / fn INTEGRATION_CPU_ror() {
Dec 02 19:46:23.711 INFO [stderr] 690 | |     let asm = "
Dec 02 19:46:23.711 INFO [stderr] 691 | |         ; To explain this: 0xFF + 0x0A will wrap to
Dec 02 19:46:23.711 INFO [stderr] 692 | |         ; 0x09 + Carry. 0x09 >> 1 is 0x04 + 1 for the
Dec 02 19:46:23.711 INFO [stderr] ...   |
Dec 02 19:46:23.711 INFO [stderr] 709 | |     assert_eq!(0x85, cpu.registers.A);
Dec 02 19:46:23.711 INFO [stderr] 710 | | }
Dec 02 19:46:23.711 INFO [stderr]     | |_^
Dec 02 19:46:23.711 INFO [stderr] 
Dec 02 19:46:23.711 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.711 INFO [stderr]    --> tests/cpu_integration.rs:704:5
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr] 704 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.711 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.711 INFO [stderr] 
Dec 02 19:46:23.711 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.711 INFO [stderr]    --> tests/cpu_integration.rs:707:5
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr] 707 |     cpu.step_n(3);
Dec 02 19:46:23.711 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.711 INFO [stderr] 
Dec 02 19:46:23.711 INFO [stderr] warning: function `INTEGRATION_CPU_brk_rti` should have a snake case name such as `integration_cpu_brk_rti`
Dec 02 19:46:23.711 INFO [stderr]    --> tests/cpu_integration.rs:713:1
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr] 713 | / fn INTEGRATION_CPU_brk_rti() {
Dec 02 19:46:23.711 INFO [stderr] 714 | |     let asm = "
Dec 02 19:46:23.711 INFO [stderr] 715 | |         LDX #$20
Dec 02 19:46:23.711 INFO [stderr] 716 | |         STX $FFFF
Dec 02 19:46:23.711 INFO [stderr] ...   |
Dec 02 19:46:23.711 INFO [stderr] 744 | |     assert_eq!(true, cpu.flags.decimal);
Dec 02 19:46:23.711 INFO [stderr] 745 | | }
Dec 02 19:46:23.711 INFO [stderr]     | |_^
Dec 02 19:46:23.711 INFO [stderr] 
Dec 02 19:46:23.711 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.711 INFO [stderr]    --> tests/cpu_integration.rs:727:5
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr] 727 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.711 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.711 INFO [stderr] 
Dec 02 19:46:23.711 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.711 INFO [stderr]    --> tests/cpu_integration.rs:728:5
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr] 728 |     cpu.load(&segments[1].code[..], segments[1].address);
Dec 02 19:46:23.711 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.711 INFO [stderr] 
Dec 02 19:46:23.711 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.711 INFO [stderr]    --> tests/cpu_integration.rs:736:5
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr] 736 |     cpu.step_n(3); // Push them to the stack
Dec 02 19:46:23.711 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.711 INFO [stderr]     |
Dec 02 19:46:23.711 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.711 INFO [stderr] 
Dec 02 19:46:23.712 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.712 INFO [stderr]    --> tests/cpu_integration.rs:741:5
Dec 02 19:46:23.712 INFO [stderr]     |
Dec 02 19:46:23.712 INFO [stderr] 741 |     cpu.step(); // Pop them from the stack
Dec 02 19:46:23.712 INFO [stderr]     |     ^^^^^^^^^^^
Dec 02 19:46:23.718 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.719 INFO [stderr] 
Dec 02 19:46:23.719 INFO [stderr] warning: function `INTEGRATION_CPU_sbc` should have a snake case name such as `integration_cpu_sbc`
Dec 02 19:46:23.719 INFO [stderr]    --> tests/cpu_integration.rs:748:1
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr] 748 | / fn INTEGRATION_CPU_sbc() {
Dec 02 19:46:23.719 INFO [stderr] 749 | |     let asm = "
Dec 02 19:46:23.719 INFO [stderr] 750 | |         LDA #$FF
Dec 02 19:46:23.719 INFO [stderr] 751 | |         SBC #$0A
Dec 02 19:46:23.719 INFO [stderr] ...   |
Dec 02 19:46:23.719 INFO [stderr] 763 | |     assert_eq!(0xF4, cpu.registers.A);
Dec 02 19:46:23.719 INFO [stderr] 764 | | }
Dec 02 19:46:23.719 INFO [stderr]     | |_^
Dec 02 19:46:23.719 INFO [stderr] 
Dec 02 19:46:23.719 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.719 INFO [stderr]    --> tests/cpu_integration.rs:758:5
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr] 758 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.719 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.719 INFO [stderr] 
Dec 02 19:46:23.719 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.719 INFO [stderr]    --> tests/cpu_integration.rs:761:5
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr] 761 |     cpu.step_n(2);
Dec 02 19:46:23.719 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.719 INFO [stderr] 
Dec 02 19:46:23.719 INFO [stderr] warning: function `INTEGRATION_CPU_sbc_with_decimal_mode` should have a snake case name such as `integration_cpu_sbc_with_decimal_mode`
Dec 02 19:46:23.719 INFO [stderr]    --> tests/cpu_integration.rs:767:1
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr] 767 | / fn INTEGRATION_CPU_sbc_with_decimal_mode() {
Dec 02 19:46:23.719 INFO [stderr] 768 | |     let asm = "
Dec 02 19:46:23.719 INFO [stderr] 769 | |         SED
Dec 02 19:46:23.719 INFO [stderr] 770 | |         LDA #$35
Dec 02 19:46:23.719 INFO [stderr] ...   |
Dec 02 19:46:23.719 INFO [stderr] 783 | |     assert_eq!(0x15, cpu.registers.A);
Dec 02 19:46:23.719 INFO [stderr] 784 | | }
Dec 02 19:46:23.719 INFO [stderr]     | |_^
Dec 02 19:46:23.719 INFO [stderr] 
Dec 02 19:46:23.719 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.719 INFO [stderr]    --> tests/cpu_integration.rs:778:5
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr] 778 |     cpu.load(&segments[0].code[..], None);
Dec 02 19:46:23.719 INFO [stderr]     |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.719 INFO [stderr] 
Dec 02 19:46:23.719 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.719 INFO [stderr]    --> tests/cpu_integration.rs:781:5
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr] 781 |     cpu.step_n(3);
Dec 02 19:46:23.719 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.719 INFO [stderr] 
Dec 02 19:46:23.719 INFO [stderr] warning: function `INTEGRATION_CPU_can_load_code_segments_at_offsets` should have a snake case name such as `integration_cpu_can_load_code_segments_at_offsets`
Dec 02 19:46:23.719 INFO [stderr]    --> tests/cpu_integration.rs:787:1
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr] 787 | / fn INTEGRATION_CPU_can_load_code_segments_at_offsets() {
Dec 02 19:46:23.719 INFO [stderr] 788 | |     let asm = "
Dec 02 19:46:23.719 INFO [stderr] 789 | |         .ORG $2000
Dec 02 19:46:23.719 INFO [stderr] 790 | |         LDA #$35
Dec 02 19:46:23.719 INFO [stderr] ...   |
Dec 02 19:46:23.719 INFO [stderr] 808 | |     assert_eq!(&[0xA9, 0x00, 0x8D, 0x00, 0x01], &cpu.memory[0xABCD..0xABD2]);
Dec 02 19:46:23.719 INFO [stderr] 809 | | }
Dec 02 19:46:23.719 INFO [stderr]     | |_^
Dec 02 19:46:23.719 INFO [stderr] 
Dec 02 19:46:23.719 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.719 INFO [stderr]    --> tests/cpu_integration.rs:803:9
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr] 803 |         cpu.load(&segment.code[..], segment.address);
Dec 02 19:46:23.719 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.719 INFO [stderr] 
Dec 02 19:46:23.719 INFO [stderr] warning: function `INTEGRATION_CPU_can_force_interrupt_code` should have a snake case name such as `integration_cpu_can_force_interrupt_code`
Dec 02 19:46:23.719 INFO [stderr]    --> tests/cpu_integration.rs:812:1
Dec 02 19:46:23.719 INFO [stderr]     |
Dec 02 19:46:23.719 INFO [stderr] 812 | / fn INTEGRATION_CPU_can_force_interrupt_code() {
Dec 02 19:46:23.719 INFO [stderr] 813 | |     let asm = "
Dec 02 19:46:23.719 INFO [stderr] 814 | |         ; Store our interrupt handler address
Dec 02 19:46:23.720 INFO [stderr] 815 | |         LDX #$00
Dec 02 19:46:23.720 INFO [stderr] ...   |
Dec 02 19:46:23.720 INFO [stderr] 854 | |     assert_eq!(0xA0, cpu.registers.A);
Dec 02 19:46:23.720 INFO [stderr] 855 | | }
Dec 02 19:46:23.720 INFO [stderr]     | |_^
Dec 02 19:46:23.720 INFO [stderr] 
Dec 02 19:46:23.720 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.720 INFO [stderr]    --> tests/cpu_integration.rs:838:9
Dec 02 19:46:23.720 INFO [stderr]     |
Dec 02 19:46:23.720 INFO [stderr] 838 |         cpu.load(&segment.code[..], segment.address);
Dec 02 19:46:23.720 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.720 INFO [stderr]     |
Dec 02 19:46:23.720 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.720 INFO [stderr] 
Dec 02 19:46:23.720 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.720 INFO [stderr]    --> tests/cpu_integration.rs:844:5
Dec 02 19:46:23.720 INFO [stderr]     |
Dec 02 19:46:23.720 INFO [stderr] 844 |     cpu.step_n(4);
Dec 02 19:46:23.720 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.720 INFO [stderr]     |
Dec 02 19:46:23.720 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.720 INFO [stderr] 
Dec 02 19:46:23.720 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.720 INFO [stderr]    --> tests/cpu_integration.rs:846:5
Dec 02 19:46:23.720 INFO [stderr]     |
Dec 02 19:46:23.720 INFO [stderr] 846 |     cpu.step_n(2);
Dec 02 19:46:23.720 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.720 INFO [stderr]     |
Dec 02 19:46:23.720 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.720 INFO [stderr] 
Dec 02 19:46:23.720 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.720 INFO [stderr]    --> tests/cpu_integration.rs:852:5
Dec 02 19:46:23.720 INFO [stderr]     |
Dec 02 19:46:23.720 INFO [stderr] 852 |     cpu.step_n(50);
Dec 02 19:46:23.720 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.720 INFO [stderr]     |
Dec 02 19:46:23.720 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.720 INFO [stderr] 
Dec 02 19:46:23.720 INFO [stderr] warning: function `INTEGRATION_CPU_cant_interrupt_when_disabled` should have a snake case name such as `integration_cpu_cant_interrupt_when_disabled`
Dec 02 19:46:23.720 INFO [stderr]    --> tests/cpu_integration.rs:858:1
Dec 02 19:46:23.720 INFO [stderr]     |
Dec 02 19:46:23.720 INFO [stderr] 858 | / fn INTEGRATION_CPU_cant_interrupt_when_disabled() {
Dec 02 19:46:23.720 INFO [stderr] 859 | |     let asm = "
Dec 02 19:46:23.720 INFO [stderr] 860 | |         ; Store our interrupt handler address
Dec 02 19:46:23.720 INFO [stderr] 861 | |         LDX #$00
Dec 02 19:46:23.720 INFO [stderr] ...   |
Dec 02 19:46:23.720 INFO [stderr] 900 | |     assert_eq!(0x30, cpu.registers.A);
Dec 02 19:46:23.720 INFO [stderr] 901 | | }
Dec 02 19:46:23.720 INFO [stderr]     | |_^
Dec 02 19:46:23.720 INFO [stderr] 
Dec 02 19:46:23.730 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.731 INFO [stderr]    --> tests/cpu_integration.rs:884:9
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr] 884 |         cpu.load(&segment.code[..], segment.address);
Dec 02 19:46:23.731 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.731 INFO [stderr] 
Dec 02 19:46:23.731 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.731 INFO [stderr]    --> tests/cpu_integration.rs:890:5
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr] 890 |     cpu.step_n(4);
Dec 02 19:46:23.731 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.731 INFO [stderr] 
Dec 02 19:46:23.731 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.731 INFO [stderr]    --> tests/cpu_integration.rs:892:5
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr] 892 |     cpu.step_n(2);
Dec 02 19:46:23.731 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.731 INFO [stderr] 
Dec 02 19:46:23.731 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.731 INFO [stderr]    --> tests/cpu_integration.rs:898:5
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr] 898 |     cpu.step_n(50);
Dec 02 19:46:23.731 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.731 INFO [stderr] 
Dec 02 19:46:23.731 INFO [stderr] warning: function `INTEGRATION_CPU_can_interrupt_when_not_disabled` should have a snake case name such as `integration_cpu_can_interrupt_when_not_disabled`
Dec 02 19:46:23.731 INFO [stderr]    --> tests/cpu_integration.rs:904:1
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr] 904 | / fn INTEGRATION_CPU_can_interrupt_when_not_disabled() {
Dec 02 19:46:23.731 INFO [stderr] 905 | |     let asm = "
Dec 02 19:46:23.731 INFO [stderr] 906 | |         ; Store our interrupt handler address
Dec 02 19:46:23.731 INFO [stderr] 907 | |         LDX #$00
Dec 02 19:46:23.731 INFO [stderr] ...   |
Dec 02 19:46:23.731 INFO [stderr] 943 | |     assert_eq!(0xA0, cpu.registers.A);
Dec 02 19:46:23.731 INFO [stderr] 944 | | }
Dec 02 19:46:23.731 INFO [stderr]     | |_^
Dec 02 19:46:23.731 INFO [stderr] 
Dec 02 19:46:23.731 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.731 INFO [stderr]    --> tests/cpu_integration.rs:929:9
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr] 929 |         cpu.load(&segment.code[..], segment.address);
Dec 02 19:46:23.731 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.731 INFO [stderr] 
Dec 02 19:46:23.731 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.731 INFO [stderr]    --> tests/cpu_integration.rs:935:5
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr] 935 |     cpu.step_n(5);
Dec 02 19:46:23.731 INFO [stderr]     |     ^^^^^^^^^^^^^^
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.731 INFO [stderr] 
Dec 02 19:46:23.731 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:23.731 INFO [stderr]    --> tests/cpu_integration.rs:941:5
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr] 941 |     cpu.step_n(50);
Dec 02 19:46:23.731 INFO [stderr]     |     ^^^^^^^^^^^^^^^
Dec 02 19:46:23.731 INFO [stderr]     |
Dec 02 19:46:23.731 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:23.731 INFO [stderr] 
Dec 02 19:46:24.099 INFO [stderr] warning: unused variable: `cpu`
Dec 02 19:46:24.099 INFO [stderr]   --> tests/cpu.rs:11:17
Dec 02 19:46:24.099 INFO [stderr]    |
Dec 02 19:46:24.099 INFO [stderr] 11 |             let cpu = Cpu::new();
Dec 02 19:46:24.099 INFO [stderr]    |                 ^^^ help: consider using `_cpu` instead
Dec 02 19:46:24.115 INFO [stderr]    |
Dec 02 19:46:24.115 INFO [stderr]    = note: #[warn(unused_variables)] on by default
Dec 02 19:46:24.115 INFO [stderr] 
Dec 02 19:46:24.115 INFO [stderr] warning: unused variable: `step_result`
Dec 02 19:46:24.115 INFO [stderr]   --> tests/cpu.rs:81:17
Dec 02 19:46:24.115 INFO [stderr]    |
Dec 02 19:46:24.115 INFO [stderr] 81 |             let step_result: CpuStepResult = cpu.step();
Dec 02 19:46:24.115 INFO [stderr]    |                 ^^^^^^^^^^^ help: consider using `_step_result` instead
Dec 02 19:46:24.115 INFO [stderr] 
Dec 02 19:46:24.347 INFO [stderr] warning: unused import: `OpCode`
Dec 02 19:46:24.347 INFO [stderr]  --> src/assembler/assembler.rs:7:33
Dec 02 19:46:24.347 INFO [stderr]   |
Dec 02 19:46:24.347 INFO [stderr] 7 | use ::opcodes::{AddressingMode, OpCode};
Dec 02 19:46:24.347 INFO [stderr]   |                                 ^^^^^^
Dec 02 19:46:24.347 INFO [stderr]   |
Dec 02 19:46:24.347 INFO [stderr]   = note: #[warn(unused_imports)] on by default
Dec 02 19:46:24.347 INFO [stderr] 
Dec 02 19:46:24.347 INFO [stderr] warning: unused import: `LexerToken`
Dec 02 19:46:24.347 INFO [stderr]   --> src/assembler/assembler.rs:10:24
Dec 02 19:46:24.347 INFO [stderr]    |
Dec 02 19:46:24.347 INFO [stderr] 10 | use assembler::token::{LexerToken, ParserToken};
Dec 02 19:46:24.347 INFO [stderr]    |                        ^^^^^^^^^^
Dec 02 19:46:24.347 INFO [stderr] 
Dec 02 19:46:24.349 INFO [stderr] warning: unused import: `AddressingMode`
Dec 02 19:46:24.349 INFO [stderr]  --> src/assembler/token.rs:1:17
Dec 02 19:46:24.349 INFO [stderr]   |
Dec 02 19:46:24.349 INFO [stderr] 1 | use ::opcodes::{AddressingMode, OpCode};
Dec 02 19:46:24.349 INFO [stderr]   |                 ^^^^^^^^^^^^^^
Dec 02 19:46:24.349 INFO [stderr] 
Dec 02 19:46:24.349 INFO [stderr] warning: unused import: `::opcodes::OpCode`
Dec 02 19:46:24.349 INFO [stderr]   --> src/assembler/lexer.rs:12:5
Dec 02 19:46:24.349 INFO [stderr]    |
Dec 02 19:46:24.349 INFO [stderr] 12 | use ::opcodes::OpCode;
Dec 02 19:46:24.349 INFO [stderr]    |     ^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.349 INFO [stderr] 
Dec 02 19:46:24.370 INFO [stderr] warning: unused import: `ImmediateBase`
Dec 02 19:46:24.370 INFO [stderr]    --> src/assembler/parser.rs:610:30
Dec 02 19:46:24.370 INFO [stderr]     |
Dec 02 19:46:24.370 INFO [stderr] 610 |     use ::assembler::token::{ImmediateBase, LexerToken, ParserToken};
Dec 02 19:46:24.370 INFO [stderr]     |                              ^^^^^^^^^^^^^
Dec 02 19:46:24.370 INFO [stderr] 
Dec 02 19:46:24.379 INFO [stderr] warning: unused import: `AddressingMode`
Dec 02 19:46:24.379 INFO [stderr]  --> src/cpu/cpu.rs:3:17
Dec 02 19:46:24.379 INFO [stderr]   |
Dec 02 19:46:24.379 INFO [stderr] 3 | use ::opcodes::{AddressingMode, OpCode};
Dec 02 19:46:24.379 INFO [stderr]   |                 ^^^^^^^^^^^^^^
Dec 02 19:46:24.379 INFO [stderr] 
Dec 02 19:46:24.439 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.439 INFO [stderr]   --> tests/cpu.rs:20:13
Dec 02 19:46:24.439 INFO [stderr]    |
Dec 02 19:46:24.439 INFO [stderr] 20 |             cpu.load(&fake_code[..], None);
Dec 02 19:46:24.439 INFO [stderr]    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.439 INFO [stderr]    |
Dec 02 19:46:24.439 INFO [stderr]    = note: #[warn(unused_must_use)] on by default
Dec 02 19:46:24.439 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.439 INFO [stderr] 
Dec 02 19:46:24.439 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.439 INFO [stderr]   --> tests/cpu.rs:31:13
Dec 02 19:46:24.439 INFO [stderr]    |
Dec 02 19:46:24.439 INFO [stderr] 31 |             cpu.load(&fake_code[..], None);
Dec 02 19:46:24.439 INFO [stderr]    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.439 INFO [stderr]    |
Dec 02 19:46:24.439 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.439 INFO [stderr] 
Dec 02 19:46:24.439 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.439 INFO [stderr]   --> tests/cpu.rs:44:13
Dec 02 19:46:24.439 INFO [stderr]    |
Dec 02 19:46:24.439 INFO [stderr] 44 |             cpu.load(&fake_code[..], 0xF000);
Dec 02 19:46:24.439 INFO [stderr]    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.439 INFO [stderr]    |
Dec 02 19:46:24.439 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.439 INFO [stderr] 
Dec 02 19:46:24.443 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.443 INFO [stderr]   --> tests/cpu.rs:68:13
Dec 02 19:46:24.443 INFO [stderr]    |
Dec 02 19:46:24.443 INFO [stderr] 68 |             cpu.load(&fake_code[..], None);
Dec 02 19:46:24.443 INFO [stderr]    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.443 INFO [stderr]    |
Dec 02 19:46:24.443 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.443 INFO [stderr] 
Dec 02 19:46:24.443 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.443 INFO [stderr]   --> tests/cpu.rs:79:13
Dec 02 19:46:24.443 INFO [stderr]    |
Dec 02 19:46:24.443 INFO [stderr] 79 |             cpu.load(&fake_code[..], None);
Dec 02 19:46:24.443 INFO [stderr]    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.443 INFO [stderr]    |
Dec 02 19:46:24.443 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.443 INFO [stderr] 
Dec 02 19:46:24.443 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.443 INFO [stderr]   --> tests/cpu.rs:88:13
Dec 02 19:46:24.443 INFO [stderr]    |
Dec 02 19:46:24.443 INFO [stderr] 88 |             cpu.load(&code[..], None);
Dec 02 19:46:24.443 INFO [stderr]    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.443 INFO [stderr]    |
Dec 02 19:46:24.443 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.443 INFO [stderr] 
Dec 02 19:46:24.443 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.443 INFO [stderr]   --> tests/cpu.rs:91:13
Dec 02 19:46:24.443 INFO [stderr]    |
Dec 02 19:46:24.443 INFO [stderr] 91 |             cpu.step();
Dec 02 19:46:24.443 INFO [stderr]    |             ^^^^^^^^^^^
Dec 02 19:46:24.443 INFO [stderr]    |
Dec 02 19:46:24.443 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.443 INFO [stderr] 
Dec 02 19:46:24.443 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.443 INFO [stderr]    --> tests/cpu.rs:100:13
Dec 02 19:46:24.443 INFO [stderr]     |
Dec 02 19:46:24.443 INFO [stderr] 100 |             cpu.load(&code[..], None);
Dec 02 19:46:24.443 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.443 INFO [stderr]     |
Dec 02 19:46:24.443 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.443 INFO [stderr] 
Dec 02 19:46:24.443 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.443 INFO [stderr]    --> tests/cpu.rs:103:13
Dec 02 19:46:24.443 INFO [stderr]     |
Dec 02 19:46:24.443 INFO [stderr] 103 |             cpu.step();
Dec 02 19:46:24.443 INFO [stderr]     |             ^^^^^^^^^^^
Dec 02 19:46:24.443 INFO [stderr]     |
Dec 02 19:46:24.443 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.443 INFO [stderr] 
Dec 02 19:46:24.443 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.443 INFO [stderr]    --> tests/cpu.rs:112:13
Dec 02 19:46:24.443 INFO [stderr]     |
Dec 02 19:46:24.443 INFO [stderr] 112 |             cpu.load(&code[..], None);
Dec 02 19:46:24.443 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.443 INFO [stderr]     |
Dec 02 19:46:24.444 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.444 INFO [stderr] 
Dec 02 19:46:24.444 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.444 INFO [stderr]    --> tests/cpu.rs:115:13
Dec 02 19:46:24.444 INFO [stderr]     |
Dec 02 19:46:24.444 INFO [stderr] 115 |             cpu.step_n(2);
Dec 02 19:46:24.444 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.444 INFO [stderr]     |
Dec 02 19:46:24.444 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.444 INFO [stderr] 
Dec 02 19:46:24.444 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.444 INFO [stderr]    --> tests/cpu.rs:124:13
Dec 02 19:46:24.444 INFO [stderr]     |
Dec 02 19:46:24.444 INFO [stderr] 124 |             cpu.load(&code[..], None);
Dec 02 19:46:24.444 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.444 INFO [stderr]     |
Dec 02 19:46:24.444 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.444 INFO [stderr] 
Dec 02 19:46:24.444 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.444 INFO [stderr]    --> tests/cpu.rs:127:13
Dec 02 19:46:24.444 INFO [stderr]     |
Dec 02 19:46:24.444 INFO [stderr] 127 |             cpu.step_n(2);
Dec 02 19:46:24.444 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.444 INFO [stderr]     |
Dec 02 19:46:24.444 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.444 INFO [stderr] 
Dec 02 19:46:24.444 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.444 INFO [stderr]    --> tests/cpu.rs:137:13
Dec 02 19:46:24.444 INFO [stderr]     |
Dec 02 19:46:24.444 INFO [stderr] 137 |             cpu.load(&code[..], None);
Dec 02 19:46:24.444 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.444 INFO [stderr]     |
Dec 02 19:46:24.444 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.444 INFO [stderr] 
Dec 02 19:46:24.451 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.451 INFO [stderr]    --> tests/cpu.rs:140:13
Dec 02 19:46:24.451 INFO [stderr]     |
Dec 02 19:46:24.451 INFO [stderr] 140 |             cpu.step_n(3);
Dec 02 19:46:24.451 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.451 INFO [stderr]     |
Dec 02 19:46:24.451 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.451 INFO [stderr] 
Dec 02 19:46:24.451 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.451 INFO [stderr]    --> tests/cpu.rs:150:13
Dec 02 19:46:24.451 INFO [stderr]     |
Dec 02 19:46:24.451 INFO [stderr] 150 |             cpu.load(&code[..], None);
Dec 02 19:46:24.451 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.451 INFO [stderr]     |
Dec 02 19:46:24.451 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.451 INFO [stderr] 
Dec 02 19:46:24.451 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.451 INFO [stderr]    --> tests/cpu.rs:153:13
Dec 02 19:46:24.451 INFO [stderr]     |
Dec 02 19:46:24.451 INFO [stderr] 153 |             cpu.step_n(3);
Dec 02 19:46:24.451 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.451 INFO [stderr]     |
Dec 02 19:46:24.451 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.451 INFO [stderr] 
Dec 02 19:46:24.451 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.451 INFO [stderr]    --> tests/cpu.rs:164:13
Dec 02 19:46:24.451 INFO [stderr]     |
Dec 02 19:46:24.451 INFO [stderr] 164 |             cpu.load(&code[..], None);
Dec 02 19:46:24.451 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.451 INFO [stderr]     |
Dec 02 19:46:24.451 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.451 INFO [stderr] 
Dec 02 19:46:24.451 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.451 INFO [stderr]    --> tests/cpu.rs:167:13
Dec 02 19:46:24.451 INFO [stderr]     |
Dec 02 19:46:24.451 INFO [stderr] 167 |             cpu.step_n(2);
Dec 02 19:46:24.451 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.451 INFO [stderr]     |
Dec 02 19:46:24.451 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.451 INFO [stderr] 
Dec 02 19:46:24.451 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:178:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 178 |             cpu.load(&code[..], None);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.452 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:181:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 181 |             cpu.step_n(2);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.452 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:192:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 192 |             cpu.load(&code[..], None);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.452 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:195:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 195 |             cpu.step_n(2);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.452 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:205:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 205 |             cpu.load(&code[..], None);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.452 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:208:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 208 |             cpu.step_n(2);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.452 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:218:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 218 |             cpu.load(&code[..], None);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.452 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:221:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 221 |             cpu.step_n(2);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.452 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:231:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 231 |             cpu.load(&code[..], None);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.452 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:234:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 234 |             cpu.step_n(3);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.452 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:245:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 245 |             cpu.load(&code[..], None);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.452 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.452 INFO [stderr]    --> tests/cpu.rs:248:13
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr] 248 |             cpu.step_n(50);
Dec 02 19:46:24.452 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.452 INFO [stderr]     |
Dec 02 19:46:24.452 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.452 INFO [stderr] 
Dec 02 19:46:24.455 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.455 INFO [stderr]    --> tests/cpu.rs:257:13
Dec 02 19:46:24.455 INFO [stderr]     |
Dec 02 19:46:24.455 INFO [stderr] 257 |             cpu.load(&code[..], None);
Dec 02 19:46:24.455 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.455 INFO [stderr]     |
Dec 02 19:46:24.455 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.455 INFO [stderr] 
Dec 02 19:46:24.455 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.455 INFO [stderr]    --> tests/cpu.rs:260:13
Dec 02 19:46:24.455 INFO [stderr]     |
Dec 02 19:46:24.455 INFO [stderr] 260 |             cpu.step_n(10);
Dec 02 19:46:24.455 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.455 INFO [stderr]     |
Dec 02 19:46:24.455 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.455 INFO [stderr] 
Dec 02 19:46:24.455 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.455 INFO [stderr]    --> tests/cpu.rs:270:13
Dec 02 19:46:24.455 INFO [stderr]     |
Dec 02 19:46:24.455 INFO [stderr] 270 |             cpu.load(&code[..], None);
Dec 02 19:46:24.455 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.455 INFO [stderr]     |
Dec 02 19:46:24.455 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.455 INFO [stderr] 
Dec 02 19:46:24.456 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.456 INFO [stderr]    --> tests/cpu.rs:273:13
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr] 273 |             cpu.step_n(10);
Dec 02 19:46:24.456 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.456 INFO [stderr] 
Dec 02 19:46:24.456 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.456 INFO [stderr]    --> tests/cpu.rs:282:13
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr] 282 |             cpu.load(&code[..], None);
Dec 02 19:46:24.456 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.456 INFO [stderr] 
Dec 02 19:46:24.456 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.456 INFO [stderr]    --> tests/cpu.rs:285:13
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr] 285 |             cpu.step_n(10);
Dec 02 19:46:24.456 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.456 INFO [stderr] 
Dec 02 19:46:24.456 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.456 INFO [stderr]    --> tests/cpu.rs:295:13
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr] 295 |             cpu.load(&code[..], None);
Dec 02 19:46:24.456 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.456 INFO [stderr] 
Dec 02 19:46:24.456 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.456 INFO [stderr]    --> tests/cpu.rs:298:13
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr] 298 |             cpu.step_n(10);
Dec 02 19:46:24.456 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.456 INFO [stderr] 
Dec 02 19:46:24.456 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.456 INFO [stderr]    --> tests/cpu.rs:310:13
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr] 310 |             cpu.load(&code[..], None);
Dec 02 19:46:24.456 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.456 INFO [stderr] 
Dec 02 19:46:24.456 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.456 INFO [stderr]    --> tests/cpu.rs:313:13
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr] 313 |             cpu.step_n(10);
Dec 02 19:46:24.456 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.456 INFO [stderr] 
Dec 02 19:46:24.456 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.456 INFO [stderr]    --> tests/cpu.rs:323:13
Dec 02 19:46:24.456 INFO [stderr]     |
Dec 02 19:46:24.456 INFO [stderr] 323 |             cpu.load(&code[..], None);
Dec 02 19:46:24.456 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.457 INFO [stderr]     |
Dec 02 19:46:24.457 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.457 INFO [stderr] 
Dec 02 19:46:24.457 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.457 INFO [stderr]    --> tests/cpu.rs:326:13
Dec 02 19:46:24.457 INFO [stderr]     |
Dec 02 19:46:24.457 INFO [stderr] 326 |             cpu.step_n(10);
Dec 02 19:46:24.457 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.457 INFO [stderr]     |
Dec 02 19:46:24.457 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.457 INFO [stderr] 
Dec 02 19:46:24.457 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.457 INFO [stderr]    --> tests/cpu.rs:336:13
Dec 02 19:46:24.457 INFO [stderr]     |
Dec 02 19:46:24.457 INFO [stderr] 336 |             cpu.load(&code[..], None);
Dec 02 19:46:24.457 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.457 INFO [stderr]     |
Dec 02 19:46:24.457 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.457 INFO [stderr] 
Dec 02 19:46:24.457 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.457 INFO [stderr]    --> tests/cpu.rs:339:13
Dec 02 19:46:24.457 INFO [stderr]     |
Dec 02 19:46:24.457 INFO [stderr] 339 |             cpu.step_n(10);
Dec 02 19:46:24.457 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.457 INFO [stderr]     |
Dec 02 19:46:24.457 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.457 INFO [stderr] 
Dec 02 19:46:24.461 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.461 INFO [stderr]    --> tests/cpu.rs:348:13
Dec 02 19:46:24.461 INFO [stderr]     |
Dec 02 19:46:24.461 INFO [stderr] 348 |             cpu.load(&code[..], None);
Dec 02 19:46:24.461 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.461 INFO [stderr]     |
Dec 02 19:46:24.461 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.461 INFO [stderr] 
Dec 02 19:46:24.461 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.461 INFO [stderr]    --> tests/cpu.rs:351:13
Dec 02 19:46:24.461 INFO [stderr]     |
Dec 02 19:46:24.461 INFO [stderr] 351 |             cpu.step_n(10);
Dec 02 19:46:24.461 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.461 INFO [stderr]     |
Dec 02 19:46:24.461 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.461 INFO [stderr] 
Dec 02 19:46:24.461 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.461 INFO [stderr]    --> tests/cpu.rs:361:13
Dec 02 19:46:24.461 INFO [stderr]     |
Dec 02 19:46:24.461 INFO [stderr] 361 |             cpu.load(&code[..], None);
Dec 02 19:46:24.461 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.461 INFO [stderr]     |
Dec 02 19:46:24.461 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.461 INFO [stderr] 
Dec 02 19:46:24.461 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.461 INFO [stderr]    --> tests/cpu.rs:364:13
Dec 02 19:46:24.461 INFO [stderr]     |
Dec 02 19:46:24.461 INFO [stderr] 364 |             cpu.step_n(10);
Dec 02 19:46:24.461 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.461 INFO [stderr]     |
Dec 02 19:46:24.461 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.461 INFO [stderr] 
Dec 02 19:46:24.463 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.463 INFO [stderr]    --> tests/cpu.rs:374:13
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr] 374 |             cpu.load(&code[..], None);
Dec 02 19:46:24.463 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.463 INFO [stderr] 
Dec 02 19:46:24.463 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.463 INFO [stderr]    --> tests/cpu.rs:377:13
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr] 377 |             cpu.step_n(10);
Dec 02 19:46:24.463 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.463 INFO [stderr] 
Dec 02 19:46:24.463 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.463 INFO [stderr]    --> tests/cpu.rs:387:13
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr] 387 |             cpu.load(&code[..], None);
Dec 02 19:46:24.463 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.463 INFO [stderr] 
Dec 02 19:46:24.463 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.463 INFO [stderr]    --> tests/cpu.rs:390:13
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr] 390 |             cpu.step_n(10);
Dec 02 19:46:24.463 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.463 INFO [stderr] 
Dec 02 19:46:24.463 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.463 INFO [stderr]    --> tests/cpu.rs:400:13
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr] 400 |             cpu.load(&code[..], None);
Dec 02 19:46:24.463 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.463 INFO [stderr] 
Dec 02 19:46:24.463 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.463 INFO [stderr]    --> tests/cpu.rs:403:13
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr] 403 |             cpu.step_n(10);
Dec 02 19:46:24.463 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.463 INFO [stderr] 
Dec 02 19:46:24.463 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.463 INFO [stderr]    --> tests/cpu.rs:413:13
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr] 413 |             cpu.load(&code[..], None);
Dec 02 19:46:24.463 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.463 INFO [stderr] 
Dec 02 19:46:24.463 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.463 INFO [stderr]    --> tests/cpu.rs:416:13
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr] 416 |             cpu.step_n(10);
Dec 02 19:46:24.463 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.463 INFO [stderr] 
Dec 02 19:46:24.463 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.463 INFO [stderr]    --> tests/cpu.rs:426:13
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr] 426 |             cpu.load(&code[..], None);
Dec 02 19:46:24.463 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.463 INFO [stderr] 
Dec 02 19:46:24.463 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.463 INFO [stderr]    --> tests/cpu.rs:430:13
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr] 430 |             cpu.step();
Dec 02 19:46:24.463 INFO [stderr]     |             ^^^^^^^^^^^
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.463 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.463 INFO [stderr] 
Dec 02 19:46:24.463 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.463 INFO [stderr]    --> tests/cpu.rs:439:13
Dec 02 19:46:24.463 INFO [stderr]     |
Dec 02 19:46:24.464 INFO [stderr] 439 |             cpu.load(&code[..], None);
Dec 02 19:46:24.464 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.464 INFO [stderr]     |
Dec 02 19:46:24.464 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.464 INFO [stderr] 
Dec 02 19:46:24.464 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.464 INFO [stderr]    --> tests/cpu.rs:443:13
Dec 02 19:46:24.464 INFO [stderr]     |
Dec 02 19:46:24.464 INFO [stderr] 443 |             cpu.step();
Dec 02 19:46:24.464 INFO [stderr]     |             ^^^^^^^^^^^
Dec 02 19:46:24.464 INFO [stderr]     |
Dec 02 19:46:24.464 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.464 INFO [stderr] 
Dec 02 19:46:24.464 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.464 INFO [stderr]    --> tests/cpu.rs:452:13
Dec 02 19:46:24.464 INFO [stderr]     |
Dec 02 19:46:24.464 INFO [stderr] 452 |             cpu.load(&code[..], None);
Dec 02 19:46:24.464 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.464 INFO [stderr]     |
Dec 02 19:46:24.464 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.464 INFO [stderr] 
Dec 02 19:46:24.464 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.464 INFO [stderr]    --> tests/cpu.rs:456:13
Dec 02 19:46:24.464 INFO [stderr]     |
Dec 02 19:46:24.464 INFO [stderr] 456 |             cpu.step();
Dec 02 19:46:24.464 INFO [stderr]     |             ^^^^^^^^^^^
Dec 02 19:46:24.464 INFO [stderr]     |
Dec 02 19:46:24.464 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.464 INFO [stderr] 
Dec 02 19:46:24.464 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.464 INFO [stderr]    --> tests/cpu.rs:465:13
Dec 02 19:46:24.464 INFO [stderr]     |
Dec 02 19:46:24.464 INFO [stderr] 465 |             cpu.load(&code[..], None);
Dec 02 19:46:24.464 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.464 INFO [stderr]     |
Dec 02 19:46:24.468 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:469:13
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr] 469 |             cpu.step();
Dec 02 19:46:24.469 INFO [stderr]     |             ^^^^^^^^^^^
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:478:13
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr] 478 |             cpu.load(&code[..], None);
Dec 02 19:46:24.469 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:482:13
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr] 482 |             cpu.step_n(2);
Dec 02 19:46:24.469 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:491:13
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr] 491 |             cpu.load(&code[..], None);
Dec 02 19:46:24.469 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:495:13
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr] 495 |             cpu.step_n(2);
Dec 02 19:46:24.469 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:504:13
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr] 504 |             cpu.load(&code[..], None);
Dec 02 19:46:24.469 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:508:13
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr] 508 |             cpu.step_n(2);
Dec 02 19:46:24.469 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:517:13
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr] 517 |             cpu.load(&code[..], None);
Dec 02 19:46:24.469 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:521:13
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr] 521 |             cpu.step_n(2);
Dec 02 19:46:24.469 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:530:13
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr] 530 |             cpu.load(&code[..], None);
Dec 02 19:46:24.469 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:534:13
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr] 534 |             cpu.step_n(2);
Dec 02 19:46:24.469 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.469 INFO [stderr]     |
Dec 02 19:46:24.469 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.469 INFO [stderr] 
Dec 02 19:46:24.469 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.469 INFO [stderr]    --> tests/cpu.rs:543:13
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr] 543 |             cpu.load(&code[..], None);
Dec 02 19:46:24.470 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.470 INFO [stderr] 
Dec 02 19:46:24.470 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.470 INFO [stderr]    --> tests/cpu.rs:547:13
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr] 547 |             cpu.step_n(2);
Dec 02 19:46:24.470 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.470 INFO [stderr] 
Dec 02 19:46:24.470 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.470 INFO [stderr]    --> tests/cpu.rs:556:13
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr] 556 |             cpu.load(&code[..], None);
Dec 02 19:46:24.470 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.470 INFO [stderr] 
Dec 02 19:46:24.470 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.470 INFO [stderr]    --> tests/cpu.rs:560:13
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr] 560 |             cpu.step_n(2);
Dec 02 19:46:24.470 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.470 INFO [stderr] 
Dec 02 19:46:24.470 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.470 INFO [stderr]    --> tests/cpu.rs:569:13
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr] 569 |             cpu.load(&code[..], None);
Dec 02 19:46:24.470 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.470 INFO [stderr] 
Dec 02 19:46:24.470 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.470 INFO [stderr]    --> tests/cpu.rs:572:13
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr] 572 |             cpu.step_n(10);
Dec 02 19:46:24.470 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.470 INFO [stderr] 
Dec 02 19:46:24.470 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.470 INFO [stderr]    --> tests/cpu.rs:581:13
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr] 581 |             cpu.load(&code[..], None);
Dec 02 19:46:24.470 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.470 INFO [stderr]     |
Dec 02 19:46:24.470 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.470 INFO [stderr] 
Dec 02 19:46:24.470 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.470 INFO [stderr]    --> tests/cpu.rs:584:13
Dec 02 19:46:24.471 INFO [stderr]     |
Dec 02 19:46:24.471 INFO [stderr] 584 |             cpu.step_n(10);
Dec 02 19:46:24.471 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.471 INFO [stderr]     |
Dec 02 19:46:24.471 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.471 INFO [stderr] 
Dec 02 19:46:24.471 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.471 INFO [stderr]    --> tests/cpu.rs:593:13
Dec 02 19:46:24.471 INFO [stderr]     |
Dec 02 19:46:24.471 INFO [stderr] 593 |             cpu.load(&code[..], None);
Dec 02 19:46:24.471 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.471 INFO [stderr]     |
Dec 02 19:46:24.471 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.471 INFO [stderr] 
Dec 02 19:46:24.471 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.471 INFO [stderr]    --> tests/cpu.rs:596:13
Dec 02 19:46:24.471 INFO [stderr]     |
Dec 02 19:46:24.471 INFO [stderr] 596 |             cpu.step_n(10);
Dec 02 19:46:24.471 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.471 INFO [stderr]     |
Dec 02 19:46:24.471 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.471 INFO [stderr] 
Dec 02 19:46:24.471 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.471 INFO [stderr]    --> tests/cpu.rs:605:13
Dec 02 19:46:24.471 INFO [stderr]     |
Dec 02 19:46:24.471 INFO [stderr] 605 |             cpu.load(&code[..], None);
Dec 02 19:46:24.471 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.471 INFO [stderr]     |
Dec 02 19:46:24.471 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.471 INFO [stderr] 
Dec 02 19:46:24.474 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.474 INFO [stderr]    --> tests/cpu.rs:608:13
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr] 608 |             cpu.step_n(2);
Dec 02 19:46:24.474 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.474 INFO [stderr] 
Dec 02 19:46:24.474 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.474 INFO [stderr]    --> tests/cpu.rs:617:13
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr] 617 |             cpu.load(&code[..], None);
Dec 02 19:46:24.474 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.474 INFO [stderr] 
Dec 02 19:46:24.474 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.474 INFO [stderr]    --> tests/cpu.rs:620:13
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr] 620 |             cpu.step_n(10);
Dec 02 19:46:24.474 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.474 INFO [stderr] 
Dec 02 19:46:24.474 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.474 INFO [stderr]    --> tests/cpu.rs:629:13
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr] 629 |             cpu.load(&code[..], None);
Dec 02 19:46:24.474 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.474 INFO [stderr] 
Dec 02 19:46:24.474 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.474 INFO [stderr]    --> tests/cpu.rs:632:13
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr] 632 |             cpu.step_n(10);
Dec 02 19:46:24.474 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.474 INFO [stderr] 
Dec 02 19:46:24.474 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.474 INFO [stderr]    --> tests/cpu.rs:641:13
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr] 641 |             cpu.load(&code[..], None);
Dec 02 19:46:24.474 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.474 INFO [stderr]     |
Dec 02 19:46:24.474 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.474 INFO [stderr] 
Dec 02 19:46:24.483 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.483 INFO [stderr]    --> tests/cpu.rs:644:13
Dec 02 19:46:24.483 INFO [stderr]     |
Dec 02 19:46:24.483 INFO [stderr] 644 |             cpu.step_n(20);
Dec 02 19:46:24.483 INFO [stderr]     |             ^^^^^^^^^^^^^^^
Dec 02 19:46:24.483 INFO [stderr]     |
Dec 02 19:46:24.483 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.483 INFO [stderr] 
Dec 02 19:46:24.483 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.483 INFO [stderr]    --> tests/cpu.rs:653:13
Dec 02 19:46:24.483 INFO [stderr]     |
Dec 02 19:46:24.483 INFO [stderr] 653 |             cpu.load(&code[..], None);
Dec 02 19:46:24.483 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:24.483 INFO [stderr]     |
Dec 02 19:46:24.483 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.483 INFO [stderr] 
Dec 02 19:46:24.483 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:24.483 INFO [stderr]    --> tests/cpu.rs:656:13
Dec 02 19:46:24.483 INFO [stderr]     |
Dec 02 19:46:24.483 INFO [stderr] 656 |             cpu.step_n(2);
Dec 02 19:46:24.483 INFO [stderr]     |             ^^^^^^^^^^^^^^
Dec 02 19:46:24.483 INFO [stderr]     |
Dec 02 19:46:24.483 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:24.483 INFO [stderr] 
Dec 02 19:46:25.338 INFO [stderr] warning: unreachable statement
Dec 02 19:46:25.339 INFO [stderr]    --> src/assembler/parser.rs:327:21
Dec 02 19:46:25.339 INFO [stderr]     |
Dec 02 19:46:25.339 INFO [stderr] 327 |                     let next = *peeker.peek().unwrap();
Dec 02 19:46:25.339 INFO [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:25.339 INFO [stderr]     |
Dec 02 19:46:25.339 INFO [stderr]     = note: #[warn(unreachable_code)] on by default
Dec 02 19:46:25.339 INFO [stderr] 
Dec 02 19:46:25.359 INFO [stderr] warning: unreachable statement
Dec 02 19:46:25.359 INFO [stderr]    --> src/assembler/parser.rs:490:9
Dec 02 19:46:25.359 INFO [stderr]     |
Dec 02 19:46:25.359 INFO [stderr] 490 |         unreachable!();
Dec 02 19:46:25.359 INFO [stderr]     |         ^^^^^^^^^^^^^^^
Dec 02 19:46:25.359 INFO [stderr]     |
Dec 02 19:46:25.359 INFO [stderr]     = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)
Dec 02 19:46:25.359 INFO [stderr] 
Dec 02 19:46:25.764 INFO [stderr] warning: variable `last_addressing_mode` is assigned to, but never used
Dec 02 19:46:25.764 INFO [stderr]    --> src/assembler/assembler.rs:181:17
Dec 02 19:46:25.764 INFO [stderr]     |
Dec 02 19:46:25.764 INFO [stderr] 181 |         let mut last_addressing_mode = AddressingMode::Absolute;
Dec 02 19:46:25.764 INFO [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:25.770 INFO [stderr]     |
Dec 02 19:46:25.797 INFO [stderr]     = note: #[warn(unused_variables)] on by default
Dec 02 19:46:25.797 INFO [stderr]     = note: consider using `_last_addressing_mode` instead
Dec 02 19:46:25.797 INFO [stderr] 
Dec 02 19:46:25.797 INFO [stderr] warning: value assigned to `last_addressing_mode` is never read
Dec 02 19:46:25.797 INFO [stderr]    --> src/assembler/assembler.rs:192:17
Dec 02 19:46:25.797 INFO [stderr]     |
Dec 02 19:46:25.797 INFO [stderr] 192 |                 last_addressing_mode = opcode.mode;
Dec 02 19:46:25.797 INFO [stderr]     |                 ^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:25.797 INFO [stderr]     |
Dec 02 19:46:25.797 INFO [stderr]     = note: #[warn(unused_assignments)] on by default
Dec 02 19:46:25.797 INFO [stderr] 
Dec 02 19:46:25.797 INFO [stderr] warning: unused variable: `added_label`
Dec 02 19:46:25.797 INFO [stderr]   --> src/assembler/parser.rs:94:21
Dec 02 19:46:25.797 INFO [stderr]    |
Dec 02 19:46:25.797 INFO [stderr] 94 |             let mut added_label = false;
Dec 02 19:46:25.797 INFO [stderr]    |                     ^^^^^^^^^^^ help: consider using `_added_label` instead
Dec 02 19:46:25.797 INFO [stderr] 
Dec 02 19:46:25.797 INFO [stderr] warning: unused variable: `opcode`
Dec 02 19:46:25.797 INFO [stderr]    --> src/assembler/parser.rs:192:21
Dec 02 19:46:25.797 INFO [stderr]     |
Dec 02 19:46:25.797 INFO [stderr] 192 |         if let Some(opcode) = OpCode::from_mnemonic(mnemonic) {
Dec 02 19:46:25.797 INFO [stderr]     |                     ^^^^^^ help: consider using `_opcode` instead
Dec 02 19:46:25.797 INFO [stderr] 
Dec 02 19:46:25.797 INFO [stderr] warning: unused variable: `next`
Dec 02 19:46:25.797 INFO [stderr]    --> src/assembler/parser.rs:327:25
Dec 02 19:46:25.797 INFO [stderr]     |
Dec 02 19:46:25.797 INFO [stderr] 327 |                     let next = *peeker.peek().unwrap();
Dec 02 19:46:25.797 INFO [stderr]     |                         ^^^^ help: consider using `_next` instead
Dec 02 19:46:25.797 INFO [stderr] 
Dec 02 19:46:25.797 INFO [stderr] warning: unused variable: `addressing_mode`
Dec 02 19:46:25.797 INFO [stderr]    --> src/assembler/parser.rs:334:21
Dec 02 19:46:25.797 INFO [stderr]     |
Dec 02 19:46:25.797 INFO [stderr] 334 |                 let addressing_mode = AddressingMode::Indirect;
Dec 02 19:46:25.797 INFO [stderr]     |                     ^^^^^^^^^^^^^^^ help: consider using `_addressing_mode` instead
Dec 02 19:46:25.797 INFO [stderr] 
Dec 02 19:46:25.797 INFO [stderr] warning: unused variable: `addressing_mode`
Dec 02 19:46:25.797 INFO [stderr]    --> src/assembler/parser.rs:406:29
Dec 02 19:46:25.797 INFO [stderr]     |
Dec 02 19:46:25.797 INFO [stderr] 406 |                         let addressing_mode = AddressingMode::IndirectY;
Dec 02 19:46:25.797 INFO [stderr]     |                             ^^^^^^^^^^^^^^^ help: consider using `_addressing_mode` instead
Dec 02 19:46:25.797 INFO [stderr] 
Dec 02 19:46:25.864 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:25.865 INFO [stderr]    --> src/assembler/lexer.rs:109:30
Dec 02 19:46:25.865 INFO [stderr]     |
Dec 02 19:46:25.865 INFO [stderr] 109 |     fn advance<I>(&mut self, mut peeker: &mut Peekable<I>)
Dec 02 19:46:25.865 INFO [stderr]     |                              ----^^^^^^
Dec 02 19:46:25.866 INFO [stderr]     |                              |
Dec 02 19:46:25.866 INFO [stderr]     |                              help: remove this `mut`
Dec 02 19:46:25.866 INFO [stderr]     |
Dec 02 19:46:25.866 INFO [stderr]     = note: #[warn(unused_mut)] on by default
Dec 02 19:46:25.866 INFO [stderr] 
Dec 02 19:46:25.919 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:25.919 INFO [stderr]    --> src/assembler/parser.rs:200:33
Dec 02 19:46:25.919 INFO [stderr]     |
Dec 02 19:46:25.919 INFO [stderr] 200 |                                 mut peeker: &mut Peekable<I>,
Dec 02 19:46:25.919 INFO [stderr]     |                                 ----^^^^^^
Dec 02 19:46:25.919 INFO [stderr]     |                                 |
Dec 02 19:46:25.919 INFO [stderr]     |                                 help: remove this `mut`
Dec 02 19:46:25.919 INFO [stderr] 
Dec 02 19:46:25.923 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:25.923 INFO [stderr]    --> src/assembler/parser.rs:494:37
Dec 02 19:46:25.923 INFO [stderr]     |
Dec 02 19:46:25.923 INFO [stderr] 494 |                                     mut peeker: &mut Peekable<I>)
Dec 02 19:46:25.923 INFO [stderr]     |                                     ----^^^^^^
Dec 02 19:46:25.923 INFO [stderr]     |                                     |
Dec 02 19:46:25.923 INFO [stderr]     |                                     help: remove this `mut`
Dec 02 19:46:25.923 INFO [stderr] 
Dec 02 19:46:25.924 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:25.924 INFO [stderr]    --> src/assembler/parser.rs:515:38
Dec 02 19:46:25.924 INFO [stderr]     |
Dec 02 19:46:25.924 INFO [stderr] 515 |                                      mut peeker: &mut Peekable<I>)
Dec 02 19:46:25.924 INFO [stderr]     |                                      ----^^^^^^
Dec 02 19:46:25.924 INFO [stderr]     |                                      |
Dec 02 19:46:25.924 INFO [stderr]     |                                      help: remove this `mut`
Dec 02 19:46:25.924 INFO [stderr] 
Dec 02 19:46:25.924 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:25.924 INFO [stderr]    --> src/assembler/parser.rs:528:17
Dec 02 19:46:25.924 INFO [stderr]     |
Dec 02 19:46:25.924 INFO [stderr] 528 |             let mut next = peeker.next().unwrap();
Dec 02 19:46:25.924 INFO [stderr]     |                 ----^^^^
Dec 02 19:46:25.924 INFO [stderr]     |                 |
Dec 02 19:46:25.924 INFO [stderr]     |                 help: remove this `mut`
Dec 02 19:46:25.924 INFO [stderr] 
Dec 02 19:46:26.021 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:26.021 INFO [stderr]    --> src/cpu/cpu.rs:530:13
Dec 02 19:46:26.021 INFO [stderr]     |
Dec 02 19:46:26.021 INFO [stderr] 530 |         let mut mem = &mut self.memory[STACK_START..STACK_END + 0x01];
Dec 02 19:46:26.021 INFO [stderr]     |             ----^^^
Dec 02 19:46:26.021 INFO [stderr]     |             |
Dec 02 19:46:26.021 INFO [stderr]     |             help: remove this `mut`
Dec 02 19:46:26.021 INFO [stderr] 
Dec 02 19:46:26.023 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:26.023 INFO [stderr]    --> src/cpu/cpu.rs:598:13
Dec 02 19:46:26.023 INFO [stderr]     |
Dec 02 19:46:26.023 INFO [stderr] 598 |         let mut mem = &mut self.memory[STACK_START..STACK_END + 0x01];
Dec 02 19:46:26.024 INFO [stderr]     |             ----^^^
Dec 02 19:46:26.024 INFO [stderr]     |             |
Dec 02 19:46:26.024 INFO [stderr]     |             help: remove this `mut`
Dec 02 19:46:26.024 INFO [stderr] 
Dec 02 19:46:26.024 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:26.024 INFO [stderr]    --> src/cpu/cpu.rs:604:13
Dec 02 19:46:26.024 INFO [stderr]     |
Dec 02 19:46:26.024 INFO [stderr] 604 |         let mut mem = &mut self.memory[STACK_START..STACK_END + 0x01];
Dec 02 19:46:26.024 INFO [stderr]     |             ----^^^
Dec 02 19:46:26.024 INFO [stderr]     |             |
Dec 02 19:46:26.024 INFO [stderr]     |             help: remove this `mut`
Dec 02 19:46:26.024 INFO [stderr] 
Dec 02 19:46:26.025 INFO [stderr] warning: variable does not need to be mutable
Dec 02 19:46:26.025 INFO [stderr]    --> src/cpu/cpu.rs:626:13
Dec 02 19:46:26.025 INFO [stderr]     |
Dec 02 19:46:26.025 INFO [stderr] 626 |         let mut mem = &mut self.memory[STACK_START..STACK_END + 0x01];
Dec 02 19:46:26.025 INFO [stderr]     |             ----^^^
Dec 02 19:46:26.025 INFO [stderr]     |             |
Dec 02 19:46:26.025 INFO [stderr]     |             help: remove this `mut`
Dec 02 19:46:26.025 INFO [stderr] 
Dec 02 19:46:26.076 INFO [stderr] warning: variant is never constructed: `Absolute`
Dec 02 19:46:26.076 INFO [stderr]   --> src/assembler/token.rs:27:5
Dec 02 19:46:26.076 INFO [stderr]    |
Dec 02 19:46:26.076 INFO [stderr] 27 |     Absolute(String),
Dec 02 19:46:26.076 INFO [stderr]    |     ^^^^^^^^^^^^^^^^
Dec 02 19:46:26.076 INFO [stderr]    |
Dec 02 19:46:26.076 INFO [stderr]    = note: #[warn(dead_code)] on by default
Dec 02 19:46:26.076 INFO [stderr] 
Dec 02 19:46:26.076 INFO [stderr] warning: method is never used: `unexpected_ident`
Dec 02 19:46:26.076 INFO [stderr]   --> src/assembler/lexer.rs:20:5
Dec 02 19:46:26.076 INFO [stderr]    |
Dec 02 19:46:26.076 INFO [stderr] 20 | /     fn unexpected_ident<A, B>(expected: A, found: B, line: u32, column: u32) -> LexerError
Dec 02 19:46:26.077 INFO [stderr] 21 | |         where A: std::fmt::Display,
Dec 02 19:46:26.077 INFO [stderr] 22 | |               B: std::fmt::Display
Dec 02 19:46:26.077 INFO [stderr] 23 | |     {
Dec 02 19:46:26.077 INFO [stderr] ...  |
Dec 02 19:46:26.077 INFO [stderr] 30 | |         }
Dec 02 19:46:26.077 INFO [stderr] 31 | |     }
Dec 02 19:46:26.077 INFO [stderr]    | |_____^
Dec 02 19:46:26.077 INFO [stderr] 
Dec 02 19:46:26.077 INFO [stderr] warning: method is never used: `expected_eol`
Dec 02 19:46:26.077 INFO [stderr]   --> src/assembler/parser.rs:32:5
Dec 02 19:46:26.077 INFO [stderr]    |
Dec 02 19:46:26.077 INFO [stderr] 32 |     fn expected_eol(line: u32) -> ParserError {
Dec 02 19:46:26.077 INFO [stderr]    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.077 INFO [stderr] 
Dec 02 19:46:26.080 INFO [stderr] warning: comparison is useless due to type limits
Dec 02 19:46:26.080 INFO [stderr]    --> src/assembler/assembler.rs:155:51
Dec 02 19:46:26.080 INFO [stderr]     |
Dec 02 19:46:26.080 INFO [stderr] 155 |                             if distance < -128 || distance > 127 {
Dec 02 19:46:26.080 INFO [stderr]     |                                                   ^^^^^^^^^^^^^^
Dec 02 19:46:26.080 INFO [stderr]     |
Dec 02 19:46:26.080 INFO [stderr]     = note: #[warn(unused_comparisons)] on by default
Dec 02 19:46:26.080 INFO [stderr] 
Dec 02 19:46:26.103 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.104 INFO [stderr]    --> src/cpu/cpu.rs:253:9
Dec 02 19:46:26.104 INFO [stderr]     |
Dec 02 19:46:26.104 INFO [stderr] 253 |         self.stack.push_u16(mem, self.registers.PC);
Dec 02 19:46:26.104 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.104 INFO [stderr]     |
Dec 02 19:46:26.104 INFO [stderr]     = note: #[warn(unused_must_use)] on by default
Dec 02 19:46:26.104 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.104 INFO [stderr] 
Dec 02 19:46:26.104 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.104 INFO [stderr]    --> src/cpu/cpu.rs:254:9
Dec 02 19:46:26.104 INFO [stderr]     |
Dec 02 19:46:26.104 INFO [stderr] 254 |         self.stack.push(mem, self.flags.to_u8());
Dec 02 19:46:26.104 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.104 INFO [stderr]     |
Dec 02 19:46:26.104 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.104 INFO [stderr] 
Dec 02 19:46:26.104 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.104 INFO [stderr]    --> src/cpu/cpu.rs:276:9
Dec 02 19:46:26.104 INFO [stderr]     |
Dec 02 19:46:26.104 INFO [stderr] 276 |         self.stack.push_u16(mem, self.registers.PC);
Dec 02 19:46:26.104 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.104 INFO [stderr]     |
Dec 02 19:46:26.104 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.104 INFO [stderr] 
Dec 02 19:46:26.104 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.104 INFO [stderr]    --> src/cpu/cpu.rs:277:9
Dec 02 19:46:26.104 INFO [stderr]     |
Dec 02 19:46:26.104 INFO [stderr] 277 |         self.stack.push(mem, self.flags.to_u8());
Dec 02 19:46:26.104 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.104 INFO [stderr]     |
Dec 02 19:46:26.104 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.104 INFO [stderr] 
Dec 02 19:46:26.105 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.105 INFO [stderr]    --> src/cpu/cpu.rs:532:9
Dec 02 19:46:26.105 INFO [stderr]     |
Dec 02 19:46:26.105 INFO [stderr] 532 |         self.stack.push_u16(mem, self.registers.PC);
Dec 02 19:46:26.105 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.105 INFO [stderr]     |
Dec 02 19:46:26.105 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.105 INFO [stderr] 
Dec 02 19:46:26.108 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.108 INFO [stderr]   --> src/cpu/stack.rs:85:9
Dec 02 19:46:26.108 INFO [stderr]    |
Dec 02 19:46:26.108 INFO [stderr] 85 |         stack.push(&mut stack_area, 55);
Dec 02 19:46:26.108 INFO [stderr]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.108 INFO [stderr]    |
Dec 02 19:46:26.108 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.108 INFO [stderr] 
Dec 02 19:46:26.109 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.109 INFO [stderr]   --> src/cpu/stack.rs:95:9
Dec 02 19:46:26.109 INFO [stderr]    |
Dec 02 19:46:26.109 INFO [stderr] 95 |         stack.push(&mut stack_area, 55);
Dec 02 19:46:26.109 INFO [stderr]    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.109 INFO [stderr]    |
Dec 02 19:46:26.109 INFO [stderr]    = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.109 INFO [stderr] 
Dec 02 19:46:26.110 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.110 INFO [stderr]    --> src/cpu/stack.rs:106:9
Dec 02 19:46:26.110 INFO [stderr]     |
Dec 02 19:46:26.110 INFO [stderr] 106 |         stack.push(&mut stack_area, 5);
Dec 02 19:46:26.111 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.111 INFO [stderr]     |
Dec 02 19:46:26.111 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.111 INFO [stderr] 
Dec 02 19:46:26.111 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.111 INFO [stderr]    --> src/cpu/stack.rs:107:9
Dec 02 19:46:26.111 INFO [stderr]     |
Dec 02 19:46:26.111 INFO [stderr] 107 |         stack.push(&mut stack_area, 10);
Dec 02 19:46:26.111 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.111 INFO [stderr]     |
Dec 02 19:46:26.111 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.111 INFO [stderr] 
Dec 02 19:46:26.111 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.111 INFO [stderr]    --> src/cpu/stack.rs:108:9
Dec 02 19:46:26.111 INFO [stderr]     |
Dec 02 19:46:26.111 INFO [stderr] 108 |         stack.push(&mut stack_area, 15);
Dec 02 19:46:26.111 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.111 INFO [stderr]     |
Dec 02 19:46:26.111 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.111 INFO [stderr] 
Dec 02 19:46:26.111 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.111 INFO [stderr]    --> src/cpu/stack.rs:109:9
Dec 02 19:46:26.111 INFO [stderr]     |
Dec 02 19:46:26.111 INFO [stderr] 109 |         stack.push(&mut stack_area, 20);
Dec 02 19:46:26.111 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.111 INFO [stderr]     |
Dec 02 19:46:26.111 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.111 INFO [stderr] 
Dec 02 19:46:26.112 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.112 INFO [stderr]    --> src/cpu/stack.rs:138:13
Dec 02 19:46:26.112 INFO [stderr]     |
Dec 02 19:46:26.112 INFO [stderr] 138 |             stack.push(&mut stack_area, 5);
Dec 02 19:46:26.112 INFO [stderr]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.112 INFO [stderr]     |
Dec 02 19:46:26.112 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.112 INFO [stderr] 
Dec 02 19:46:26.113 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.113 INFO [stderr]    --> src/cpu/stack.rs:151:9
Dec 02 19:46:26.113 INFO [stderr]     |
Dec 02 19:46:26.113 INFO [stderr] 151 |         stack.push_u16(&mut stack_area, 0x4400);
Dec 02 19:46:26.113 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.113 INFO [stderr]     |
Dec 02 19:46:26.113 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.113 INFO [stderr] 
Dec 02 19:46:26.114 INFO [stderr] warning: unused `std::result::Result` which must be used
Dec 02 19:46:26.114 INFO [stderr]    --> src/cpu/stack.rs:162:9
Dec 02 19:46:26.114 INFO [stderr]     |
Dec 02 19:46:26.114 INFO [stderr] 162 |         stack.push_u16(&mut stack_area, 0x4400);
Dec 02 19:46:26.114 INFO [stderr]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Dec 02 19:46:26.114 INFO [stderr]     |
Dec 02 19:46:26.114 INFO [stderr]     = note: this `Result` may be an `Err` variant, which should be handled
Dec 02 19:46:26.114 INFO [stderr] 
Dec 02 19:46:26.115 INFO [stderr] warning: static variable `OpCodes` should have an upper case name such as `OP_CODES`
Dec 02 19:46:26.115 INFO [stderr]     --> src/opcodes.rs:53:1
Dec 02 19:46:26.115 INFO [stderr]      |
Dec 02 19:46:26.115 INFO [stderr] 53   | / static OpCodes: [OpCode; 151] = [OpCode {
Dec 02 19:46:26.115 INFO [stderr] 54   | |                                      code: 0x69,
Dec 02 19:46:26.115 INFO [stderr] 55   | |                                      mnemonic: "ADC",
Dec 02 19:46:26.115 INFO [stderr] 56   | |                                      length: 2,
Dec 02 19:46:26.115 INFO [stderr] ...    |
Dec 02 19:46:26.115 INFO [stderr] 1108 | |                                      mode: AddressingMode::Absolute,
Dec 02 19:46:26.115 INFO [stderr] 1109 | |                                  }];
Dec 02 19:46:26.115 INFO [stderr]      | |____________________________________^
Dec 02 19:46:26.115 INFO [stderr] 
Dec 02 19:46:28.179 INFO [stderr]     Finished dev [unoptimized + debuginfo] target(s) in 7.34s
Dec 02 19:46:28.187 INFO [stderr] su: No module specific data is present
Dec 02 19:46:28.668 INFO running `"docker" "inspect" "3a656ca38ef8582bb44650262065c1ee371b1d6a126885a90b3924b274b5dc23"`
Dec 02 19:46:28.980 INFO running `"docker" "rm" "-f" "3a656ca38ef8582bb44650262065c1ee371b1d6a126885a90b3924b274b5dc23"`
Dec 02 19:46:29.218 INFO [stdout] 3a656ca38ef8582bb44650262065c1ee371b1d6a126885a90b3924b274b5dc23
Dec 02 19:46:29.223 INFO running `"docker" "create" "-v" "/mnt/big/crater/work/local/target-dirs/beta-1.31-5/worker-7/1.30.1:/target:rw,Z" "-v" "/mnt/big/crater/work/local/test-source/worker-7/beta-1.31-5/1.30.1:/source:ro,Z" "-v" "/mnt/big/crater/work/local/cargo-home:/cargo-home:ro,Z" "-v" "/mnt/big/crater/work/local/rustup-home:/rustup-home:ro,Z" "-e" "USER_ID=1000" "-e" "SOURCE_DIR=/source" "-e" "USER_ID=1000" "-e" "CMD=cargo +1.30.1 test --frozen" "-e" "CARGO_TARGET_DIR=/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/cargo-home" "-e" "RUSTUP_HOME=/rustup-home" "-m" "1536M" "--network" "none" "crater"`
Dec 02 19:46:29.535 INFO [stdout] 8aa4dec4e4430973a6fa5822abf20fcd2811c4b0f4f9a5538de9e10ac63f2ed5
Dec 02 19:46:29.540 INFO running `"docker" "start" "-a" "8aa4dec4e4430973a6fa5822abf20fcd2811c4b0f4f9a5538de9e10ac63f2ed5"`
Dec 02 19:46:30.151 INFO [stderr] usermod: no changes
Dec 02 19:46:30.177 INFO [stderr]     Finished dev [unoptimized + debuginfo] target(s) in 0.01s
Dec 02 19:46:30.179 INFO [stderr]      Running /target/debug/deps/rs6502-28bc13b225496c02
Dec 02 19:46:30.182 INFO [stdout] 
Dec 02 19:46:30.182 INFO [stdout] running 63 tests
Dec 02 19:46:30.184 INFO [stdout] test assembler::assembler::tests::can_assemble_basic_code ... ok
Dec 02 19:46:30.184 INFO [stdout] test assembler::assembler::tests::can_jump_between_code_segments ... ok
Dec 02 19:46:30.184 INFO [stdout] test assembler::assembler::tests::can_assemble_clearmem_implementation_that_jumps_forward ... ok
Dec 02 19:46:30.185 INFO [stdout] test assembler::assembler::tests::can_jump_to_label_behind ... ok
Dec 02 19:46:30.185 INFO [stdout] test assembler::assembler::tests::can_jump_to_label_ahead ... ok
Dec 02 19:46:30.185 INFO [stdout] test assembler::assembler::tests::can_dump_bytes_with_other_code ... ok
Dec 02 19:46:30.186 INFO [stdout] test assembler::assembler::tests::can_jump_to_label_with_colon_behind ... ok
Dec 02 19:46:30.186 INFO [stdout] test assembler::assembler::tests::can_use_variables ... ok
Dec 02 19:46:30.187 INFO [stdout] test assembler::assembler::tests::can_dump_raw_bytes ... ok
Dec 02 19:46:30.187 INFO [stdout] test assembler::assembler::tests::can_use_variables_assigned_to_variables ... ok
Dec 02 19:46:30.187 INFO [stdout] test assembler::assembler::tests::can_assemble_clearmem_implementation ... ok
Dec 02 19:46:30.187 INFO [stdout] test assembler::lexer::tests::can_lex_absolute_addressing ... ok
Dec 02 19:46:30.187 INFO [stdout] test assembler::lexer::tests::can_handle_directives ... ok
Dec 02 19:46:30.187 INFO [stdout] test assembler::lexer::tests::can_handle_lots_of_whitespace ... ok
Dec 02 19:46:30.194 INFO [stdout] test assembler::assembler::tests::can_assemble_clearmem_implementation_that_jumps_forward_and_is_lowercase ... ok
Dec 02 19:46:30.194 INFO [stdout] test assembler::assembler::tests::can_use_variables_for_indirect_addressing ... ok
Dec 02 19:46:30.195 INFO [stdout] test assembler::lexer::tests::can_lex_base_ten_variable_assignment ... ok
Dec 02 19:46:30.195 INFO [stdout] test assembler::lexer::tests::can_lex_basic_opcode_and_addressing_mode ... ok
Dec 02 19:46:30.195 INFO [stdout] test assembler::lexer::tests::can_lex_indirect_x_addressing ... ok
Dec 02 19:46:30.196 INFO [stdout] test assembler::lexer::tests::can_lex_indirect_y_addressing ... ok
Dec 02 19:46:30.196 INFO [stdout] test assembler::lexer::tests::can_lex_variable_assignment ... ok
Dec 02 19:46:30.196 INFO [stdout] test assembler::assembler::tests::can_assign_code_segments_to_different_memory_addresses ... ok
Dec 02 19:46:30.196 INFO [stdout] test assembler::assembler::tests::can_dump_single_raw_byte ... ok
Dec 02 19:46:30.196 INFO [stdout] test assembler::parser::tests::can_parse_double_labels_on_one_line ... ok
Dec 02 19:46:30.196 INFO [stdout] test assembler::parser::tests::can_parse_labels_via_colon_terminator ... ok
Dec 02 19:46:30.200 INFO [stdout] test assembler::parser::tests::can_parse_implied_stack_instructions ... ok
Dec 02 19:46:30.200 INFO [stdout] test assembler::parser::tests::can_parse_indirect_jump_instruction ... ok
Dec 02 19:46:30.200 INFO [stdout] test assembler::lexer::tests::errors_on_unexpected_token_square_bracket ... ok
Dec 02 19:46:30.200 INFO [stdout] test assembler::parser::tests::can_handle_correct_zero_page_y_usage ... ok
Dec 02 19:46:30.200 INFO [stdout] test assembler::parser::tests::can_parse_indirect_x_addressing ... ok
Dec 02 19:46:30.200 INFO [stdout] test assembler::lexer::tests::errors_on_unexpected_token ... ok
Dec 02 19:46:30.200 INFO [stdout] test assembler::parser::tests::can_parse_directives ... ok
Dec 02 19:46:30.200 INFO [stdout] test assembler::parser::tests::can_parse_labels_via_lonely_label ... ok
Dec 02 19:46:30.200 INFO [stdout] test assembler::parser::tests::errors_on_incorrect_indirect_x_addressing ... ok
Dec 02 19:46:30.200 INFO [stdout] test cpu::flags::tests::can_convert_to_and_from ... ok
Dec 02 19:46:30.200 INFO [stdout] test cpu::flags::tests::can_convert_to_u8 ... ok
Dec 02 19:46:30.200 INFO [stdout] test cpu::flags::tests::default_is_four ... ok
Dec 02 19:46:30.200 INFO [stdout] test cpu::stack::tests::can_not_pop_empty_stack ... ok
Dec 02 19:46:30.200 INFO [stdout] test cpu::stack::tests::can_not_push_to_full_stack ... ok
Dec 02 19:46:30.202 INFO [stdout] test assembler::parser::tests::errors_on_indirect_addressing_early_eol ... ok
Dec 02 19:46:30.202 INFO [stdout] test assembler::parser::tests::errors_on_incorrect_zero_page_y_usage ... ok
Dec 02 19:46:30.202 INFO [stdout] test assembler::parser::tests::can_parse_opcode_with_correct_absolute_x_addressing_mode ... ok
Dec 02 19:46:30.202 INFO [stdout] test assembler::parser::tests::can_parse_opcode_with_implied_addressing_mode ... ok
Dec 02 19:46:30.202 INFO [stdout] test assembler::parser::tests::can_parse_opcodes_after_labels_on_one_line ... ok
Dec 02 19:46:30.202 INFO [stdout] test disassembler::tests::can_disassemble_absolute_addressing ... ok
Dec 02 19:46:30.202 INFO [stdout] test assembler::parser::tests::errors_on_eight_bit_indirect_jump_instruction ... ok
Dec 02 19:46:30.202 INFO [stdout] test assembler::parser::tests::errors_on_incorrect_opcode_addressing_mode_with_variable ... ok
Dec 02 19:46:30.202 INFO [stdout] test cpu::stack::tests::can_push ... ok
Dec 02 19:46:30.202 INFO [stdout] test cpu::stack::tests::can_push_then_pop ... ok
Dec 02 19:46:30.202 INFO [stdout] test disassembler::tests::can_disassemble_indirect_indexed_addressing ... ok
Dec 02 19:46:30.204 INFO [stdout] test disassembler::tests::can_disassemble_indirect_jmp ... ok
Dec 02 19:46:30.204 INFO [stdout] test cpu::stack::tests::can_push_then_pop_multiple ... ok
Dec 02 19:46:30.204 INFO [stdout] test cpu::stack::tests::can_push_then_pop_u16 ... ok
Dec 02 19:46:30.204 INFO [stdout] test cpu::stack::tests::can_push_u16 ... ok
Dec 02 19:46:30.204 INFO [stdout] test disassembler::tests::can_disassemble_relative_addressing ... ok
Dec 02 19:46:30.204 INFO [stdout] test disassembler::tests::can_disassemble_absolute_indexed_addressing ... ok
Dec 02 19:46:30.204 INFO [stdout] test disassembler::tests::can_disassemble_zero_page_indexed_addressing ... ok
Dec 02 19:46:30.204 INFO [stdout] test disassembler::tests::can_disassemble_zero_page_addressing ... ok
Dec 02 19:46:30.204 INFO [stdout] test disassembler::tests::dumps_unknown_bytes ... ok
Dec 02 19:46:30.204 INFO [stdout] test disassembler::tests::can_disassemble_basic_instructions ... ok
Dec 02 19:46:30.204 INFO [stdout] test disassembler::tests::can_disassemble_without_byte_offsets ... ok
Dec 02 19:46:30.204 INFO [stdout] test disassembler::tests::move_memory_down_test ... ok
Dec 02 19:46:30.204 INFO [stdout] test disassembler::tests::test_memset_implementation ... ok
Dec 02 19:46:30.204 INFO [stdout] 
Dec 02 19:46:30.204 INFO [stdout] test result: ok. 63 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
Dec 02 19:46:30.204 INFO [stdout] 
Dec 02 19:46:30.205 INFO [stderr]      Running /target/debug/deps/assembly-6ee5f139ec3a3a71
Dec 02 19:46:30.206 INFO [stdout] 
Dec 02 19:46:30.206 INFO [stdout] running 3 tests
Dec 02 19:46:30.219 INFO [stdout] test INTEGRATION_ASSEMBLY_can_assemble_disassemble_basic_opcodes ... ok
Dec 02 19:46:30.219 INFO [stdout] test INTEGRATION_ASSEMBLY_can_assemble_disassemble_random_memory_segments ... ok
Dec 02 19:46:30.219 INFO [stdout] test INTEGRATION_ASSEMBLY_can_assemble_disassemble_clearmem_implementation ... ok
Dec 02 19:46:30.219 INFO [stdout] 
Dec 02 19:46:30.219 INFO [stdout] test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
Dec 02 19:46:30.219 INFO [stdout] 
Dec 02 19:46:30.221 INFO [stderr]      Running /target/debug/deps/cpu-e26ff6c15db7f370
Dec 02 19:46:30.223 INFO [stdout] 
Dec 02 19:46:30.223 INFO [stdout] running 52 tests
Dec 02 19:46:30.226 INFO [stdout] test tests::cpu::adc_can_add_numbers_in_binary_coded_decimal_and_set_carry ... ok
Dec 02 19:46:30.227 INFO [stdout] test tests::cpu::and_can_apply_logical_and_operation_and_set_sign_flag ... ok
Dec 02 19:46:30.243 INFO [stdout] test tests::cpu::and_can_apply_logical_and_operation ... ok
Dec 02 19:46:30.243 INFO [stdout] test tests::cpu::adc_can_add_basic_numbers_set_carry_and_wrap_around ... ok
Dec 02 19:46:30.243 INFO [stdout] test tests::cpu::adc_can_disable_decimal_flag ... ok
Dec 02 19:46:30.243 INFO [stdout] test tests::cpu::adc_can_set_decimal_flag ... ok
Dec 02 19:46:30.243 INFO [stdout] test tests::cpu::adc_can_add_numbers_in_binary_coded_decimal ... ok
Dec 02 19:46:30.243 INFO [stdout] test tests::cpu::adc_can_add_basic_numbers ... ok
Dec 02 19:46:30.253 INFO [stdout] test tests::cpu::asl_can_shift_bits_left ... ok
Dec 02 19:46:30.253 INFO [stdout] test tests::cpu::bit_can_set_flags_and_preserve_registers ... ok
Dec 02 19:46:30.253 INFO [stdout] test tests::cpu::asl_shifts_last_bit_into_carry ... ok
Dec 02 19:46:30.253 INFO [stdout] test tests::cpu::bcc_can_jump_forward ... ok
Dec 02 19:46:30.254 INFO [stdout] test tests::cpu::bcs_can_jump_forward ... ok
Dec 02 19:46:30.254 INFO [stdout] test tests::cpu::bpl_does_not_jump_on_sign_set ... ok
Dec 02 19:46:30.254 INFO [stdout] test tests::cpu::bcc_can_jump_backward ... ok
Dec 02 19:46:30.254 INFO [stdout] test tests::cpu::bit_can_set_overflow_flag ... ok
Dec 02 19:46:30.254 INFO [stdout] test tests::cpu::bvs_does_jump_on_overflow_set ... ok
Dec 02 19:46:30.254 INFO [stdout] test tests::cpu::bmi_can_jump_forward ... ok
Dec 02 19:46:30.258 INFO [stdout] test tests::cpu::bvs_does_not_jump_on_overflow_clear ... ok
Dec 02 19:46:30.258 INFO [stdout] test tests::cpu::bvc_does_jump_on_overflow_clear ... ok
Dec 02 19:46:30.258 INFO [stdout] test tests::cpu::beq_can_jump_forward ... ok
Dec 02 19:46:30.258 INFO [stdout] test tests::cpu::can_load_code_segment_at_default_address ... ok
Dec 02 19:46:30.259 INFO [stdout] test tests::cpu::can_instantiate_cpu ... ok
Dec 02 19:46:30.259 INFO [stdout] test tests::cpu::clc_clears_carry_flag ... ok
Dec 02 19:46:30.259 INFO [stdout] test tests::cpu::can_load_code_segment_into_memory ... ok
Dec 02 19:46:30.259 INFO [stdout] test tests::cpu::cli_clears_interrupt_flag ... ok
Dec 02 19:46:30.259 INFO [stdout] test tests::cpu::can_load_code_segment_at_specific_address ... ok
Dec 02 19:46:30.259 INFO [stdout] test tests::cpu::can_get_operand_from_opcode ... ok
Dec 02 19:46:30.260 INFO [stdout] test tests::cpu::cld_clears_decimal_flag ... ok
Dec 02 19:46:30.260 INFO [stdout] test tests::cpu::cmp_sets_zero_flag ... ok
Dec 02 19:46:30.260 INFO [stdout] test tests::cpu::cpx_clears_carry_flag ... ok
Dec 02 19:46:30.261 INFO [stdout] test tests::cpu::bne_does_not_jump_on_zero ... ok
Dec 02 19:46:30.261 INFO [stdout] test tests::cpu::bne_jumps_on_non_zero ... ok
Dec 02 19:46:30.261 INFO [stdout] test tests::cpu::bvc_does_not_jump_on_overflow_set ... ok
Dec 02 19:46:30.261 INFO [stdout] test tests::cpu::bpl_does_jump_on_sign_not_set ... ok
Dec 02 19:46:30.262 INFO [stdout] test tests::cpu::dex_decrements ... ok
Dec 02 19:46:30.262 INFO [stdout] test tests::cpu::cmp_sets_carry_flag ... ok
Dec 02 19:46:30.262 INFO [stdout] test tests::cpu::eor_xors ... ok
Dec 02 19:46:30.262 INFO [stdout] test tests::cpu::dec_decrements ... ok
Dec 02 19:46:30.263 INFO [stdout] test tests::cpu::cpy_sets_carry_flag ... ok
Dec 02 19:46:30.263 INFO [stdout] test tests::cpu::errors_when_code_segment_extends_past_memory_bounds ... ok
Dec 02 19:46:30.264 INFO [stdout] test tests::cpu::inx_increments_x ... ok
Dec 02 19:46:30.264 INFO [stdout] test tests::cpu::errors_on_unknown_opcode ... ok
Dec 02 19:46:30.264 INFO [stdout] test tests::cpu::cpx_sets_carry_flag ... ok
Dec 02 19:46:30.264 INFO [stdout] test tests::cpu::cpy_clears_carry_flag ... ok
Dec 02 19:46:30.264 INFO [stdout] test tests::cpu::sta_can_store_bytes_in_memory ... ok
Dec 02 19:46:30.265 INFO [stdout] test tests::cpu::dey_decrements ... ok
Dec 02 19:46:30.267 INFO [stdout] test tests::cpu::iny_increments_y ... ok
Dec 02 19:46:30.267 INFO [stdout] test tests::cpu::jmp_jumps ... ok
Dec 02 19:46:30.267 INFO [stdout] test tests::cpu::clv_clears_overflow_flag ... ok
Dec 02 19:46:30.267 INFO [stdout] test tests::cpu::cmp_clears_carry_flag ... ok
Dec 02 19:46:30.268 INFO [stdout] test tests::cpu::inc_increments ... ok
Dec 02 19:46:30.268 INFO [stdout] 
Dec 02 19:46:30.268 INFO [stdout] test result: ok. 52 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
Dec 02 19:46:30.268 INFO [stdout] 
Dec 02 19:46:30.271 INFO [stderr]      Running /target/debug/deps/cpu_integration-d8e9b02db043ae80
Dec 02 19:46:30.276 INFO [stdout] 
Dec 02 19:46:30.276 INFO [stdout] running 38 tests
Dec 02 19:46:30.296 INFO [stdout] test INTEGRATION_CPU_bne_branches_on_zero_clear ... ok
Dec 02 19:46:30.297 INFO [stdout] test INTEGRATION_CPU_bmi_branches_on_sign_bit_set ... ok
Dec 02 19:46:30.297 INFO [stdout] test INTEGRATION_CPU_brk_rti ... ok
Dec 02 19:46:30.298 INFO [stdout] test INTEGRATION_CPU_bpl_does_not_branch_on_sign_set ... ok
Dec 02 19:46:30.299 INFO [stdout] test INTEGRATION_CPU_bpl_branches_on_sign_clear ... ok
Dec 02 19:46:30.299 INFO [stdout] test INTEGRATION_CPU_can_add_basic_numbers_in_accumulator ... ok
Dec 02 19:46:30.299 INFO [stdout] test INTEGRATION_CPU_can_branch_on_beq ... ok
Dec 02 19:46:30.301 INFO [stdout] test INTEGRATION_CPU_can_add_binary_coded_decimal_numbers_in_accumulator ... ok
Dec 02 19:46:30.301 INFO [stdout] test INTEGRATION_CPU_can_load_byte_into_memory_and_logical_AND_it_with_A_register ... ok
Dec 02 19:46:30.302 INFO [stdout] test INTEGRATION_CPU_can_branch_on_carry_flag ... ok
Dec 02 19:46:30.302 INFO [stdout] test INTEGRATION_CPU_can_add_mixed_mode_numbers_in_accumulator ... ok
Dec 02 19:46:30.307 INFO [stdout] test INTEGRATION_CPU_can_loop_on_bcc ... ok
Dec 02 19:46:30.315 INFO [stdout] test INTEGRATION_CPU_can_overwrite_own_memory ... ok
Dec 02 19:46:30.317 INFO [stdout] test INTEGRATION_CPU_can_branch_on_bcs ... ok
Dec 02 19:46:30.317 INFO [stdout] test INTEGRATION_CPU_can_store_bytes_in_memory ... ok
Dec 02 19:46:30.318 INFO [stdout] test INTEGRATION_CPU_can_load_byte_into_memory_and_logical_AND_it_with_A_register_using_a_variable ... ok
Dec 02 19:46:30.323 INFO [stdout] test INTEGRATION_CPU_can_load_code_segments_at_offsets ... ok
Dec 02 19:46:30.323 INFO [stdout] test INTEGRATION_CPU_can_branch_on_carry_flag_to_correct_offset ... ok
Dec 02 19:46:30.324 INFO [stdout] test INTEGRATION_CPU_can_force_interrupt_code ... ok
Dec 02 19:46:30.343 INFO [stdout] test INTEGRATION_CPU_dex_decrements ... ok
Dec 02 19:46:30.343 INFO [stdout] test INTEGRATION_CPU_can_interrupt_when_not_disabled ... ok
Dec 02 19:46:30.347 INFO [stdout] test INTEGRATION_CPU_cmp_does_branch_on_accumulator_greater_than_memory_bcs ... ok
Dec 02 19:46:30.347 INFO [stdout] test INTEGRATION_CPU_does_not_branch_on_clear_carry_flag ... ok
Dec 02 19:46:30.347 INFO [stdout] test INTEGRATION_CPU_lsr_can_halve_a_number ... ok
Dec 02 19:46:30.347 INFO [stdout] test INTEGRATION_CPU_cmp_does_branch_on_accumulator_less_than_equal_to_bcc ... ok
Dec 02 19:46:30.347 INFO [stdout] test INTEGRATION_CPU_cmp_does_branch_on_accumulator_less_than_memory_bcc ... ok
Dec 02 19:46:30.347 INFO [stdout] test INTEGRATION_CPU_dec_decrements ... ok
Dec 02 19:46:30.355 INFO [stdout] test INTEGRATION_CPU_cant_interrupt_when_disabled ... ok
Dec 02 19:46:30.355 INFO [stdout] test INTEGRATION_CPU_does_not_branch_on_beq ... ok
Dec 02 19:46:30.355 INFO [stdout] test INTEGRATION_CPU_jsr_rts_combination_works_when_code_segment_loaded_at_weird_address ... ok
Dec 02 19:46:30.355 INFO [stdout] test INTEGRATION_CPU_jsr_rts_combination_works ... ok
Dec 02 19:46:30.355 INFO [stdout] test INTEGRATION_CPU_pha_pla ... ok
Dec 02 19:46:30.355 INFO [stdout] test INTEGRATION_CPU_rol ... ok
Dec 02 19:46:30.355 INFO [stdout] test INTEGRATION_CPU_preserves_flags_on_bit ... ok
Dec 02 19:46:30.355 INFO [stdout] test INTEGRATION_CPU_ora_ors_against_accumulator ... ok
Dec 02 19:46:30.355 INFO [stdout] test INTEGRATION_CPU_ror ... ok
Dec 02 19:46:30.355 INFO [stdout] test INTEGRATION_CPU_sbc_with_decimal_mode ... ok
Dec 02 19:46:30.355 INFO [stdout] test INTEGRATION_CPU_sbc ... ok
Dec 02 19:46:30.355 INFO [stdout] 
Dec 02 19:46:30.355 INFO [stdout] test result: ok. 38 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
Dec 02 19:46:30.355 INFO [stdout] 
Dec 02 19:46:30.359 INFO [stderr]    Doc-tests rs6502
Dec 02 19:46:31.466 INFO [stdout] 
Dec 02 19:46:31.466 INFO [stdout] running 5 tests
Dec 02 19:46:33.827 INFO [stdout] test src/disassembler.rs - disassembler::Disassembler::with_code_only (line 52) ... ok
Dec 02 19:46:34.274 INFO [stdout] test src/disassembler.rs - disassembler::Disassembler::with_verbose_output (line 79) ... ok
Dec 02 19:46:35.199 INFO [stdout] test src/disassembler.rs - disassembler::Disassembler::disassemble_with_addresses (line 122) ... ok
Dec 02 19:46:35.273 INFO [stdout] test src/disassembler.rs - disassembler::Disassembler::clean_asm (line 264) ... ok
Dec 02 19:46:35.347 INFO [stdout] test src/disassembler.rs - disassembler::Disassembler::new (line 25) ... ok
Dec 02 19:46:35.347 INFO [stdout] 
Dec 02 19:46:35.347 INFO [stdout] test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
Dec 02 19:46:35.347 INFO [stdout] 
Dec 02 19:46:35.362 INFO [stderr] su: No module specific data is present
Dec 02 19:46:35.729 INFO running `"docker" "inspect" "8aa4dec4e4430973a6fa5822abf20fcd2811c4b0f4f9a5538de9e10ac63f2ed5"`
Dec 02 19:46:35.840 INFO running `"docker" "rm" "-f" "8aa4dec4e4430973a6fa5822abf20fcd2811c4b0f4f9a5538de9e10ac63f2ed5"`
Dec 02 19:46:35.935 INFO [stdout] 8aa4dec4e4430973a6fa5822abf20fcd2811c4b0f4f9a5538de9e10ac63f2ed5
