[GNUnet-SVN] r19959 - gnunet/src/namestore

[gnunet]

Author: grothoff
Date: 2012-02-22 23:34:13 +0100 (Wed, 22 Feb 2012)
New Revision: 19959

Modified:
   gnunet/src/namestore/plugin_namestore_sqlite.c
   gnunet/src/namestore/test_plugin_namestore.c
   gnunet/src/namestore/test_plugin_namestore_sqlite.conf
Log:
-extended testcase plus misc fixes

Modified: gnunet/src/namestore/plugin_namestore_sqlite.c
===================================================================
--- gnunet/src/namestore/plugin_namestore_sqlite.c      2012-02-22 20:49:54 UTC 
(rev 19958)
+++ gnunet/src/namestore/plugin_namestore_sqlite.c      2012-02-22 22:34:13 UTC 
(rev 19959)
@@ -245,6 +245,9 @@
          sqlite3_exec (plugin->dbh, "PRAGMA auto_vacuum=INCREMENTAL", NULL,
                        NULL, ENULL));
   CHECK (SQLITE_OK ==
+         sqlite3_exec (plugin->dbh, "PRAGMA encoding=\"UTF-8\"", NULL,
+                       NULL, ENULL));
+  CHECK (SQLITE_OK ==
          sqlite3_exec (plugin->dbh, "PRAGMA locking_mode=EXCLUSIVE", NULL, 
NULL,
                        ENULL));
   CHECK (SQLITE_OK ==
@@ -266,9 +269,9 @@
       (sqlite3_exec
        (plugin->dbh,
         "CREATE TABLE ns090records (" 
-        " zone_hash TEXT NOT NULL DEFAULT ''," 
+        " zone_hash BLOB NOT NULL DEFAULT ''," 
         " zone_revision INT4 NOT NULL DEFAULT 0," 
-        " record_name_hash TEXT NOT NULL DEFAULT ''," 
+        " record_name_hash BLOB NOT NULL DEFAULT ''," 
         " record_name TEXT NOT NULL DEFAULT ''," 
        " record_type INT4 NOT NULL DEFAULT 0,"
         " node_location_depth INT4 NOT NULL DEFAULT 0," 
@@ -293,7 +296,7 @@
       (sqlite3_exec
        (plugin->dbh,
         "CREATE TABLE ns090nodes (" 
-        " zone_hash TEXT NOT NULL DEFAULT ''," 
+        " zone_hash BLOB NOT NULL DEFAULT ''," 
         " zone_revision INT4 NOT NULL DEFAULT 0," 
         " node_location_depth INT4 NOT NULL DEFAULT 0," 
         " node_location_offset INT8 NOT NULL DEFAULT 0," 
@@ -317,10 +320,10 @@
       (sqlite3_exec
        (plugin->dbh,
         "CREATE TABLE ns090signatures (" 
-        " zone_hash TEXT NOT NULL DEFAULT ''," 
+        " zone_hash BLOB NOT NULL DEFAULT ''," 
         " zone_revision INT4 NOT NULL DEFAULT 0," 
         " zone_time INT8 NOT NULL DEFAULT 0," 
-        " zone_root_hash TEXT NOT NULL DEFAULT 0," 
+        " zone_root_hash BLOB NOT NULL DEFAULT 0," 
         " zone_root_depth INT4 NOT NULL DEFAULT 0," 
         " zone_public_key BLOB NOT NULL DEFAULT 0," 
         " zone_signature BLOB NOT NULL DEFAULT 0" 
@@ -480,7 +483,7 @@
   if ((SQLITE_OK != sqlite3_bind_blob (plugin->put_record, 1, zone, sizeof 
(GNUNET_HashCode), SQLITE_STATIC)) ||
       (SQLITE_OK != sqlite3_bind_int64 (plugin->put_record, 2, loc->revision)) 
||
       (SQLITE_OK != sqlite3_bind_blob (plugin->put_record, 3, &nh, sizeof 
(GNUNET_HashCode), SQLITE_STATIC)) ||
-      (SQLITE_OK != sqlite3_bind_text (plugin->put_record, 4, name, name_len, 
SQLITE_STATIC)) ||
+      (SQLITE_OK != sqlite3_bind_text (plugin->put_record, 4, name, -1, 
SQLITE_STATIC)) ||
       (SQLITE_OK != sqlite3_bind_int (plugin->put_record, 5, record_type)) ||
       (SQLITE_OK != sqlite3_bind_int (plugin->put_record, 6, loc->depth)) ||
       (SQLITE_OK != sqlite3_bind_int64 (plugin->put_record, 7, loc->offset)) ||
@@ -607,6 +610,7 @@
 {
   struct Plugin *plugin = cls;
   unsigned int ret;
+  int sret;
   struct GNUNET_TIME_Absolute expiration;
   uint32_t record_type;
   enum GNUNET_NAMESTORE_RecordFlags flags;
@@ -615,8 +619,12 @@
   struct GNUNET_NAMESTORE_SignatureLocation loc;
   const char *name;
 
-  if ((SQLITE_OK != sqlite3_bind_blob (plugin->iterate_records, 1, zone, 
sizeof (GNUNET_HashCode), SQLITE_STATIC)) ||
-      (SQLITE_OK != sqlite3_bind_blob (plugin->iterate_records, 2, name_hash, 
sizeof (GNUNET_HashCode), SQLITE_STATIC)) )
+  if ((SQLITE_OK != sqlite3_bind_blob (plugin->iterate_records, 1, 
+                                      zone, sizeof (GNUNET_HashCode), 
+                                      SQLITE_STATIC)) ||
+      (SQLITE_OK != sqlite3_bind_blob (plugin->iterate_records, 2, 
+                                      name_hash, sizeof (GNUNET_HashCode), 
+                                      SQLITE_STATIC)) )
   {
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind_XXXX");
@@ -625,28 +633,27 @@
                   GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                   "sqlite3_reset");
     return GNUNET_SYSERR;
-
   }
   ret = 0;
-  while (SQLITE_ROW == (ret = sqlite3_step (plugin->iterate_records)))
+  while (SQLITE_ROW == (sret = sqlite3_step (plugin->iterate_records)))
   {
     ret++;
     if (NULL == iter)
       continue; /* FIXME: just counting can be done more cheaply... */
-    loc.revision = sqlite3_column_int (plugin->iterate_records, 1);
-    name = (const char*) sqlite3_column_text (plugin->iterate_records, 2);
-    record_type = sqlite3_column_int (plugin->iterate_records, 3);
-    loc.depth = sqlite3_column_int (plugin->iterate_records, 4);
-    loc.offset = sqlite3_column_int64 (plugin->iterate_records, 5);
-    expiration.abs_value = (uint64_t) sqlite3_column_int64 
(plugin->iterate_records, 6);
-    flags = (enum GNUNET_NAMESTORE_RecordFlags) sqlite3_column_int 
(plugin->iterate_records, 7);
-    data = sqlite3_column_blob (plugin->iterate_records, 8);
-    data_size = sqlite3_column_bytes (plugin->iterate_records, 8);
+    loc.revision = sqlite3_column_int (plugin->iterate_records, 0);
+    name = (const char*) sqlite3_column_text (plugin->iterate_records, 1);
+    record_type = sqlite3_column_int (plugin->iterate_records, 2);
+    loc.depth = sqlite3_column_int (plugin->iterate_records, 3);
+    loc.offset = sqlite3_column_int64 (plugin->iterate_records, 4);
+    expiration.abs_value = (uint64_t) sqlite3_column_int64 
(plugin->iterate_records, 5);
+    flags = (enum GNUNET_NAMESTORE_RecordFlags) sqlite3_column_int 
(plugin->iterate_records, 6);
+    data = sqlite3_column_blob (plugin->iterate_records, 7);
+    data_size = sqlite3_column_bytes (plugin->iterate_records, 7);
     iter (iter_cls, zone,
          &loc, name, record_type,
          expiration, flags, data_size, data);
   }
-  if (SQLITE_DONE != ret)
+  if (SQLITE_DONE != sret)
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite_step");
   sqlite3_finalize (plugin->iterate_records);
   return ret;
@@ -698,10 +705,10 @@
   ret = GNUNET_NO;
   if (SQLITE_ROW == (ret = sqlite3_step (plugin->get_node)))    
   {
-    ploc.offset = sqlite3_column_int64 (plugin->get_node, 1);
-    rloc.offset = sqlite3_column_int64 (plugin->get_node, 2);
-    hashcodes = sqlite3_column_blob (plugin->get_node, 3);
-    hashcodes_size = sqlite3_column_bytes (plugin->get_node, 3);    
+    ploc.offset = sqlite3_column_int64 (plugin->get_node, 0);
+    rloc.offset = sqlite3_column_int64 (plugin->get_node, 1);
+    hashcodes = sqlite3_column_blob (plugin->get_node, 2);
+    hashcodes_size = sqlite3_column_bytes (plugin->get_node, 2);
     if (0 != (hashcodes_size % sizeof (GNUNET_HashCode)))
     {
       GNUNET_break (0);
@@ -718,7 +725,7 @@
          hashcodes);
     }
   }
-  if (SQLITE_DONE != ret)
+  else if (SQLITE_DONE != ret)
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite_step");
   sqlite3_finalize (plugin->get_node);
   return ret;
@@ -748,7 +755,7 @@
   const GNUNET_HashCode *top_hash;
 
   GNUNET_assert (NULL != cb);
-  if ((SQLITE_OK != sqlite3_bind_blob (plugin->get_signature, 1, zone, sizeof 
(GNUNET_HashCode), SQLITE_STATIC)))
+  if (SQLITE_OK != sqlite3_bind_blob (plugin->get_signature, 1, zone, sizeof 
(GNUNET_HashCode), SQLITE_STATIC))
   {
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind_XXXX");
@@ -762,16 +769,16 @@
   if (SQLITE_ROW == (ret = sqlite3_step (plugin->get_signature)))    
   {
     top_loc.offset = 0;
-    top_loc.revision = sqlite3_column_int (plugin->get_signature, 1);
-    zone_time.abs_value = sqlite3_column_int64 (plugin->get_signature, 2);
-    top_hash = sqlite3_column_blob (plugin->get_signature, 3);
-    top_loc.depth = sqlite3_column_int (plugin->get_signature, 4);
-    zone_key = sqlite3_column_blob (plugin->get_signature, 5);
-    zone_sig = sqlite3_column_blob (plugin->get_signature, 6);
+    top_loc.revision = sqlite3_column_int (plugin->get_signature, 0);
+    zone_time.abs_value = sqlite3_column_int64 (plugin->get_signature, 1);
+    top_hash = sqlite3_column_blob (plugin->get_signature, 2);
+    top_loc.depth = sqlite3_column_int (plugin->get_signature, 3);
+    zone_key = sqlite3_column_blob (plugin->get_signature, 4);
+    zone_sig = sqlite3_column_blob (plugin->get_signature, 5);
 
-    if ((sizeof (GNUNET_HashCode) != sqlite3_column_bytes 
(plugin->get_signature, 3)) ||
-       (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) != 
sqlite3_column_bytes (plugin->get_signature, 5)) ||
-       (sizeof (struct GNUNET_CRYPTO_RsaSignature) != sqlite3_column_bytes 
(plugin->get_signature, 6)))
+    if ((sizeof (GNUNET_HashCode) != sqlite3_column_bytes 
(plugin->get_signature, 2)) ||
+       (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) != 
sqlite3_column_bytes (plugin->get_signature, 4)) ||
+       (sizeof (struct GNUNET_CRYPTO_RsaSignature) != sqlite3_column_bytes 
(plugin->get_signature, 5)))
     {
       GNUNET_break (0);
       /* FIXME: delete bogus record & full zone (!?) */
@@ -809,7 +816,7 @@
 {
   int n;
 
-  if (SQLITE_OK != sqlite3_bind_blob (plugin->delete_zone_records, 1, &zone, 
sizeof (GNUNET_HashCode), SQLITE_STATIC))
+  if (SQLITE_OK != sqlite3_bind_blob (plugin->delete_zone_records, 1, zone, 
sizeof (GNUNET_HashCode), SQLITE_STATIC))
   {
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind_XXXX");

Modified: gnunet/src/namestore/test_plugin_namestore.c
===================================================================
--- gnunet/src/namestore/test_plugin_namestore.c        2012-02-22 20:49:54 UTC 
(rev 19958)
+++ gnunet/src/namestore/test_plugin_namestore.c        2012-02-22 22:34:13 UTC 
(rev 19959)
@@ -80,12 +80,295 @@
 }
 
 
+/**
+ * Function called by for each matching record.
+ *
+ * @param cls closure
+ * @param zone hash of the public key of the zone
+ * @param loc location of the signature for this record
+ * @param name name that is being mapped (at most 255 characters long)
+ * @param record_type type of the record (A, AAAA, PKEY, etc.)
+ * @param expiration expiration time for the content
+ * @param flags flags for the content
+ * @param data_size number of bytes in data
+ * @param data value, semantics depend on 'record_type' (see RFCs for DNS and 
+ *             GNS specification for GNS extensions) 
+ */
+static void 
+test_record (void *cls,
+            const GNUNET_HashCode *zone,
+            const struct GNUNET_NAMESTORE_SignatureLocation *loc,
+            const char *name,
+            uint32_t record_type,
+            struct GNUNET_TIME_Absolute expiration,
+            enum GNUNET_NAMESTORE_RecordFlags flags,
+            size_t data_size,
+            const void *data)
+{
+  int *idp = cls;
+  int id = *idp;
+  size_t tdata_size = id * 17;
+  char tdata[tdata_size];
+  GNUNET_HashCode tzone;
+  char tname[32];
+  uint32_t trecord_type;
+  struct GNUNET_NAMESTORE_SignatureLocation tloc;
+  enum GNUNET_NAMESTORE_RecordFlags tflags;               
+  
+  memset (&tzone, 42, sizeof (tzone));
+  memset (tdata, id % 255, sizeof (tdata));
+  GNUNET_snprintf (tname, sizeof (tname),
+                  "aa%u", (unsigned int) id);
+  trecord_type = id % 4;
+  tloc.depth = (id % 10);
+  tloc.offset = (id % 3);
+  tloc.revision = id % 1024;
+  tflags = GNUNET_NAMESTORE_RF_AUTHORITY;
+  
+  GNUNET_assert (0 == memcmp (&tzone, zone, sizeof (GNUNET_HashCode)));
+  GNUNET_assert (trecord_type == record_type);
+  GNUNET_assert (0 == strcmp (tname, name));
+  GNUNET_assert (tdata_size == data_size);
+  GNUNET_assert (0 == memcmp (data, tdata, data_size));
+  GNUNET_assert (flags == tflags);
+  GNUNET_assert (0 == memcmp (loc, &tloc, sizeof (struct 
GNUNET_NAMESTORE_SignatureLocation)));
+}
+
+
 static void
+get_record (struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
+{
+  GNUNET_HashCode zone;
+  GNUNET_HashCode nh;
+  char name[32];
+  
+  memset (&zone, 42, sizeof (zone));
+  GNUNET_snprintf (name, sizeof (name),
+                  "aa%u", (unsigned int) id);
+  GNUNET_CRYPTO_hash (name, strlen (name), &nh);
+  GNUNET_assert (1 == nsp->iterate_records (nsp->cls,
+                                           &zone,
+                                           &nh,
+                                           &test_record, &id));
+}
+
+
+/**
+ * Function called with the matching node.
+ *
+ * @param cls closure
+ * @param zone hash of public key of the zone
+ * @param loc location in the B-tree
+ * @param ploc parent's location in the B-tree (must have depth = loc.depth - 
1), NULL for root
+ * @param num_entries number of entries at this node in the B-tree
+ * @param entries the 'num_entries' entries to store (hashes over the
+ *                records)
+ */
+static void
+test_node (void *cls,
+          const GNUNET_HashCode *zone,
+          const struct GNUNET_NAMESTORE_SignatureLocation *loc,
+          const struct GNUNET_NAMESTORE_SignatureLocation *ploc,
+          unsigned int num_entries,
+          const GNUNET_HashCode *entries)
+{
+  int *idp = cls;
+  int id = *idp;
+  struct GNUNET_NAMESTORE_SignatureLocation tloc;
+  struct GNUNET_NAMESTORE_SignatureLocation tploc;
+  unsigned int tnum_entries = 1 + (id % 15);
+  GNUNET_HashCode tentries[num_entries];
+  unsigned int i;
+
+  tloc.depth = (id % 10);
+  tloc.offset = (id % 3);
+  tloc.revision = id % 1024;
+  tploc.depth = tloc.depth + 1;
+  tploc.offset = (id % 5);
+  tploc.revision = tloc.revision;
+  for (i=0;i<tnum_entries;i++)
+    memset (&tentries[i], (id+i) % 255, sizeof (GNUNET_HashCode));
+  GNUNET_assert (0 == memcmp (&tloc, loc, 
+                             sizeof (const struct 
GNUNET_NAMESTORE_SignatureLocation)));
+  GNUNET_assert (0 == memcmp (&tploc, ploc, 
+                             sizeof (const struct 
GNUNET_NAMESTORE_SignatureLocation)));
+  GNUNET_assert (num_entries == tnum_entries);
+  GNUNET_assert (0 == memcmp (entries, tentries, sizeof (tentries)));
+}
+
+
+static void
+get_node (struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
+{
+  GNUNET_HashCode zone;
+  struct GNUNET_NAMESTORE_SignatureLocation loc;
+
+  memset (&zone, 42, sizeof (zone));
+  loc.depth = (id % 10);
+  loc.offset = (id % 3);
+  loc.revision = id % 1024;
+  GNUNET_assert (GNUNET_OK ==
+                nsp->get_node (nsp->cls,
+                               &zone,
+                               &loc,
+                               &test_node,
+                               &id));
+}
+
+
+/**
+ * Function called with the matching signature.
+ *
+ * @param cls closure
+ * @param zone public key of the zone
+ * @param loc location of the root in the B-tree (depth, revision)
+ * @param top_sig signature signing the zone
+ * @param zone_time time the signature was created
+ * @param root_hash top level hash that is being signed
+ */
+static void
+test_signature (void *cls,
+               const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+               const struct GNUNET_NAMESTORE_SignatureLocation *loc,
+               const struct GNUNET_CRYPTO_RsaSignature *top_sig,
+               struct GNUNET_TIME_Absolute zone_time,
+               const GNUNET_HashCode *root_hash)
+{
+  int *idp = cls;
+  int id = *idp;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded tzone_key;
+  struct GNUNET_NAMESTORE_SignatureLocation tloc;
+  struct GNUNET_CRYPTO_RsaSignature ttop_sig;
+  GNUNET_HashCode troot_hash;
+
+  memset (&tzone_key, 13, sizeof (tzone_key));
+  tloc.depth = (id % 10);
+  tloc.offset = (id % 3);
+  tloc.revision = id % 1024;
+  memset (&ttop_sig, 24, sizeof (ttop_sig));
+  memset (&troot_hash, 42, sizeof (troot_hash));
+
+  GNUNET_assert (0 == memcmp (&tzone_key, zone_key, sizeof (GNUNET_HashCode)));
+  GNUNET_assert (0 == memcmp (&tloc, loc, sizeof (struct 
GNUNET_NAMESTORE_SignatureLocation)));
+  GNUNET_assert (0 == memcmp (&ttop_sig, top_sig, sizeof (struct 
GNUNET_CRYPTO_RsaSignature)));
+  GNUNET_assert (0 == memcmp (&troot_hash, root_hash, sizeof 
(GNUNET_HashCode)));
+}
+
+
+static void
+get_signature (struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
+{
+  GNUNET_HashCode root_hash;
+
+  memset (&root_hash, 42, sizeof (root_hash));
+  GNUNET_assert (GNUNET_OK ==
+                nsp->get_signature (nsp->cls,
+                                    &root_hash,
+                                    test_signature,
+                                    &id));
+}
+
+
+static void
+put_record (struct GNUNET_NAMESTORE_PluginFunctions *nsp, int id)
+{
+  size_t data_size = id * 17;
+  char data[data_size];
+  GNUNET_HashCode zone;
+  char name[32];
+  uint32_t record_type;
+  struct GNUNET_NAMESTORE_SignatureLocation loc;
+  struct GNUNET_TIME_Absolute expiration;
+  enum GNUNET_NAMESTORE_RecordFlags flags;                
+  
+  memset (&zone, 42, sizeof (zone));
+  memset (data, id % 255, sizeof (data));
+  GNUNET_snprintf (name, sizeof (name),
+                  "aa%u", (unsigned int) id);
+  record_type = id % 4;
+  loc.depth = (id % 10);
+  loc.offset = (id % 3);
+  loc.revision = id % 1024;
+  expiration = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS);
+  flags = GNUNET_NAMESTORE_RF_AUTHORITY;
+
+  GNUNET_assert (GNUNET_OK ==
+                nsp->put_record (nsp->cls,
+                                 &zone,
+                                 name,
+                                 record_type,
+                                 &loc,
+                                 expiration,
+                                 flags,
+                                 data_size,
+                                 data));
+}
+
+
+static void
+put_node (struct GNUNET_NAMESTORE_PluginFunctions *nsp,
+         int id)
+{
+  GNUNET_HashCode zone;
+  struct GNUNET_NAMESTORE_SignatureLocation loc;
+  struct GNUNET_NAMESTORE_SignatureLocation ploc;
+  unsigned int num_entries = 1 + (id % 15);
+  GNUNET_HashCode entries[num_entries];
+  unsigned int i;
+
+  memset (&zone, 42, sizeof (zone));
+  loc.depth = (id % 10);
+  loc.offset = (id % 3);
+  loc.revision = id % 1024;
+  ploc.depth = loc.depth + 1;
+  ploc.offset = (id % 5);
+  ploc.revision = loc.revision;
+  for (i=0;i<num_entries;i++)
+    memset (&entries[i], (id+i) % 255, sizeof (GNUNET_HashCode));
+  GNUNET_assert (GNUNET_OK ==
+                nsp->put_node (nsp->cls,
+                               &zone,
+                               &loc,
+                               &ploc,
+                               num_entries,
+                               entries));
+}
+
+
+static void
+put_signature (struct GNUNET_NAMESTORE_PluginFunctions *nsp,
+              int id)
+{
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded zone_key;
+  struct GNUNET_NAMESTORE_SignatureLocation loc;
+  struct GNUNET_CRYPTO_RsaSignature top_sig;
+  GNUNET_HashCode root_hash;
+  struct GNUNET_TIME_Absolute zone_time;
+
+  memset (&zone_key, 13, sizeof (zone_key));
+  loc.depth = (id % 10);
+  loc.offset = (id % 3);
+  loc.revision = id % 1024;
+  memset (&top_sig, 24, sizeof (top_sig));
+  memset (&root_hash, 42, sizeof (root_hash));
+  zone_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS);
+  
+  GNUNET_assert (GNUNET_OK ==
+                nsp->put_signature (nsp->cls,
+                                    &zone_key,
+                                    &loc,
+                                    &top_sig,
+                                    &root_hash,
+                                    zone_time));
+}
+
+
+static void
 run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  struct GNUNET_NAMESTORE_PluginFunctions *nsp;
-
+  struct GNUNET_NAMESTORE_PluginFunctions *nsp;  
+  
   ok = 0;
   nsp = load_plugin (cfg);
   if (NULL == nsp)
@@ -95,6 +378,12 @@
             "Failed to initialize namestore.  Database likely not setup, 
skipping test.\n");
     return;
   }
+  put_record (nsp, 1);
+  get_record (nsp, 1);
+  put_node (nsp, 1);
+  get_node (nsp, 1);
+  put_signature (nsp, 1);
+  get_signature (nsp, 1);
   
   unload_plugin (nsp);
 }

Modified: gnunet/src/namestore/test_plugin_namestore_sqlite.conf
===================================================================
--- gnunet/src/namestore/test_plugin_namestore_sqlite.conf      2012-02-22 
20:49:54 UTC (rev 19958)
+++ gnunet/src/namestore/test_plugin_namestore_sqlite.conf      2012-02-22 
22:34:13 UTC (rev 19959)
@@ -1,2 +1,2 @@
 [namestore-sqlite]
-FILENAME = $SERVICEHOME/namestore/sqlite.db
+FILENAME = /tmp/gnunet-test-plugin-namestore-sqlite/sqlite.db