diff --git a/tests/test-commands.c b/tests/test-commands.c
new file mode 100644
index 0000000..e2f40c6
--- /dev/null
+++ b/tests/test-commands.c
@@ -0,0 +1,417 @@
+/*
+ * Test code for lib/command.c
+ *
+ * Copyright (C) 2013 by Open Source Routing.
+ * Copyright (C) 2013 by Internet Systems Consortium, Inc. ("ISC")
+ *
+ * This program reads in a list of commandlines from stdin
+ * and calls all the public functions of lib/command.c for
+ * both the given command lines and fuzzed versions thereof.
+ *
+ * The output is currently not validated but only logged. It can
+ * be diffed to find regressions between versions.
+ *
+ * Quagga 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, or (at your option) any
+ * later version.
+ *
+ * Quagga 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 Quagga; see the file COPYING.  If not, write to the Free
+ * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+#define REALLY_NEED_PLAIN_GETOPT 1
+
+#include <zebra.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "command.h"
+#include "memory.h"
+#include "vector.h"
+#include "prng.h"
+
+extern vector cmdvec;
+extern struct cmd_node vty_node;
+extern void test_init_cmd(void); /* provided in test-commands-defun.c */
+
+struct thread_master *master; /* dummy for libzebra*/
+
+static vector test_cmds;
+static char test_buf[32768];
+
+static struct cmd_node bgp_node =
+{
+  BGP_NODE,
+  "%s(config-router)# ",
+};
+
+static struct cmd_node rip_node =
+{
+  RIP_NODE,
+  "%s(config-router)# ",
+};
+
+static struct cmd_node isis_node =
+{
+  ISIS_NODE,
+  "%s(config-router)# ",
+};
+
+static struct cmd_node interface_node =
+{
+  INTERFACE_NODE,
+  "%s(config-if)# ",
+};
+
+static struct cmd_node rmap_node =
+{
+  RMAP_NODE,
+  "%s(config-route-map)# "
+};
+
+static struct cmd_node zebra_node =
+{
+  ZEBRA_NODE,
+  "%s(config-router)# "
+};
+
+static struct cmd_node bgp_vpnv4_node =
+{
+  BGP_VPNV4_NODE,
+  "%s(config-router-af)# "
+};
+
+static struct cmd_node bgp_ipv4_node =
+{
+  BGP_IPV4_NODE,
+  "%s(config-router-af)# "
+};
+
+static struct cmd_node bgp_ipv4m_node =
+{
+  BGP_IPV4M_NODE,
+  "%s(config-router-af)# "
+};
+
+static struct cmd_node bgp_ipv6_node =
+{
+  BGP_IPV6_NODE,
+  "%s(config-router-af)# "
+};
+
+static struct cmd_node bgp_ipv6m_node =
+{
+  BGP_IPV6M_NODE,
+  "%s(config-router-af)# "
+};
+
+static struct cmd_node ospf_node =
+{
+  OSPF_NODE,
+  "%s(config-router)# "
+};
+
+static struct cmd_node ripng_node =
+{
+  RIPNG_NODE,
+  "%s(config-router)# "
+};
+
+static struct cmd_node ospf6_node =
+{
+  OSPF6_NODE,
+  "%s(config-ospf6)# "
+};
+
+static struct cmd_node babel_node =
+{
+  BABEL_NODE,
+  "%s(config-babel)# "
+};
+
+static struct cmd_node keychain_node =
+{
+  KEYCHAIN_NODE,
+  "%s(config-keychain)# "
+};
+
+static struct cmd_node keychain_key_node =
+{
+  KEYCHAIN_KEY_NODE,
+  "%s(config-keychain-key)# "
+};
+
+static int
+test_callback(struct cmd_element *cmd, struct vty *vty, int argc, const char *argv[])
+{
+  int offset;
+  int rv;
+  int i;
+
+  offset = 0;
+  rv = snprintf(test_buf, sizeof(test_buf), "'%s'", cmd->string);
+  if (rv < 0)
+    abort();
+
+  offset += rv;
+
+  for (i = 0; i < argc; i++)
+    {
+      rv = snprintf(test_buf + offset, sizeof(test_buf) - offset, "%s'%s'",
+                    (i == 0) ? ": " : ", ", argv[i]);
+      if (rv < 0)
+        abort();
+      offset += rv;
+    }
+
+  return CMD_SUCCESS;
+}
+
+static void
+test_load(void)
+{
+  char line[4096];
+
+  test_cmds = vector_init(VECTOR_MIN_SIZE);
+
+  while (fgets(line, sizeof(line), stdin) != NULL)
+    {
+      if (strlen(line))
+        line[strlen(line) - 1] = '\0';
+      if (line[0] == '#')
+        continue;
+      vector_set(test_cmds, XSTRDUP(MTYPE_STRVEC, line));
+    }
+}
+
+static void
+test_init(void)
+{
+  unsigned int node;
+  unsigned int i;
+  struct cmd_node *cnode;
+  struct cmd_element *cmd;
+
+  cmd_init(1);
+
+  install_node (&bgp_node, NULL);
+  install_node (&rip_node, NULL);
+  install_node (&interface_node, NULL);
+  install_node (&rmap_node, NULL);
+  install_node (&zebra_node, NULL);
+  install_node (&bgp_vpnv4_node, NULL);
+  install_node (&bgp_ipv4_node, NULL);
+  install_node (&bgp_ipv4m_node, NULL);
+  install_node (&bgp_ipv6_node, NULL);
+  install_node (&bgp_ipv6m_node, NULL);
+  install_node (&ospf_node, NULL);
+  install_node (&ripng_node, NULL);
+  install_node (&ospf6_node, NULL);
+  install_node (&babel_node, NULL);
+  install_node (&keychain_node, NULL);
+  install_node (&keychain_key_node, NULL);
+  install_node (&isis_node, NULL);
+  install_node (&vty_node, NULL);
+
+  test_init_cmd();
+
+  for (node = 0; node < vector_active(cmdvec); node++)
+    if ((cnode = vector_slot(cmdvec, node)) != NULL)
+      for (i = 0; i < vector_active(cnode->cmd_vector); i++)
+        if ((cmd = vector_slot(cnode->cmd_vector, i)) != NULL)
+          {
+            cmd->daemon = 0;
+            cmd->func = test_callback;
+          }
+  sort_node();
+
+  test_load();
+  vty_init_vtysh();
+}
+
+static void
+test_terminate(void)
+{
+  unsigned int i;
+
+  vty_terminate();
+  for (i = 0; i < vector_active(test_cmds); i++)
+    XFREE(MTYPE_STRVEC, vector_slot(test_cmds, i));
+  vector_free(test_cmds);
+  cmd_terminate();
+}
+
+static void
+test_run(struct prng *prng, struct vty *vty, const char *cmd, unsigned int edit_dist, unsigned int node_index, int verbose)
+{
+  const char *test_str;
+  vector vline;
+  int ret;
+  unsigned int i;
+  char **completions;
+  unsigned int j;
+  struct cmd_node *cnode;
+  vector descriptions;
+  int appended_null;
+  int no_match;
+
+  test_str = prng_fuzz(prng, cmd, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_:. /", edit_dist);
+  vline = cmd_make_strvec(test_str);
+
+  if (vline == NULL)
+    return;
+
+  appended_null = 0;
+  for (i = 0; i < vector_active(cmdvec); i++)
+    if ((cnode = vector_slot(cmdvec, i)) != NULL)
+      {
+        if (node_index != (unsigned int)-1 && i != node_index)
+          continue;
+
+        if (appended_null)
+          {
+            vector_unset(vline, vector_active(vline) - 1);
+            appended_null = 0;
+          }
+        vty->node = cnode->node;
+        test_buf[0] = '\0';
+        ret = cmd_execute_command(vline, vty, NULL, 0);
+        no_match = (ret == CMD_ERR_NO_MATCH);
+        if (verbose || !no_match)
+          printf("execute relaxed '%s'@%d: rv==%d%s%s\n",
+                 test_str,
+                 cnode->node,
+                 ret,
+                 (test_buf[0] != '\0') ? ", " : "",
+                 test_buf);
+
+        vty->node = cnode->node;
+        test_buf[0] = '\0';
+        ret = cmd_execute_command_strict(vline, vty, NULL);
+        if (verbose || !no_match)
+          printf("execute strict '%s'@%d: rv==%d%s%s\n",
+                 test_str,
+                 cnode->node,
+                 ret,
+                 (test_buf[0] != '\0') ? ", " : "",
+                 test_buf);
+
+        if (isspace((int) test_str[strlen(test_str) - 1]))
+          {
+            vector_set (vline, NULL);
+            appended_null = 1;
+          }
+
+        vty->node = cnode->node;
+        completions = cmd_complete_command(vline, vty, &ret);
+        if (verbose || !no_match)
+          printf("complete '%s'@%d: rv==%d\n",
+                 test_str,
+                 cnode->node,
+                 ret);
+        if (completions != NULL)
+          {
+            for (j = 0; completions[j] != NULL; j++)
+              {
+                printf("  '%s'\n", completions[j]);
+                XFREE(MTYPE_TMP, completions[j]);
+              }
+            XFREE(MTYPE_VECTOR_INDEX, completions);
+          }
+
+        vty->node = cnode->node;
+        descriptions = cmd_describe_command(vline, vty, &ret);
+        if (verbose || !no_match)
+          printf("describe '%s'@%d: rv==%d\n",
+                 test_str,
+                 cnode->node,
+                 ret);
+        if (descriptions != NULL)
+          {
+            for (j = 0; j < vector_active(descriptions); j++)
+              {
+                struct desc *cmd = vector_slot(descriptions, j);
+                printf("  '%s' '%s'\n", cmd->cmd, cmd->str);
+              }
+            vector_free(descriptions);
+          }
+      }
+  cmd_free_strvec(vline);
+}
+
+int
+main(int argc, char **argv)
+{
+  int opt;
+  struct prng *prng;
+  struct vty *vty;
+  unsigned int edit_distance;
+  unsigned int max_edit_distance;
+  unsigned int node_index;
+  int verbose;
+  unsigned int test_cmd;
+  unsigned int iteration;
+  unsigned int num_iterations;
+
+  max_edit_distance = 3;
+  node_index = -1;
+  verbose = 0;
+
+  while ((opt = getopt(argc, argv, "e:n:v")) != -1)
+    {
+      switch (opt)
+        {
+        case 'e':
+          max_edit_distance = atoi(optarg);
+          break;
+        case 'n':
+          node_index = atoi(optarg);
+          break;
+        case 'v':
+          verbose++;
+          break;
+        default:
+          fprintf(stderr, "Usage: %s [-e <edit_dist>] [-n <node_idx>] [-v]\n", argv[0]);
+          exit(1);
+          break;
+        }
+    }
+
+  test_init();
+  prng = prng_new(0);
+
+  vty = vty_new();
+  vty->type = VTY_TERM;
+
+  fprintf(stderr, "Progress:\n0/%u", vector_active(test_cmds));
+  for (test_cmd = 0; test_cmd < vector_active(test_cmds); test_cmd++)
+    {
+      for (edit_distance = 0;
+           edit_distance <= max_edit_distance;
+           edit_distance++)
+        {
+          num_iterations = 1 << edit_distance;
+          num_iterations *= num_iterations * num_iterations;
+
+          for (iteration = 0; iteration < num_iterations; iteration++)
+            test_run(prng, vty, vector_slot(test_cmds, test_cmd), edit_distance, node_index, verbose);
+        }
+      fprintf(stderr, "\r%u/%u", test_cmd + 1, vector_active(test_cmds));
+    }
+  fprintf(stderr, "\nDone.\n");
+
+  vty_close(vty);
+  prng_free(prng);
+  test_terminate();
+  return 0;
+}