projects / oweals / gnunet.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
commented out wrong message type
[oweals/gnunet.git] / src / psycstore / test_psycstore.c
diff --git a/src/psycstore/test_psycstore.c b/src/psycstore/test_psycstore.c
index b0ae3b924cb9ccbba2e3158f087ffe08799c096c..37e6b657cdd3f0c31e5f920df764772243bdbeb9 100644 (file)
--- a/src/psycstore/test_psycstore.c
+++ b/src/psycstore/test_psycstore.c
@@ -54,7 +54,7 @@ static struct GNUNET_PSYCSTORE_OperationHandle *op;
 /**
  * Handle for task for timeout termination.
  */
-static struct GNUNET_SCHEDULER_Task * end_badly_task;
+static struct GNUNET_SCHEDULER_Task *end_badly_task;
 
 static struct GNUNET_CRYPTO_EddsaPrivateKey *channel_key;
 static struct GNUNET_CRYPTO_EcdsaPrivateKey *slave_key;
@@ -113,10 +113,9 @@ cleanup ()
  * Terminate the testcase (failure).
  *
  * @param cls NULL
- * @param tc scheduler context
  */
 static void
-end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+end_badly (void *cls)
 {
   res = 1;
   cleanup ();
@@ -127,10 +126,9 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * Terminate the testcase (success).
  *
  * @param cls NULL
- * @param tc scheduler context
  */
 static void
-end_normally (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+end_normally (void *cls)
 {
   res = 0;
   cleanup ();
@@ -143,7 +141,7 @@ end_normally (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 end ()
 {
-  if (end_badly_task != NULL)
+  if (NULL != end_badly_task)
   {
     GNUNET_SCHEDULER_cancel (end_badly_task);
     end_badly_task = NULL;
@@ -153,12 +151,16 @@ end ()
 }
 
 
-void
-state_reset_result (void *cls, int64_t result,
-                    const char *err_msg, uint16_t err_msg_size)
+static void
+state_reset_result (void *cls,
+                    int64_t result,
+                    const char *err_msg,
+                    uint16_t err_msg_size)
 {
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_reset_result:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "state_reset_result:\t%d\n",
+              (int) result);
   GNUNET_assert (GNUNET_OK == result);
 
   op = GNUNET_PSYCSTORE_state_reset (h, &channel_pub_key,
@@ -170,7 +172,10 @@ state_reset_result (void *cls, int64_t result,
 
 
 static int
-state_result (void *cls, const char *name, const void *value, uint32_t value_size)
+state_result (void *cls,
+              const char *name,
+              const void *value,
+              uint32_t value_size)
 {
   struct StateClosure *scls = cls;
   const char *nam = scls->name[scls->n];
@@ -181,27 +186,29 @@ state_result (void *cls, const char *name, const void *value, uint32_t value_siz
       && 0 == memcmp (value, val, val_size)
       && 0 == strcmp (name, nam))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "  variable %s matches\n", name);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "  variable %s matches\n",
+                name);
     return GNUNET_YES;
   }
   else
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "  variable %s differs\nReceived: %.*s\nExpected: %.*s\n",
-                name, value_size, value, val_size, val);
+                name, (int) value_size, (char*) value, (int) val_size, (char*) val);
     GNUNET_assert (0);
     return GNUNET_SYSERR;
   }
 }
 
 
-void
+static void
 state_get_prefix_result (void *cls, int64_t result,
                          const char *err_msg, uint16_t err_msg_size)
 {
   struct StateClosure *scls = cls;
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_get_prefix_result:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_get_prefix_result:\t%ld\n", (long int) result);
   GNUNET_assert (GNUNET_OK == result && 2 == scls->n);
 
   op = GNUNET_PSYCSTORE_state_reset (h, &channel_pub_key,
@@ -209,12 +216,12 @@ state_get_prefix_result (void *cls, int64_t result,
 }
 
 
-void
+static void
 state_get_result (void *cls, int64_t result,
                   const char *err_msg, uint16_t err_msg_size)
 {
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_get_result:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_get_result:\t%ld\n", (long int) result);
   GNUNET_assert (GNUNET_OK == result);
 
   scls.n = 0;
@@ -233,7 +240,7 @@ state_get_result (void *cls, int64_t result,
 }
 
 
-void
+static void
 counters_result (void *cls, int status, uint64_t max_fragment_id,
                  uint64_t max_message_id, uint64_t max_group_generation,
                  uint64_t max_state_message_id)
@@ -262,12 +269,12 @@ counters_result (void *cls, int status, uint64_t max_fragment_id,
 }
 
 
-void
+static void
 state_modify_result (void *cls, int64_t result,
                      const char *err_msg, uint16_t err_msg_size)
 {
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_modify_result:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_modify_result:\t%ld\n", (long int) result);
   GNUNET_assert (GNUNET_OK == result);
 
   op = GNUNET_PSYCSTORE_counters_get (h, &channel_pub_key,
@@ -275,13 +282,13 @@ state_modify_result (void *cls, int64_t result,
 }
 
 
-void
+static void
 state_sync_result (void *cls, int64_t result,
                    const char *err_msg, uint16_t err_msg_size)
 {
   struct FragmentClosure *fcls = cls;
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_sync_result:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_sync_result:\t%ld\n", (long int) result);
   GNUNET_assert (GNUNET_OK == result);
 
   op = GNUNET_PSYCSTORE_state_modify (h, &channel_pub_key,
@@ -290,7 +297,7 @@ state_sync_result (void *cls, int64_t result,
 }
 
 
-int
+static int
 fragment_result (void *cls,
                  struct GNUNET_MULTICAST_MessageHeader *msg,
                  enum GNUNET_PSYCSTORE_MessageFlags flags)
@@ -319,13 +326,13 @@ fragment_result (void *cls,
 }
 
 
-void
+static void
 message_get_latest_result (void *cls, int64_t result,
                            const char *err_msg, uint16_t err_msg_size)
 {
   struct FragmentClosure *fcls = cls;
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get_latest:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get_latest:\t%ld\n", (long int) result);
   GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
 
   modifiers[0] = (struct GNUNET_PSYC_Modifier) {
@@ -348,13 +355,13 @@ message_get_latest_result (void *cls, int64_t result,
 }
 
 
-void
+static void
 message_get_result (void *cls, int64_t result,
                     const char *err_msg, uint16_t err_msg_size)
 {
   struct FragmentClosure *fcls = cls;
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get:\t%ld\n", (long int) result);
   GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
 
   fcls->n = 0;
@@ -365,13 +372,13 @@ message_get_result (void *cls, int64_t result,
 }
 
 
-void
+static void
 message_get_fragment_result (void *cls, int64_t result,
                              const char *err_msg, uint16_t err_msg_size)
 {
   struct FragmentClosure *fcls = cls;
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get_fragment:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get_fragment:\t%ld\n", (long int) result);
   GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
 
   fcls->n = 0;
@@ -384,13 +391,13 @@ message_get_fragment_result (void *cls, int64_t result,
 }
 
 
-void
+static void
 fragment_get_latest_result (void *cls, int64_t result,
                             const char *err_msg, uint16_t err_msg_size)
 {
   struct FragmentClosure *fcls = cls;
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "fragment_get_latest:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "fragment_get_latest:\t%ld\n", (long int) result);
   GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
 
   fcls->n = 1;
@@ -403,13 +410,15 @@ fragment_get_latest_result (void *cls, int64_t result,
 }
 
 
-void
+static void
 fragment_get_result (void *cls, int64_t result,
                      const char *err_msg, uint16_t err_msg_size)
 {
   struct FragmentClosure *fcls = cls;
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "fragment_get:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "fragment_get:\t%d\n",
+              (int) result);
   GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
 
   fcls->n = 0;
@@ -421,12 +430,12 @@ fragment_get_result (void *cls, int64_t result,
 }
 
 
-void
+static void
 fragment_store_result (void *cls, int64_t result,
                        const char *err_msg, uint16_t err_msg_size)
 {
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "fragment_store:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "fragment_store:\t%ld\n", (long int) result);
   GNUNET_assert (GNUNET_OK == result);
 
   if ((intptr_t) cls == GNUNET_YES)
@@ -442,7 +451,7 @@ fragment_store_result (void *cls, int64_t result,
 }
 
 
-void
+static void
 fragment_store ()
 {
   struct GNUNET_MULTICAST_MessageHeader *msg;
@@ -460,7 +469,7 @@ fragment_store ()
   msg->group_generation = GNUNET_htonll (INT64_MAX - 3);
   msg->flags = htonl (GNUNET_MULTICAST_MESSAGE_LAST_FRAGMENT);
 
-  memcpy (&msg[1], &channel_pub_key, sizeof (channel_pub_key));
+  GNUNET_memcpy (&msg[1], &channel_pub_key, sizeof (channel_pub_key));
 
   msg->purpose.size = htonl (ntohs (msg->header.size)
                              - sizeof (msg->header)
@@ -475,7 +484,7 @@ fragment_store ()
 
   fcls.flags[1] = GNUNET_PSYCSTORE_MESSAGE_STATE_APPLIED;
   fcls.msg[1] = msg = GNUNET_malloc (sizeof (*msg) + sizeof (channel_pub_key));
-  memcpy (msg, fcls.msg[0], sizeof (*msg) + sizeof (channel_pub_key));
+  GNUNET_memcpy (msg, fcls.msg[0], sizeof (*msg) + sizeof (channel_pub_key));
   msg->fragment_id = GNUNET_htonll (INT64_MAX - 4);
   msg->fragment_offset = GNUNET_htonll (1024);
 
@@ -484,7 +493,7 @@ fragment_store ()
 
   fcls.flags[2] = GNUNET_PSYCSTORE_MESSAGE_STATE_HASH;
   fcls.msg[2] = msg = GNUNET_malloc (sizeof (*msg) + sizeof (channel_pub_key));
-  memcpy (msg, fcls.msg[1], sizeof (*msg) + sizeof (channel_pub_key));
+  GNUNET_memcpy (msg, fcls.msg[1], sizeof (*msg) + sizeof (channel_pub_key));
   msg->fragment_id = GNUNET_htonll (INT64_MAX);
   msg->fragment_offset = GNUNET_htonll (16384);
 
@@ -493,24 +502,24 @@ fragment_store ()
 }
 
 
-void
+static void
 membership_test_result (void *cls, int64_t result,
                         const char *err_msg, uint16_t err_msg_size)
 {
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "membership_test:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "membership_test:\t%ld\n", (long int) result);
   GNUNET_assert (GNUNET_OK == result);
 
   fragment_store ();
 }
 
 
-void
+static void
 membership_store_result (void *cls, int64_t result,
                          const char *err_msg, uint16_t err_msg_size)
 {
   op = NULL;
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "membership_store:\t%d\n", result);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "membership_store:\t%ld\n", (long int) result);
   GNUNET_assert (GNUNET_OK == result);
 
   op = GNUNET_PSYCSTORE_membership_test (h, &channel_pub_key, &slave_pub_key,
Unnamed repository; edit this file 'description' to name the repository.