[assembler] modify a driver test to verify the whole executable.

Author: youngman-g

assembler/src/asmlib/driver/tests.rs

@@ -13,8 +13,8 @@ use super::super::span::*;
 use super::super::symbol::{SymbolContext, SymbolName};
 use super::super::symtab::LookupOperation;
 use super::super::types::BlockIdentifier;
-use super::assemble_pass1;
 use super::{assemble_nonempty_valid_input, assemble_source};
+use super::{assemble_pass1, Binary, BinaryChunk};
 use base::{
     charset::Script,
     prelude::{u18, u36, Address, Unsigned18Bit, Unsigned36Bit},
@@ -535,11 +535,19 @@ fn test_440_330_220_110_with_commas() {
 
 #[test]
 fn test_alternate_base_with_commas() {
-    let input = "10·,11·,,12,13· ** Note that 12 is in the default, octal, base\n";
-    let program = assemble_source(input, Default::default()).expect("program is valid");
-    dbg!(&program);
-    assert_eq!(program.chunks.len(), 1); // one chunk (no RC-block needed).
-    assert_eq!(program.chunks[0].words[0], u36!(0o012_013_012_015));
+    assert_eq!(
+        assemble_source(
+            "10·,11·,,12,13· ** Note that 12 is in the default, octal, base\n",
+            Default::default(),
+        ),
+        Ok(Binary {
+            entry_point: None,
+            chunks: vec![BinaryChunk {
+                address: Address::from(u18!(0o00200000)),
+                words: vec![u36!(0o012_013_012_015)]
+            }]
+        })
+    );
 }
 
 #[test]

assembler/src/asmlib/types.rs

@@ -171,6 +171,63 @@ pub enum AssemblerFailure {
     MachineLimitExceeded(MachineLimitExceededFailure),
 }
 
+impl PartialEq<AssemblerFailure> for AssemblerFailure {
+    fn eq(&self, other: &AssemblerFailure) -> bool {
+        use AssemblerFailure::*;
+        match (self, other) {
+            (InternalError(s1), InternalError(s2)) if s1 == s2 => true,
+            (BadTapeBlock(s1), BadTapeBlock(s2)) if s1 == s2 => true,
+            (IoErrorOnStdout { error: e1 }, IoErrorOnStdout { error: e2 })
+                if e1.to_string() == e2.to_string() =>
+            {
+                true
+            }
+            (
+                IoErrorOnInput {
+                    error: e1,
+                    filename: f1,
+                },
+                IoErrorOnInput {
+                    error: e2,
+                    filename: f2,
+                },
+            ) => e1.to_string() == e2.to_string() && f1 == f2,
+            (
+                IoErrorOnOutput {
+                    error: e1,
+                    filename: f1,
+                },
+                IoErrorOnOutput {
+                    error: e2,
+                    filename: f2,
+                },
+            ) => e1.to_string() == e2.to_string() && f1 == f2,
+            (
+                InvalidProgram {
+                    span: span1,
+                    msg: msg1,
+                },
+                InvalidProgram {
+                    span: span2,
+                    msg: msg2,
+                },
+            ) => span1 == span2 && msg1 == msg2,
+            (
+                SyntaxError {
+                    location: loc1,
+                    msg: msg1,
+                },
+                SyntaxError {
+                    location: loc2,
+                    msg: msg2,
+                },
+            ) => loc1 == loc2 && msg1 == msg2,
+            (MachineLimitExceeded(e1), MachineLimitExceeded(e2)) if e1 == e2 => true,
+            _ => false,
+        }
+    }
+}
+
 impl From<MachineLimitExceededFailure> for AssemblerFailure {
     fn from(f: MachineLimitExceededFailure) -> AssemblerFailure {
         AssemblerFailure::MachineLimitExceeded(f)