/*

 * test-completion-model.c

 * This file is part of GtkSourceView

 *

 * Copyright (C) 2013 - Sébastien Wilmet <swilmet@gnome.org>

 *

 * GtkSourceView 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.

 *

 * GtkSourceView 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include <gtk/gtk.h>

#include <gtksourceview/gtksource.h>

#include "gtksourceview/gtksourcecompletionmodel.h"

/* Basic provider.

 * The populate function is not implemented. Proposals are created

 * independendly (it is more convenient).

 */

typedef struct _TestProvider      TestProvider;

typedef struct _TestProviderClass TestProviderClass;

struct _TestProvider

{

	GObject parent_instance;

	gint priority;

};

struct _TestProviderClass

{

	GObjectClass parent_class;

};

GType test_provider_get_type (void);

static void test_provider_iface_init (GtkSourceCompletionProviderIface *iface);

G_DEFINE_TYPE_WITH_CODE (TestProvider,

			 test_provider,

			 G_TYPE_OBJECT,

			 G_IMPLEMENT_INTERFACE (GTK_SOURCE_TYPE_COMPLETION_PROVIDER,

						test_provider_iface_init));

static gchar *

test_provider_get_name (GtkSourceCompletionProvider *provider)

{

	return g_strdup ("Hobbits");

}

static gint

test_provider_get_priority (GtkSourceCompletionProvider *provider)

{

	return ((TestProvider *)provider)->priority;

}

static void

test_provider_iface_init (GtkSourceCompletionProviderIface *iface)

{

	iface->get_name = test_provider_get_name;

	iface->get_priority = test_provider_get_priority;

}

static void

test_provider_class_init (TestProviderClass *klass)

{

}

static void

test_provider_init (TestProvider *self)

{

	self->priority = 0;

}

static TestProvider *

test_provider_new (void)

{

	return g_object_new (test_provider_get_type (), NULL);

}

/* Utilities functions */

static GList *

create_proposals (void)

{

	GtkSourceCompletionItem *item;

	GList *list = NULL;

	item = gtk_source_completion_item_new2 ();

	gtk_source_completion_item_set_label (item, "Bilbo");

	gtk_source_completion_item_set_text (item, "Bilbo");

	list = g_list_prepend (list, item);

	item = gtk_source_completion_item_new2 ();

	gtk_source_completion_item_set_label (item, "Frodo");

	gtk_source_completion_item_set_text (item, "Frodo");

	list = g_list_prepend (list, item);

	return list;

}

/* Each returned provider is associated with a list of proposals.

 * The providers are sorted in decreasing order of priority, i.e. the same order

 * as in the CompletionModel.

 */

static void

create_providers (GList **all_providers,

		  GList **all_list_proposals)

{

	TestProvider *provider;

	*all_providers = NULL;

	*all_list_proposals = NULL;

	provider = test_provider_new ();

	provider->priority = 5;

	*all_providers = g_list_append (*all_providers, provider);

	*all_list_proposals = g_list_append (*all_list_proposals, create_proposals ());

	provider = test_provider_new ();

	provider->priority = 3;

	*all_providers = g_list_append (*all_providers, provider);

	*all_list_proposals = g_list_append (*all_list_proposals, create_proposals ());

}

static void

populate_model (GtkSourceCompletionModel *model,

		GList                    *all_providers,

		GList                    *all_list_proposals)

{

	GList *cur_provider;

	GList *cur_list_proposals;

	for (cur_provider = all_providers,

	     cur_list_proposals = all_list_proposals;

	     cur_provider != NULL;

	     cur_provider = g_list_next (cur_provider),

	     cur_list_proposals = g_list_next (cur_list_proposals))

	{

		gtk_source_completion_model_add_proposals (model,

							   GTK_SOURCE_COMPLETION_PROVIDER (cur_provider->data),

							   cur_list_proposals->data);

	}

}

static void

free_providers (GList *all_providers,

		GList *all_list_proposals)

{

	GList *cur_list_proposals = NULL;

	g_list_free_full (all_providers, g_object_unref);

	for (cur_list_proposals = all_list_proposals;

	     cur_list_proposals != NULL;

	     cur_list_proposals = g_list_next (cur_list_proposals))

	{

		g_list_free_full (cur_list_proposals->data, g_object_unref);

	}

	g_list_free (all_list_proposals);

}

/* Check whether the provider is correctly present in the CompletionModel, at

 * the position specified by @iter.

 */

static void

check_provider (GtkSourceCompletionModel    *model,

		GtkSourceCompletionProvider *provider,

		GList                       *list_proposals,

		gboolean                     is_header_visible,

		GtkTreeIter                 *iter)

{

	GtkSourceCompletionProposal *proposal_get = NULL;

	GtkSourceCompletionProvider *provider_get = NULL;

	GList *cur_proposal = NULL;

	/* Check the header */

	if (is_header_visible)

	{

		g_assert (gtk_source_completion_model_iter_is_header (model, iter));

		gtk_tree_model_get (GTK_TREE_MODEL (model), iter,

				    GTK_SOURCE_COMPLETION_MODEL_COLUMN_PROPOSAL, &proposal_get,

				    GTK_SOURCE_COMPLETION_MODEL_COLUMN_PROVIDER, &provider_get,

				    -1);

		g_assert (proposal_get == NULL);

		g_assert (provider_get == provider);

		g_assert (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), iter));

	}

	/* Check the proposals */

	cur_proposal = list_proposals;

	while (TRUE)

	{

		gtk_tree_model_get (GTK_TREE_MODEL (model), iter,

				    GTK_SOURCE_COMPLETION_MODEL_COLUMN_PROPOSAL, &proposal_get,

				    GTK_SOURCE_COMPLETION_MODEL_COLUMN_PROVIDER, &provider_get,

				    -1);

		g_assert (proposal_get == cur_proposal->data);

		g_assert (provider_get == provider);

		cur_proposal = g_list_next (cur_proposal);

		if (cur_proposal == NULL)

		{

			break;

		}

		g_assert (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), iter));

	}

}

/* Check the full contents of a CompletionModel. */

static void

check_all_providers (GtkSourceCompletionModel *model,

		     GList                    *all_providers,

		     GList                    *all_list_proposals,

		     gboolean                  is_header_visible)

{

	GtkTreeIter iter;

	GList *cur_provider = NULL;

	GList *cur_list_proposals = NULL;

	g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter));

	cur_provider = all_providers;

	cur_list_proposals = all_list_proposals;

	while (TRUE)

	{

		check_provider (model,

				GTK_SOURCE_COMPLETION_PROVIDER (cur_provider->data),

				cur_list_proposals->data,

				is_header_visible,

				&iter);

		cur_provider = g_list_next (cur_provider);

		cur_list_proposals = g_list_next (cur_list_proposals);

		if (cur_provider == NULL)

		{

			g_assert (cur_list_proposals == NULL);

			break;

		}

		g_assert (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));

	}

	g_assert (!gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));

}

static void

check_all_providers_with_and_without_headers (GtkSourceCompletionModel *model,

					      GList                    *all_providers,

					      GList                    *all_list_proposals)

{

	gtk_source_completion_model_set_show_headers (model, TRUE);

	check_all_providers (model, all_providers, all_list_proposals, TRUE);

	gtk_source_completion_model_set_show_headers (model, FALSE);

	check_all_providers (model, all_providers, all_list_proposals, FALSE);

}

static gboolean

same_list_contents (GList *list1, GList *list2)

{

	GList *cur_item1 = list1;

	GList *cur_item2 = list2;

	if (g_list_length (list1) != g_list_length (list2))

	{

		return FALSE;

	}

	while (cur_item1 != NULL)

	{

		if (cur_item1->data != cur_item2->data)

		{

			return FALSE;

		}

		cur_item1 = g_list_next (cur_item1);

		cur_item2 = g_list_next (cur_item2);

	}

	return TRUE;

}

/* Tests */

static void

test_is_empty (void)

{

	GtkSourceCompletionModel *model;

	TestProvider *provider;

	GList *list_providers = NULL;

	GList *list_proposals = NULL;

	GList *visible_providers = NULL;

	/* Completely empty */

	model = gtk_source_completion_model_new ();

	g_assert (gtk_source_completion_model_is_empty (model, FALSE));

	g_assert (gtk_source_completion_model_is_empty (model, TRUE));

	/* One visible provider */

	provider = test_provider_new ();

	list_providers = g_list_append (list_providers, provider);

	list_proposals = create_proposals ();

	gtk_source_completion_model_add_proposals (model,

						   GTK_SOURCE_COMPLETION_PROVIDER (provider),

						   list_proposals);

	g_assert (!gtk_source_completion_model_is_empty (model, FALSE));

	g_assert (!gtk_source_completion_model_is_empty (model, TRUE));

	/* One invisible provider */

	visible_providers = g_list_append (visible_providers, test_provider_new ());

	gtk_source_completion_model_set_visible_providers (model, visible_providers);

	g_assert (!gtk_source_completion_model_is_empty (model, FALSE));

	g_assert (gtk_source_completion_model_is_empty (model, TRUE));

	g_object_unref (model);

	g_list_free_full (list_providers, g_object_unref);

	g_list_free_full (list_proposals, g_object_unref);

	g_list_free_full (visible_providers, g_object_unref);

}

static void

test_get_visible_providers (void)

{

	GtkSourceCompletionModel *model;

	TestProvider *provider;

	GList *list_providers = NULL;

	GList *visible_providers = NULL;

	model = gtk_source_completion_model_new ();

	g_assert (gtk_source_completion_model_get_visible_providers (model) == NULL);

	provider = test_provider_new ();

	list_providers = g_list_append (list_providers, provider);

	gtk_source_completion_model_set_visible_providers (model, list_providers);

	visible_providers = gtk_source_completion_model_get_visible_providers (model);

	g_assert (visible_providers->data == provider);

	g_object_unref (model);

	g_list_free_full (list_providers, g_object_unref);

}

/* Create several providers with associated proposals, populate them in a

 * CompletionModel, and check whether the CompletionModel correctly contains the

 * providers.

 */

static void

test_simple_populate (void)

{

	GtkSourceCompletionModel *model;

	GList *all_providers = NULL;

	GList *all_list_proposals = NULL;

	model = gtk_source_completion_model_new ();

	create_providers (&all_providers, &all_list_proposals);

	populate_model (model, all_providers, all_list_proposals);

	check_all_providers_with_and_without_headers (model, all_providers, all_list_proposals);

	g_object_unref (model);

	free_providers (all_providers, all_list_proposals);

}

static void

test_set_visible_providers (void)

{

	GtkSourceCompletionModel *model;

	GList *all_providers = NULL;

	GList *all_list_proposals = NULL;

	GList *subset_providers = NULL;

	GList *subset_list_proposals = NULL;

	TestProvider *other_provider;

	/* Populate the model with two providers */

	model = gtk_source_completion_model_new ();

	create_providers (&all_providers, &all_list_proposals);

	populate_model (model, all_providers, all_list_proposals);

	/* The two providers are initially visible */

	check_all_providers_with_and_without_headers (model, all_providers, all_list_proposals);

	gtk_source_completion_model_set_visible_providers (model, NULL);

	check_all_providers_with_and_without_headers (model, all_providers, all_list_proposals);

	gtk_source_completion_model_set_visible_providers (model, all_providers);

	check_all_providers_with_and_without_headers (model, all_providers, all_list_proposals);

	/* Only first provider visible */

	subset_providers = g_list_append (subset_providers, all_providers->data);

	subset_list_proposals = g_list_append (subset_list_proposals, all_list_proposals->data);

	gtk_source_completion_model_set_visible_providers (model, subset_providers);

	check_all_providers_with_and_without_headers (model, subset_providers, subset_list_proposals);

	/* Only second provider visible */

	subset_providers->data = all_providers->next->data;

	subset_list_proposals->data = all_list_proposals->next->data;

	gtk_source_completion_model_set_visible_providers (model, subset_providers);

	check_all_providers_with_and_without_headers (model, subset_providers, subset_list_proposals);

	/* No visible providers */

	other_provider = test_provider_new ();

	subset_providers->data = other_provider;

	gtk_source_completion_model_set_visible_providers (model, subset_providers);

	g_assert (gtk_source_completion_model_is_empty (model, TRUE));

	/* The two providers are visible again */

	gtk_source_completion_model_set_visible_providers (model, NULL);

	check_all_providers_with_and_without_headers (model, all_providers, all_list_proposals);

	g_object_unref (model);

	g_object_unref (other_provider);

	free_providers (all_providers, all_list_proposals);

	g_list_free (subset_providers);

	g_list_free (subset_list_proposals);

}

static void

test_populate_several_batches (void)

{

	GtkSourceCompletionModel *model = gtk_source_completion_model_new ();

	GtkSourceCompletionProvider *provider = GTK_SOURCE_COMPLETION_PROVIDER (test_provider_new ());

	GList *list_providers = g_list_append (NULL, provider);

	GList *first_proposals = create_proposals ();

	GList *second_proposals = create_proposals ();

	GList *all_proposals;

	GtkTreeIter iter;

	gtk_source_completion_model_set_show_headers (model, TRUE);

	/* First batch */

	gtk_source_completion_model_add_proposals (model, provider, first_proposals);

	g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter));

	check_provider (model, provider, first_proposals, TRUE, &iter);

	g_assert (!gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));

	/* Second batch */

	gtk_source_completion_model_add_proposals (model, provider, second_proposals);

	all_proposals = g_list_copy (first_proposals);

	all_proposals = g_list_concat (all_proposals, g_list_copy (second_proposals));

	g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter));

	check_provider (model, provider, all_proposals, TRUE, &iter);

	g_assert (!gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter));

	g_object_unref (model);

	g_object_unref (provider);

	g_list_free (list_providers);

	g_list_free (first_proposals);

	g_list_free (second_proposals);

	g_list_free_full (all_proposals, g_object_unref);

}

static void

test_get_providers (void)

{

	GtkSourceCompletionModel *model = gtk_source_completion_model_new ();

	GList *all_providers = NULL;

	GList *all_list_proposals = NULL;

	GList *providers_get = NULL;

	/* Empty */

	g_assert (gtk_source_completion_model_get_providers (model) == NULL);

	/* Non-empty */

	create_providers (&all_providers, &all_list_proposals);

	populate_model (model, all_providers, all_list_proposals);

	providers_get = gtk_source_completion_model_get_providers (model);

	g_assert (same_list_contents (all_providers, providers_get));

	g_object_unref (model);

	free_providers (all_providers, all_list_proposals);

	g_list_free (providers_get);

}

static void

test_iters_impl (gboolean show_headers)

{

	GtkSourceCompletionModel *model = gtk_source_completion_model_new ();

	GList *all_providers = NULL;

	GList *all_list_proposals = NULL;

	GtkTreeIter first_iter;

	GtkTreeIter last_iter;

	GtkTreeIter other_iter;

	GtkTreePath *path = NULL;

	gint nb_items;

	gint *indices;

	/* Test last_proposal() */

	g_assert (!gtk_source_completion_model_last_proposal (model, &last_iter));

	create_providers (&all_providers, &all_list_proposals);

	populate_model (model, all_providers, all_list_proposals);

	gtk_source_completion_model_set_show_headers (model, show_headers);

	g_assert (gtk_source_completion_model_last_proposal (model, &last_iter));

	/* Get the last proposal by another means, and compare it */

	nb_items = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (model), NULL);

	g_assert (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (model),

						 &other_iter,

						 NULL,

						 nb_items - 1));

	g_assert (gtk_source_completion_model_iter_equal (model, &last_iter, &other_iter));

	/* Test get_path() */

	path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &last_iter);

	indices = gtk_tree_path_get_indices (path);

	g_assert (indices[0] == nb_items - 1);

	/* Test iter_previous() */

	while (gtk_source_completion_model_iter_previous (model, &other_iter));

	g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &first_iter));

	g_assert (gtk_source_completion_model_iter_equal (model, &first_iter, &other_iter));

	/* Test iter_children() */

	g_assert (gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &other_iter, NULL));

	g_assert (gtk_source_completion_model_iter_equal (model, &first_iter, &other_iter));

	g_assert (!gtk_tree_model_iter_children (GTK_TREE_MODEL (model), &other_iter, &first_iter));

	/* Test iter_has_child() */

	g_assert (!gtk_tree_model_iter_has_child (GTK_TREE_MODEL (model), &first_iter));

	/* Test iter_parent() */

	g_assert (!gtk_tree_model_iter_parent (GTK_TREE_MODEL (model), &other_iter, &first_iter));

	g_object_unref (model);

	free_providers (all_providers, all_list_proposals);

	gtk_tree_path_free (path);

}

static void

test_iters (void)

{

	test_iters_impl (FALSE);

	test_iters_impl (TRUE);

}

static void

on_row_changed (GtkTreeModel                *model,

		GtkTreePath                 *path,

		GtkTreeIter                 *iter,

		GtkSourceCompletionProposal *proposal)

{

	GtkSourceCompletionProposal *row_proposal = NULL;

	gtk_tree_model_get (model, iter,

			    GTK_SOURCE_COMPLETION_MODEL_COLUMN_PROPOSAL, &row_proposal,

			    -1);

	/* Make sure that the signal was emitted for the good row. */

	g_assert (proposal == row_proposal);

}

static void

test_row_changed (void)

{

	GtkSourceCompletionModel *model = gtk_source_completion_model_new ();

	TestProvider *provider = test_provider_new ();

	GList *proposals = create_proposals ();

	GtkSourceCompletionProposal *proposal = proposals->data;

	gtk_source_completion_model_add_proposals (model,

						   GTK_SOURCE_COMPLETION_PROVIDER (provider),

						   proposals);

	g_signal_connect (model,

			  "row-changed",

			  G_CALLBACK (on_row_changed),

			  proposal);

	gtk_source_completion_proposal_changed (proposal);

	g_object_unref (model);

	g_object_unref (provider);

	g_list_free_full (proposals, g_object_unref);

}

int

main (int argc, char **argv)

{

	gtk_test_init (&argc, &argv);

	g_test_add_func ("/CompletionModel/is-empty",

			 test_is_empty);

	g_test_add_func ("/CompletionModel/get-visible-providers",

			 test_get_visible_providers);

	g_test_add_func ("/CompletionModel/simple-populate",

			 test_simple_populate);

	g_test_add_func ("/CompletionModel/set-visible-providers",

			 test_set_visible_providers);

	g_test_add_func ("/CompletionModel/populate-several-batches",

			 test_populate_several_batches);

	g_test_add_func ("/CompletionModel/get-providers",

			 test_get_providers);

	g_test_add_func ("/CompletionModel/iters",

			 test_iters);

	g_test_add_func ("/CompletionModel/row-changed",

			 test_row_changed);

	return g_test_run ();

}