update tests to properly reflect answer order.

diff --git a/Cargo.toml b/Cargo.toml
index 7d3168db86f572121a8bd875856661079669473f..08e048a785cb5b936bd1883c5febcef0abc47910 100644 (file)
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "rusty-wam"
-version = "0.7.4"
+version = "0.7.5"
 authors = ["Mark Thom"]
 
 [dependencies]

diff --git a/src/prolog/ast.rs b/src/prolog/ast.rs
index a9dc647c5caa4002665e32f857cf2ee1560b1d67..103f769af6725c309f7ec4eaff3f5bae6fae8602 100644 (file)
--- a/src/prolog/ast.rs
+++ b/src/prolog/ast.rs
@@ -300,7 +300,7 @@ pub enum Term {
 }
 
 pub enum InlinedQueryTerm {
-    CompareNumber(CompareNumberQT, Vec<Box<Term>>),
+    CompareNumber(CompareNumberQT, Vec<Box<Term>>),    
     IsAtomic(Vec<Box<Term>>),
     IsVar(Vec<Box<Term>>),
     IsInteger(Vec<Box<Term>>)
@@ -309,7 +309,7 @@ pub enum InlinedQueryTerm {
 impl InlinedQueryTerm {
     pub fn arity(&self) -> usize {
         match self {
-            &InlinedQueryTerm::CompareNumber(_, _) => 2,
+            &InlinedQueryTerm::CompareNumber(_, _) => 2,            
             &InlinedQueryTerm::IsAtomic(_) => 1,
             &InlinedQueryTerm::IsInteger(_) => 1,
             &InlinedQueryTerm::IsVar(_) => 1,
@@ -346,8 +346,8 @@ impl QueryTerm {
         match self {
             &QueryTerm::Arg(_) => 3,
             &QueryTerm::Catch(_) => 3,
-            &QueryTerm::Throw(_) => 1,            
             &QueryTerm::Display(_) => 1,
+            &QueryTerm::Throw(_) => 1,            
             &QueryTerm::DuplicateTerm(_) => 2,
             &QueryTerm::Functor(_) => 3,
             &QueryTerm::Inlined(ref term) => term.arity(),
@@ -384,8 +384,8 @@ impl<'a> ClauseType<'a> {
             &ClauseType::Arg => "arg",
             &ClauseType::CallN => "call",
             &ClauseType::Catch => "catch",
-            &ClauseType::Deep(_, _, name, _) => name.as_str(),
             &ClauseType::Display => "display",
+            &ClauseType::Deep(_, _, name, _) => name.as_str(),            
             &ClauseType::DuplicateTerm => "duplicate_term",
             &ClauseType::Functor => "functor",
             &ClauseType::Is => "is",
@@ -735,7 +735,7 @@ pub enum ArithmeticInstruction {
 
 pub enum BuiltInInstruction {
     CleanUpBlock,
-    CompareNumber(CompareNumberQT, ArithmeticTerm, ArithmeticTerm),
+    CompareNumber(CompareNumberQT, ArithmeticTerm, ArithmeticTerm),    
     EraseBall,
     Fail,
     GetArg,
@@ -765,9 +765,9 @@ pub enum ControlInstruction {
     CallN(usize), // arity.
     CatchCall,
     CatchExecute,
-    Deallocate,
     DisplayCall,
     DisplayExecute,
+    Deallocate,
     DuplicateTermCall,
     DuplicateTermExecute,
     Execute(TabledRc<Atom>, usize),

diff --git a/src/prolog/codegen.rs b/src/prolog/codegen.rs
index 384423c394af465519ba96439d257b34f8a9a32b..34d90b93be08b59eee76533265e96c0ad55cf425 100644 (file)
--- a/src/prolog/codegen.rs
+++ b/src/prolog/codegen.rs
@@ -578,12 +578,8 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<'a, TermMarker>
         code
     }
 
-    fn compile_query_line(&mut self,
-                          term: &'a QueryTerm,
-                          term_loc: GenContext,
-                          code: &mut Code,
-                          index: usize,
-                          is_exposed: bool)
+    fn compile_query_line(&mut self, term: &'a QueryTerm, term_loc: GenContext,
+                          code: &mut Code, index: usize, is_exposed: bool)
     {
         self.marker.reset_arg(term.arity());
 

diff --git a/src/prolog/fixtures.rs b/src/prolog/fixtures.rs
index d9404cd0dfaadda8804e6250a052548278246c73..7d09b5bd7f9e3a2cdaca9bee43b8574be6ee1278 100644 (file)
--- a/src/prolog/fixtures.rs
+++ b/src/prolog/fixtures.rs
@@ -92,7 +92,7 @@ impl<'a> VariableFixtures<'a>
         // 1. move the use sets of each variable to a local HashMap, use_set
         // (iterate mutably, swap mutable refs).
         // 2. drain use_set. For each use set of U, add into the
-        // no-use sets of appropriate variables T /= U.
+        // no-use sets of appropriate variables T =/= U.
         // 3. Move the use sets back to their original locations in the fixture.
         // Compute the conflict set of u.
 

diff --git a/src/prolog/io.rs b/src/prolog/io.rs
index 1e56aee49bbaf900a3b13a87839a782b961f50d0..276a531edbb5af55a467bc7f3d71bbc9c6581164 100644 (file)
--- a/src/prolog/io.rs
+++ b/src/prolog/io.rs
@@ -112,9 +112,9 @@ impl fmt::Display for ControlInstruction {
             &ControlInstruction::CatchExecute =>
                 write!(f, "execute_catch"),
             &ControlInstruction::DisplayCall =>
-                write!(f, "call_display"),
+                write!(f, "display_call"),
             &ControlInstruction::DisplayExecute =>
-                write!(f, "execute_display"),
+                write!(f, "display_execute"),
             &ControlInstruction::DuplicateTermCall =>
                 write!(f, "call_duplicate_term"),
             &ControlInstruction::DuplicateTermExecute =>
@@ -164,7 +164,7 @@ impl fmt::Display for BuiltInInstruction {
             &BuiltInInstruction::CleanUpBlock =>
                 write!(f, "clean_up_block"),
             &BuiltInInstruction::CompareNumber(cmp, ref at_1, ref at_2) =>
-                write!(f, "number_test {}, {}, {} ", cmp, at_1, at_2),
+                write!(f, "number_test {}, {}, {} ", cmp, at_1, at_2),            
             &BuiltInInstruction::DynamicCompareNumber(cmp) =>
                 write!(f, "dynamic_number_test {}", cmp),
             &BuiltInInstruction::EraseBall =>

diff --git a/src/prolog/iterators.rs b/src/prolog/iterators.rs
index 074d2bd54d77cd14965c106de77b04913264fc7b..8db60dccde4eac9e4dd9c5d4b06c3353079d66c2 100644 (file)
--- a/src/prolog/iterators.rs
+++ b/src/prolog/iterators.rs
@@ -39,11 +39,7 @@ impl<'a> QueryIterator<'a> {
             &QueryTerm::Catch(ref terms) => {
                 let state = TermIterState::Clause(0, ClauseType::Catch, terms);
                 QueryIterator { state_stack: vec![state] }
-            },
-            &QueryTerm::Display(ref terms) => {
-                let state = TermIterState::Clause(0, ClauseType::Display, terms);
-                QueryIterator { state_stack: vec![state] }
-            },
+            },            
             &QueryTerm::DuplicateTerm(ref terms) => {
                 let state = TermIterState::Clause(0, ClauseType::DuplicateTerm, terms);
                 QueryIterator { state_stack: vec![state] }
@@ -56,11 +52,15 @@ impl<'a> QueryIterator<'a> {
                 let state = TermIterState::Clause(0, ClauseType::Functor, terms);
                 QueryIterator { state_stack: vec![state] }
             },
+            &QueryTerm::Display(ref terms) => {
+                let state = TermIterState::Clause(0, ClauseType::Display, terms);
+                QueryIterator { state_stack: vec![state] }
+            },
             &QueryTerm::Inlined(InlinedQueryTerm::CompareNumber(_, ref terms))
           | &QueryTerm::Is(ref terms) => {
                     let state = TermIterState::Clause(0, ClauseType::Is, terms);
                     QueryIterator { state_stack: vec![state] }
-            },
+            },            
             &QueryTerm::Inlined(InlinedQueryTerm::IsAtomic(ref terms))
           | &QueryTerm::Inlined(InlinedQueryTerm::IsInteger(ref terms))
           | &QueryTerm::Inlined(InlinedQueryTerm::IsVar(ref terms)) =>

diff --git a/src/prolog/parser b/src/prolog/parser
index 87d3b043bb178fb10818cd7cd34dd8c47651621d..aa164cabe63b508a1227f15e4bb40b517717a2f3 160000 (submodule)
--- a/src/prolog/parser
+++ b/src/prolog/parser
@@ -1 +1 @@
-Subproject commit 87d3b043bb178fb10818cd7cd34dd8c47651621d
+Subproject commit aa164cabe63b508a1227f15e4bb40b517717a2f3

diff --git a/src/test_utils.rs b/src/test_utils.rs
index 56d8f889359d29a08bcdc5d1330c233afa2c475c..8507ff37f716d205f9228310fd74c15c52a26f0f 100644 (file)
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -6,65 +6,76 @@ use prolog::machine::*;
 use prolog::parser::toplevel::*;
 
 use std::collections::HashSet;
+use std::mem::swap;
 
 pub struct TestOutputter {
-    contents: Vec<String>
+    results: Vec<HashSet<String>>,
+    contents: HashSet<String>,
+    focus: String
+}
+
+impl TestOutputter {
+    fn cache(&mut self) {
+        self.begin_new_var();
+
+        let mut contents = HashSet::new();
+        swap(&mut contents, &mut self.contents);
+        
+        self.results.push(contents);
+    }
 }
 
 impl HeapCellValueOutputter for TestOutputter {
-    type Output = HashSet<String>;
+    type Output = Vec<HashSet<String>>;
 
     fn new() -> Self {
-        TestOutputter { contents: vec![] }
+        TestOutputter { results: vec![],
+                        contents: HashSet::new(),
+                        focus: String::new() }
     }
 
-    fn append(&mut self, contents: &str) {
-        if let Some(ref mut result) = self.contents.last_mut() {
-            **result += contents;
-        }
+    fn append(&mut self, focus: &str) {        
+        self.focus += focus;        
     }
 
-    fn begin_new_var(&mut self) {
-        self.contents.push(String::new());
+    fn begin_new_var(&mut self) {        
+        if !self.focus.is_empty() {
+            let mut focus = String::new();
+            swap(&mut focus, &mut self.focus);
+            
+            self.contents.insert(focus);
+        }
     }
 
     fn result(self) -> Self::Output {
-        self.contents.into_iter().collect()
+        self.results
     }
 
     fn ends_with(&self, s: &str) -> bool {
-        if let Some(ref result) = self.contents.last() {
-            result.ends_with(s)
-        } else {
-            false
-        }
+        self.focus.ends_with(s)
     }
 
     fn len(&self) -> usize {
-        if let Some(ref result) = self.contents.last() {
-            result.len()
-        } else {
-            0
-        }
+        self.focus.len()
     }
 
     fn truncate(&mut self, len: usize) {
-        if let Some(ref mut result) = self.contents.last_mut() {
-            result.truncate(len);
-        }
+        self.focus.truncate(len);
     }
 }
 
 pub fn collect_test_output<'a>(wam: &mut Machine, alloc_locs: AllocVarDict<'a>,
                                mut heap_locs: HeapVarDict<'a>)
-                               -> HashSet<String>
+                               -> Vec<HashSet<String>>
 {
     let mut output = TestOutputter::new();
     output = wam.heap_view(&heap_locs, output);
-
+    output.cache();
+    
     while let EvalSession::SubsequentQuerySuccess = wam.continue_query(&alloc_locs, &mut heap_locs)
     {
         output = wam.heap_view(&heap_locs, output);
+        output.cache();
     }
 
     output.result()
@@ -72,11 +83,12 @@ pub fn collect_test_output<'a>(wam: &mut Machine, alloc_locs: AllocVarDict<'a>,
 
 pub fn collect_test_output_with_limit<'a>(wam: &mut Machine, alloc_locs: AllocVarDict<'a>,
                                           mut heap_locs: HeapVarDict<'a>, limit: usize)
-                                          -> HashSet<String>
+                                          -> Vec<HashSet<String>>
 {
     let mut output = TestOutputter::new();
     output = wam.heap_view(&heap_locs, output);
-
+    output.cache();
+    
     let mut count  = 1;
 
     if count == limit {
@@ -86,7 +98,8 @@ pub fn collect_test_output_with_limit<'a>(wam: &mut Machine, alloc_locs: AllocVa
     while let EvalSession::SubsequentQuerySuccess = wam.continue_query(&alloc_locs, &mut heap_locs)
     {
         output = wam.heap_view(&heap_locs, output);
-
+        output.cache();
+        
         count += 1;
 
         if count == limit {
@@ -116,7 +129,7 @@ pub fn submit(wam: &mut Machine, buffer: &str) -> bool
 }
 
 #[allow(dead_code)]
-pub fn submit_query(wam: &mut Machine, buffer: &str, result: HashSet<String>) -> bool
+pub fn submit_query(wam: &mut Machine, buffer: &str, result: Vec<HashSet<String>>) -> bool
 {
     wam.reset();
 
@@ -134,8 +147,8 @@ pub fn submit_query(wam: &mut Machine, buffer: &str, result: HashSet<String>) ->
 
 #[allow(dead_code)]
 pub fn submit_query_with_limit(wam: &mut Machine, buffer: &str,
-                         result: HashSet<String>, limit: usize)
-                         -> bool
+                               result: Vec<HashSet<String>>, limit: usize)
+                               -> bool
 {
     wam.reset();
 
@@ -161,8 +174,8 @@ macro_rules! expand_strs {
 
 #[allow(unused_macros)]
 macro_rules! assert_prolog_success_with_limit {
-    ($wam:expr, $buf:expr, $res:expr, $limit:expr) => (
-        assert!(submit_query_with_limit($wam, $buf, expand_strs!($res), $limit))
+    ($wam:expr, $buf:expr, [$($res:expr),*], $limit:expr) => (
+        assert!(submit_query_with_limit($wam, $buf, vec![$(expand_strs!($res)),*], $limit))
     )
 }
 
@@ -175,8 +188,8 @@ macro_rules! assert_prolog_failure {
 
 #[allow(unused_macros)]
 macro_rules! assert_prolog_success {
-    ($wam:expr, $query:expr, $res:expr) => (
-        assert!(submit_query($wam, $query, expand_strs!($res)))
+    ($wam:expr, $query:expr, [$($res:expr),*]) => (
+        assert!(submit_query($wam, $query, vec![$(expand_strs!($res)),*]))
     );
     ($wam:expr, $buf:expr) => (
         assert_eq!(submit($wam, $buf), true)

diff --git a/src/tests.rs b/src/tests.rs
index 73ba0111496f8ff900a27f3050628fc8dac98c7d..4bee1d8a257eb99c856bf2b3820d95201c6d44a3 100644 (file)
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -9,9 +9,9 @@ fn test_queries_on_facts()
     submit(&mut wam, "p(Z, Z).");
     submit(&mut wam, "clouds(are, nice).");
 
-    assert_prolog_success!(&mut wam, "?- p(Z, Z).", ["Z = _0"]);
-    assert_prolog_success!(&mut wam, "?- p(Z, z).", ["Z = z"]);
-    assert_prolog_success!(&mut wam, "?- p(Z, w).", ["Z = w"]);
+    assert_prolog_success!(&mut wam, "?- p(Z, Z).", [["Z = _0"]]);
+    assert_prolog_success!(&mut wam, "?- p(Z, z).", [["Z = z"]]);
+    assert_prolog_success!(&mut wam, "?- p(Z, w).", [["Z = w"]]);
 
     assert_prolog_failure!(&mut wam, "?- p(z, w).");
 
@@ -19,20 +19,20 @@ fn test_queries_on_facts()
 
     assert_prolog_failure!(&mut wam, "?- clouds(Z, Z).");
 
-    assert_prolog_success!(&mut wam, "?- clouds(are, Z).", ["Z = nice"]);
-    assert_prolog_success!(&mut wam, "?- clouds(Z, nice).", ["Z = are"]);
+    assert_prolog_success!(&mut wam, "?- clouds(are, Z).", [["Z = nice"]]);
+    assert_prolog_success!(&mut wam, "?- clouds(Z, nice).", [["Z = are"]]);
 
     submit(&mut wam, "p(Z, h(Z, W), f(W)).");
 
     assert_prolog_failure!(&mut wam, "?- p(z, h(z, z), f(w)).");
     assert_prolog_success!(&mut wam, "?- p(z, h(z, w), f(w)).");
-    assert_prolog_success!(&mut wam, "?- p(z, h(z, W), f(w)).", ["W = w"]);
-    assert_prolog_success!(&mut wam, "?- p(Z, h(Z, w), f(Z)).", ["Z = w"]);
+    assert_prolog_success!(&mut wam, "?- p(z, h(z, W), f(w)).", [["W = w"]]);
+    assert_prolog_success!(&mut wam, "?- p(Z, h(Z, w), f(Z)).", [["Z = w"]]);
     assert_prolog_failure!(&mut wam, "?- p(z, h(Z, w), f(Z)).");
 
     submit(&mut wam, "p(f(X), h(Y, f(a)), Y).");
 
-    assert_prolog_success!(&mut wam, "?- p(Z, h(Z, W), f(W)).", ["W = f(a)", "Z = f(f(a))"]);
+    assert_prolog_success!(&mut wam, "?- p(Z, h(Z, W), f(W)).", [["W = f(a)", "Z = f(f(a))"]]);
 }
 
 #[test]
@@ -43,44 +43,48 @@ fn test_queries_on_rules() {
     submit(&mut wam, "q(q, s).");
     submit(&mut wam, "r(s, t).");
 
-    assert_prolog_success!(&mut wam, "?- p(X, Y).", ["Y = t", "X = q"]);
+    assert_prolog_success!(&mut wam, "?- p(X, Y).", [["Y = t", "X = q"]]);
     assert_prolog_success!(&mut wam, "?- p(q, t).");
     assert_prolog_failure!(&mut wam, "?- p(t, q).");
-    assert_prolog_success!(&mut wam, "?- p(q, T).", ["T = t"]);
+    assert_prolog_success!(&mut wam, "?- p(q, T).", [["T = t"]]);
     assert_prolog_failure!(&mut wam, "?- p(t, t).");
 
     submit(&mut wam, "p(X, Y) :- q(f(f(X)), R), r(S, T).");
     submit(&mut wam, "q(f(f(X)), r).");
 
-    assert_prolog_success!(&mut wam, "?- p(X, Y).", ["X = _0", "Y = _1"]);
+    assert_prolog_success!(&mut wam, "?- p(X, Y).", [["X = _0", "Y = _1"]]);
 
     submit(&mut wam, "q(f(f(x)), r).");
 
-    assert_prolog_success!(&mut wam, "?- p(X, Y).", ["X = x", "Y = _1"]);
+    assert_prolog_success!(&mut wam, "?- p(X, Y).", [["X = x", "Y = _1"]]);
 
     submit(&mut wam, "p(X, Y) :- q(X, Y), r(X, Y).");
     submit(&mut wam, "q(s, t).");
     submit(&mut wam, "r(X, Y) :- r(a).");
     submit(&mut wam, "r(a).");
 
-    assert_prolog_success!(&mut wam, "?- p(X, Y).", ["X = s", "Y = t"]);
+    assert_prolog_success!(&mut wam, "?- p(X, Y).", [["X = s", "Y = t"]]);
     assert_prolog_failure!(&mut wam, "?- p(t, S).");
-    assert_prolog_success!(&mut wam, "?- p(s, T).", ["T = t"]);
-    assert_prolog_success!(&mut wam, "?- p(S, t).", ["S = s"]);
+    assert_prolog_success!(&mut wam, "?- p(s, T).", [["T = t"]]);
+    assert_prolog_success!(&mut wam, "?- p(S, t).", [["S = s"]]);
 
     submit(&mut wam, "p(f(f(a), g(b), X), g(b), h) :- q(X, Y).");
     submit(&mut wam, "q(X, Y).");
 
-    assert_prolog_success!(&mut wam,  "?- p(f(X, Y, Z), g(b), h).", ["Z = _3", "Y = g(b)", "X = f(a)"]);
+    assert_prolog_success!(&mut wam,  "?- p(f(X, Y, Z), g(b), h).",
+                           [["Z = _3", "Y = g(b)", "X = f(a)"]]);
     assert_prolog_failure!(&mut wam, "?- p(f(X, g(Y), Z), g(Z), X).");
-    assert_prolog_success!(&mut wam, "?- p(f(X, g(Y), Z), g(Z), h).", ["Z = b", "Y = b", "X = f(a)"]);
-    assert_prolog_success!(&mut wam, "?- p(Z, Y, X).", ["X = h", "Y = g(b)", "Z = f(f(a), g(b), _7)"]);
-    assert_prolog_success!(&mut wam, "?- p(f(X, Y, Z), Y, h).", ["Y = g(b)", "Z = _3", "X = f(a)"]);
+    assert_prolog_success!(&mut wam, "?- p(f(X, g(Y), Z), g(Z), h).",
+                           [["Z = b", "Y = b", "X = f(a)"]]);
+    assert_prolog_success!(&mut wam, "?- p(Z, Y, X).",
+                           [["X = h", "Y = g(b)", "Z = f(f(a), g(b), _7)"]]);
+    assert_prolog_success!(&mut wam, "?- p(f(X, Y, Z), Y, h).",
+                           [["Y = g(b)", "Z = _3", "X = f(a)"]]);
 
     submit(&mut wam, "p(_, f(_, Y, _)) :- h(Y).");
     submit(&mut wam, "h(y).");
 
-    assert_prolog_success!(&mut wam, "?- p(_, f(_, Y, _)).", ["Y = y"]);
+    assert_prolog_success!(&mut wam, "?- p(_, f(_, Y, _)).", [["Y = y"]]);
     assert_prolog_success!(&mut wam, "?- p(_, f(_, y, _)).");
     assert_prolog_failure!(&mut wam, "?- p(_, f(_, z, _)).");
 }
@@ -91,61 +95,61 @@ fn test_queries_on_predicates() {
 
     submit(&mut wam, "p(X, a). p(b, X).");
 
-    assert_prolog_success!(&mut wam, "?- p(x, Y).", ["Y = a"]);
-    assert_prolog_success!(&mut wam, "?- p(X, a).", ["X = _0",  // 1st case
-                                                     "X = b"]); // 2nd case.
-    assert_prolog_success!(&mut wam, "?- p(b, X).", ["X = a",  // 1st case
-                                                     "X = _0"]); // 2nd case.
-    assert_prolog_success!(&mut wam, "?- p(X, X).", ["X = a",
-                                                     "X = b"]);
+    assert_prolog_success!(&mut wam, "?- p(x, Y).", [["Y = a"]]);
+    assert_prolog_success!(&mut wam, "?- p(X, a).", [["X = _0"],  // 1st case
+                                                     ["X = b"]]); // 2nd case.
+    assert_prolog_success!(&mut wam, "?- p(b, X).", [["X = a"],  // 1st case
+                                                     ["X = _0"]]); // 2nd case.
+    assert_prolog_success!(&mut wam, "?- p(X, X).", [["X = a"],
+                                                     ["X = b"]]);
     assert_prolog_success!(&mut wam, "?- p(b, a).");
     assert_prolog_failure!(&mut wam, "?- p(a, b).");
 
     submit(&mut wam, "p(X, Y, a). p(X, a, Y). p(X, Y, a).");
 
-    assert_prolog_success!(&mut wam, "?- p(c, d, X).", ["X = a",
-                                                    "X = a"]);
+    assert_prolog_success!(&mut wam, "?- p(c, d, X).", [["X = a"],
+                                                        ["X = a"]]);
     assert_prolog_success!(&mut wam, "?- p(a, a, a).");
     assert_prolog_failure!(&mut wam, "?- p(b, c, d).");
 
     submit(&mut wam, "p(X, a). p(X, Y) :- q(Z), p(X, X).");
 
-    assert_prolog_success!(&mut wam, "?- p(X, Y).", ["X = _0", "Y = a"]);
+    assert_prolog_success!(&mut wam, "?- p(X, Y).", [["X = _0", "Y = a"]]);
     assert_prolog_success!(&mut wam, "?- p(x, a).");
-    assert_prolog_success!(&mut wam, "?- p(X, a).", ["X = _0"]);
+    assert_prolog_success!(&mut wam, "?- p(X, a).", [["X = _0"]]);
     assert_prolog_failure!(&mut wam, "?- p(X, b).");
 
     submit(&mut wam, "q(z).");
 
-    assert_prolog_success_with_limit!(&mut wam, "?- p(X, b).", ["X = a",
-                                                                "X = a",
-                                                                "X = a"],
+    assert_prolog_success_with_limit!(&mut wam, "?- p(X, b).", [["X = a"],
+                                                                ["X = a"],
+                                                                ["X = a"]],
                                       3);
     assert_prolog_success!(&mut wam, "?- p(x, a).");
-    assert_prolog_success_with_limit!(&mut wam, "?- p(X, Y).", ["X = _0", "Y = a",
-                                                                "Y = _1", "X = a",
-                                                                "Y = _1", "X = a"],
+    assert_prolog_success_with_limit!(&mut wam, "?- p(X, Y).", [["X = _0", "Y = a"],
+                                                                ["Y = _1", "X = a"],
+                                                                ["Y = _1", "X = a"]],
                                       3);
 
     submit(&mut wam, "p(X, a). p(X, Y) :- q(Y), p(X, X).");
 
-    assert_prolog_success_with_limit!(&mut wam, "?- p(X, Y).", ["X = _0", "Y = a",
-                                                                "Y = z", "X = a"],
+    assert_prolog_success_with_limit!(&mut wam, "?- p(X, Y).", [["X = _0", "Y = a"],
+                                                                ["Y = z", "X = a"]],
                                       2);
     assert_prolog_failure!(&mut wam, "?- p(X, b).");
 
     submit(&mut wam, "p(a, z). p(X, Y) :- q(Y), p(X, Y).");
 
-    assert_prolog_success_with_limit!(&mut wam, "?- p(X, Y).", ["X = a", "Y = z",
-                                                                "X = a", "Y = z"],
+    assert_prolog_success_with_limit!(&mut wam, "?- p(X, Y).", [["X = a", "Y = z"],
+                                                                ["X = a", "Y = z"]],
                                       2);
 
-    assert_prolog_success_with_limit!(&mut wam, "?- p(X, z).", ["X = a",
-                                                                "X = a"],
+    assert_prolog_success_with_limit!(&mut wam, "?- p(X, z).", [["X = a"],
+                                                                ["X = a"]],
                                       2);
     assert_prolog_success!(&mut wam, "?- p(a, z).");
-    assert_prolog_success_with_limit!(&mut wam, "?- p(a, X).", ["X = z",
-                                                                "X = z"],
+    assert_prolog_success_with_limit!(&mut wam, "?- p(a, X).", [["X = z"],
+                                                                ["X = z"]],
                                       2);
     assert_prolog_failure!(&mut wam, "?- p(b, a).");
 
@@ -156,10 +160,10 @@ fn test_queries_on_predicates() {
     submit(&mut wam, "r(y).");
     submit(&mut wam, "s(z).");
 
-    assert_prolog_success!(&mut wam, "?- p(X, Y, Z).", ["Y = y", "X = x", "Z = z",
-                                                        "Y = b", "X = a", "Z = x"]);
+    assert_prolog_success!(&mut wam, "?- p(X, Y, Z).", [["Y = y", "X = x", "Z = z"],
+                                                        ["Y = b", "X = a", "Z = x"]]);
     assert_prolog_failure!(&mut wam, "?- p(a, b, c).");
-    assert_prolog_success!(&mut wam, "?- p(a, b, C).", ["C = x"]);
+    assert_prolog_success!(&mut wam, "?- p(a, b, C).", [["C = x"]]);
 
     submit(&mut wam, "p(X) :- q(X). p(X) :- r(X).");
     submit(&mut wam, "q(X) :- a.");
@@ -168,8 +172,8 @@ fn test_queries_on_predicates() {
     submit(&mut wam, "s(x, t).");
     submit(&mut wam, "t(y, u).");
 
-    assert_prolog_success!(&mut wam, "?- p(X).", ["X = x",
-                                                  "X = y"]);
+    assert_prolog_success!(&mut wam, "?- p(X).", [["X = x"],
+                                                  ["X = y"]]);
     assert_prolog_success!(&mut wam, "?- p(x).");
     assert_prolog_success!(&mut wam, "?- p(y).");
     assert_prolog_failure!(&mut wam, "?- p(z).");
@@ -181,75 +185,75 @@ fn test_queries_on_predicates() {
     submit(&mut wam, "f(s).");
     submit(&mut wam, "z(Z).");
 
-    assert_prolog_success!(&mut wam, "?- p(X, Y, Z).", ["Y = h(w)", "X = f(f(s))", "Z = _2",
-                                                        "Y = h(x)", "X = f(f(s))", "Z = _2",
-                                                        "Y = h(z)", "X = f(f(s))", "Z = _2",
-                                                        "Y = w", "Z = _2", "X = _0",
-                                                        "Y = w", "Z = _2", "X = _0",
-                                                        "Y = w", "Z = _2", "X = _0",
-                                                        "Y = w", "Z = _2", "X = _0",
-                                                        "Y = x", "Z = _2", "X = _0",
-                                                        "Y = x", "Z = _2", "X = _0",
-                                                        "Y = x", "Z = _2", "X = _0",
-                                                        "Y = x", "Z = _2", "X = _0",
-                                                        "Y = z", "Z = _2", "X = _0",
-                                                        "Y = z", "Z = _2", "X = _0",
-                                                        "Y = z", "Z = _2", "X = _0",
-                                                        "Y = z", "Z = _2", "X = _0"]);
-    assert_prolog_success!(&mut wam, "?- p(X, X, Z).", ["Z = _1", "X = w",
-                                                        "Z = _1", "X = w",
-                                                        "Z = _1", "X = w",
-                                                        "Z = _1", "X = w",
-                                                        "Z = _1", "X = x",
-                                                        "Z = _1", "X = x",
-                                                        "Z = _1", "X = x",
-                                                        "Z = _1", "X = x",
-                                                        "Z = _1", "X = z",
-                                                        "Z = _1", "X = z",
-                                                        "Z = _1", "X = z",
-                                                        "Z = _1", "X = z"]);
-    assert_prolog_success!(&mut wam, "?- p(f(f(Z)), Y, Z).", ["Y = h(w)", "Z = s",
-                                                              "Y = h(x)", "Z = s",
-                                                              "Y = h(z)", "Z = s",
-                                                              "Y = w", "Z = _1",
-                                                              "Y = w", "Z = _1",
-                                                              "Y = w", "Z = _1",
-                                                              "Y = w", "Z = _1",
-                                                              "Y = x", "Z = _1",
-                                                              "Y = x", "Z = _1",
-                                                              "Y = x", "Z = _1",
-                                                              "Y = x", "Z = _1",
-                                                              "Y = z", "Z = _1",
-                                                              "Y = z", "Z = _1",
-                                                              "Y = z", "Z = _1",
-                                                              "Y = z", "Z = _1"]);
-    assert_prolog_success!(&mut wam, "?- p(X, X, X).", ["X = w",
-                                                        "X = w",
-                                                        "X = w",
-                                                        "X = w",
-                                                        "X = x",
-                                                        "X = x",
-                                                        "X = x",
-                                                        "X = x",
-                                                        "X = z",
-                                                        "X = z",
-                                                        "X = z",
-                                                        "X = z"]);
-    assert_prolog_success!(&mut wam, "?- p(X, Y, X).", ["Y = h(w)", "X = f(f(s))",
-                                                        "Y = h(x)", "X = f(f(s))",
-                                                        "Y = h(z)", "X = f(f(s))",
-                                                        "Y = w", "X = _0",
-                                                        "Y = w", "X = _0",
-                                                        "Y = w", "X = _0",
-                                                        "Y = w", "X = _0",
-                                                        "Y = x", "X = _0",
-                                                        "Y = x", "X = _0",
-                                                        "Y = x", "X = _0",
-                                                        "Y = x", "X = _0",
-                                                        "Y = z", "X = _0",
-                                                        "Y = z", "X = _0",
-                                                        "Y = z", "X = _0",
-                                                        "Y = z", "X = _0"]);
+    assert_prolog_success!(&mut wam, "?- p(X, Y, Z).", [["Y = h(w)", "X = f(f(s))", "Z = _2"],
+                                                        ["Y = h(x)", "X = f(f(s))", "Z = _2"],
+                                                        ["Y = h(z)", "X = f(f(s))", "Z = _2"],
+                                                        ["Y = w", "Z = _2", "X = _0"],
+                                                        ["Y = w", "Z = _2", "X = _0"],
+                                                        ["Y = w", "Z = _2", "X = _0"],
+                                                        ["Y = w", "Z = _2", "X = _0"],
+                                                        ["Y = x", "Z = _2", "X = _0"],
+                                                        ["Y = x", "Z = _2", "X = _0"],
+                                                        ["Y = x", "Z = _2", "X = _0"],
+                                                        ["Y = x", "Z = _2", "X = _0"],
+                                                        ["Y = z", "Z = _2", "X = _0"],
+                                                        ["Y = z", "Z = _2", "X = _0"],
+                                                        ["Y = z", "Z = _2", "X = _0"],
+                                                        ["Y = z", "Z = _2", "X = _0"]]);
+    assert_prolog_success!(&mut wam, "?- p(X, X, Z).", [["Z = _1", "X = w"],
+                                                        ["Z = _1", "X = w"],
+                                                        ["Z = _1", "X = w"],
+                                                        ["Z = _1", "X = w"],
+                                                        ["Z = _1", "X = x"],
+                                                        ["Z = _1", "X = x"],
+                                                        ["Z = _1", "X = x"],
+                                                        ["Z = _1", "X = x"],
+                                                        ["Z = _1", "X = z"],
+                                                        ["Z = _1", "X = z"],
+                                                        ["Z = _1", "X = z"],
+                                                        ["Z = _1", "X = z"]]);
+    assert_prolog_success!(&mut wam, "?- p(f(f(Z)), Y, Z).", [["Y = h(w)", "Z = s"],
+                                                              ["Y = h(x)", "Z = s"],
+                                                              ["Y = h(z)", "Z = s"],
+                                                              ["Y = w", "Z = _1"],
+                                                              ["Y = w", "Z = _1"],
+                                                              ["Y = w", "Z = _1"],
+                                                              ["Y = w", "Z = _1"],
+                                                              ["Y = x", "Z = _1"],
+                                                              ["Y = x", "Z = _1"],
+                                                              ["Y = x", "Z = _1"],
+                                                              ["Y = x", "Z = _1"],
+                                                              ["Y = z", "Z = _1"],
+                                                              ["Y = z", "Z = _1"],
+                                                              ["Y = z", "Z = _1"],
+                                                              ["Y = z", "Z = _1"]]);
+    assert_prolog_success!(&mut wam, "?- p(X, X, X).", [["X = w"],
+                                                        ["X = w"],
+                                                        ["X = w"],
+                                                        ["X = w"],
+                                                        ["X = x"],
+                                                        ["X = x"],
+                                                        ["X = x"],
+                                                        ["X = x"],
+                                                        ["X = z"],
+                                                        ["X = z"],
+                                                        ["X = z"],
+                                                        ["X = z"]]);
+    assert_prolog_success!(&mut wam, "?- p(X, Y, X).", [["Y = h(w)", "X = f(f(s))"],
+                                                        ["Y = h(x)", "X = f(f(s))"],
+                                                        ["Y = h(z)", "X = f(f(s))"],
+                                                        ["Y = w", "X = _0"],
+                                                        ["Y = w", "X = _0"],
+                                                        ["Y = w", "X = _0"],
+                                                        ["Y = w", "X = _0"],
+                                                        ["Y = x", "X = _0"],
+                                                        ["Y = x", "X = _0"],
+                                                        ["Y = x", "X = _0"],
+                                                        ["Y = x", "X = _0"],
+                                                        ["Y = z", "X = _0"],
+                                                        ["Y = z", "X = _0"],
+                                                        ["Y = z", "X = _0"],
+                                                        ["Y = z", "X = _0"]]);
     assert_prolog_failure!(&mut wam, "?- p(f(f(X)), h(f(X)), Y).");
 
     submit(&mut wam, "p(X) :- f(Y), g(Y), i(X, Y).");
@@ -257,16 +261,16 @@ fn test_queries_on_predicates() {
     submit(&mut wam, "f(f(a)). f(f(b)). f(f(c)).");
     submit(&mut wam, "i(X, X).");
 
-    assert_prolog_success!(&mut wam, "?- p(X).", ["X = f(a)",
-                                                  "X = f(b)",
-                                                  "X = f(c)"]);
+    assert_prolog_success!(&mut wam, "?- p(X).", [["X = f(a)"],
+                                                  ["X = f(b)"],
+                                                  ["X = f(c)"]]);
 
     submit(&mut wam, "p(X) :- f(f(Y)), g(Y, f(Y)), i(X, f(Y)).");
     submit(&mut wam, "g(Y, f(Y)) :- g(f(Y)).");
 
-    assert_prolog_success!(&mut wam, "?- p(X).", ["X = f(a)",
-                                                  "X = f(b)",
-                                                  "X = f(c)"]);
+    assert_prolog_success!(&mut wam, "?- p(X).", [["X = f(a)"],
+                                                  ["X = f(b)"],
+                                                  ["X = f(c)"]]);
 }
 
 #[test]
@@ -277,13 +281,12 @@ fn test_queries_on_cuts() {
     submit(&mut wam, "memberchk(X, [X|_]) :- !.
                       memberchk(X, [_|Xs]) :- memberchk(X, Xs).");
 
-    assert_prolog_success!(&mut wam, "?- memberchk(X, [a,b,c]).", ["X = a"]);
-    assert_prolog_success!(&mut wam, "?- memberchk([X,X], [a,b,c,[d,e],[d,d]]).", ["X = d"]);
-    assert_prolog_success!(&mut wam, "?- memberchk([X,X], [a,b,c,[D,d],[e,e]]).", ["X = d", "D = d"]);
+    assert_prolog_success!(&mut wam, "?- memberchk(X, [a,b,c]).", [["X = a"]]);
+    assert_prolog_success!(&mut wam, "?- memberchk([X,X], [a,b,c,[d,e],[d,d]]).", [["X = d"]]);
+    assert_prolog_success!(&mut wam, "?- memberchk([X,X], [a,b,c,[D,d],[e,e]]).", [["X = d", "D = d"]]);
     assert_prolog_failure!(&mut wam, "?- memberchk([X,X], [a,b,c,[e,d],[f,e]]).");
     assert_prolog_failure!(&mut wam, "?- memberchk([X,X,Y], [a,b,c,[e,d],[f,e]]).");
-    assert_prolog_success!(&mut wam, "?- memberchk([X,X,Y], [a,b,c,[e,e,d],[f,e]]).", ["X = e",
-                                                                                       "Y = d"]);
+    assert_prolog_success!(&mut wam, "?- memberchk([X,X,Y], [a,b,c,[e,e,d],[f,e]]).", [["X = e", "Y = d"]]);
 
     // test deep cuts.
     submit(&mut wam, "commit :- a, !.");
@@ -300,7 +303,7 @@ fn test_queries_on_cuts() {
 
     submit(&mut wam, "a(x).");
 
-    assert_prolog_success!(&mut wam, "?- commit(X).", ["X = x"]);
+    assert_prolog_success!(&mut wam, "?- commit(X).", [["X = x"]]);
 
     submit(&mut wam, "a :- b, !, c. a :- d.");
 
@@ -327,11 +330,11 @@ fn test_queries_on_cuts() {
     submit(&mut wam, "c(c).");
     submit(&mut wam, "d(d).");
 
-    assert_prolog_success!(&mut wam, "?- a(X).", ["X = c"]);
+    assert_prolog_success!(&mut wam, "?- a(X).", [["X = c"]]);
 
     submit(&mut wam, "b.");
 
-    assert_prolog_success!(&mut wam, "?- a(X).", ["X = c"]);
+    assert_prolog_success!(&mut wam, "?- a(X).", [["X = c"]]);
 
     wam.clear();
 
@@ -344,11 +347,11 @@ fn test_queries_on_cuts() {
 
     submit(&mut wam, "d(d).");
 
-    assert_prolog_success!(&mut wam, "?- a(X).", ["X = d"]);
+    assert_prolog_success!(&mut wam, "?- a(X).", [["X = d"]]);
 
     submit(&mut wam, "c(c).");
 
-    assert_prolog_success!(&mut wam, "?- a(X).", ["X = c"]);
+    assert_prolog_success!(&mut wam, "?- a(X).", [["X = c"]]);
 }
 
 #[test]
@@ -358,52 +361,52 @@ fn test_queries_on_lists()
 
     submit(&mut wam, "p([Z, W]).");
 
-    assert_prolog_success!(&mut wam, "?- p([Z, Z]).", ["Z = _0"]);
+    assert_prolog_success!(&mut wam, "?- p([Z, Z]).", [["Z = _0"]]);
     assert_prolog_failure!(&mut wam, "?- p([Z, W, Y]).");
-    assert_prolog_success!(&mut wam, "?- p([Z | W]).", ["Z = _0", "W = [_3]"]);
-    assert_prolog_success!(&mut wam, "?- p([Z | [Z]]).", ["Z = _0"]);
-    assert_prolog_success!(&mut wam, "?- p([Z | [W]]).", ["Z = _2", "W = _0"]);
+    assert_prolog_success!(&mut wam, "?- p([Z | W]).", [["Z = _0", "W = [_3]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Z | [Z]]).", [["Z = _0"]]);
+    assert_prolog_success!(&mut wam, "?- p([Z | [W]]).", [["Z = _2", "W = _0"]]);
     assert_prolog_failure!(&mut wam, "?- p([Z | []]).");
 
     submit(&mut wam, "p([Z, Z]).");
 
-    assert_prolog_success!(&mut wam, "?- p([Z, Z]).", ["Z = _0"]);
+    assert_prolog_success!(&mut wam, "?- p([Z, Z]).", [["Z = _0"]]);
     assert_prolog_failure!(&mut wam, "?- p([Z, W, Y]).");
-    assert_prolog_success!(&mut wam, "?- p([Z | W]).", ["Z = _0", "W = [_0]"]);
-    assert_prolog_success!(&mut wam, "?- p([Z | [Z]]).", ["Z = _0"]);
-    assert_prolog_success!(&mut wam, "?- p([Z | [W]]).", ["Z = _2", "W = _2"]);
+    assert_prolog_success!(&mut wam, "?- p([Z | W]).", [["Z = _0", "W = [_0]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Z | [Z]]).", [["Z = _0"]]);
+    assert_prolog_success!(&mut wam, "?- p([Z | [W]]).", [["Z = _2", "W = _2"]]);
     assert_prolog_failure!(&mut wam, "?- p([Z | []]).");
 
     submit(&mut wam, "p([Z]).");
 
     assert_prolog_failure!(&mut wam, "?- p([Z, Z]).");
     assert_prolog_failure!(&mut wam, "?- p([Z, W, Y]).");
-    assert_prolog_success!(&mut wam, "?- p([Z | W]).", ["W = []", "Z = _0"]);
+    assert_prolog_success!(&mut wam, "?- p([Z | W]).", [["W = []", "Z = _0"]]);
     assert_prolog_failure!(&mut wam, "?- p([Z | [Z]]).");
     assert_prolog_failure!(&mut wam, "?- p([Z | [W]]).");
-    assert_prolog_success!(&mut wam, "?- p([Z | []]).", ["Z = _0"]);
+    assert_prolog_success!(&mut wam, "?- p([Z | []]).", [["Z = _0"]]);
 
     submit(&mut wam, "member(X, [X|_]).
                       member(X, [_|Xs]) :- member(X, Xs).");
 
     assert_prolog_failure!(&mut wam, "?- member(a, [c, [X, Y]]).");
     assert_prolog_failure!(&mut wam, "?- member(c, [a, [X, Y]]).");
-    assert_prolog_success!(&mut wam, "?- member(a, [a, [X, Y]]).", ["X = _2", "Y = _0"]);
+    assert_prolog_success!(&mut wam, "?- member(a, [a, [X, Y]]).", [["X = _2", "Y = _0"]]);
 
-    assert_prolog_success!(&mut wam, "?- member(a, [X, Y, Z]).", ["Y = _2", "X = a",  "Z = _0",
-                                                                  "Y = a",  "X = _4", "Z = _0",
-                                                                  "Y = _2",  "X = _4", "Z = a"]);
+    assert_prolog_success!(&mut wam, "?- member(a, [X, Y, Z]).", [["Y = _2", "X = a",  "Z = _0"],
+                                                                  ["Y = a",  "X = _4", "Z = _0"],
+                                                                  ["Y = _2",  "X = _4", "Z = a"]]);
 
-    assert_prolog_success!(&mut wam, "?- member([X, X], [a, [X, Y]]).", ["X = _0", "Y = _0"]);
+    assert_prolog_success!(&mut wam, "?- member([X, X], [a, [X, Y]]).", [["X = _0", "Y = _0"]]);
     assert_prolog_success!(&mut wam, "?- member([X, X], [a, [b, c], [b, b], [Z, x], [d, f]]).",
-                           ["Z = _14", "X = b",
-                            "Z = x",   "X = x"]);
+                           [["Z = _14", "X = b"],
+                            ["Z = x",   "X = x"]]);
     assert_prolog_failure!(&mut wam, "?- member([X, X], [a, [b, c], [b, d], [foo, x], [d, f]]).");
     assert_prolog_success!(&mut wam, "?- member([X, Y], [a, [b, c], [b, b], [Z, x], [d, f]]).",
-                           ["X = b", "Y = c", "Z = _14",
-                            "X = b", "Y = b", "Z = _14",
-                            "X = _14", "Y = x", "Z = _14",
-                            "X = d", "Y = f", "Z = _14"]);
+                           [["X = b", "Y = c", "Z = _14"],
+                            ["X = b", "Y = b", "Z = _14"],
+                            ["X = _14", "Y = x", "Z = _14"],
+                            ["X = d", "Y = f", "Z = _14"]]);
     assert_prolog_failure!(&mut wam, "?- member([X, Y, Y], [a, [b, c], [b, b], [Z, x], [d, f]]).");
     assert_prolog_failure!(&mut wam, "?- member([X, Y, Z], [a, [b, c], [b, b], [Z, x], [d, f]]).");
 }
@@ -434,10 +437,10 @@ fn test_queries_on_indexed_predicates()
     assert_prolog_failure!(&mut wam, "?- p(g(b)).");
     assert_prolog_success!(&mut wam, "?- p([]).");
     assert_prolog_success!(&mut wam, "?- p([c, d, e]).");
-    assert_prolog_success!(&mut wam, "?- p([c, d | X]).", ["X = [e]"]);
-    assert_prolog_success!(&mut wam, "?- p([c|X]).", ["X = [d, e]"]);
-    assert_prolog_success!(&mut wam, "?- p([Y|X]).", ["Y = c", "X = [d, e]"]);
-    assert_prolog_success!(&mut wam, "?- p([Y|[d|Xs]]).", ["Xs = [e]", "Y = c"]);
+    assert_prolog_success!(&mut wam, "?- p([c, d | X]).", [["X = [e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([c|X]).", [["X = [d, e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Y|X]).", [["Y = c", "X = [d, e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Y|[d|Xs]]).", [["Xs = [e]", "Y = c"]]);
 
     submit(&mut wam, "a.");
 
@@ -451,11 +454,11 @@ fn test_queries_on_indexed_predicates()
     assert_prolog_failure!(&mut wam, "?- p(g(b)).");
     assert_prolog_success!(&mut wam, "?- p([]).");
     assert_prolog_success!(&mut wam, "?- p([c, d, e]).");
-    assert_prolog_success!(&mut wam, "?- p([c, d | X]).", ["X = [e]"]);
-    assert_prolog_success!(&mut wam, "?- p([c|X]).", ["X = [d, e]"]);
-    assert_prolog_success!(&mut wam, "?- p([Y|X]).", ["X = b", "Y = a",
-                                                      "Y = c", "X = [d, e]"]);
-    assert_prolog_success!(&mut wam, "?- p([Y|[d|Xs]]).", ["Xs = [e]", "Y = c"]);
+    assert_prolog_success!(&mut wam, "?- p([c, d | X]).", [["X = [e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([c|X]).", [["X = [d, e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Y|X]).", [["X = b", "Y = a"],
+                                                      ["Y = c", "X = [d, e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Y|[d|Xs]]).", [["Xs = [e]", "Y = c"]]);
 
     submit(&mut wam, "b.");
     submit(&mut wam, "f(x).");
@@ -464,65 +467,65 @@ fn test_queries_on_indexed_predicates()
     assert_prolog_success!(&mut wam, "?- p(b).");
     assert_prolog_failure!(&mut wam, "?- p(c).");
     assert_prolog_success!(&mut wam, "?- p(f(a)).");
-    assert_prolog_success!(&mut wam, "?- p(g(b, X)).", ["X = c"]);
-    assert_prolog_success!(&mut wam, "?- p(g(Y, X)).", ["X = c", "Y = b"]);
-    assert_prolog_success!(&mut wam, "?- p(g(Y, c)).", ["Y = b"]);
+    assert_prolog_success!(&mut wam, "?- p(g(b, X)).", [["X = c"]]);
+    assert_prolog_success!(&mut wam, "?- p(g(Y, X)).", [["X = c", "Y = b"]]);
+    assert_prolog_success!(&mut wam, "?- p(g(Y, c)).", [["Y = b"]]);
     assert_prolog_success!(&mut wam, "?- p(g(b)).");
     assert_prolog_success!(&mut wam, "?- p([]).");
     assert_prolog_success!(&mut wam, "?- p([c, d, e]).");
-    assert_prolog_success!(&mut wam, "?- p([c, d | X]).", ["X = [e]"]);
-    assert_prolog_success!(&mut wam, "?- p([c|X]).", ["X = [d, e]"]);
-    assert_prolog_success!(&mut wam, "?- p([Y|X]).", ["X = b", "Y = a",
-                                                      "Y = c", "X = [d, e]"]);
-    assert_prolog_success!(&mut wam, "?- p([Y|[d|Xs]]).", ["Xs = [e]", "Y = c"]);
+    assert_prolog_success!(&mut wam, "?- p([c, d | X]).", [["X = [e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([c|X]).", [["X = [d, e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Y|X]).", [["X = b", "Y = a"],
+                                                      ["Y = c", "X = [d, e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Y|[d|Xs]]).", [["Xs = [e]", "Y = c"]]);
 
     submit(&mut wam, "c.");
     submit(&mut wam, "g(X).");
 
-    assert_eq!(submit(&mut wam, "?- p(a)."), true);
-    assert_eq!(submit(&mut wam, "?- p(b)."), true);
-    assert_eq!(submit(&mut wam, "?- p(c)."), true);
-    assert_eq!(submit(&mut wam, "?- p(f(a))."), true);
-    assert_prolog_success!(&mut wam, "?- p(g(b, X)).", ["X = c"]);
-    assert_prolog_success!(&mut wam, "?- p(g(Y, X)).", ["X = c", "Y = b"]);
-    assert_prolog_success!(&mut wam, "?- p(g(Y, c)).", ["Y = b"]);
-    assert_eq!(submit(&mut wam, "?- p(g(b))."), true);
-    assert_eq!(submit(&mut wam, "?- p([])."), true);
-    assert_eq!(submit(&mut wam, "?- p([c, d, e])."), true);
-    assert_prolog_success!(&mut wam, "?- p([c, d | X]).", ["X = [e]"]);
-    assert_prolog_success!(&mut wam, "?- p([c|X]).", ["X = [d, e]"]);
-    assert_prolog_success!(&mut wam, "?- p([Y|X]).", ["X = b", "Y = a",
-                                                      "Y = c", "X = [d, e]"]);
-    assert_prolog_success!(&mut wam, "?- p([Y|[d|Xs]]).", ["Xs = [e]", "Y = c"]);
-    assert_eq!(submit(&mut wam, "?- p(blah)."), false);
+    assert_prolog_success!(&mut wam, "?- p(a).");
+    assert_prolog_success!(&mut wam, "?- p(b).");
+    assert_prolog_success!(&mut wam, "?- p(c).");
+    assert_prolog_success!(&mut wam, "?- p(f(a)).");
+    assert_prolog_success!(&mut wam, "?- p(g(b, X)).", [["X = c"]]);
+    assert_prolog_success!(&mut wam, "?- p(g(Y, X)).", [["X = c", "Y = b"]]);
+    assert_prolog_success!(&mut wam, "?- p(g(Y, c)).", [["Y = b"]]);
+    assert_prolog_success!(&mut wam, "?- p(g(b)).");
+    assert_prolog_success!(&mut wam, "?- p([]).");
+    assert_prolog_success!(&mut wam, "?- p([c, d, e]).");
+    assert_prolog_success!(&mut wam, "?- p([c, d | X]).", [["X = [e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([c|X]).", [["X = [d, e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Y|X]).", [["X = b", "Y = a"],
+                                                      ["Y = c", "X = [d, e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Y|[d|Xs]]).", [["Xs = [e]", "Y = c"]]);
+    assert_prolog_failure!(&mut wam, "?- p(blah).");
 
     submit(&mut wam, "x.");
 
-    assert_eq!(submit(&mut wam, "?- p(a)."), true);
-    assert_eq!(submit(&mut wam, "?- p(b)."), true);
-    assert_eq!(submit(&mut wam, "?- p(c)."), true);
-    assert_eq!(submit(&mut wam, "?- p(true(a))."), true);
-
-    assert_prolog_success!(&mut wam, "?- p(g(b, X)).", ["X = c",
-                                                        "X = _2"]);
-    assert_prolog_success!(&mut wam, "?- p(g(Y, X)).", ["X = c", "Y = b",
-                                                        "X = _2", "Y = _1"]);
-    assert_prolog_success!(&mut wam, "?- p(g(Y, c)).", ["Y = b",
-                                                        "Y = _1"]);
-
-    assert_eq!(submit(&mut wam, "?- p(g(b))."), true);
-    assert_eq!(submit(&mut wam, "?- p([])."), true);
-    assert_eq!(submit(&mut wam, "?- p([c, d, e])."), true);
-
-    assert_prolog_success!(&mut wam, "?- p([c, d | X]).", ["X = _1",
-                                                           "X = [e]"]);
-    assert_prolog_success!(&mut wam, "?- p([c|X]).", ["X = [d, e]",
-                                                      "X = _1"]);
-    assert_prolog_success!(&mut wam, "?- p([Y|X]).", ["X = b", "Y = a",
-                                                      "Y = c", "X = [d, e]",
-                                                      "X = _1", "Y = _0"]);
-    assert_prolog_success!(&mut wam, "?- p([Y|[d|Xs]]).", ["Xs = [e]", "Y = c",
-                                                           "Xs = _1", "Y = _2"]);
+    assert_prolog_success!(&mut wam, "?- p(a).");
+    assert_prolog_success!(&mut wam, "?- p(b).");
+    assert_prolog_success!(&mut wam, "?- p(c).");
+    assert_prolog_success!(&mut wam, "?- p(true(a)).");
+
+    assert_prolog_success!(&mut wam, "?- p(g(b, X)).", [["X = c"],
+                                                        ["X = _2"]]);
+    assert_prolog_success!(&mut wam, "?- p(g(Y, X)).", [["X = c", "Y = b"],
+                                                        ["X = _2", "Y = _1"]]);
+    assert_prolog_success!(&mut wam, "?- p(g(Y, c)).", [["Y = b"],
+                                                        ["Y = _1"]]);
+
+    assert_prolog_success!(&mut wam, "?- p(g(b)).");
+    assert_prolog_success!(&mut wam, "?- p([]).");
+    assert_prolog_success!(&mut wam, "?- p([c, d, e]).");
+
+    assert_prolog_success!(&mut wam, "?- p([c, d | X]).", [["X = _1"],
+                                                           ["X = [e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([c|X]).", [["X = _1"],
+                                                      ["X = [d, e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Y|X]).", [["X = b", "Y = a"],
+                                                      ["X = _1", "Y = _0"],
+                                                      ["Y = c", "X = [d, e]"]]);
+    assert_prolog_success!(&mut wam, "?- p([Y|[d|Xs]]).", [["Xs = _1", "Y = _2"],
+                                                           ["Xs = [e]", "Y = c"]]);
 
     assert_prolog_success!(&mut wam, "?- p(blah).");
 
@@ -538,38 +541,38 @@ fn test_queries_on_indexed_predicates()
                       ind_call(repeat) :- ind_call(repeat).
                       ind_call(false).");
 
-    assert_eq!(submit(&mut wam, "?- ind_call(repeat)."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(false)."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(ind_call(repeat))."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(ind_call(false))."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(notrace)."), false);
-    assert_eq!(submit(&mut wam, "?- ind_call(nl)."), false);
-    assert_eq!(submit(&mut wam, "?- ind_call(builtin(X))."), false);
-    assert_eq!(submit(&mut wam, "?- ind_call(extern(X))."), false);
+    assert_prolog_success!(&mut wam, "?- ind_call(repeat).");
+    assert_prolog_success!(&mut wam, "?- ind_call(false).");
+    assert_prolog_success!(&mut wam, "?- ind_call(ind_call(repeat)).");
+    assert_prolog_success!(&mut wam, "?- ind_call(ind_call(false)).");
+    assert_prolog_failure!(&mut wam, "?- ind_call(notrace).");
+    assert_prolog_failure!(&mut wam, "?- ind_call(nl).");
+    assert_prolog_failure!(&mut wam, "?- ind_call(builtin(X)).");
+    assert_prolog_failure!(&mut wam, "?- ind_call(extern(X)).");
 
     submit(&mut wam, "notrace.");
     submit(&mut wam, "nl.");
 
-    assert_eq!(submit(&mut wam, "?- ind_call(repeat)."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(false)."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(ind_call(repeat))."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(ind_call(false))."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(notrace)."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(nl)."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(builtin(X))."), false);
-    assert_eq!(submit(&mut wam, "?- ind_call(extern(X))."), false);
+    assert_prolog_success!(&mut wam, "?- ind_call(repeat).");
+    assert_prolog_success!(&mut wam, "?- ind_call(false).");
+    assert_prolog_success!(&mut wam, "?- ind_call(ind_call(repeat)).");
+    assert_prolog_success!(&mut wam, "?- ind_call(ind_call(false)).");
+    assert_prolog_success!(&mut wam, "?- ind_call(notrace).");
+    assert_prolog_success!(&mut wam, "?- ind_call(nl).");
+    assert_prolog_failure!(&mut wam, "?- ind_call(builtin(X)).");
+    assert_prolog_failure!(&mut wam, "?- ind_call(extern(X)).");
 
     submit(&mut wam, "builtin(X).");
     submit(&mut wam, "extern(x).");
 
-    assert_eq!(submit(&mut wam, "?- ind_call(repeat)."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(false)."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(ind_call(repeat))."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(ind_call(false))."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(notrace)."), true);
-    assert_eq!(submit(&mut wam, "?- ind_call(nl)."), true);
-    assert_prolog_success!(&mut wam, "?- ind_call(builtin(X)).", ["X = _1"]);
-    assert_prolog_success!(&mut wam, "?- ind_call(extern(X)).", ["X = _1"]);
+    assert_prolog_success!(&mut wam, "?- ind_call(repeat).");
+    assert_prolog_success!(&mut wam, "?- ind_call(false).");
+    assert_prolog_success!(&mut wam, "?- ind_call(ind_call(repeat)).");
+    assert_prolog_success!(&mut wam, "?- ind_call(ind_call(false)).");
+    assert_prolog_success!(&mut wam, "?- ind_call(notrace).");
+    assert_prolog_success!(&mut wam, "?- ind_call(nl).");
+    assert_prolog_success!(&mut wam, "?- ind_call(builtin(X)).", [["X = _1"]]);
+    assert_prolog_success!(&mut wam, "?- ind_call(extern(X)).", [["X = _1"]]);
 }
 
 #[test]
@@ -579,89 +582,89 @@ fn test_queries_on_conjuctive_queries() {
     submit(&mut wam, "p(a, b).");
     submit(&mut wam, "q(b, c).");
 
-    assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, Z).", ["X = a", "Z = c", "Y = b"]);
+    assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, Z).", [["X = a", "Z = c", "Y = b"]]);
     assert_prolog_failure!(&mut wam, "?- p(X, Y), q(Y, X).");
 
     submit(&mut wam, "p(a, [f(g(X))]).");
     submit(&mut wam, "q(Y, c).");
 
-    assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, Z).", ["Y = f(g(_9))", "X = a", "Z = c"]);
+    assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, Z).", [["Y = f(g(_9))", "X = a", "Z = c"]]);
     assert_prolog_failure!(&mut wam, "?- p(X, Y), q(Y, X).");
 
     submit(&mut wam, "member(X, [X|_]).
                       member(X, [_|Xs]) :- member(X, Xs).");
 
     assert_prolog_success!(&mut wam, "?- member(X, [a,b,c]), member(X, [a,b,c]).",
-                           ["X = a",
-                            "X = b",
-                            "X = c"]);
+                           [["X = a"],
+                            ["X = b"],
+                            ["X = c"]]);
     assert_prolog_success!(&mut wam, "?- member(X, [a,b,c]), member(X, [b,c]).",
-                           ["X = b",
-                            "X = c"]);
+                           [["X = b"],
+                            ["X = c"]]);
     assert_prolog_success!(&mut wam, "?- member(X, [a,c]), member(X, [b,c]).",
-                           ["X = c"]);
+                           [["X = c"]]);
     assert_prolog_success!(&mut wam, "?- member(X, [a,b,c,d]), !, member(X, [a,d]).",
-                           ["X = a"]);
+                           [["X = a"]]);
     assert_prolog_failure!(&mut wam, "?- member(X, [a,b,c,d]), !, member(X, [e]).");
     assert_prolog_success!(&mut wam, "?- member([X,X],[a,b,c,[d,d],[e,d]]),
                                          member(X, [a,b,c,d,e,f,g]),
                                          member(Y, [X, a, b, c, d]).",
-                           ["X = d", "Y = d",
-                            "X = d", "Y = a",
-                            "X = d", "Y = b",
-                            "X = d", "Y = c",
-                            "X = d", "Y = d"]);
+                           [["X = d", "Y = d"],
+                            ["X = d", "Y = a"],
+                            ["X = d", "Y = b"],
+                            ["X = d", "Y = c"],
+                            ["X = d", "Y = d"]]);
 
     submit(&mut wam, "p(a, [f(g(X))]). p(X, c) :- c.");
     submit(&mut wam, "c.");
     submit(&mut wam, "q(Y, c).");
 
     assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, Z).",
-                           ["X = a",  "Z = c", "Y = f(g(_9))",
-                            "X = _0", "Z = c", "Y = c"]);
+                           [["X = a",  "Z = c", "Y = f(g(_9))"],
+                            ["X = _0", "Z = c", "Y = c"]]);
     assert_prolog_success!(&mut wam, "?- p(X, Y), !, q(Y, Z).",
-                           ["Z = c", "Y = f(g(_9))", "X = a"]);
+                           [["Z = c", "Y = f(g(_9))", "X = a"]]);
 
     submit(&mut wam, "q([f(g(x))], Z). q([f(g(y))], Y). q([f(g(z))], a).");
 
     assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, Z).",
-                           ["Z = _10", "X = a", "Y = f(g(x))",
-                            "Z = _10", "X = a", "Y = f(g(y))",
-                            "Z = a", "X = a", "Y = f(g(z))"]);
+                           [["Z = _10", "X = a", "Y = f(g(x))"],
+                            ["Z = _10", "X = a", "Y = f(g(y))"],
+                            ["Z = a", "X = a", "Y = f(g(z))"]]);
     assert_prolog_success!(&mut wam, "?- p(X, Y), !, q(Y, Z).",
-                           ["X = a", "Y = f(g(x))", "Z = _10",
-                            "X = a", "Y = f(g(y))", "Z = _10",
-                            "X = a", "Y = f(g(z))", "Z = a"]);
+                           [["X = a", "Y = f(g(x))", "Z = _10"],
+                            ["X = a", "Y = f(g(y))", "Z = _10"],
+                            ["X = a", "Y = f(g(z))", "Z = a"]]);
     assert_prolog_success!(&mut wam, "?- p(X, Y), !, q(Y, X).",
-                           ["X = a", "Y = f(g(x))",
-                            "X = a", "Y = f(g(y))",
-                            "X = a", "Y = f(g(z))"]);
+                           [["X = a", "Y = f(g(x))"],
+                            ["X = a", "Y = f(g(y))"],
+                            ["X = a", "Y = f(g(z))"]]);
 
     submit(&mut wam, "p(X, [f(g(x))]). p(X, [f(g(y))]). p(X, [f(g(z))]).");
 
     assert_prolog_failure!(&mut wam, "?- q(f(X), Y), p(X, Y).");
     assert_prolog_success!(&mut wam, "?- q(X, Y), p(X, Y).",
-                           ["Y = [f(g(x))]", "X = f(g(x))",
-                            "Y = [f(g(y))]", "X = f(g(x))",
-                            "Y = [f(g(z))]", "X = f(g(x))",
-                            "Y = [f(g(x))]", "X = f(g(y))",
-                            "Y = [f(g(y))]", "X = f(g(y))",
-                            "Y = [f(g(z))]", "X = f(g(y))"]);
+                           [["Y = [f(g(x))]", "X = f(g(x))"],
+                            ["Y = [f(g(y))]", "X = f(g(x))"],
+                            ["Y = [f(g(z))]", "X = f(g(x))"],
+                            ["Y = [f(g(x))]", "X = f(g(y))"],
+                            ["Y = [f(g(y))]", "X = f(g(y))"],
+                            ["Y = [f(g(z))]", "X = f(g(y))"]]);
     assert_prolog_success!(&mut wam, "?- p(X, Y), q(X, Y).",
-                           ["Y = f(g(x))", "X = [f(g(x))]",
-                            "Y = f(g(x))", "X = [f(g(y))]",
-                            "Y = f(g(y))", "X = [f(g(x))]",
-                            "Y = f(g(y))", "X = [f(g(y))]",
-                            "Y = f(g(z))", "X = [f(g(x))]",
-                            "Y = f(g(z))", "X = [f(g(y))]"]);
+                           [["Y = f(g(x))", "X = [f(g(x))]"],
+                            ["Y = f(g(x))", "X = [f(g(y))]"],
+                            ["Y = f(g(y))", "X = [f(g(x))]"],
+                            ["Y = f(g(y))", "X = [f(g(y))]"],
+                            ["Y = f(g(z))", "X = [f(g(x))]"],
+                            ["Y = f(g(z))", "X = [f(g(y))]"]]);
     assert_prolog_success!(&mut wam, "?- p(X, Y), q(Y, X).",
-                           ["Y = f(g(x))", "X = s_0_2",
-                            "Y = f(g(y))", "X = s_0_2",
-                            "Y = f(g(z))", "X = a"]);
+                           [["Y = f(g(x))", "X = s_0_2"],
+                            ["Y = f(g(y))", "X = s_0_2"],
+                            ["Y = f(g(z))", "X = a"]]);
     assert_prolog_success!(&mut wam, "?- q(X, Y), p(Y, X).",
-                           ["Y = s_0_1", "X = f(g(x))",
-                            "Y = s_0_1", "X = f(g(y))",
-                            "Y = a"    , "X = f(g(z))"]);
+                           [["Y = s_0_1", "X = f(g(x))"],
+                            ["Y = s_0_1", "X = f(g(y))"],
+                            ["Y = a"    , "X = f(g(z))"]]);
 }
 
 #[test]
@@ -674,160 +677,160 @@ fn test_queries_on_call_n()
     submit(&mut wam, "f(a). f(b). f(c).");
 
     assert_prolog_success!(&mut wam, "?- maplist(f, [X,Y,Z]).",
-                           ["X = a", "Y = a", "Z = a",
-                            "X = a", "Y = a", "Z = b",
-                            "X = a", "Y = a", "Z = c",
-                            "X = a", "Y = b", "Z = a",
-                            "X = a", "Y = b", "Z = b",
-                            "X = a", "Y = b", "Z = c",
-                            "X = a", "Y = c", "Z = a",
-                            "X = a", "Y = c", "Z = b",
-                            "X = a", "Y = c", "Z = c",
-                            "X = b", "Y = a", "Z = a",
-                            "X = b", "Y = a", "Z = b",
-                            "X = b", "Y = a", "Z = c",
-                            "X = b", "Y = b", "Z = a",
-                            "X = b", "Y = b", "Z = b",
-                            "X = b", "Y = b", "Z = c",
-                            "X = b", "Y = c", "Z = a",
-                            "X = b", "Y = c", "Z = b",
-                            "X = b", "Y = c", "Z = c",
-                            "X = c", "Y = a", "Z = a",
-                            "X = c", "Y = a", "Z = b",
-                            "X = c", "Y = a", "Z = c",
-                            "X = c", "Y = b", "Z = a",
-                            "X = c", "Y = b", "Z = b",
-                            "X = c", "Y = b", "Z = c",
-                            "X = c", "Y = c", "Z = a",
-                            "X = c", "Y = c", "Z = b",
-                            "X = c", "Y = c", "Z = c"]);
+                           [["X = a", "Y = a", "Z = a"],
+                            ["X = a", "Y = a", "Z = b"],
+                            ["X = a", "Y = a", "Z = c"],
+                            ["X = a", "Y = b", "Z = a"],
+                            ["X = a", "Y = b", "Z = b"],
+                            ["X = a", "Y = b", "Z = c"],
+                            ["X = a", "Y = c", "Z = a"],
+                            ["X = a", "Y = c", "Z = b"],
+                            ["X = a", "Y = c", "Z = c"],
+                            ["X = b", "Y = a", "Z = a"],
+                            ["X = b", "Y = a", "Z = b"],
+                            ["X = b", "Y = a", "Z = c"],
+                            ["X = b", "Y = b", "Z = a"],
+                            ["X = b", "Y = b", "Z = b"],
+                            ["X = b", "Y = b", "Z = c"],
+                            ["X = b", "Y = c", "Z = a"],
+                            ["X = b", "Y = c", "Z = b"],
+                            ["X = b", "Y = c", "Z = c"],
+                            ["X = c", "Y = a", "Z = a"],
+                            ["X = c", "Y = a", "Z = b"],
+                            ["X = c", "Y = a", "Z = c"],
+                            ["X = c", "Y = b", "Z = a"],
+                            ["X = c", "Y = b", "Z = b"],
+                            ["X = c", "Y = b", "Z = c"],
+                            ["X = c", "Y = c", "Z = a"],
+                            ["X = c", "Y = c", "Z = b"],
+                            ["X = c", "Y = c", "Z = c"]]);
 
     assert_prolog_success!(&mut wam, "?- maplist(f, [a,Y,Z]).",
-                           ["Z = a", "Y = a",
-                            "Z = a", "Y = b",
-                            "Z = a", "Y = c",
-                            "Z = b", "Y = a",
-                            "Z = b", "Y = b",
-                            "Z = b", "Y = c",
-                            "Z = c", "Y = a",
-                            "Z = c", "Y = b",
-                            "Z = c", "Y = c"]);
+                           [["Y = a", "Z = a"],
+                            ["Y = a", "Z = b"],
+                            ["Y = a", "Z = c"],
+                            ["Y = b", "Z = a"],
+                            ["Y = b", "Z = b"],
+                            ["Y = b", "Z = c"],
+                            ["Y = c", "Z = a"],
+                            ["Y = c", "Z = b"],
+                            ["Y = c", "Z = c"]]);
 
     assert_prolog_success!(&mut wam, "?- maplist(f, [X,a,b]).",
-                           ["X = a",
-                            "X = b",
-                            "X = c"]);
-    assert_eq!(submit(&mut wam, "?- maplist(f, [c,a,b])."), true);
-    assert_eq!(submit(&mut wam, "?- maplist(f, [d,e,f])."), false);
-    assert_eq!(submit(&mut wam, "?- maplist(f, [])."), true);
-    assert_eq!(submit(&mut wam, "?- maplist(f(X), [a,b,c])."), false);
+                           [["X = a"],
+                            ["X = b"],
+                            ["X = c"]]);
+    assert_prolog_success!(&mut wam, "?- maplist(f, [c,a,b]).");
+    assert_prolog_failure!(&mut wam, "?- maplist(f, [d,e,f]).");
+    assert_prolog_success!(&mut wam, "?- maplist(f, []).");
+    assert_prolog_failure!(&mut wam, "?- maplist(f(X), [a,b,c]).");
 
     submit(&mut wam, "f(X) :- call(X), call(X).");
     submit(&mut wam, "p(x). p(y).");
 
-    assert_eq!(submit(&mut wam, "?- f(p)."), false);
-    assert_prolog_success!(&mut wam, "?- f(p(X)).", ["X = x",
-                                                     "X = y"]);
-    assert_eq!(submit(&mut wam, "?- f(p(x))."), true);
-    assert_eq!(submit(&mut wam, "?- f(p(w))."), false);
-    assert_eq!(submit(&mut wam, "?- f(p(X, Y))."), false);
+    assert_prolog_failure!(&mut wam, "?- f(p).");
+    assert_prolog_success!(&mut wam, "?- f(p(X)).", [["X = x"],
+                                                     ["X = y"]]);
+    assert_prolog_success!(&mut wam, "?- f(p(x)).");
+    assert_prolog_failure!(&mut wam, "?- f(p(w)).");
+    assert_prolog_failure!(&mut wam, "?- f(p(X, Y)).");
 
     submit(&mut wam, "f(P) :- call(P, X), call(P, Y).");
 
-    assert_eq!(submit(&mut wam, "?- f(p)."), true);
-    assert_eq!(submit(&mut wam, "?- f(non_existent)."), false);
+    assert_prolog_success!(&mut wam, "?- f(p).");
+    assert_prolog_failure!(&mut wam, "?- f(non_existent).");
 
     submit(&mut wam, "f(P, X, Y) :- call(P, X), call(P, Y).");
 
-    assert_prolog_success!(&mut wam, "?- f(p, X, Y).", ["X = x", "Y = x",
-                                                        "X = y", "Y = x",
-                                                        "X = x", "Y = y",
-                                                        "X = y", "Y = y"]);
-    assert_prolog_success!(&mut wam, "?- f(p, x, Y).", ["Y = x",
-                                                        "Y = y"]);
-    assert_prolog_success!(&mut wam, "?- f(p, X, y).", ["X = x",
-                                                        "X = y"]);
-    assert_eq!(submit(&mut wam, "?- f(p, x, y)."), true);
-    assert_eq!(submit(&mut wam, "?- f(p, X, z)."), false);
-    assert_eq!(submit(&mut wam, "?- f(p, z, Y)."), false);
-
-    assert_prolog_success!(&mut wam, "?- call(p, X).", ["X = x",
-                                                        "X = y"]);
-    assert_eq!(submit(&mut wam, "?- call(p, x)."), true);
-    assert_eq!(submit(&mut wam, "?- call(p, y)."), true);
-    assert_eq!(submit(&mut wam, "?- call(p, z)."), false);
+    assert_prolog_success!(&mut wam, "?- f(p, X, Y).", [["Y = x", "X = x"],
+                                                        ["Y = y", "X = x"],
+                                                        ["Y = x", "X = y"],
+                                                        ["Y = y", "X = y"]]);
+    assert_prolog_success!(&mut wam, "?- f(p, x, Y).", [["Y = x"],
+                                                        ["Y = y"]]);
+    assert_prolog_success!(&mut wam, "?- f(p, X, y).", [["X = x"],
+                                                        ["X = y"]]);    
+    assert_prolog_success!(&mut wam, "?- f(p, x, y).");
+    assert_prolog_failure!(&mut wam, "?- f(p, X, z).");
+    assert_prolog_failure!(&mut wam, "?- f(p, z, Y).");
+
+    assert_prolog_success!(&mut wam, "?- call(p, X).", [["X = x"],
+                                                        ["X = y"]]);
+    assert_prolog_success!(&mut wam, "?- call(p, x).");
+    assert_prolog_success!(&mut wam, "?- call(p, y).");
+    assert_prolog_failure!(&mut wam, "?- call(p, z).");
 
     submit(&mut wam, "r(f(X)) :- p(X). r(g(Y)) :- p(Y).");
 
     assert_prolog_success!(&mut wam, "?- f(r, X, Y).",
-                           ["X = f(x)", "Y = f(x)",
-                            "X = f(x)", "Y = f(y)",
-                            "X = f(x)", "Y = g(x)",
-                            "X = f(x)", "Y = g(y)",
-                            "X = f(y)", "Y = f(x)",
-                            "X = f(y)", "Y = f(y)",
-                            "X = f(y)", "Y = g(x)",
-                            "X = f(y)", "Y = g(y)",
-                            "X = g(x)", "Y = f(x)",
-                            "X = g(x)", "Y = f(y)",
-                            "X = g(x)", "Y = g(x)",
-                            "X = g(x)", "Y = g(y)",
-                            "X = g(y)", "Y = f(x)",
-                            "X = g(y)", "Y = f(y)",
-                            "X = g(y)", "Y = g(x)",
-                            "X = g(y)", "Y = g(y)"]);
+                           [["X = f(x)", "Y = f(x)"],
+                            ["X = f(x)", "Y = f(y)"],
+                            ["X = f(x)", "Y = g(x)"],
+                            ["X = f(x)", "Y = g(y)"],
+                            ["X = f(y)", "Y = f(x)"],
+                            ["X = f(y)", "Y = f(y)"],
+                            ["X = f(y)", "Y = g(x)"],
+                            ["X = f(y)", "Y = g(y)"],
+                            ["X = g(x)", "Y = f(x)"],
+                            ["X = g(x)", "Y = f(y)"],
+                            ["X = g(x)", "Y = g(x)"],
+                            ["X = g(x)", "Y = g(y)"],
+                            ["X = g(y)", "Y = f(x)"],
+                            ["X = g(y)", "Y = f(y)"],
+                            ["X = g(y)", "Y = g(x)"],
+                            ["X = g(y)", "Y = g(y)"]]);
     assert_prolog_success!(&mut wam, "?- f(r, X, X).",
-                           ["X = f(x)",
-                            "X = f(y)",
-                            "X = g(x)",
-                            "X = g(y)"]);
+                           [["X = f(x)"],
+                            ["X = f(y)"],
+                            ["X = g(x)"],
+                            ["X = g(y)"]]);
     assert_prolog_success!(&mut wam, "?- f(r, f(X), g(Y)).",
-                           ["X = x", "Y = x",
-                            "X = x", "Y = y",
-                            "X = y", "Y = x",
-                            "X = y", "Y = y"]);
-    assert_eq!(submit(&mut wam, "?- f(r, j(X), h(Y))."), false);
+                           [["X = x", "Y = x"],
+                            ["X = x", "Y = y"],
+                            ["X = y", "Y = x"],
+                            ["X = y", "Y = y"]]);
+    assert_prolog_failure!(&mut wam, "?- f(r, j(X), h(Y)).");
 
     submit(&mut wam, "p(one, one). p(one, two). p(two, two).");
 
     assert_prolog_success!(&mut wam, "?- f(p(one), X, Y).",
-                           ["X = one", "Y = one",
-                            "X = one", "Y = two",
-                            "X = two", "Y = two",
-                            "X = two", "Y = one"]);
+                           [["X = one", "Y = one"],
+                            ["X = one", "Y = two"],
+                            ["X = two", "Y = one"],
+                            ["X = two", "Y = two"]]);
     assert_prolog_success!(&mut wam, "?- f(p(one), X, X).",
-                           ["X = one",
-                            "X = two"]);
+                           [["X = one"],
+                            ["X = two"]]);
     assert_prolog_success!(&mut wam, "?- f(p(one), one, Y).",
-                           ["Y = one",
-                            "Y = two"]);
-    assert_eq!(submit(&mut wam, "?- f(p(one), one, two)."), true);
-    assert_eq!(submit(&mut wam, "?- f(p(one), one, three)."), false);
-
-    assert_eq!(submit(&mut wam, "?- f(p(two), one, two)."), false);
-    assert_eq!(submit(&mut wam, "?- f(p(two), two, one)."), false);
-    assert_eq!(submit(&mut wam, "?- f(p(two), two, two)."), true);
-    assert_eq!(submit(&mut wam, "?- f(p(two), two, three)."), false);
-
-    assert_eq!(submit(&mut wam, "?- f(p(three), X, Y)."), false);
-    assert_eq!(submit(&mut wam, "?- f(p(three), X, X)."), false);
-    assert_eq!(submit(&mut wam, "?- f(p(three), one, Y)."), false);
-    assert_eq!(submit(&mut wam, "?- f(p(three), one, two)."), false);
-    assert_eq!(submit(&mut wam, "?- f(p(three), one, three)."), false);
+                           [["Y = one"],
+                            ["Y = two"]]);
+    assert_prolog_success!(&mut wam, "?- f(p(one), one, two).");
+    assert_prolog_failure!(&mut wam, "?- f(p(one), one, three).");
+
+    assert_prolog_failure!(&mut wam, "?- f(p(two), one, two).");
+    assert_prolog_failure!(&mut wam, "?- f(p(two), two, one).");
+    assert_prolog_success!(&mut wam, "?- f(p(two), two, two).");
+    assert_prolog_failure!(&mut wam, "?- f(p(two), two, three).");
+
+    assert_prolog_failure!(&mut wam, "?- f(p(three), X, Y).");
+    assert_prolog_failure!(&mut wam, "?- f(p(three), X, X).");
+    assert_prolog_failure!(&mut wam, "?- f(p(three), one, Y).");
+    assert_prolog_failure!(&mut wam, "?- f(p(three), one, two).");
+    assert_prolog_failure!(&mut wam, "?- f(p(three), one, three).");
 
     submit(&mut wam, "f(P, X) :- call(P, X).");
 
-    assert_eq!(submit(&mut wam, "?- f(p(one), one)."), true);
-    assert_eq!(submit(&mut wam, "?- f(p(two), two)."), true);
-    assert_eq!(submit(&mut wam, "?- f(p(two), one)."), false);
-    assert_eq!(submit(&mut wam, "?- f(p(three), one)."), false);
-    assert_eq!(submit(&mut wam, "?- f(p(one), three)."), false);
-    assert_eq!(submit(&mut wam, "?- f(p(two), three)."), false);
+    assert_prolog_success!(&mut wam, "?- f(p(one), one).");
+    assert_prolog_success!(&mut wam, "?- f(p(two), two).");
+    assert_prolog_failure!(&mut wam, "?- f(p(two), one).");
+    assert_prolog_failure!(&mut wam, "?- f(p(three), one).");
+    assert_prolog_failure!(&mut wam, "?- f(p(one), three).");
+    assert_prolog_failure!(&mut wam, "?- f(p(two), three).");
 
     submit(&mut wam, "p(f(g(X)), compound, [lists,are,good]).");
 
     assert_prolog_success!(&mut wam, "?- call(p(f(g(X))), Y, Z).",
-                           ["Y = compound", "Z = [lists, are, good]", "X = _3"]);
+                           [["Y = compound", "Z = [lists, are, good]", "X = _3"]]);
 
     submit(&mut wam, "david_lynch(coffee).
                       david_lynch(pie).
@@ -839,81 +842,83 @@ fn test_queries_on_call_n()
                       kyle(flintstones).");
 
     assert_prolog_success!(&mut wam, "?- call(david_lynch, X).",
-                           ["X = coffee",
-                            "X = pie",
-                            "X = kyle(dune)",
-                            "X = kyle(blue_velvet)",
-                            "X = kyle(showgirls)",
-                            "X = kyle(flintstones)"]);
+                           [["X = coffee"],
+                            ["X = pie"],
+                            ["X = kyle(dune)"],
+                            ["X = kyle(blue_velvet)"],
+                            ["X = kyle(showgirls)"],
+                            ["X = kyle(flintstones)"]]);
     assert_prolog_success!(&mut wam, "?- call(david_lynch, kyle(Film)).",
-                           ["Film = dune",
-                            "Film = blue_velvet",
-                            "Film = showgirls",
-                            "Film = flintstones"]);
-    assert_eq!(submit(&mut wam, "?- call(david_lynch, kyle(Film), _)."), false);
+                           [["Film = dune"],
+                            ["Film = blue_velvet"],
+                            ["Film = showgirls"],
+                            ["Film = flintstones"]]);
+    assert_prolog_failure!(&mut wam, "?- call(david_lynch, kyle(Film), _).");
 
     submit(&mut wam, "call_mult(P, X) :- call(call(P), X).");
 
     assert_prolog_success!(&mut wam, "?- call_mult(p(X), Y).",
-                           ["Y = one", "X = one",
-                            "Y = two", "X = one",
-                            "Y = two", "X = two"]);
+                           [["Y = one", "X = one"],
+                            ["Y = two", "X = one"],
+                            ["Y = two", "X = two"]]);
     assert_prolog_success!(&mut wam, "?- call_mult(p(X), X).",
-                           ["X = one",
-                            "X = two"]);
+                           [["X = one"],
+                            ["X = two"]]);
     assert_prolog_success!(&mut wam, "?- call_mult(p(one), X).",
-                           ["X = one",
-                            "X = two"]);
-    assert_prolog_success!(&mut wam, "?- call_mult(p(X), one).", ["X = one"]);
-    assert_eq!(submit(&mut wam, "?- call_mult(p(two), one)."), false);
-    assert_eq!(submit(&mut wam, "?- call_mult(p(two), two)."), true);
+                           [["X = one"],
+                            ["X = two"]]);
+    assert_prolog_success!(&mut wam, "?- call_mult(p(X), one).",
+                           [["X = one"]]);
+    
+    assert_prolog_failure!(&mut wam, "?- call_mult(p(two), one).");
+    assert_prolog_success!(&mut wam, "?- call_mult(p(two), two).");
 
     assert_prolog_success!(&mut wam, "?- call(call(p(one)), X), call(call(p(two)), two).",
-                           ["X = one",
-                            "X = two"]);
+                           [["X = one"],
+                            ["X = two"]]);
     assert_prolog_success!(&mut wam, "?- call(call(p(one, X))), call(call(p(two, two))).",
-                           ["X = one",
-                            "X = two"]);
-    assert_eq!(submit(&mut wam, "?- call(call(p(one)), X), call(call(p(two)), one)."), false);
+                           [["X = one"],
+                            ["X = two"]]);
+    assert_prolog_failure!(&mut wam, "?- call(call(p(one)), X), call(call(p(two)), one).");
     assert_prolog_success!(&mut wam, "?- call(call(p(X)), X), call(call(p(Y)), Y).",
-                           ["X = one", "Y = one",
-                            "X = one", "Y = two",
-                            "X = two", "Y = two",
-                            "X = two", "Y = one"]);
+                           [["X = one", "Y = one"],
+                            ["X = one", "Y = two"],
+                            ["X = two", "Y = one"],
+                            ["X = two", "Y = two"]]);
     assert_prolog_success!(&mut wam, "?- call(call(p(X)), Y), call(call(p(Y)), X).",
-                           ["X = one", "Y = one",
-                            "X = two", "Y = two"]);
+                           [["X = one", "Y = one"],
+                            ["X = two", "Y = two"]]);
     assert_prolog_success!(&mut wam, "?- call(call(p), X, Y), call(call(call(p)), X, Y).",
-                           ["X = one", "Y = one",
-                            "Y = two", "X = one",
-                            "Y = two", "X = two"]);
+                           [["X = one", "Y = one"],
+                            ["Y = two", "X = one"],
+                            ["Y = two", "X = two"]]);
     assert_prolog_success!(&mut wam, "?- call(call(p), X, Y), call(call(call(p(X))), Y).",
-                           ["X = one", "Y = one",
-                            "Y = two", "X = one",
-                            "Y = two", "X = two"]);
-    assert_eq!(submit(&mut wam, "?- call(call(p), X, Y), call(call(call(p(X))), X, Y)."), false);
+                           [["X = one", "Y = one"],
+                            ["Y = two", "X = one"],
+                            ["Y = two", "X = two"]]);
+    assert_prolog_failure!(&mut wam, "?- call(call(p), X, Y), call(call(call(p(X))), X, Y).");
     assert_prolog_success!(&mut wam, "?- call(call(p), X, Y), call(call(call(p(X))), X).",
-                           ["X = one", "Y = one",
-                            "Y = two", "X = one",
-                            "Y = two", "X = two"]);
+                           [["X = one", "Y = one"],
+                            ["Y = two", "X = one"],
+                            ["Y = two", "X = two"]]);
 
     submit(&mut wam, "f(call(f, undefined)). f(undefined).");
     submit(&mut wam, "call_var(P) :- P.");
 
     assert_prolog_success!(&mut wam, "?- f(X), call_var(X).",
-                           ["X = call(f, undefined)"]);
+                           [["X = call(f, undefined)"]]);
     assert_prolog_success!(&mut wam, "?- f(call(f, Q)), call_var(call(f, Q)).",
-                           ["Q = undefined"]);
-    assert_eq!(submit(&mut wam, "?- call_var(call(undefined, Q))."), false);
-
-    assert_eq!(submit(&mut wam, "?- call(call)."), false);
-    assert_eq!(submit(&mut wam, "?- call(call(call))."), false);
-    assert_eq!(submit(&mut wam, "?- call(call(call(call)))."), false);
-    assert_eq!(submit(&mut wam, "?- call(call(call(call(call))))."), false);
-    assert_eq!(submit(&mut wam, "?- call(call(call(call(call(call)))))."), false);
+                           [["Q = undefined"]]);
+    assert_prolog_failure!(&mut wam, "?- call_var(call(undefined, Q)).");
+
+    assert_prolog_failure!(&mut wam, "?- call(call).");
+    assert_prolog_failure!(&mut wam, "?- call(call(call)).");
+    assert_prolog_failure!(&mut wam, "?- call(call(call(call))).");
+    assert_prolog_failure!(&mut wam, "?- call(call(call(call(call)))).");
+    assert_prolog_failure!(&mut wam, "?- call(call(call(call(call(call))))).");
     assert_prolog_success!(&mut wam, "?- call(call(call(call(call(call(p(X))))))).",
-                           ["X = x",
-                            "X = y"]);
+                           [["X = x"],
+                            ["X = y"]]);
 }
 
 #[test]
@@ -925,32 +930,32 @@ fn test_queries_on_exceptions()
     submit(&mut wam, "handle(stuff).");
 
     assert_prolog_success!(&mut wam, "?- catch(f(X), E, handle(E)).",
-                           ["E = _2", "X = a",
-                            "E = stuff", "X = _1"]);
+                           [["E = _2", "X = a"],
+                            ["E = stuff", "X = _1"]]);
 
     submit(&mut wam, "f(a). f(X) :- g(X).");
     submit(&mut wam, "g(x). g(y). g(z).");
     submit(&mut wam, "handle(x). handle(y).");
 
     assert_prolog_success!(&mut wam, "?- catch(f(X), X, handle(X)).",
-                           ["X = a",
-                            "X = x",
-                            "X = y",
-                            "X = z"]);
+                           [["X = a"],
+                            ["X = x"],
+                            ["X = y"],
+                            ["X = z"]]);
     assert_prolog_success!(&mut wam, "?- catch(f(a), _, handle(X)).",
-                           ["X = _4"]);
+                           [["X = _4"]]);
     assert_prolog_failure!(&mut wam, "?- catch(f(b), _, handle(X)).");
 
     submit(&mut wam, "g(x). g(X) :- throw(x).");
 
     assert_prolog_success!(&mut wam, "?- catch(f(X), x, handle(X)).",
-                           ["X = a",
-                            "X = x",
-                            "X = x",
-                            "X = y"]);
+                           [["X = a"],
+                            ["X = x"],
+                            ["X = x"],
+                            ["X = y"]]);
     assert_prolog_success!(&mut wam, "?- catch(f(X), x, handle(z)).",
-                           ["X = a",
-                            "X = x"]);
+                           [["X = a"],
+                            ["X = x"]]);
     assert_prolog_success!(&mut wam, "?- catch(f(z), x, handle(x)).");
     assert_prolog_success!(&mut wam, "?- catch(f(z), x, handle(y)).");
     assert_prolog_failure!(&mut wam, "?- catch(f(z), x, handle(z)).");
@@ -960,11 +965,11 @@ fn test_queries_on_exceptions()
 
     // the first 3 cases should deterministically succeed.
     assert_prolog_success!(&mut wam, "?- catch(f(X), E, handle(E)).",
-                           ["X = _1", "E = stuff"]);
+                           [["X = _1", "E = stuff"]]);
     assert_prolog_success!(&mut wam, "?- catch(f(X), E, handle(stuff)).",
-                           ["X = _1", "E = stuff"]);
+                           [["X = _1", "E = stuff"]]);
     assert_prolog_success!(&mut wam, "?- catch(f(X), E, handle(other_stuff)).",
-                           ["X = _1", "E = stuff"]);
+                           [["X = _1", "E = stuff"]]);
     assert_prolog_failure!(&mut wam, "?- catch(f(X), E, handle(not_stuff)).");
 
     submit(&mut wam, "f(success). f(X) :- catch(g(X), E, handle(E)).");
@@ -972,12 +977,12 @@ fn test_queries_on_exceptions()
     submit(&mut wam, "handle(x). handle(y). handle(z).");
 
     assert_prolog_success!(&mut wam, "?- catch(f(X), E, E).",
-                           ["X = success", "E = _2",
-                            "X = g_success", "E = _2",
-                            "X = g_success_2", "E = _2",
-                            "X = _1", "E = _2",
-                            "X = _1", "E = _2",
-                            "X = _1", "E = _2"]);
+                           [["X = success", "E = _2"],
+                            ["X = g_success", "E = _2"],
+                            ["X = g_success_2", "E = _2"],
+                            ["X = _1", "E = _2"],
+                            ["X = _1", "E = _2"],
+                            ["X = _1", "E = _2"]]);
     assert_prolog_failure!(&mut wam, "?- catch(f(fail), _, _).");
     assert_prolog_success!(&mut wam, "?- catch(f(x), _, _).");
     assert_prolog_success!(&mut wam, "?- catch(f(y), _, _).");
@@ -988,37 +993,37 @@ fn test_queries_on_exceptions()
     submit(&mut wam, "handle(x). handle(y). handle(z). handle(v) :- throw(X).");
 
     assert_prolog_success!(&mut wam, "?- catch(f(X), E, E).",
-                           ["X = success", "E = _2",
-                            "X = g_success", "E = _2",
-                            "X = g_success_2", "E = _2",
-                            "X = x", "E = _2",
-                            "X = y", "E = _2",
-                            "X = z", "E = _2"]);
+                           [["X = success", "E = _2"],
+                            ["X = g_success", "E = _2"],
+                            ["X = g_success_2", "E = _2"],
+                            ["X = x", "E = _2"],
+                            ["X = y", "E = _2"],
+                            ["X = z", "E = _2"]]);
 
     submit(&mut wam, "handle(x). handle(y). handle(z). handle(v) :- throw(handle_top(X)).");
     submit(&mut wam, "handle_top(an_error_1). handle_top(an_error_2).");
 
     assert_prolog_success!(&mut wam, "?- catch(f(X), E, E).",
-                           ["X = success", "E = _2",
-                            "X = g_success", "E = _2",
-                            "X = g_success_2", "E = _2",
-                            "X = x", "E = _2",
-                            "X = y", "E = _2",
-                            "X = z", "E = _2",
-                            "X = _1", "E = handle_top(an_error_1)",
-                            "X = _1", "E = handle_top(an_error_2)"]);
+                           [["X = success", "E = _2"],
+                            ["X = g_success", "E = _2"],
+                            ["X = g_success_2", "E = _2"],
+                            ["X = x", "E = _2"],
+                            ["X = y", "E = _2"],
+                            ["X = z", "E = _2"],
+                            ["X = _1", "E = handle_top(an_error_1)"],
+                            ["X = _1", "E = handle_top(an_error_2)"]]);
 
     submit(&mut wam, "handle(x). handle(y). handle(z). handle(v) :- throw(X).");
 
     assert_prolog_success!(&mut wam, "?- catch(f(X), E, handle_top(E)).",
-                           ["X = success", "E = _2",
-                            "X = g_success", "E = _2",
-                            "X = g_success_2", "E = _2",
-                            "X = x", "E = _2",
-                            "X = y", "E = _2",
-                            "X = z", "E = _2",
-                            "E = an_error_1", "X = _1",
-                            "E = an_error_2", "X = _1"]);
+                           [["X = success", "E = _2"],
+                            ["X = g_success", "E = _2"],
+                            ["X = g_success_2", "E = _2"],
+                            ["X = x", "E = _2"],
+                            ["X = y", "E = _2"],
+                            ["X = z", "E = _2"],
+                            ["E = an_error_1", "X = _1"],
+                            ["E = an_error_2", "X = _1"]]);
 }
 
 #[test]
@@ -1026,16 +1031,16 @@ fn test_queries_on_arithmetic()
 {
     let mut wam = Machine::new();
 
-    assert_prolog_success!(&mut wam, "?- X is 1, X is X.", ["X = 1"]);
+    assert_prolog_success!(&mut wam, "?- X is 1, X is X.", [["X = 1"]]);
     assert_prolog_failure!(&mut wam, "?- X is 1, X is X + 1.");
-    assert_prolog_success!(&mut wam, "?- X is 1, X is X + 0.", ["X = 1"]);
-    assert_prolog_success!(&mut wam, "?- X is 1, X is X * 1.", ["X = 1"]);
+    assert_prolog_success!(&mut wam, "?- X is 1, X is X + 0.", [["X = 1"]]);
+    assert_prolog_success!(&mut wam, "?- X is 1, X is X * 1.", [["X = 1"]]);
     assert_prolog_failure!(&mut wam, "?- X is 1, X is X * 2.");
 
     assert_prolog_failure!(&mut wam, "?- X is 1 + a.");
     assert_prolog_failure!(&mut wam, "?- X is 1 + Y.");
     assert_prolog_success!(&mut wam, "?- Y is 2 + 2 - 2, X is 1 + Y, X = 3.",
-                           ["X = 3", "Y = 2"]);
+                           [["X = 3", "Y = 2"]]);
     assert_prolog_failure!(&mut wam, "?- Y is 2 + 2 - 2, X is 1 + Y, X = 2.");
 
     assert_prolog_success!(&mut wam, "?- 6 is 6.");
@@ -1051,56 +1056,56 @@ fn test_queries_on_arithmetic()
     submit(&mut wam, "f(X) :- X is 5 // 0.");
 
     assert_prolog_success!(&mut wam, "?- catch(f(X), evaluation_error(E), true), E = zero_divisor.",
-                           ["E = zero_divisor", "X = _1"]);
+                           [["E = zero_divisor", "X = _1"]]);
 
     submit(&mut wam, "f(X) :- X is (5 rdiv 1) / 0.");
 
     assert_prolog_success!(&mut wam, "?- catch(f(X), evaluation_error(E), true), E = zero_divisor.",
-                           ["E = zero_divisor", "X = _1"]);
+                           [["E = zero_divisor", "X = _1"]]);
 
     submit(&mut wam, "f(X) :- X is 5.0 / 0.");
 
     assert_prolog_success!(&mut wam, "?- catch(f(X), evaluation_error(E), true), E = zero_divisor.",
-                           ["E = zero_divisor", "X = _1"]);
+                           [["E = zero_divisor", "X = _1"]]);
 
     assert_prolog_success!(&mut wam, "?- X is ((3 + 4) // 2) + 2 - 1 // 1, Y is 2+2, Z is X+Y.",
-                           ["Y = 4", "X = 4", "Z = 8"]);
+                           [["Y = 4", "X = 4", "Z = 8"]]);
 
     assert_prolog_success!(&mut wam, "?- X is ((3 + 4) // 2) + 2 - 1 // 1, Y is 2+2, Z = 8, Y is 4.",
-                           ["Y = 4", "X = 4", "Z = 8"]);
+                           [["Y = 4", "X = 4", "Z = 8"]]);
 
     assert_prolog_success!(&mut wam, "?- X is (3 rdiv 4) / 2, Y is 3 rdiv 8, X = Y.",
-                           ["X = 3/8", "Y = 3/8"]);
+                           [["X = 3/8", "Y = 3/8"]]);
 
-    assert_prolog_success!(&mut wam, "?- X is 10 xor -4, X is -10.", ["X = -10"]);
-    assert_prolog_success!(&mut wam, "?- X is 4 xor -7, X is -3.", ["X = -3"]);
-    assert_prolog_success!(&mut wam, "?- X is 10 xor 5 + 55, X = 70.", ["X = 70"]);
+    assert_prolog_success!(&mut wam, "?- X is 10 xor -4, X is -10.", [["X = -10"]]);
+    assert_prolog_success!(&mut wam, "?- X is 4 xor -7, X is -3.", [["X = -3"]]);
+    assert_prolog_success!(&mut wam, "?- X is 10 xor 5 + 55, X = 70.", [["X = 70"]]);
 
-    assert_prolog_success!(&mut wam, "?- X is 10 rem -3, X = 1.", ["X = 1"]);
-    assert_prolog_success!(&mut wam, "?- X is 10 mod -3, X is -2.", ["X = -2"]);
+    assert_prolog_success!(&mut wam, "?- X is 10 rem -3, X = 1.",   [["X = 1"]]);
+    assert_prolog_success!(&mut wam, "?- X is 10 mod -3, X is -2.", [["X = -2"]]);
 
-    assert_prolog_success!(&mut wam, "?- call(is, X, 3 + 4).", ["X = 7"]);
+    assert_prolog_success!(&mut wam, "?- call(is, X, 3 + 4).", [["X = 7"]]);
 
-    assert_prolog_success!(&mut wam, "?- Y is 3 + 3, call(is, X, Y + 4).", ["Y = 6", "X = 10"]);
-    assert_prolog_success!(&mut wam, "?- call(is, X, 3 + 4.5).", ["X = 7.5"]);
-    assert_prolog_success!(&mut wam, "?- X is 2 rdiv 3, call(is, Y, X*X).", ["X = 2/3", "Y = 4/9"]);
+    assert_prolog_success!(&mut wam, "?- Y is 3 + 3, call(is, X, Y + 4).", [["Y = 6", "X = 10"]]);
+    assert_prolog_success!(&mut wam, "?- call(is, X, 3 + 4.5).", [["X = 7.5"]]);
+    assert_prolog_success!(&mut wam, "?- X is 2 rdiv 3, call(is, Y, X*X).", [["X = 2/3", "Y = 4/9"]]);
 
     assert_prolog_failure!(&mut wam, "?- call(>, 3, 3 + 3).");
     assert_prolog_failure!(&mut wam, "?- X is 3 + 3, call(>, 3, X).");
 
-    assert_prolog_success!(&mut wam, "?- X is 3 + 3, call(<, 3, X).", ["X = 6"]);
-    assert_prolog_success!(&mut wam, "?- X is 3 + 3, X =:= 3 + 3.", ["X = 6"]);
+    assert_prolog_success!(&mut wam, "?- X is 3 + 3, call(<, 3, X).", [["X = 6"]]);
+    assert_prolog_success!(&mut wam, "?- X is 3 + 3, X =:= 3 + 3.", [["X = 6"]]);
 
     assert_prolog_success!(&mut wam, "?- catch(call(is, X, 3 // 0), E, true).",
-                           ["X = _5", "E = evaluation_error(zero_divisor)"]);
+                           [["X = _5", "E = evaluation_error(zero_divisor)"]]);
     
-    assert_prolog_success!(&mut wam, "?- catch(call(is, X, 3 // 3), _, true).", ["X = 1"]);
+    assert_prolog_success!(&mut wam, "?- catch(call(is, X, 3 // 3), _, true).", [["X = 1"]]);
 
     submit(&mut wam, "f(X, Sum) :- ( integer(X) -> Sum is X + X * X + 3 ; 
                                      var(X) -> Sum = 1, X = 1 ).");
 
-    assert_prolog_success!(&mut wam, "?- f(X, Sum).", ["X = 1", "Sum = 1"]);
-    assert_prolog_success!(&mut wam, "?- f(5, Sum).", ["Sum = 33"]);
+    assert_prolog_success!(&mut wam, "?- f(X, Sum).", [["X = 1", "Sum = 1"]]);
+    assert_prolog_success!(&mut wam, "?- f(5, Sum).", [["Sum = 33"]]);
     assert_prolog_success!(&mut wam, "?- f(5, 33).");
     assert_prolog_failure!(&mut wam, "?- f(5, 32).");
 }