Version 1.2.1 imported1.2.1

git-archimport-id: mdk@sv.gnu.org/mdk--devel--1--patch-1

8 files changed, 1309 insertions, 0 deletions

diff --git a/mixlib/testsuite/Makefile.am b/mixlib/testsuite/Makefile.am
new file mode 100644
index 0000000..834f833
--- /dev/null
+++ b/mixlib/testsuite/Makefile.am
@@ -0,0 +1,32 @@
+## Process this file with automake to produce Makefile.in
+
+# Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+#  
+# This file is free software; as a special exception the author gives
+# unlimited permission to copy and/or distribute it, with or without 
+# modifications, as long as this notice is preserved.
+# 
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# $Id: Makefile.am,v 1.2 2001/09/29 01:53:51 jao Exp $
+
+INCLUDES =  -I$(includedir) -I$(top_srcdir) -I$(top_srcdir)/mixlib
+LDADD = $(top_builddir)/mixlib/libmix.a 
+
+check_PROGRAMS = mixtypest mixinstest mixvminstest mixparsertest mixdevtest mixevaltest
+TESTS = $(check_PROGRAMS)
+
+mixtypest_SOURCES = test.h mix_types_t.c
+mixinstest_SOURCES = test.h mix_ins_t.c
+mixvminstest_SOURCES = test.h mix_vm_ins_t.c
+mixparsertest_SOURCES = test.h mix_parser_t.c
+mixdevtest_SOURCES = test.h mix_device_t.c
+mixevaltest_SOURCES = test.h mix_eval_t.c
+
+
+
+
+
+
diff --git a/mixlib/testsuite/mix_device_t.c b/mixlib/testsuite/mix_device_t.c
new file mode 100644
index 0000000..8638d2f
--- /dev/null
+++ b/mixlib/testsuite/mix_device_t.c
@@ -0,0 +1,76 @@
+/* -*-c-*- -------------- mix_device_t.c :
+ * Implementation of the functions declared in mix_device_t.h
+ * ------------------------------------------------------------------
+ * Copyright (C) 2000 Free Software Foundation, Inc.
+ *  
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *  
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *  
+ */
+
+#include <stdlib.h>
+#include <mix_device.h>
+
+/* Define VERBOSE_TEST if you want to get prints of the test */
+/* #define VERBOSE_TEST */
+#include "test.h"
+
+static int S_ = MIX_CHAR_MAX +1;
+
+int 
+main (int argc, char **argv) 
+{
+  mix_device_t *console;
+  size_t s;
+  mix_word_t **block;
+  mix_char_t mchars[S_];
+  gchar chars[S_];
+  int i, j;
+  int bno;
+  
+  
+  INIT_TEST;
+  
+  console = mix_device_new (mix_dev_CONSOLE);
+  s = mix_device_block_size (console);
+  bno = S_/(s*5);
+  if (bno == 0) bno = 1;
+  
+  block = g_new (mix_word_t *, bno);
+  for (i = 0; i < bno; ++i)
+    block[i] = g_new (mix_word_t, s);
+  
+  for (i = 0; i < S_; ++i) {
+    chars[i] = mix_char_to_ascii (i);
+    mchars[i] = mix_ascii_to_char (chars[i]);
+    g_assert (mchars[i] == i);
+  }
+  
+  for (i = 0; i < bno; ++i) {
+    for (j = 0; j < s; ++j) {
+      int n = i*s + 5*j;
+      if (n < S_) 
+	block[i][j] = mix_bytes_to_word (mchars + n, 5);
+      else
+	block[i][j] = 0;
+    }
+  }
+   
+  for (i = 0; i < bno; ++i) {
+    mix_device_write (console, block[i]);
+  }
+  
+  
+  return EXIT_SUCCESS;
+}
diff --git a/mixlib/testsuite/mix_eval_t.c b/mixlib/testsuite/mix_eval_t.c
new file mode 100644
index 0000000..9b62fd6
--- /dev/null
+++ b/mixlib/testsuite/mix_eval_t.c
@@ -0,0 +1,119 @@
+/* -*-c-*- -------------- mix_eval_t.c :
+ * Test of mix_eval_t
+ * ------------------------------------------------------------------
+ *  Last change: Time-stamp: "01/02/20 00:26:15 jose"
+ * ------------------------------------------------------------------
+ * Copyright (C) 2000 Free Software Foundation, Inc.
+ *  
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *  
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *  
+ */
+
+
+#include <stdlib.h>
+#include <mix_eval.h>
+/* Define VERBOSE_TEST if you want to get prints of the test */
+/* #define VERBOSE_TEST */
+#include "test.h"
+
+typedef struct test_case_t
+{
+  const gchar *expr;
+  gint value;
+  mix_eval_result_t result;
+} test_case_t;
+
+#define ok_case(exp,val) {exp, val, MIX_EVAL_OK}
+#define err_case(exp,err) {exp, 0, err}
+
+typedef struct sym_val_t
+{
+  const gchar *sym;
+  mix_word_t value;
+} sym_val_t;
+
+#define new_symbol(sym,val) {sym, mix_word_new (val)}
+
+int 
+main(int argc, char **argv)
+{
+  size_t k;
+  mix_eval_t *eval;
+  mix_short_t loc = mix_short_new (30);
+  sym_val_t symbols[] = {
+    new_symbol ("s0", 43),
+    new_symbol ("s1", -1234),
+    new_symbol ("s2", 0),
+    new_symbol ("s3", -20),
+    new_symbol (NULL, 0)
+  };
+  
+  test_case_t cases[] = {
+    ok_case ("2343", 2343),
+    ok_case ("-890", -890),
+    ok_case ("15+1015", 1030),
+    ok_case ("1-481", -480),
+    ok_case ("2300/10", 230),
+    ok_case ("24*3", 72),
+    ok_case ("2:5", 21),
+    ok_case ("1//3", 357913941),
+    ok_case ("12+*", 42),
+    ok_case ("***", 900),
+    ok_case ("1:3*2-4", 18),
+    ok_case ("-1+5*20/6", 13),
+    ok_case ("-1000(0,2),1", 1),
+    ok_case ("s0-s2*3", 129),
+    ok_case ("s3**", -600),
+    ok_case ("s3(3:5)", 20),
+    ok_case ("-s1", 1234),
+    ok_case ("s1/10+s0", 166),
+    err_case ("foo", MIX_EVAL_UNDEF_SYM),
+    err_case ("11--2", MIX_EVAL_SYNTAX),
+    err_case ("s2*foo*3", MIX_EVAL_UNDEF_SYM),
+    err_case ("12/32),1", MIX_EVAL_MIS_PAREN),
+    err_case ("2000(88)", MIX_EVAL_INV_FSPEC),
+    ok_case (NULL, 0)
+  };
+  
+  INIT_TEST;
+  g_print ("Entering mix_eval test...");
+  eval = mix_eval_new ();
+
+  for (k = 0; symbols[k].sym; ++k)
+    mix_eval_set_symbol (eval, symbols[k].sym, symbols[k].value);
+  
+  for (k = 0; cases[k].expr; ++k) {
+    mix_eval_result_t r = cases[k].result, s;
+    g_print ("Evaluating \"%s\" = %d ...",
+	       cases[k].expr, cases[k].value);
+    
+    s = mix_eval_expression_with_loc (eval, cases[k].expr, loc);
+    g_assert (s == r);
+    if ( s == MIX_EVAL_OK ) {
+      mix_word_print (mix_eval_value (eval), "... ");
+      g_print ("\n");
+      g_assert (mix_eval_value (eval) == mix_word_new(cases[k].value));
+    } else {
+      g_print ("\n------->%s, at pos %d\n",
+	       mix_eval_last_error_string (eval),
+	       mix_eval_last_error_pos (eval));
+    }
+  }
+  mix_eval_delete (eval);
+
+  return EXIT_SUCCESS;
+}
+
+
diff --git a/mixlib/testsuite/mix_ins_t.c b/mixlib/testsuite/mix_ins_t.c
new file mode 100644
index 0000000..8dcc619
--- /dev/null
+++ b/mixlib/testsuite/mix_ins_t.c
@@ -0,0 +1,79 @@
+/*----------------------- mix_ins_t.c -------------------------------
+ * Tests for mix_ins.h
+ *-------------------------------------------------------------------
+** Copyright (C) 1999  Free Software Foundation, Inc.
+**  
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2 of the License, or
+** (at your option) any later version.
+**  
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**  
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**  
+*/
+
+#include <stdlib.h>
+#include <mix_ins.h>
+
+/* Define VERBOSE_TEST if you want to get prints of the test */
+/* #define VERBOSE_TEST */
+#include "test.h"
+
+
+int
+main(int argc, const char**argv)
+{
+  mix_word_t words[6];
+  mix_ins_t ins[3];
+  guint k;
+  
+  INIT_TEST;
+  
+  g_print("\n...ok.\nTesting mix_ins_id_t properties...\n");
+  for ( k = 0; k < mix_INVALID_INS; ++k )
+    {
+      mix_opcode_t c = mix_get_opcode_from_id(k);
+      mix_fspec_t f = mix_get_fspec_from_id(k);
+      mix_ins_id_t id = mix_get_ins_id(c,f);
+      
+      g_print("%02d:%s (%1d:%1d),  ",
+	      c, mix_get_string_from_id(k), 
+	      mix_fspec_left(f), mix_fspec_right(f));
+      if ( (k+1)%3 == 0 ) g_print("\n");
+
+      g_assert(id==k);
+    }
+  
+  g_print("\n...ok.\nTesting mix_ins_t properties...\n");
+  for ( k = 1; k < mix_INVALID_INS; ++k )
+    {
+      g_print("%d ",k);
+      mix_ins_fill_from_id(ins[0], k);
+      g_assert(mix_ins_id_from_ins(ins[0]) == k);
+      ins[0].address = 0x0123;
+      ins[0].index = mix_I2;
+      words[2] = mix_ins_to_word(ins);
+      g_assert(ins[0].address == mix_get_ins_address(words[2]));
+      g_assert(ins[0].index == mix_get_ins_index(words[2]));
+      g_assert(ins[0].fspec == mix_get_ins_fspec(words[2]));
+      g_assert(ins[0].opcode == mix_get_ins_opcode(words[2]));
+      g_assert(mix_word_to_ins(words[2],ins+1) == k);
+      g_assert(ins[0].address == ins[1].address);
+      g_assert(ins[0].index == ins[1].index);
+      g_assert(ins[0].fspec == ins[1].fspec);
+      g_assert(ins[0].opcode == ins[1].opcode);
+    }
+  
+  g_print("\n...ok.\n");
+  
+  
+  
+  return EXIT_SUCCESS;
+}
diff --git a/mixlib/testsuite/mix_parser_t.c b/mixlib/testsuite/mix_parser_t.c
new file mode 100644
index 0000000..215fc70
--- /dev/null
+++ b/mixlib/testsuite/mix_parser_t.c
@@ -0,0 +1,85 @@
+/* -*-c-*- -------------- mix_parser_t.c :
+ * Test of mix_parser_t
+ * ------------------------------------------------------------------
+ * Copyright (C) 2000 Free Software Foundation, Inc.
+ *  
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *  
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *  
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *  
+ */
+
+
+
+#include <stdlib.h>
+#include <mix_parser.h>
+
+/* Define VERBOSE_TEST if you want to get prints of the test */
+/* #define VERBOSE_TEST */
+#include "test.h"
+
+static const gchar * const FILES_[] = { "test1" , "taocp145"
+};
+
+static const size_t FILE_NO_ = sizeof(FILES_)/sizeof(FILES_[0]);
+
+static void
+test_code_(const gchar *name)
+{
+  mix_parser_t *parser = mix_parser_new(name);
+  mix_parser_err_t err;
+  mix_code_file_t *code;
+  mix_ins_desc_t ins;
+  
+  g_assert(parser);
+  err =  mix_parser_compile(parser);
+  if ( err != MIX_PERR_OK ) {
+    g_print(mix_parser_err_string(err));
+    g_print("\n");
+  }   
+  g_assert(err == MIX_PERR_OK);
+  err = mix_parser_write_code(parser, name, FALSE);
+  code = mix_code_file_new_read(name);
+  g_assert(code);
+  g_message("%s: Version: %d.%d", name, mix_code_file_major_version(code),
+	    mix_code_file_minor_version(code));
+  mix_short_print(mix_code_file_get_start_addr(code), "Start address: ");
+  g_print("\n");
+  while ( mix_code_file_get_ins(code, &ins) ) {
+    mix_ins_t i;
+    mix_word_to_ins_uncheck(ins.ins, i);
+    mix_short_print(ins.address, "addr: ");
+    g_print(" : ");
+    mix_ins_print(&i);
+    g_print("\n");
+  }
+  
+  mix_parser_delete(parser);
+  mix_code_file_delete(code);
+}
+
+int 
+main(int argc, char **argv)
+{
+  size_t k;
+  
+  INIT_TEST;
+
+  for (k = 0; k < FILE_NO_; ++k)
+    // test_code_(FILES_[k]);
+    ;
+    
+
+  return EXIT_SUCCESS;
+}
+
diff --git a/mixlib/testsuite/mix_types_t.c b/mixlib/testsuite/mix_types_t.c
new file mode 100644
index 0000000..ababead
--- /dev/null
+++ b/mixlib/testsuite/mix_types_t.c
@@ -0,0 +1,369 @@
+/*----------------------- mix_types_t.c -----------------------------
+ * Tests for mix_types.h
+ * ------------------------------------------------------------------
+*
+** Copyright (C) 1999, 2004 Free Software Foundation, Inc.
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**
+*/
+
+
+#include <stdlib.h>
+#include <mix_types.h>
+
+/* Define VERBOSE_TEST if you want to get prints of the test */
+/* #define VERBOSE_TEST */
+#include "test.h"
+
+/* compare two words */
+static gboolean
+word_compare_(mix_word_t w1, mix_word_t w2)
+{
+  if ( mix_word_magnitude(w1) == 0 )
+    return ( mix_word_magnitude(w2) == 0 );
+  else
+    return ( w1 == w2 );
+}
+
+
+/* create a word from an array of bytes and check the result */
+static void
+test_word_from_bytes_(mix_word_t *word,
+		     mix_byte_t *bytes,
+		     unsigned byteno,
+		     const char *message)
+{
+  mix_byte_t r;
+  unsigned int k;
+
+  *word = mix_bytes_to_word(bytes,byteno);
+  mix_word_print(*word,message);
+  g_print("\n");
+  for ( k = 5-byteno; k < 5; ++k ) {
+    PRINT_BYTE(r = mix_word_get_byte(*word,k+1));
+    g_print(" (k = %d)\n",k);
+    g_assert( r  == bytes[k-5+byteno] );
+  }
+}
+
+
+/* test field access */
+static void
+test_field_access_(mix_fspec_t l, mix_fspec_t r,
+		   mix_word_t from, mix_word_t to)
+{
+  mix_fspec_t f  = mix_fspec_new(l,r);
+  mix_word_t result;
+
+  PRINT_BYTE(l); g_print(", ");
+  PRINT_BYTE(r); g_print(", ");
+  PRINT_BYTE(f); g_print("\n  ");
+  mix_word_print(from, "from: ");
+  mix_word_print(to, " to: ");
+  g_assert( mix_fspec_left(f) == l );
+  g_assert( mix_fspec_right(f) == r );
+  result = mix_word_set_field(f,from,to);
+  mix_word_print(result,"\n\tresult: ");
+  g_assert( mix_word_get_field(f,from) == mix_word_get_field(f,result) );
+  g_print("\n");
+}
+
+/* test word addition */
+static void
+test_word_add_(mix_word_t w1, mix_word_t w2)
+{
+  mix_word_t r;
+
+  r = mix_word_add(w1,w2);
+  mix_word_print(w1,"\n");
+  mix_word_print(w2,NULL);
+  mix_word_print(r," = ");
+  g_assert( word_compare_(mix_word_sub(r,w1), w2) );
+  g_assert( word_compare_(mix_word_sub(r,w2), w1) );
+  /* while asserting the following, take into account that 0 != -0
+     for mix words, although they are logically equivalent
+  */
+  g_assert( word_compare_(mix_word_sub(w1,r), mix_word_negative(w2)) );
+  g_assert( word_compare_(mix_word_sub(w2,r), mix_word_negative(w1)) );
+  g_assert( word_compare_(mix_word_add(w2,w1), r) );
+}
+
+/* test word multiplication */
+static void
+test_word_mul_(mix_word_t w1, mix_word_t w2)
+{
+  mix_word_t h, l, q, r = 0;
+  mix_word_mul(w1,w2,&h,&l);
+  mix_word_print(w1,"\n");
+  mix_word_print(w2,"*");
+  mix_word_print(h,"\n  =");
+  mix_word_print(l,NULL);
+  if ( w1 != 0 ) {
+    g_assert( mix_word_div(h,l,w1,&q,&r) == FALSE );
+    g_assert( mix_word_magnitude(r) == 0 );
+    g_assert( q == w2 );
+  } else {
+    g_assert( mix_word_magnitude(l) == 0 && mix_word_magnitude(h) == 0 );
+  }
+  if ( w2 != 0 ) {
+    g_assert( mix_word_div(h,l,w2,&q,&r) == FALSE );
+    g_assert( mix_word_magnitude(r) == 0 );
+    g_assert( q == w1 );
+  } else {
+    g_assert( mix_word_magnitude(l) == 0 && mix_word_magnitude(h) == 0 );
+  }
+
+}
+
+/* test word division */
+static void
+test_word_div_(mix_word_t h, mix_word_t l, mix_word_t by)
+{
+  mix_word_t q,r;
+  gboolean overflow;
+
+  overflow = mix_word_div(h,l,by,&q,&r);
+
+  mix_word_print(h,"\n\n");
+  mix_word_print(l,NULL);
+  mix_word_print(by,"\n div by ");
+
+  if ( !overflow ) {
+    mix_word_t h1, l1, h2;
+    mix_word_print(q,"\n q = ");
+    mix_word_print(r,"  r = ");
+    mix_word_mul(by,q,&h1,&l1);
+    mix_word_add_and_carry(l1,r,&h2,&l1);
+    h1 = mix_word_add(h1,h2);
+    g_assert( mix_word_magnitude(r) < mix_word_magnitude(by) );
+    g_assert( word_compare_(h1,h) );
+    g_assert( mix_word_magnitude(l1) == mix_word_magnitude(l) );
+  } else
+    g_print("\n\t = overflow");
+
+}
+
+static void
+test_mix_char_(void)
+{
+  mix_char_t mchar;
+  guchar achar;
+  guint k;
+  g_print("\nTesting mix_char_t. Table of mix_chars:\n");
+
+  for (k = 0; k < MIX_CHAR_MAX + 1; ++k) {
+    mchar = k;
+    achar = mix_char_to_ascii(mchar);
+    g_print("%02d: %c, ", k, achar);
+    if ( (k+1)%5 == 0 ) g_print("\n");
+    g_assert( mchar == mix_ascii_to_char(achar) );
+  }
+
+  g_print("\nchar <-> byte conversions...\n");
+
+  for (k = 0; k < MIX_CHAR_MAX + 1; ++k) {
+    mix_byte_t c = mix_byte_new (k);
+    g_assert (c == mix_byte_to_char (mix_char_to_byte (c)));
+  }
+
+  g_print("\n");
+}
+
+
+/* main test driver for mix_types.h/c */
+
+int main(int argc, char **argv)
+{
+  unsigned int j,k;
+  mix_byte_t bytes[5] = { 0, 3, 20, 30, 40 };
+  mix_byte_t r;
+  mix_short_t ss[6];
+  mix_word_t words[6];
+
+  INIT_TEST;
+
+  g_print("Testing mix_byte_t arithmetics...\n");
+  PRINT_BYTE(bytes[0]);  g_print(", ");
+  PRINT_BYTE(bytes[1]);  g_print(", ");
+  PRINT_BYTE(bytes[2]);  g_print(", ");
+  PRINT_BYTE(bytes[3]);  g_print(", ");
+  PRINT_BYTE(bytes[4]);  g_print("\n");
+  PRINT_BYTE(r = mix_byte_add(bytes[1],bytes[2]));
+  g_print("\n"); g_assert(r == 23);
+  PRINT_BYTE(r = mix_byte_add(bytes[3],bytes[4]));
+  g_print("\n"); g_assert(r == 6);
+  PRINT_BYTE(r = mix_byte_sub(bytes[0],bytes[1]));
+  g_print("\n"); g_assert(r == 61);
+  PRINT_BYTE(r = mix_byte_sub(bytes[4],bytes[3]));
+  g_print("\n"); g_assert(r == 10);
+  PRINT_BYTE(r = mix_byte_sub(bytes[1],bytes[4]));
+  g_print("\n"); g_assert(r == 27);
+  PRINT_BYTE(r = mix_byte_mul(bytes[0],bytes[1]));
+  g_print("\n"); g_assert(r == 0);
+  PRINT_BYTE(r = mix_byte_mul(bytes[1],bytes[2]));
+  g_print("\n"); g_assert(r == 60);
+  PRINT_BYTE(r = mix_byte_mul(bytes[1],bytes[4]));
+  g_print("\n"); g_assert(r == 56);
+  PRINT_BYTE(r = mix_byte_mul(bytes[4],bytes[1]));
+  g_print("\n"); g_assert(r == 56);
+  PRINT_BYTE(r = mix_byte_div(bytes[4],bytes[2]));
+  g_print("\n"); g_assert(r == 2);
+  PRINT_BYTE(r = mix_byte_div(bytes[3],bytes[2]));
+  g_print("\n"); g_assert(r == 1);
+
+  test_mix_char_();
+
+  g_print("\nTesting word<->short conversions...");
+  words[0] = mix_bytes_to_word(bytes+1,5);
+  words[1] = mix_word_negative(words[0]);
+  ss[0] = mix_word_to_short(words[0]);
+  ss[1] = mix_word_to_short(words[1]);
+  mix_word_print(words[0],"\nwords[0]=");
+  mix_word_print(words[1],"\nwords[1]=");
+  mix_short_print(ss[0],"\nss[0]=");
+  mix_short_print(ss[1],"\nss[1]=");
+  g_assert(mix_short_is_positive(ss[0]));
+  g_assert(mix_short_is_negative(ss[1]));
+  words[2] = mix_short_to_word(ss[0]);
+  words[3] = mix_short_to_word(ss[1]);
+  mix_word_print(words[2],"\nwords[2]=");
+  mix_word_print(words[3],"\nwords[3]=");
+  g_assert(mix_word_sign(words[0]) == mix_word_sign(words[2]));
+  g_assert(mix_word_sign(words[1]) == mix_word_sign(words[3]));
+  g_assert(mix_short_magnitude(ss[0]) == mix_word_magnitude(words[2]));
+  g_assert(mix_short_magnitude(ss[1]) == mix_word_magnitude(words[3]));
+  g_assert(mix_word_get_byte(words[0],4) == mix_word_get_byte(words[2],4));
+  g_assert(mix_word_get_byte(words[0],5) == mix_word_get_byte(words[2],5));
+  g_assert(mix_word_get_byte(words[1],4) == mix_word_get_byte(words[3],4));
+  g_assert(mix_word_get_byte(words[1],5) == mix_word_get_byte(words[3],5));
+  words[4] = mix_word_extract_field(mix_fspec_new(4,5),words[0]);
+  words[5] = mix_word_extract_field(mix_fspec_new(4,5),words[1]);
+  mix_word_reverse_sign(words[5]);
+  g_assert(words[4] == words[2]);
+  g_assert(words[5] == words[3]);
+
+  g_print("Testing mix_word_t creation and byte access...\n");
+  test_word_from_bytes_(words,bytes,5,"word[0] created from bytes[0-4]");
+  test_word_from_bytes_(words+1,bytes,4,"\nword[1] created from bytes[0-3]");
+  test_word_from_bytes_(words+2,bytes,3,"\nword[2] created from bytes[0-2]");
+  words[3] = mix_word_negative(words[2]);
+  g_assert( mix_word_negative(words[3]) == words[2] );
+  g_assert( mix_word_is_negative(words[3]) && !mix_word_is_negative(words[2]));
+  mix_word_print(words[3],"\nword[3] created from -word[2]");
+  test_word_from_bytes_(words+4,bytes+2,2,"\nword[2] created from bytes[2-3]");
+
+  g_print("\nTesting mix_word_t field access...\n");
+  mix_word_set_byte(words+3,1,12);
+  mix_word_set_byte(words+3,2,58);
+  g_assert( mix_word_get_byte(words[3],1) == 12 );
+  g_assert( mix_word_get_byte(words[3],2) == 58 );
+  test_field_access_(0,5,words[3],words[4]);
+  test_field_access_(1,5,words[3],words[4]);
+  test_field_access_(2,5,words[3],words[4]);
+  test_field_access_(3,5,words[3],words[4]);
+  test_field_access_(4,5,words[3],words[4]);
+  test_field_access_(5,5,words[3],words[4]);
+  test_field_access_(0,0,words[3],words[4]);
+
+  g_print("\n\nTesting mix_word_t arithmetics...\n");
+  words[0] = MIX_WORD_MAX;
+  words[1] = mix_word_negative(words[0]);
+  for ( k = 1; k < 6; ++k ) {
+    mix_word_set_byte(words+2,k,5*k);
+    mix_word_set_byte(words+4,k,10*(5-k));
+    mix_word_set_byte(words+3,k,21 + 3*k);
+  }
+  words[5] = 0;
+
+  g_print("\n***addition***");
+  for ( k = 0; k < 6; ++k )
+    for ( j = 0; j <= k; ++j ) {
+      test_word_add_(words[k],mix_word_negative(words[j]));
+      test_word_add_(words[k],words[j]);
+    }
+  g_print("\n***product***");
+  for ( k = 0; k < 6; ++k )
+    for ( j = 0; j <= k; ++j ) {
+      test_word_mul_(words[k],words[j]);
+    }
+  g_print("\n***division***");
+  for ( k = 0; k < 6; ++k ) {
+    test_word_div_(words[k],0,words[0]);
+    for ( j = 0; j <= k; ++j ) {
+      test_word_div_(k,words[j],words[j]);
+      test_word_div_(0,mix_word_add(mix_word_magnitude(words[j]),j),words[j]);
+      test_word_div_(mix_word_negative(k),words[j],words[j]);
+    }
+  }
+
+  g_print("\nTesting shift operations...\n");
+  for ( k = 0; k < 10; ++k )
+    mix_word_set_byte(words+(k/5),1+(k%5),k+1);
+
+  mix_word_print(words[0],"A = ");
+  mix_word_print(words[1],"X = ");
+  for ( k = 0; k < 11; ++k ) {
+    mix_word_t A, X;
+    unsigned int m;
+
+    mix_word_shift_left(words[0],words[1],k,&A,&X);
+    g_print("\nShift left %d:\n",k);
+    mix_word_print(A,"A ");
+    mix_word_print(X,"X ");
+    for ( m = 0; m < 10 - k; ++m )
+      g_assert( mix_word_get_byte( m < 5 ? A:X, (m%5)+1 ) ==
+	      mix_word_get_byte(words[(m+k)/5], ((m+k)%5)+1) );
+    for ( ; m < 10; ++m )
+      g_assert( mix_word_get_byte( m < 5 ? A:X, (m%5)+1 ) == 0 );
+
+    mix_word_shift_right(words[0],words[1],k,&A,&X);
+    g_print("\nShift right %d:\n",k);
+    mix_word_print(A,"A ");
+    mix_word_print(X,"X ");
+    for ( m = 0; m < k; ++m )
+      g_assert( mix_word_get_byte( m < 5 ? A:X, (m%5)+1 ) == 0 );
+    for ( ; m < 10; ++m )
+      g_assert( mix_word_get_byte( m < 5 ? A:X, (m%5)+1 ) ==
+	      mix_word_get_byte(words[(m-k)/5], ((m-k)%5)+1) );
+
+    mix_word_shift_left_circular(words[0],words[1],k,&A,&X);
+    g_print("\nShift left circular %d:\n",k);
+    mix_word_print(A,"A ");
+    mix_word_print(X,"X ");
+    for ( m = 0; m < 10 - k; ++m )
+      g_assert( mix_word_get_byte( m < 5 ? A:X, (m%5)+1 ) ==
+	      mix_word_get_byte(words[(m+k)/5], ((m+k)%5)+1) );
+    for ( ; m < 10; ++m )
+      g_assert( mix_word_get_byte( m < 5 ? A:X, (m%5)+1 ) ==
+	      mix_word_get_byte(words[(m-10+k)/5], 1+((m-10+k)%5)) );
+    mix_word_shift_right_circular(A, X, k, &A, &X);
+    g_print("\nRe-shiftting right...\n");
+    mix_word_print(A, "A ");
+    mix_word_print(X, "X ");
+    g_assert(A == words[0]);
+    g_assert(X == words[1]);
+  }
+
+
+  g_print("\n");
+  return EXIT_SUCCESS;
+}
+
+
+
+
+
+
diff --git a/mixlib/testsuite/mix_vm_ins_t.c b/mixlib/testsuite/mix_vm_ins_t.c
new file mode 100644
index 0000000..458cbba
--- /dev/null
+++ b/mixlib/testsuite/mix_vm_ins_t.c
@@ -0,0 +1,505 @@
+/* ---------------------- mix_vm_ins_t.c :
+ * Tests for the virtual machine instruction handlers.
+ * ------------------------------------------------------------------
+** Copyright (C) 2000, 2004 Free Software Foundation, Inc.
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2 of the License, or
+** (at your option) any later version.
+**
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**
+*/
+
+
+#include <stdlib.h>
+/* #define VERBOSE_TEST */
+#include "test.h"
+#include "mix_vm.h"
+#include "mix_vm_dump.h"
+
+typedef struct
+{
+  mix_word_t rA_b, rA_a;
+  mix_word_t rX_b, rX_a;
+  mix_short_t rJ_b, rJ_a;
+  mix_short_t rI_b[6], rI_a[6];
+  gboolean over_b, over_a;
+  mix_cmpflag_t cmp_b, cmp_a;
+  mix_address_t begin, end;
+  mix_word_t  *cells_b, *cells_a;
+  const mix_ins_t *ins;
+} test_desc_t;
+
+static void
+set_cells_(test_desc_t *t, mix_address_t begin, mix_address_t end)
+{
+  g_assert(begin <= end);
+  t->begin = begin;
+  t->end = end;
+  t->cells_b = g_new(mix_word_t,end-begin);
+  t->cells_a = g_new(mix_word_t,end-begin);
+}
+
+static void
+free_cells_(test_desc_t *t)
+{
+  g_assert(t);
+  g_free(t->cells_a);
+  g_free(t->cells_b);
+  t->cells_a = t->cells_b = NULL;
+  t->begin = t->end = 0;
+}
+
+
+static void
+fill_test_desc_(test_desc_t *t, const mix_vm_t *vm, const mix_ins_t *ins)
+{
+  guint k;
+  g_assert(t);
+  g_assert(vm);
+
+  t->rA_b = t->rA_a = mix_vm_get_rA(vm);
+  t->rX_b = t->rX_a = mix_vm_get_rX(vm);
+  t->rJ_b = t->rJ_a = mix_vm_get_rJ(vm);
+  for ( k = 0; k < 6; ++k )
+    t->rI_b[k] = t->rI_a[k] = mix_vm_get_rI(vm,k+1);
+  t->cmp_b = t->cmp_a = mix_vm_get_cmpflag(vm);
+  t->over_b = t->over_a = mix_vm_get_overflow(vm);
+
+  for (k = 0; k < t->end-t->begin; ++k)
+    t->cells_a[k] = t->cells_b[k] =
+      mix_vm_get_addr_contents(vm,t->begin+k);
+  t->ins = ins;
+}
+
+
+static void
+run_test_(test_desc_t *t, mix_vm_t *vm, mix_dump_context_t *dc)
+{
+  guint k;
+  g_assert(t);
+  g_assert(vm);
+
+  mix_vm_set_rA(vm, t->rA_b);
+  mix_vm_set_rX(vm, t->rX_b);
+  mix_vm_set_rJ(vm, t->rJ_b);
+  for (k = 0; k < 6; ++k) mix_vm_set_rI(vm, k+1, t->rI_b[k]);
+  for (k = t->begin; k < t->end; ++k)
+    mix_vm_set_addr_contents(vm, k, t->cells_b[k-t->begin]);
+  mix_vm_set_cmpflag(vm, t->cmp_b);
+  mix_vm_set_overflow(vm, t->over_b);
+
+  mix_ins_print(t->ins);
+  if (dc) {
+    mix_dump_context_range(dc, t->begin, t->end);
+    mix_vm_dump(vm,dc);
+  }
+  k = mix_vm_exec_ins(vm, t->ins);
+  if (dc) mix_vm_dump(vm, dc);
+  g_assert(k == TRUE);
+  g_assert(mix_vm_get_rA(vm) == t->rA_a);
+  g_assert(mix_vm_get_rX(vm) == t->rX_a);
+  for (k = 0; k < 6; ++k) g_assert(mix_vm_get_rI(vm, k+1) == t->rI_a[k]);
+  g_assert(mix_vm_get_cmpflag(vm) == t->cmp_a);
+  g_assert(mix_vm_get_overflow(vm) == t->over_a);
+  for (k = t->begin; k < t->end; ++k)
+    g_assert(mix_vm_get_addr_contents(vm, k) == t->cells_a[k-t->begin]);
+}
+
+
+
+static void
+test_arithmetics_(mix_vm_t *vm, mix_dump_context_t *dc)
+{
+  test_desc_t test;
+  mix_ins_t ins;
+
+  g_print("\nTesting arithmetic instructions...\n");
+  mix_vm_reset(vm);
+  mix_ins_fill_from_id(ins,mix_ADD);
+  ins.index = 0;
+  ins.address = 1000;
+  mix_vm_set_rA(vm,mix_word_new_b(19,18,1,2,22));
+  mix_vm_set_addr_contents(vm,1000,mix_word_new_b(1,36,5,0,50));
+  set_cells_(&test,1000,1001);
+  fill_test_desc_(&test,vm,&ins);
+  test.rA_a = mix_word_new_b(20,54,6,3,8);
+  run_test_(&test, vm, dc);
+
+  mix_ins_fill_from_id(ins,mix_SUB);
+  mix_vm_set_rA(vm,mix_word_new_bn(19,18,0,0,9));
+  mix_vm_set_addr_contents(vm,1000,mix_word_new_bn(31,16,2,22,0));
+  fill_test_desc_(&test,vm,&ins);
+  test.rA_a = mix_word_new_b(11,62,2,21,55);
+  run_test_(&test, vm, dc);
+
+  mix_ins_fill_from_id(ins,mix_MUL);
+  mix_vm_set_rA(vm,mix_word_new_b(1,1,1,1,1));
+  mix_vm_set_addr_contents(vm,1000, mix_word_new_b(1,1,1,1,1));
+  fill_test_desc_(&test,vm,&ins);
+  test.rA_a = mix_word_new_b(0,1,2,3,4);
+  test.rX_a = mix_word_new_b(5,4,3,2,1);
+  run_test_(&test, vm, dc);
+
+  ins.fspec = mix_fspec_new(1,1);
+  mix_vm_set_rA(vm,mix_word_new_bn(0,0,0,1,48));
+  mix_vm_set_addr_contents(vm,1000,mix_word_new_bn(2,16,2,22,0));
+  fill_test_desc_(&test,vm,&ins);
+  test.rA_a = MIX_WORD_MINUS_ZERO;
+  test.rX_a = mix_word_new_bn(0,0,0,3,32);
+  run_test_(&test, vm, dc);
+
+  mix_vm_set_rA(vm,mix_word_new_bn(0,0,0,1,48));
+  mix_vm_set_addr_contents(vm,1000,mix_word_new_b(2,0,34,33,1));
+  fill_test_desc_(&test,vm,&ins);
+  test.rA_a = MIX_WORD_MINUS_ZERO;
+  test.rX_a = mix_word_new_bn(0,0,0,3,32);
+  run_test_(&test, vm, dc);
+
+  ins.fspec = mix_fspec_new(0,5);
+  mix_vm_set_rA(vm,mix_word_new_bn(50,0,1,48,4));
+  mix_vm_set_addr_contents(vm,1000,mix_word_new_bn(2,0,0,0,0));
+  fill_test_desc_(&test,vm,&ins);
+  test.rA_a = mix_word_new_b(1,36,0,3,32);
+  test.rX_a = mix_word_new_b(8,0,0,0,0);
+  run_test_(&test, vm, dc);
+
+  mix_ins_fill_from_id(ins,mix_DIV);
+  mix_vm_set_rA(vm,MIX_WORD_ZERO);
+  mix_vm_set_rX(vm,mix_word_new_b(0,0,0,0,17));
+  mix_vm_set_addr_contents(vm,1000, mix_word_new_b(0,0,0,0,3));
+  fill_test_desc_(&test,vm,&ins);
+  test.rA_a = mix_word_new_b(0,0,0,0,5);
+  test.rX_a = mix_word_new_b(0,0,0,0,2);
+  run_test_(&test, vm, dc);
+
+  mix_vm_set_rA(vm,MIX_WORD_ZERO);
+  mix_vm_set_rX(vm,mix_word_new_bn(0,0,0,0,17));
+  mix_vm_set_addr_contents(vm,1000, mix_word_new_b(0,0,0,0,3));
+  fill_test_desc_(&test,vm,&ins);
+  test.rA_a = mix_word_new_b(0,0,0,0,5);
+  test.rX_a = mix_word_new_b(0,0,0,0,2);
+  run_test_(&test, vm, dc);
+
+  mix_vm_set_rA(vm, MIX_WORD_MINUS_ZERO);
+  mix_vm_set_rX(vm, mix_word_new_b(19,19,0,3,1));
+  mix_vm_set_addr_contents(vm,1000, mix_word_new_bn(0,0,0,2,0));
+  fill_test_desc_(&test,vm,&ins);
+  test.rA_a = mix_word_new_b(0,9,41,32,1);
+  test.rX_a = mix_word_new_bn(0,0,0,1,1);
+  run_test_(&test, vm, dc);
+
+  free_cells_(&test);
+}
+
+static void
+test_shift_(mix_vm_t *vm, mix_dump_context_t *dc)
+{
+  test_desc_t test;
+  mix_ins_t ins;
+
+  g_print("Testing shift instructions...\n");
+  mix_vm_reset(vm);
+  set_cells_(&test,0,0);
+  fill_test_desc_(&test,vm,&ins);
+  mix_ins_fill_from_id(ins,mix_SRAX);
+  ins.index = 0;
+  ins.address = 1;
+  test.rA_b = mix_word_new_b(1,2,3,4,5);
+  test.rX_b = mix_word_new_bn(6,7,8,9,10);
+  test.rA_a = mix_word_new_b(0,1,2,3,4);
+  test.rX_a = mix_word_new_bn(5,6,7,8,9);
+  run_test_(&test, vm, dc);
+
+  mix_ins_fill_from_id(ins, mix_SLA);
+  ins.address = 2;
+  fill_test_desc_(&test, vm, &ins);
+  test.rA_a = mix_word_new_b(2,3,4,0,0);
+  run_test_(&test, vm, dc);
+
+  mix_ins_fill_from_id(ins, mix_SRC);
+  ins.address = 4;
+  fill_test_desc_(&test, vm, &ins);
+  test.rA_a = mix_word_new_b(6,7,8,9,2);
+  test.rX_a = mix_word_new_bn(3,4,0,0,5);
+  run_test_(&test, vm, dc);
+
+  mix_ins_fill_from_id(ins, mix_SRA);
+  ins.address = 2;
+  fill_test_desc_(&test, vm, &ins);
+  test.rA_a = mix_word_new_b(0,0,6,7,8);
+  run_test_(&test, vm, dc);
+
+  mix_ins_fill_from_id(ins, mix_SLC);
+  ins.address = 501;
+  fill_test_desc_(&test, vm, &ins);
+  test.rA_a = mix_word_new_b(0,6,7,8,3);
+  test.rX_a = mix_word_new_bn(4,0,0,5,0);
+  run_test_(&test, vm, dc);
+}
+
+static void
+test_spc_(mix_vm_t *vm, mix_dump_context_t *dc)
+{
+  test_desc_t test;
+  mix_ins_t ins;
+
+  g_print("Testing special instructions...\n");
+  mix_vm_reset(vm);
+  set_cells_(&test,0,0);
+  fill_test_desc_(&test,vm,&ins);
+  mix_ins_fill_from_id(ins,mix_NUM);
+  ins.index = 0;
+  ins.address = 0;
+  test.rA_b = mix_word_new_bn(0,0,31,32,39);
+  test.rX_b = mix_word_new_b(37,57,47,30,30);
+  test.rA_a = mix_word_negative(12977700);
+  test.rX_a = test.rX_b;
+  run_test_(&test, vm, dc);
+
+  mix_ins_fill_from_id(ins, mix_INCA);
+  ins.address = 1;
+  fill_test_desc_(&test, vm, &ins);
+  test.rA_a = mix_word_negative(12977699);
+  run_test_(&test, vm, dc);
+
+  mix_ins_fill_from_id(ins, mix_CHAR);
+  fill_test_desc_(&test, vm, &ins);
+  test.rA_a = mix_word_new_bn(30,30,31,32,39);
+  test.rX_a = mix_word_new_b(37,37,36,39,39);
+  run_test_(&test, vm, dc);
+
+  mix_ins_fill_from_id(ins, mix_HLT);
+  fill_test_desc_(&test, vm, &ins);
+  run_test_(&test, vm, dc);
+  g_assert(mix_vm_is_halted(vm));
+
+}
+
+static void
+test_move_(mix_vm_t *vm, mix_dump_context_t *dc)
+{
+  test_desc_t test;
+  mix_ins_t ins;
+  guint k;
+
+  g_print("Testing move instruction...\n");
+  mix_vm_reset(vm);
+  set_cells_(&test,0,10);
+  fill_test_desc_(&test,vm,&ins);
+  mix_ins_fill_from_id(ins,mix_MOVE);
+
+  ins.index = 0;
+  ins.address = 0;
+  ins.fspec = 5;
+  for ( k = 0; k < 5; ++k )
+    test.cells_b[k] = test.cells_a[k+5] = test.cells_a[k] =mix_word_new(100*k);
+
+  test.rI_b[0] = 5;
+  test.rI_a[0] = 10;
+  run_test_(&test,vm,dc);
+
+  free_cells_(&test);
+}
+
+
+
+static void
+test_load_(mix_vm_t *vm, mix_dump_context_t *dc)
+{
+  test_desc_t test;
+  mix_ins_t ins;
+  mix_ins_id_t ids[4] = {mix_LDA, mix_LDX, mix_LDAN, mix_LDXN};
+  mix_word_t r_a[14] = {
+    mix_word_new_bn(1,16,3,5,4),
+    mix_word_new_b(1,16,3,5,4),
+    mix_word_new_b(0,0,3,5,4),
+    mix_word_new_bn(0,0,1,16,3),
+    mix_word_new_b(0,0,0,0,5),
+    mix_word_new_b(0,0,0,0,1),
+    MIX_WORD_MINUS_ZERO,
+    mix_word_new_b(1,16,3,5,4),
+    mix_word_new_bn(1,16,3,5,4),
+    mix_word_new_bn(0,0,3,5,4),
+    mix_word_new_b(0,0,1,16,3),
+    mix_word_new_bn(0,0,0,0,5),
+    mix_word_new_bn(0,0,0,0,1),
+    MIX_WORD_ZERO
+  };
+  mix_fspec_t fs[11] = {5,13,29,3,36,9,0,0,0,0,0};
+  mix_address_t a_a[11] = {
+    MIX_SHORT_MINUS_ZERO,
+    mix_short_new_bn(0,1),
+    mix_short_new_bn(1,16),
+    mix_short_new_bn(16,3),
+    mix_short_new_bn(3,5),
+    mix_short_new_bn(5,4),
+    mix_short_new_b(1,16),
+    mix_short_new_b(16,3),
+    mix_short_new_b(5,4),
+    mix_short_new_b(5,4),
+    mix_short_new_b(3,5)
+  };
+  mix_word_t val = mix_word_new_bn(1,16,3,5,4);
+  gint j;
+
+  g_print("Testing load instructions...\n");
+  set_cells_(&test,2000,2001);
+  ins.index = 1;
+  ins.address = mix_short_negative(50);
+
+  mix_vm_reset(vm);
+  mix_vm_set_addr_contents(vm, 2000, val);
+
+  for (j = 0; j < 4; ++j)
+    {
+      gint k;
+      mix_ins_fill_from_id(ins,ids[j]);
+      for ( k = 0; k < 7; ++k ) {
+	fill_test_desc_(&test,vm,&ins);
+	ins.fspec = fs[k];
+	switch (ids[j])
+	  {
+	  case mix_LDA: test.rA_a = r_a[k]; break;
+	  case mix_LDX: test.rX_a = r_a[k]; break;
+	  case mix_LDAN: test.rA_a = r_a[k + 7]; break;
+	  case mix_LDXN: test.rX_a = r_a[k + 7]; break;
+	  default: g_assert_not_reached();
+	  }
+	test.rI_b[0] = test.rI_a[0] = 2050;
+	run_test_(&test, vm, dc);
+      }
+    }
+
+  ins.index = 0;
+  ins.address = 2000;
+  fs[0] = 0; fs[1] = 1; fs[2] = 2; fs[3] = 3; fs[4] = 4; fs[5] = 5;
+  fs[6] = 10; fs[7] = 11; fs[8] = 37; fs[9] = 29; fs[10] = 12;
+
+  mix_vm_reset(vm);
+  mix_vm_set_addr_contents(vm, 2000, val);
+  for ( j = 0; j < 14; j++ )
+    {
+      guint k;
+      if (j == 6 || j == 7 ) continue; /* mix_LDX, mix_LDAN */
+      mix_ins_fill_from_id(ins, mix_LD1 + j);
+      for (k = 0; k < 11; ++k)
+	{
+	  fill_test_desc_(&test, vm, &ins);
+	  ins.fspec = fs[k];
+	  if ( j < 6  )
+	    test.rI_a[j] = a_a[k];
+	  else /* mix_LDiN */
+	    test.rI_a[j-8] = mix_short_negative (a_a[k]);
+	  run_test_(&test, vm, dc);
+	}
+    }
+
+  free_cells_(&test);
+}
+
+
+static void
+test_store_(mix_vm_t *vm, mix_dump_context_t *dc)
+{
+  test_desc_t test;
+  mix_ins_t ins;
+  mix_word_t reg = mix_word_new_b(6,7,8,9,0);
+  mix_word_t add = mix_word_new_bn(1,2,3,4,5);
+  mix_word_t addr[6] = { mix_word_new_b(6,7,8,9,0),
+			  mix_word_new_bn(6,7,8,9,0),
+			  mix_word_new_bn(1,2,3,4,0),
+			  mix_word_new_bn(1,0,3,4,5),
+			  mix_word_new_bn(1,9,0,4,5),
+			  mix_word_new_b(0,2,3,4,5)};
+  mix_word_t addri[6] = { mix_word_new_b(0,0,0,9,0),
+			  mix_word_new_bn(0,0,0,9,0),
+			  mix_word_new_bn(1,2,3,4,0),
+			  mix_word_new_bn(1,0,3,4,5),
+			  mix_word_new_bn(1,9,0,4,5),
+			  mix_word_new_b(0,2,3,4,5)};
+  mix_word_t addrz[6] = { mix_word_new_b(0,0,0,0,0),
+			  mix_word_new_bn(0,0,0,0,0),
+			  mix_word_new_bn(1,2,3,4,0),
+			  mix_word_new_bn(1,0,3,4,5),
+			  mix_word_new_bn(1,0,0,4,5),
+			  mix_word_new_b(0,2,3,4,5)};
+  mix_fspec_t fs[6] = {5,13,45,18,19,1};
+  gint i,j;
+
+  g_print("Testing store instructions...\n");
+
+  set_cells_(&test,2000,2001);
+  ins.index = 0;
+  ins.address = 2000;
+
+  mix_vm_reset(vm);
+  fill_test_desc_(&test,vm,&ins);
+  test.rA_a = test.rA_b = test.rX_a = test.rX_b = reg;
+  test.rJ_a = test.rJ_b = mix_word_to_short(reg);
+  for (j = 0; j < 6; ++j)
+    test.rI_a[j] = test.rI_b[j] = test.rJ_a;
+  test.cells_b[0] = add;
+
+  for (i = 0; i < 10; ++i)
+    {
+      mix_ins_fill_from_id(ins,mix_STA+i);
+      for (j = 0; j < 6; ++j)
+	{
+	  ins.fspec = fs[j];
+	  if (i == 0 || i == 7 ) /* mix_STA, mix_STX */
+	    test.cells_a[0] = addr[j];
+	  else if ( i < 9 ) /* mix_STi, mix_STJ */
+	    test.cells_a[0] = addri[j];
+	  else /* mix_STZ */
+	    test.cells_a[0] = addrz[j];
+	  run_test_(&test,vm,dc);
+	}
+    }
+
+  free_cells_(&test);
+}
+
+
+
+int
+main(int argc, const char **argv)
+{
+  mix_vm_t *vm;
+  mix_dump_context_t *dc;
+
+  INIT_TEST;
+
+  vm = mix_vm_new();
+
+#ifdef VERBOSE_TEST
+  dc = mix_dump_context_new(MIX_DUMP_DEF_CHANNEL, 0, 0, MIX_DUMP_ALL);
+#else
+  dc = NULL;
+#endif
+
+  test_arithmetics_(vm, dc);
+  test_shift_(vm, dc);
+  test_spc_(vm,dc);
+  test_move_(vm,dc);
+  test_load_(vm,dc);
+  test_store_(vm,dc);
+
+  mix_vm_delete(vm);
+
+#ifdef VERBOSE_TEST
+  mix_dump_context_delete(dc);
+#endif
+
+  return EXIT_SUCCESS;
+}
+
diff --git a/mixlib/testsuite/test.h b/mixlib/testsuite/test.h
new file mode 100644
index 0000000..7f8eb0c
--- /dev/null
+++ b/mixlib/testsuite/test.h
@@ -0,0 +1,44 @@
+/*
+** Copyright (C) 1999 Free Software Foundation, Inc.
+**  
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2 of the License, or
+** (at your option) any later version.
+**  
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+**  
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+**  
+*/
+
+/* Common definitions for test programs */
+
+#ifndef TEST_H
+#define TEST_H
+
+#include <glib.h>
+#include <mix.h>
+
+#define PRINT_BYTE(byte) g_print("%s = %02d",#byte,byte)
+
+#ifdef VERBOSE_TEST /* get printed information  */
+#define INIT_TEST \
+ do { g_set_print_handler(NULL); mix_init_lib(); } while(FALSE);
+#else /* no printed information */
+static void
+dummy_print_f_(const gchar *m)
+{
+  /* no output */
+}
+#define INIT_TEST \
+do { g_set_print_handler(dummy_print_f_); mix_init_lib(); } while(FALSE);
+#endif /* VERBOSE_TEST */
+
+
+#endif /* TEST_H */