/* GLIB - Library of useful routines for C programming
 * Copyright (C) 2001 Joshua Nathaniel Pritikin
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#undef G_LOG_DOMAIN

#ifdef GLIB_COMPILATION
#undef GLIB_COMPILATION
#endif

#include <stdlib.h>
#include <stdio.h>
#include "gring.h"

#define	TEST(cond)	G_STMT_START { gboolean failed = !(cond); \
if (failed) \
  g_print ("\n(%s:%d) failed for: %s\n", __FILE__, __LINE__, ( # cond )); \
else \
  g_print ("."); fflush (stdout); \
} G_STMT_END

void walk_signature(gpointer list, GString *sig)   // GList or GRing
{
  GList *elem;

  g_string_assign(sig, "");

  for (elem=list; elem; elem = g_ring_next(list, elem))
    g_string_append(sig, elem->data);
}

gboolean match_list(GRing *rhead, GList *lhead)
{
  static GString *sig1=0;
  static GString *sig2=0;

  if (!sig1) {
    sig1 = g_string_new(0);
    sig2 = g_string_new(0);
  }

  walk_signature(rhead, sig1);
  walk_signature(lhead, sig2);

  //g_print("%s =? %s\n", sig1->str, sig2->str);

  return strcmp(sig1->str, sig2->str) == 0;
}

gint
_str_compare(const gchar *s1, const gchar *s2)
{ return strcmp(s1,s2); }

gint
_elem_compare(gpointer d1, gpointer d2)
{ return d1 - d2; }

void
_sum (gchar *data, gint *sum)
{
  *sum += atoi(data);
}

#define NUM_TDATA 36
static char *tdata[NUM_TDATA] = {
  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
  "a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
  "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
  "u", "v", "w", "x", "y", "z"
};

int main() {
  GRing *ring=0;
  GList *list=0;
  GRing *ring1;
  GList *list1;
  gint xx;
  gint tx;
  gint sum1, sum2;

  for (xx=0; xx < 5; xx++) {
    ring = g_ring_append(ring, tdata[xx]);
    list = g_list_append(list, tdata[xx]);
  }

  for (xx=0; xx < 6; xx++) {
    GRing *rx;
    GList *lx;

    rx = g_ring_nth (ring, xx);
    lx = g_list_nth (list, xx);
    TEST((rx==0 && lx==0) || rx->data == lx->data);

    rx = g_ring_nth_prev (g_ring_last(ring), xx);
    lx = g_list_nth_prev (g_list_last(list), xx);
    TEST((rx==0 && lx==0) || rx->data == lx->data);
  }

  TEST(match_list(ring, list));
  
  g_ring_free(ring);
  g_list_free(list);
  ring = NULL;
  list = NULL;

  for (xx=0; xx < 5; xx++) {
    ring = g_ring_prepend(ring, tdata[xx]);
    list = g_list_prepend(list, tdata[xx]);
  }

  TEST(match_list(ring, list));
  
  TEST (g_ring_find_nearby (ring, NULL) == NULL);

  for (ring1=ring; ring1; ring1 = g_ring_next (ring, ring1)) {
    TEST (g_ring_find_nearby (ring, ring1->data) == ring1);
  }

  ring = g_ring_prepend(ring, tdata[6]);
  list = g_list_prepend(list, tdata[6]);

  for (ring1=ring; ring1; ring1 = g_ring_next (ring, ring1)) {
    TEST (g_ring_find_nearby (ring, ring1->data) == ring1);
  }

  ring = g_ring_remove(ring, tdata[2]);
  list = g_list_remove(list, tdata[2]);
  ring = g_ring_remove(ring, tdata[8]);
  list = g_list_remove(list, tdata[8]);

  TEST(match_list(ring, list));

  ring = g_ring_remove_link(ring, NULL);
  list = g_list_remove_link(list, NULL);

  ring1 = ring;
  list1 = list;
  ring = g_ring_remove_link(ring, ring1);
  list = g_list_remove_link(list, list1);
  ring = g_ring_remove_link(ring, ring1);
  list = g_list_remove_link(list, list1);
  g_ring_free_1(ring1);
  g_list_free_1(list1);
  
  TEST(match_list(ring, list));

  g_ring_free(ring);
  g_list_free(list);
  ring = NULL;
  list = NULL;

  tx=0;
  for (xx=0; xx < 2; xx++) {
    ring = g_ring_insert(ring, tdata[tx], -1);
    list = g_list_insert(list, tdata[tx++], -1);

    ring = g_ring_insert(ring, tdata[tx], 0);
    list = g_list_insert(list, tdata[tx++], 0);
    
    ring = g_ring_insert(ring, tdata[tx], 1);
    list = g_list_insert(list, tdata[tx++], 1);

    ring = g_ring_insert(ring, tdata[tx], 2);
    list = g_list_insert(list, tdata[tx++], 2);

    ring = g_ring_insert(ring, tdata[tx], 100);
    list = g_list_insert(list, tdata[tx++], 100);
  }
  
  TEST(match_list(ring, list));
  
  g_ring_free(ring);
  g_list_free(list);
  ring = NULL;
  list = NULL;

  ring = g_ring_insert_sorted (ring, tdata[4], (GCompareDataFunc) _str_compare, NULL);
  list = g_list_insert_sorted (list, tdata[4], (GCompareFunc) _str_compare);

  ring = g_ring_insert_sorted (ring, tdata[5], (GCompareDataFunc) _str_compare, NULL);
  list = g_list_insert_sorted (list, tdata[5], (GCompareFunc) _str_compare);

  ring = g_ring_insert_sorted (ring, tdata[3], (GCompareDataFunc) _str_compare, NULL);
  list = g_list_insert_sorted (list, tdata[3], (GCompareFunc) _str_compare);

  ring = g_ring_insert_sorted (ring, tdata[5], (GCompareDataFunc) _str_compare, NULL);
  list = g_list_insert_sorted (list, tdata[5], (GCompareFunc) _str_compare);

  ring = g_ring_insert_sorted (ring, tdata[6], (GCompareDataFunc) _str_compare, NULL);
  list = g_list_insert_sorted (list, tdata[6], (GCompareFunc) _str_compare);

  ring = g_ring_insert_sorted (ring, tdata[8], (GCompareDataFunc) _str_compare, NULL);
  list = g_list_insert_sorted (list, tdata[8], (GCompareFunc) _str_compare);

  ring = g_ring_insert_sorted (ring, tdata[7], (GCompareDataFunc) _str_compare, NULL);
  list = g_list_insert_sorted (list, tdata[7], (GCompareFunc) _str_compare);

  sum1 = sum2 = 0;
  g_ring_foreach(&ring, (GFunc) _sum, &sum1);
  g_list_foreach(list, (GFunc) _sum, &sum2);
  TEST (sum1 == sum2);

  TEST (match_list(ring, list));
  
  TEST (g_ring_find (ring, tdata[20]) == NULL);
  TEST (g_list_find (list, tdata[20]) == NULL);

  TEST (g_ring_find (ring, tdata[7])->data == tdata[7]);
  TEST (g_list_find (list, tdata[7])->data == tdata[7]);

  // API difference XXX
  TEST (g_ring_find_custom (ring, (GCompareFunc) _elem_compare, tdata[20]) == NULL);
  TEST (g_list_find_custom (list, tdata[20], (GCompareFunc) _elem_compare) == NULL);

  TEST (g_ring_find_custom (ring, (GCompareFunc) _elem_compare, tdata[7])->data == tdata[7]);
  TEST (g_list_find_custom (list, tdata[7], (GCompareFunc) _elem_compare)->data == tdata[7]);

  TEST (g_ring_index (ring, tdata[7]) ==
	g_list_index (list, tdata[7]));
  TEST (g_ring_index (ring, tdata[20]) ==
	g_list_index (list, tdata[20]));

  TEST (g_ring_position (ring, ring->prev) ==
	g_list_position (list, g_list_last(list)));
  TEST (g_ring_position (ring, 0) ==
	g_list_position (list, 0));

  TEST (g_ring_length (ring) ==
	g_list_length (list));
  TEST (g_ring_length (0) ==
	g_list_length (0));

  ring = g_ring_reverse (ring);
  list = g_list_reverse (list);

  TEST(match_list(ring, list));

  ring = g_ring_reverse (ring);
  list = g_list_reverse (list);

  ring1 = NULL;
  list1 = NULL;
  ring1 = g_ring_append (ring1, tdata[10]);
  list1 = g_list_append (list1, tdata[10]);
  ring1 = g_ring_append (ring1, tdata[11]);
  list1 = g_list_append (list1, tdata[11]);

  ring = g_ring_concat (ring, ring1);
  list = g_list_concat (list, list1);

  TEST(match_list(ring, list));

  ring1 = g_ring_copy (ring);

  TEST(match_list(ring, ring1));

  g_ring_free (ring1);

  ring = g_ring_remove_all (ring, tdata[5]);
  list = g_list_remove_all (list, tdata[5]);

  TEST(match_list(ring, list));

  ring = g_ring_delete_link (ring, ring);
  list = g_list_delete_link (list, list);

  TEST(match_list(ring, list));

  while (ring)
    ring = g_ring_delete_link (ring, ring);
  while (list)
    list = g_list_delete_link (list, list);

  g_print("\n");

  return 0;
}