Esempio n. 1
0
static void
add_generator (unsigned *n_inout,
               DskJsonValue ***arr_inout,
               unsigned *alloced_inout,
               int       px,
               int       py,
               unsigned  update_number)
{
  DskJsonMember members[6];
  static const char *colors[] = { "#ffffff", "#ff0000", "#00ff00", "#2222ff", "#ff00ff", "#00ffff", "#ffff00" };
  members[0].name = "x";
  members[0].value = dsk_json_value_new_number (px - TILE_SIZE * 7 / 8);
  members[1].name = "y";
  members[1].value = dsk_json_value_new_number (py - TILE_SIZE * 7 / 8);
  members[2].name = "width";
  members[2].value = dsk_json_value_new_number (TILE_SIZE * 7 / 4);
  members[3].name = "height";
  members[3].value = dsk_json_value_new_number (TILE_SIZE * 7 / 4);
  members[4].name = "color";
  members[4].value = dsk_json_value_new_string (7, (char*) colors[update_number % DSK_N_ELEMENTS (colors)]);
  members[5].name = "type";
  members[5].value = dsk_json_value_new_string (10, "hollow_box");

  append_element_json (n_inout, arr_inout, alloced_inout,
           dsk_json_value_new_object (DSK_N_ELEMENTS (members), members));
}
Esempio n. 2
0
static void
test_various_read_write (void)
{
  unsigned i;
  for (i = 0; i < DSK_N_ELEMENTS (test_datasets); i++)
    test_various_read_write_1 (test_datasets[i].name,
                               test_datasets[i].n_entries,
                               test_datasets[i].entries,
                               test_datasets[i].to_write);
  if (cmdline_slow)
    for (i = 0; i < DSK_N_ELEMENTS (test_slow_datasets); i++)
      test_various_read_write_1 (test_slow_datasets[i].name,
                                 test_slow_datasets[i].n_entries,
                                 test_slow_datasets[i].entries,
                                 test_slow_datasets[i].to_write);
}
Esempio n. 3
0
int main(int argc, char **argv)
{
  unsigned port = 0;
  DskHttpServer *server;
  unsigned i;
  DskError *error = NULL;

  dsk_cmdline_init ("snipez server", "Run a snipez server", NULL, 0);
  dsk_cmdline_add_uint ("port", "Port Number",
                        "PORT", DSK_CMDLINE_MANDATORY, &port);
  dsk_cmdline_add_uint ("update-period", "Update Period",
                        "MILLIS", 0, &update_period_msecs);
  dsk_cmdline_add_func ("make-maze", "Make a Maze",
                        "WIDTHxHEIGHT", DSK_CMDLINE_OPTIONAL,
                        handle_make_maze, NULL);
  dsk_cmdline_add_shortcut ('p', "port");
  dsk_cmdline_process_args (&argc, &argv);

  server = dsk_http_server_new ();
  for (i = 0; i < DSK_N_ELEMENTS (handlers); i++)
    {
      dsk_http_server_match_save (server);
      dsk_http_server_add_match (server, DSK_HTTP_SERVER_MATCH_PATH,
                                 handlers[i].pattern);
      dsk_http_server_register_cgi_handler (server,
                                            (DskHttpServerCgiFunc) handlers[i].handler,
                                            NULL, NULL);
      dsk_http_server_match_restore (server);
    }
  if (!dsk_http_server_bind_tcp (server, NULL, port, &error))
    dsk_die ("error binding to port %u: %s", port, error->message);

  return dsk_main_run ();
}
Esempio n. 4
0
static void
char_class_union_inplace (struct CharClass *inout, const struct CharClass *addend)
{
  unsigned i;
  if (IS_SINGLE_CHAR_CLASS (addend))
    CHAR_CLASS_BITVEC_SET (inout, SINGLE_CHAR_CLASS_GET_CHAR (addend));
  else
    for (i = 0; i < DSK_N_ELEMENTS (inout->set); i++)
      inout->set[i] |= addend->set[i];
}
Esempio n. 5
0
static void
test_simple_write_seek (void)
{
  unsigned i;
  for (i = 0; i < DSK_N_ELEMENTS (test_seek_datasets); i++)
    test_various_write_seek_1 (test_seek_datasets[i].name,
                               test_seek_datasets[i].n_entries,
                               test_seek_datasets[i].entries,
                               test_seek_datasets[i].n_neg_entries,
                               test_seek_datasets[i].neg_entries);
}
Esempio n. 6
0
/* Parse a backslash-escape special character class,
   include a lot of punctuation.  The backslash
   should already have been skipped. */
static dsk_boolean
get_backslash_char_class (const char **p_at, struct CharClass **out)
{
  const char *start = *p_at;
  char bs = *start;
  if (dsk_ascii_ispunct (bs))
    *out = MK_LITERAL_CHAR_CLASS (bs);
  else if (bs == 'n')
    *out = MK_LITERAL_CHAR_CLASS ('\n');
  else if (bs == 'r')
    *out = MK_LITERAL_CHAR_CLASS ('\r');
  else if (bs == 't')
    *out = MK_LITERAL_CHAR_CLASS ('\t');
  else if (bs == 'v')
    *out = MK_LITERAL_CHAR_CLASS ('\v');
  else if (dsk_ascii_isdigit (bs))
    {
      uint8_t value;
      if (!dsk_ascii_isdigit (start[1]))
        {
          value = start[0] - '0';
          *p_at = start + 1;
        }
      else if (!dsk_ascii_isdigit (start[2]))
        {
          value = (start[0] - '0') * 8 + (start[1] - '0');
          *p_at = start + 2;
        }
      else
        {
          value = (start[0] - '0') * 64 + (start[1] - '0') * 8 + (start[2] - '0');
          *p_at = start + 3;
        }
      *out = MK_LITERAL_CHAR_CLASS (value);
      return DSK_TRUE;
    }
  else
    {
      unsigned i;
      for (i = 0; i < DSK_N_ELEMENTS (special_char_classes); i++)
        if (special_char_classes[i].c == bs)
          {
            *out = &special_char_classes[i].cclass;
            *p_at = start + 1;
            return DSK_TRUE;
          }
      return DSK_FALSE;
    }
  *p_at = start + 1;
  return DSK_TRUE;
}
Esempio n. 7
0
int main(int argc, char **argv)
{
  unsigned i;
  char test_dir_buf[256];
  DskError *error = NULL;

  dsk_cmdline_init ("test table internals (the 'file' abstraction)",
                    "Test Table Internals",
                    NULL, 0);
  dsk_cmdline_add_boolean ("verbose", "extra logging", NULL, 0,
                           &cmdline_verbose);
  dsk_cmdline_add_boolean ("slow", "run tests that are fairly slow", NULL, 0,
                           &cmdline_slow);
  dsk_cmdline_add_boolean ("keep-testdir", "do not delete working directory", NULL, 0,
                           &cmdline_keep_testdir);
  dsk_cmdline_process_args (&argc, &argv);

  snprintf (test_dir_buf, sizeof (test_dir_buf),
            "test-table-file-%u-%u", (unsigned)time(NULL), (unsigned)getpid());
  location = dsk_dir_new (NULL, test_dir_buf, DSK_DIR_NEW_MAYBE_CREATE, &error);
  if (location == NULL)
    dsk_die ("error making directory: %s", error->message);

  for (i = 0; i < DSK_N_ELEMENTS (tests); i++)
    {
      fprintf (stderr, "Test: %s... ", tests[i].name);
      tests[i].test ();
      fprintf (stderr, " done.\n");
    }

  if (cmdline_keep_testdir)
    {
      fprintf (stderr,
               "test-table-file: keep-testdir: preserving test directory %s\n",
               dsk_dir_get_str (location));
    }
  else
    {
      DskError *error = NULL;
      if (!dsk_remove_dir_recursive (dsk_dir_get_str (location), &error))
        dsk_die ("error removing directory %s: %s",
                 dsk_dir_get_str (location), error->message);
    }
  dsk_cleanup ();
  return 0;
}
Esempio n. 8
0
int main(int argc, char **argv)
{
  unsigned i;

  dsk_cmdline_init ("test HTTP-Header parsing",
                    "Test the HTTP-Header Parsing Code",
                    NULL, 0);
  dsk_cmdline_add_boolean ("verbose", "extra logging", NULL, 0,
                           &cmdline_verbose);
  dsk_cmdline_process_args (&argc, &argv);

  for (i = 0; i < DSK_N_ELEMENTS (tests); i++)
    {
      fprintf (stderr, "Test: %s... ", tests[i].name);
      tests[i].test ();
      fprintf (stderr, " done.\n");
    }
  dsk_cleanup ();
  return 0;
}
Esempio n. 9
0
static void
add_bullet (unsigned *n_inout,
            DskJsonValue ***arr_inout,
            unsigned *alloced_inout,
            int       px,
            int       py)
{
  DskJsonMember members[5];
  members[0].name = "x";
  members[0].value = dsk_json_value_new_number (px);
  members[1].name = "y";
  members[1].value = dsk_json_value_new_number (py);
  members[2].name = "radius";
  members[2].value = dsk_json_value_new_number (TILE_SIZE * 3 / 8);
  members[3].name = "color";
  members[3].value = dsk_json_value_new_string (7, "#ffffff");
  members[4].name = "type";
  members[4].value = dsk_json_value_new_string (6, "circle");
  append_element_json (n_inout, arr_inout, alloced_inout,
           dsk_json_value_new_object (DSK_N_ELEMENTS (members), members));
}
Esempio n. 10
0
static void
handle_get_games_list (DskHttpServerRequest *request)
{
  unsigned n_games = 0;
  Game *game;
  DskJsonValue **game_info, **at;
  for (game = all_games; game; game = game->next_game)
    n_games++;
  game_info = dsk_malloc (sizeof (DskJsonValue *) * n_games);

  at = game_info;
  for (game = all_games; game; game = game->next_game, at++)
    {
      Object *object;
      unsigned n_players = 0;
      DskJsonValue **pat;
      DskJsonMember members[2] = {
        { "name", dsk_json_value_new_string (strlen (game->name), game->name) },
        { "players", NULL },
      };
      DskJsonValue **players;
      for (object = game->objects[OBJECT_TYPE_USER]; object != NULL; object = object->next_in_game)
        n_players++;
      players = dsk_malloc (sizeof (DskJsonValue *) * n_players);
      pat = players;
      for (object = game->objects[OBJECT_TYPE_USER]; object != NULL; object = object->next_in_game)
        {
          User *player = (User *)object;
          *pat++ = dsk_json_value_new_string (strlen (player->name), player->name);
        }
      members[1].value = dsk_json_value_new_array (n_players, players);
      dsk_free (players);
      *at++ = dsk_json_value_new_object (DSK_N_ELEMENTS (members), members);
    }

  respond_take_json (request, dsk_json_value_new_array (n_games, game_info));
  dsk_free (game_info);
}
Esempio n. 11
0
static void
add_wall (unsigned *n_inout,
          DskJsonValue ***arr_inout,
          unsigned *alloced_inout,
          int x, int y, unsigned width, unsigned height)
{
  DskJsonMember members[6];
  members[0].name = "x";
  members[0].value = dsk_json_value_new_number (x);
  members[1].name = "y";
  members[1].value = dsk_json_value_new_number (y);
  members[2].name = "width";
  members[2].value = dsk_json_value_new_number (width);
  members[3].name = "height";
  members[3].value = dsk_json_value_new_number (height);
  members[4].name = "color";
  members[4].value = dsk_json_value_new_string (7, "#ffffff");
  members[5].name = "type";
  members[5].value = dsk_json_value_new_string (9, "rectangle");

  append_element_json (n_inout, arr_inout, alloced_inout,
           dsk_json_value_new_object (DSK_N_ELEMENTS (members), members));
}
Esempio n. 12
0
static void
test_various_write_seek_1 (const char *name,
                           unsigned    n_entries,
                           TestEntry  *entries,
                           unsigned    n_negative,
                           TestEntry  *neg_entries)
{
  DskError *error = NULL;
  unsigned i;
  DskTableFileInterface *iface = &dsk_table_file_interface_trivial;
  DskTableFileWriter *writer;
  DskTableFileSeeker *seeker;

  if (cmdline_verbose)
    fprintf (stderr, "running dataset %s [%u]\n", name, n_entries);
  else
    fprintf (stderr, ".");

  writer = iface->new_writer (iface, location, "base", &error);
  if (writer == NULL)
    dsk_die ("%s", error->message);
  for (i = 0; i < n_entries; i++)
    {
      TestEntry *e = entries + i;
      if (!writer->write (writer,
                          strlen (e->key), (uint8_t*) e->key,
                          strlen (e->value), (uint8_t*) e->value,
                          &error))
        dsk_die ("error writing: %s", error->message);
    }
  if (!writer->close (writer, &error))
    dsk_die ("error closing writer: %s", error->message);
  writer->destroy (writer);

  /* --- now test seeker --- */

  /* pick the step size. */
  {
  static unsigned prime_table[] = { 29, 31, 37, 41, 43, 47, 53, 59, 61, 67 };
  unsigned *p_ptr = prime_table + DSK_N_ELEMENTS (prime_table) - 1;
  unsigned max_test, n_test, test_i, step;
  while (n_entries % *p_ptr == 0)
    p_ptr--;
  step = *p_ptr % n_entries;

  /* create seeker */
  seeker = iface->new_seeker (iface, location, "base", &error);
  if (seeker == NULL)
    dsk_die ("error creating seeker from newly finished writer: %s",
             error->message);

  max_test = cmdline_slow ? 100000 : 1000;
  n_test = DSK_MIN (n_entries, max_test);
  test_i = step;
  for (i = 0; i < n_test; i++)
    {
      unsigned key_len, value_len;
      const uint8_t *key_data, *value_data;
      /* do the seek */
      if (!seeker->find (seeker,
                         str_test_func,
                         (void*) entries[test_i].key,
                         DSK_TABLE_FILE_FIND_ANY,
                         &key_len, &key_data,
                         &value_len, &value_data,
                         &error))
        {
          if (error)
            dsk_die ("error doing find that should have succeeded: %s",
                     error->message);
          else
            dsk_die ("not found doing find that should have succeeded");
        }
#if 0
      dsk_warning ("test=%s, got result %.*s", entries[test_i].key,
                   (int) key_len, key_data);
#endif
      dsk_assert (key_len == strlen (entries[test_i].key));
      dsk_assert (value_len == strlen (entries[test_i].value));
      dsk_assert (memcmp (key_data, entries[test_i].key, key_len) == 0);
      dsk_assert (memcmp (value_data, entries[test_i].value, value_len) == 0);

      /* advance test_i */
      test_i += step;
      if (test_i >= n_entries)
        test_i -= n_entries;
    }

  /* do negative tests */
  for (i = 0; i < n_negative; i++)
    {
      unsigned key_len, value_len;
      const uint8_t *key_data, *value_data;
      /* do the seek */
      if (!seeker->find (seeker,
                         str_test_func,
                         (void*) neg_entries[i].key,
                         DSK_TABLE_FILE_FIND_ANY,
                         &key_len, &key_data,
                         &value_len, &value_data,
                         &error))
        {
          if (error)
            dsk_die ("error doing find that should have returned nothing: %s",
                     error->message);
        }
      else if (key_len == strlen (neg_entries[i].key)
               && memcmp (key_data, neg_entries[i].key, key_len) == 0)
        {
          dsk_die ("found result when none expected");
        }
    }


  seeker->destroy (seeker);
  }
}
Esempio n. 13
0
int main(int argc, char** argv)
{

  DskBuffer gskbuffer;
  char buf[1024];
  char *str;

  dsk_cmdline_init ("test dsk-buffer code", "test DskBuffer", NULL, 0);
  dsk_cmdline_process_args (&argc, &argv);

  dsk_buffer_init (&gskbuffer);
  dsk_assert (gskbuffer.size == 0);
  dsk_buffer_append (&gskbuffer, 5, "hello");
  dsk_assert (gskbuffer.size == 5);
  dsk_assert (dsk_buffer_read (&gskbuffer, sizeof (buf), buf) == 5);
  dsk_assert (memcmp (buf, "hello", 5) == 0);
  dsk_assert (gskbuffer.size == 0);
  dsk_buffer_clear (&gskbuffer);

  dsk_buffer_init (&gskbuffer);
  count (&gskbuffer, 1, 100000);
  decount (&gskbuffer, 1, 100000);
  dsk_assert (gskbuffer.size == 0);
  dsk_buffer_clear (&gskbuffer);

  dsk_buffer_init (&gskbuffer);
  dsk_buffer_append_string (&gskbuffer, "hello\na\nb");
  str = dsk_buffer_read_line (&gskbuffer);
  dsk_assert (str);
  dsk_assert (strcmp (str, "hello") == 0);
  dsk_free (str);
  str = dsk_buffer_read_line (&gskbuffer);
  dsk_assert (str);
  dsk_assert (strcmp (str, "a") == 0);
  dsk_free (str);
  dsk_assert (gskbuffer.size == 1);
  dsk_assert (dsk_buffer_read_line (&gskbuffer) == NULL);
  dsk_buffer_append_byte (&gskbuffer, '\n');
  str = dsk_buffer_read_line (&gskbuffer);
  dsk_assert (str);
  dsk_assert (strcmp (str, "b") == 0);
  dsk_free (str);
  dsk_assert (gskbuffer.size == 0);
  dsk_buffer_clear (&gskbuffer);

  dsk_buffer_init (&gskbuffer);
  dsk_buffer_append (&gskbuffer, 5, "hello");
  dsk_buffer_append_foreign (&gskbuffer, 4, "test", NULL, NULL);
  dsk_buffer_append (&gskbuffer, 5, "hello");
  dsk_assert (gskbuffer.size == 14);
  dsk_assert (dsk_buffer_read (&gskbuffer, sizeof (buf), buf) == 14);
  dsk_assert (memcmp (buf, "hellotesthello", 14) == 0);
  dsk_assert (gskbuffer.size == 0);

  /* Test that the foreign data really is not being stored in the DskBuffer */
  {
    char test_str[5];
    strcpy (test_str, "test");
    dsk_buffer_init (&gskbuffer);
    dsk_buffer_append (&gskbuffer, 5, "hello");
    dsk_buffer_append_foreign (&gskbuffer, 4, test_str, NULL, NULL);
    dsk_buffer_append (&gskbuffer, 5, "hello");
    dsk_assert (gskbuffer.size == 14);
    dsk_assert (dsk_buffer_peek (&gskbuffer, sizeof (buf), buf) == 14);
    dsk_assert (memcmp (buf, "hellotesthello", 14) == 0);
    test_str[1] = '3';
    dsk_assert (gskbuffer.size == 14);
    dsk_assert (dsk_buffer_read (&gskbuffer, sizeof (buf), buf) == 14);
    dsk_assert (memcmp (buf, "hellot3sthello", 14) == 0);
    dsk_buffer_clear (&gskbuffer);
  }

  /* Test str_index_of */
  {
    DskBuffer buffer = DSK_BUFFER_INIT;
    dsk_buffer_append_foreign (&buffer, 3, "abc", NULL, NULL);
    dsk_buffer_append_foreign (&buffer, 3, "def", NULL, NULL);
    dsk_buffer_append_foreign (&buffer, 3, "gad", NULL, NULL);
#if 0
    dsk_assert (dsk_buffer_str_index_of (&buffer, "cdefg") == 2);
    dsk_assert (dsk_buffer_str_index_of (&buffer, "ad") == 7);
    dsk_assert (dsk_buffer_str_index_of (&buffer, "ab") == 0);
    dsk_assert (dsk_buffer_str_index_of (&buffer, "a") == 0);
    dsk_assert (dsk_buffer_str_index_of (&buffer, "g") == 6);
#endif
    dsk_buffer_clear (&buffer);
  }

  static const char *before_strs[] = {
    "",
    "foo",
    NULL, NULL
  };
  before_strs[2] = generate_str (100, 1000);
  before_strs[3] = generate_str (10000, 100000);
  static const char *placeholder_strs[] = {
    "",
    "bar",
    NULL, NULL, NULL
  };
  placeholder_strs[2] = generate_str (100, 1000);
  placeholder_strs[3] = generate_str (10000, 100000);
  placeholder_strs[4] = generate_str (100000, 1000000);
  static const char *after_strs[] = {
    "",
    "foo",
    NULL, NULL
  };
  after_strs[2] = generate_str (100, 1000);
  after_strs[3] = generate_str (10000, 100000);
  unsigned bi, pi, ai;
  for (bi = 0; bi < DSK_N_ELEMENTS (before_strs); bi++)
    for (pi = 0; pi < DSK_N_ELEMENTS (placeholder_strs); pi++)
      for (ai = 0; ai < DSK_N_ELEMENTS (after_strs); ai++)
        {
          DskBuffer buffer = DSK_BUFFER_INIT;
          const char *pi_str = placeholder_strs[pi];
          DskBufferPlaceholder placeholder;
          dsk_buffer_append_string (&buffer, before_strs[bi]);
          dsk_buffer_append_placeholder (&buffer, strlen (pi_str), &placeholder);
          dsk_buffer_append_string (&buffer, after_strs[ai]);
          dsk_buffer_placeholder_set (&placeholder, pi_str);
          dsk_assert (try_initial_remove (&buffer, before_strs[bi]));
          dsk_assert (try_initial_remove (&buffer, pi_str));
          dsk_assert (try_initial_remove (&buffer, after_strs[ai]));
          dsk_assert (buffer.size == 0);
        }

  return 0;
}