/* 

 * Copyright © 2008 Ryan Lortie

 * 

 * This program 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.1 of the License, or (at your option) any later version.

 * 

 * See the included COPYING file for more information.

 */

#include <string.h>

#include <stdio.h>

#include <glib.h>

/* keep track of GString instances to make sure nothing leaks */

static int strings_allocated;

/* === the GMarkupParser functions === */

static void

subparser_start_element (GMarkupParseContext  *context,

                         const gchar          *element_name,

                         const gchar         **attribute_names,

                         const gchar         **attribute_values,

                         gpointer              user_data,

                         GError              **error)

{

  g_string_append_printf (user_data, "{%s}", element_name);

  /* we don't like trouble... */

  if (strcmp (element_name, "trouble") == 0)

    g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                 "we don't like trouble");

}

static void

subparser_end_element (GMarkupParseContext  *context,

                       const gchar          *element_name,

                       gpointer              user_data,

                       GError              **error)

{

  g_string_append_printf (user_data, "{/%s}", element_name);

}

static void

subparser_error (GMarkupParseContext *context,

                 GError              *error,

                 gpointer             user_data)

{

  g_string_free (user_data, TRUE);

  strings_allocated--;

}

static GMarkupParser subparser_parser =

{

  subparser_start_element,

  subparser_end_element,

  NULL,

  NULL,

  subparser_error

};

/* convenience functions for a parser that does not

 * replay the starting tag into the subparser...

 */

static void

subparser_start (GMarkupParseContext *ctx)

{

  gpointer user_data;

  user_data = g_string_new (NULL);

  strings_allocated++;

  g_markup_parse_context_push (ctx, &subparser_parser, user_data);

}

static char *

subparser_end (GMarkupParseContext  *ctx,

               GError              **error)

{

  GString *string;

  char *result;

  string = g_markup_parse_context_pop (ctx);

  result = string->str;

  g_string_free (string, FALSE);

  strings_allocated--;

  if (result == NULL || result[0] == '\0')

    {

      g_free (result);

      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                   "got no data");

      return NULL;

    }

  return result;

}

/* convenience functions for a parser that -does-

 * replay the starting tag into the subparser...

 */

static gboolean

replay_parser_start (GMarkupParseContext  *ctx,

                     const char           *element_name,

                     const char          **attribute_names,

                     const char          **attribute_values,

                     GError              **error)

{

  GError *tmp_error = NULL;

  gpointer user_data;

  user_data = g_string_new (NULL);

  strings_allocated++;

  subparser_parser.start_element (ctx, element_name,

                                  attribute_names, attribute_values,

                                  user_data, &tmp_error);

  if (tmp_error)

    {

      g_propagate_error (error, tmp_error);

      g_string_free (user_data, TRUE);

      strings_allocated--;

      return FALSE;

    }

  g_markup_parse_context_push (ctx, &subparser_parser, user_data);

  return TRUE;

}

static char *

replay_parser_end (GMarkupParseContext  *ctx,

                   GError              **error)

{

  GError *tmp_error = NULL;

  GString *string;

  char *result;

  string = g_markup_parse_context_pop (ctx);

  subparser_parser.end_element (ctx, g_markup_parse_context_get_element (ctx),

                                string, &tmp_error);

  if (tmp_error)

    {

      g_propagate_error (error, tmp_error);

      g_string_free (string, TRUE);

      strings_allocated--;

      return NULL;

    }

  result = string->str;

  g_string_free (string, FALSE);

  strings_allocated--;

  if (result == NULL || result[0] == '\0')

    {

      g_free (result);

      g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,

                   "got no data");

      return NULL;

    }

  return result;

}

/* === start interface between subparser and calling parser === */

static void      subparser_start      (GMarkupParseContext  *ctx);

static char     *subparser_end        (GMarkupParseContext  *ctx,

                                       GError              **error);

/* === end interface between subparser and calling parser === */

/* === start interface between replay parser and calling parser === */

static gboolean  replay_parser_start  (GMarkupParseContext  *ctx,

                                       const char           *element_name,

                                       const char          **attribute_names,

                                       const char          **attribute_values,

                                       GError              **error);

static char     *replay_parser_end    (GMarkupParseContext  *ctx,

                                       GError              **error);

/* === end interface between replay parser and calling parser === */

/* now comes our parser for the test.

 *

 * we recognise the tags <test> and <sub>.

 * <test> is ignored.

 * <sub> invokes the subparser (no replay).

 *

 * "unknown tags" are passed to the reply subparser

 * (so the unknown tag is fed to the subparser...)

 */

static void

start_element (GMarkupParseContext  *context,

               const gchar          *element_name,

               const gchar         **attribute_names,

               const gchar         **attribute_values,

               gpointer              user_data,

               GError              **error)

{

  g_string_append_printf (user_data, "<%s>", element_name);

  if (strcmp (element_name, "test") == 0)

    {

      /* do nothing */

    }

  else if (strcmp (element_name, "sub") == 0)

    {

      /* invoke subparser */

      subparser_start (context);

    }

  else

    {

      /* unknown tag.  invoke replay subparser */

      if (!replay_parser_start (context, element_name,

                                attribute_names, attribute_values,

                                error))

        return;

    }

}

static void

end_element (GMarkupParseContext  *context,

             const gchar          *element_name,

             gpointer              user_data,

             GError              **error)

{

  if (strcmp (element_name, "test") == 0)

    {

      /* do nothing */

    }

  else if (strcmp (element_name, "sub") == 0)

    {

      char *result;

      if ((result = subparser_end (context, error)) == NULL)

        return;

      g_string_append_printf (user_data, "<<%s>>", result);

      g_free (result);

    }

  else

    {

      char *result;

      if ((result = replay_parser_end (context, error)) == NULL)

        return;

      g_string_append_printf (user_data, "[[%s]]", result);

      g_free (result);

    }

  g_string_append_printf (user_data, "</%s>", element_name);

}

static GMarkupParser parser =

{

  start_element,

  end_element

};

typedef struct

{

  const char *markup;

  const char *result;

  const char *error_message;

} TestCase;

static void

test (gconstpointer user_data)

{

  const TestCase *tc = user_data;

  GMarkupParseContext *ctx;

  GString *string;

  gboolean result;

  GError *error;

  error = NULL;

  string = g_string_new (NULL);

  ctx = g_markup_parse_context_new (&parser, 0, string, NULL);

  result = g_markup_parse_context_parse (ctx, tc->markup,

                                         strlen (tc->markup), &error);

  if (result)

    result = g_markup_parse_context_end_parse (ctx, &error);

  g_markup_parse_context_free (ctx);

  g_assert (strings_allocated == 0);

  if (result)

    {

      if (tc->error_message)

        g_error ("expected failure (about '%s') passed!\n"

                 "  in: %s\n  out: %s",

                 tc->error_message, tc->markup, string->str);

    }

  else

    {

      if (!tc->error_message)

        g_error ("unexpected failure: '%s'\n"

                 "  in: %s\n  out: %s",

                 error->message, tc->markup, string->str);

      if (!strstr (error->message, tc->error_message))

        g_error ("failed for the wrong reason.\n"

                 "  expecting message about '%s'\n"

                 "  got message '%s'\n"

                 "  in: %s\n  out: %s",

                 tc->error_message, error->message, tc->markup, string->str);

    }

  if (strcmp (string->str, tc->result) != 0)

    g_error ("got the wrong result.\n"

             "  expected: '%s'\n"

             "  got: '%s'\n"

             "  input: %s",

             tc->result, string->str, tc->markup);

  if (error)

    g_error_free (error);

  g_string_free (string, TRUE);

}

TestCase test_cases[] = /* successful runs */

{

    /* in */                    /* out */

  { "<test/>",                  "<test></test>" },

  { "<sub><foo/></sub>",        "<sub><<{foo}{/foo}>></sub>" },

  { "<sub><foo/><bar/></sub>",  "<sub><<{foo}{/foo}{bar}{/bar}>></sub>" },

  { "<foo><bar/></foo>",        "<foo>[[{foo}{bar}{/bar}{/foo}]]</foo>" },

  { "<foo><x/><y/></foo>",      "<foo>[[{foo}{x}{/x}{y}{/y}{/foo}]]</foo>" },

  { "<foo/>",                   "<foo>[[{foo}{/foo}]]</foo>" },

  { "<sub><foo/></sub><bar/>",  "<sub><<{foo}{/foo}>></sub>"

                                "<bar>[[{bar}{/bar}]]</bar>" }

};

TestCase error_cases[] = /* error cases */

{

    /* in */                    /* out */                       /* error */

  { "<foo><>",                  "<foo>",                        ">"},

  { "",                         "",                             "empty" },

  { "<trouble/>",               "<trouble>",                    "trouble" },

  { "<sub><trouble>",           "<sub>",                        "trouble" },

  { "<foo><trouble>",           "<foo>",                        "trouble" },

  { "<sub></sub>",              "<sub>",                        "no data" },

  { "<sub/>",                   "<sub>",                        "no data" }

};

#define add_tests(func, basename, array) \

  G_STMT_START { \

    int __add_tests_i;                                                  \

                                                                        \

    for (__add_tests_i  = 0;                                            \

         __add_tests_i < G_N_ELEMENTS (array);                          \

         __add_tests_i++)                                               \

      {                                                                 \

        char *testname;                                                 \

                                                                        \

        testname = g_strdup_printf ("%s/%d", basename, __add_tests_i);  \

        g_test_add_data_func (testname, &array[__add_tests_i], func);   \

        g_free (testname);                                              \

      }                                                                 \

  } G_STMT_END

int

main (int argc, char **argv)

{

  g_setenv ("LC_ALL", "C", TRUE);

  g_test_init (&argc, &argv, NULL);

  add_tests (test, "/glib/markup/subparser/success", test_cases);

  add_tests (test, "/glib/markup/subparser/failure", error_cases);

  return g_test_run ();

}