From 4b187937acb52b5ee5da7c687ded09e7b2c1825a Mon Sep 17 00:00:00 2001

From: Vladimir 'phcoder' Serbinenko <phcoder@gmail.com>

Date: Thu, 2 May 2013 14:39:03 +0200

Subject: [PATCH 401/482] 	First automated video test (running videotest

 and comparing results)

---

 ChangeLog                             |   4 +

 Makefile.util.def                     |   7 +

 grub-core/Makefile.core.def           |   8 +

 grub-core/tests/checksums.c           |  27 +++

 grub-core/tests/fake_input.c          |  67 ++++++

 grub-core/tests/lib/functional_test.c |  29 ++-

 grub-core/tests/video_checksum.c      | 435 ++++++++++++++++++++++++++++++++++

 grub-core/tests/videotest_checksum.c  | 286 ++++++++++++++++++++++

 grub-core/video/capture.c             | 128 ++++++++++

 grub-core/video/video.c               |  13 +-

 include/grub/emu/export.h             |   3 +-

 include/grub/test.h                   |   9 +

 include/grub/video.h                  | 120 +++++++++-

 tests/grub_func_test.in               |  12 +

 tests/util/grub-shell.in              |   2 +

 util/grub-render-label.c              |  97 ++------

 16 files changed, 1150 insertions(+), 97 deletions(-)

 create mode 100644 grub-core/tests/checksums.c

 create mode 100644 grub-core/tests/fake_input.c

 create mode 100644 grub-core/tests/video_checksum.c

 create mode 100644 grub-core/tests/videotest_checksum.c

 create mode 100644 grub-core/video/capture.c

 create mode 100644 tests/grub_func_test.in

diff --git a/ChangeLog b/ChangeLog

index b202abe..37595a9 100644

--- a/ChangeLog

+++ b/ChangeLog

@@ -1,5 +1,9 @@

 2013-05-02  Vladimir Serbinenko  <phcoder@gmail.com>

+	First automated video test (running videotest and comparing results)

+

+2013-05-02  Vladimir Serbinenko  <phcoder@gmail.com>

+

 	* grub-core/commands/videotest.c: Reduce flickering and draw 6 squares

 	instead of 2 to have full RGB/CMY test pattern.

diff --git a/Makefile.util.def b/Makefile.util.def

index fbd37eb..a357341 100644

--- a/Makefile.util.def

+++ b/Makefile.util.def

@@ -67,6 +67,7 @@ library = {

   common = grub-core/video/fb/fbfill.c;

   common = grub-core/video/fb/video_fb.c;

   common = grub-core/video/video.c;

+  common = grub-core/video/capture.c;

   common = grub-core/video/colors.c;

   common = grub-core/unidata.c;

   common = grub-core/io/bufio.c;

@@ -814,6 +815,12 @@ script = {

   common = tests/grub_script_strcmp.in;

 };

+script = {

+  testcase;

+  name = grub_func_test;

+  common = tests/grub_func_test.in;

+};

+

 program = {

   testcase;

   name = example_unit_test;

diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def

index 7e19acb..2fa0ea7 100644

--- a/grub-core/Makefile.core.def

+++ b/grub-core/Makefile.core.def

@@ -1731,6 +1731,9 @@ module = {

   name = functional_test;

   common = tests/lib/functional_test.c;

   common = tests/lib/test.c;

+  common = tests/video_checksum.c;

+  common = tests/fake_input.c;

+  common = video/capture.c;

 };

 module = {

@@ -1739,6 +1742,11 @@ module = {

 };

 module = {

+  name = videotest_checksum;

+  common = tests/videotest_checksum.c;

+};

+

+module = {

   name = bitmap;

   common = video/bitmap.c;

   enable = videomodules;

diff --git a/grub-core/tests/checksums.c b/grub-core/tests/checksums.c

new file mode 100644

index 0000000..93d100f

--- /dev/null

+++ b/grub-core/tests/checksums.c

@@ -0,0 +1,27 @@

+  { "videotest", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x7f1853ba, 0x7f1853ba, 0x7f1853ba, 0x7f1853ba, 0x7f1853ba, }, 5 },

+  { "videotest", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xff1957f0, 0xff1957f0, 0xff1957f0, 0xff1957f0, 0xff1957f0, }, 5 },

+  { "videotest", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xcb45d8c5, 0xcb45d8c5, 0xcb45d8c5, 0xcb45d8c5, 0xcb45d8c5, }, 5 },

+  { "videotest", 640, 480, 0x1, 256, 15, 2, 10, 5, 5, 5, 0, 5, 0, 0 /* 640x480xrgb555 */, (grub_uint32_t []) { 0x2c97569c, 0x2c97569c, 0x2c97569c, 0x2c97569c, 0x2c97569c, }, 5 },

+  { "videotest", 800, 600, 0x1, 256, 15, 2, 10, 5, 5, 5, 0, 5, 0, 0 /* 800x600xrgb555 */, (grub_uint32_t []) { 0x9bd7a3ac, 0x9bd7a3ac, 0x9bd7a3ac, 0x9bd7a3ac, 0x9bd7a3ac, }, 5 },

+  { "videotest", 1024, 768, 0x1, 256, 15, 2, 10, 5, 5, 5, 0, 5, 0, 0 /* 1024x768xrgb555 */, (grub_uint32_t []) { 0xedbceb9c, 0xedbceb9c, 0xedbceb9c, 0xedbceb9c, 0xedbceb9c, }, 5 },

+  { "videotest", 640, 480, 0x1, 256, 16, 2, 11, 5, 5, 6, 0, 5, 0, 0 /* 640x480xrgb565 */, (grub_uint32_t []) { 0x3c2a42f1, 0x3c2a42f1, 0x3c2a42f1, 0x3c2a42f1, 0x3c2a42f1, }, 5 },

+  { "videotest", 800, 600, 0x1, 256, 16, 2, 11, 5, 5, 6, 0, 5, 0, 0 /* 800x600xrgb565 */, (grub_uint32_t []) { 0xb25ce62a, 0xb25ce62a, 0xb25ce62a, 0xb25ce62a, 0xb25ce62a, }, 5 },

+  { "videotest", 1024, 768, 0x1, 256, 16, 2, 11, 5, 5, 6, 0, 5, 0, 0 /* 1024x768xrgb565 */, (grub_uint32_t []) { 0x66cee14c, 0x66cee14c, 0x66cee14c, 0x66cee14c, 0x66cee14c, }, 5 },

+  { "videotest", 640, 480, 0x1, 256, 24, 3, 16, 8, 8, 8, 0, 8, 0, 0 /* 640x480xrgb888 */, (grub_uint32_t []) { 0x61db45b7, 0x1d867efe, 0x99613325, 0xe53c086c, 0x9543de62, }, 5 },

+  { "videotest", 800, 600, 0x1, 256, 24, 3, 16, 8, 8, 8, 0, 8, 0, 0 /* 800x600xrgb888 */, (grub_uint32_t []) { 0xa46eb37f, 0xd2a59656, 0x49f8f92d, 0x3f33dc04, 0x7aae512a, }, 5 },

+  { "videotest", 1024, 768, 0x1, 256, 24, 3, 16, 8, 8, 8, 0, 8, 0, 0 /* 1024x768xrgb888 */, (grub_uint32_t []) { 0xb864a496, 0x6c22313b, 0x1505f93d, 0xc1436c90, 0xe74a6931, }, 5 },

+  { "videotest", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgb888 */, (grub_uint32_t []) { 0x2b154617, 0x692e98df, 0xaf62fb87, 0xed59254f, 0x26164bc6, }, 5 },

+  { "videotest", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgb888 */, (grub_uint32_t []) { 0x3b0fbc56, 0xd9d57c0e, 0xfb564a17, 0x198c8a4f, 0xbe502625, }, 5 },

+  { "videotest", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgb888 */, (grub_uint32_t []) { 0x6e6c9b36, 0x4ae9f137, 0x27664f34, 0x3e32535, 0xfc793332, }, 5 },

+  { "videotest", 640, 480, 0x1, 256, 15, 2, 0, 5, 5, 5, 10, 5, 0, 0 /* 640x480xbgr555 */, (grub_uint32_t []) { 0x9056f776, 0x9056f776, 0x9056f776, 0x9056f776, 0x9056f776, }, 5 },

+  { "videotest", 800, 600, 0x1, 256, 15, 2, 0, 5, 5, 5, 10, 5, 0, 0 /* 800x600xbgr555 */, (grub_uint32_t []) { 0x2bde3c67, 0x2bde3c67, 0x2bde3c67, 0x2bde3c67, 0x2bde3c67, }, 5 },

+  { "videotest", 1024, 768, 0x1, 256, 15, 2, 0, 5, 5, 5, 10, 5, 0, 0 /* 1024x768xbgr555 */, (grub_uint32_t []) { 0xb04615f3, 0xb04615f3, 0xb04615f3, 0xb04615f3, 0xb04615f3, }, 5 },

+  { "videotest", 640, 480, 0x1, 256, 16, 2, 0, 5, 5, 6, 11, 5, 0, 0 /* 640x480xbgr565 */, (grub_uint32_t []) { 0xba8df8dd, 0xba8df8dd, 0xba8df8dd, 0xba8df8dd, 0xba8df8dd, }, 5 },

+  { "videotest", 800, 600, 0x1, 256, 16, 2, 0, 5, 5, 6, 11, 5, 0, 0 /* 800x600xbgr565 */, (grub_uint32_t []) { 0x84ac1329, 0x84ac1329, 0x84ac1329, 0x84ac1329, 0x84ac1329, }, 5 },

+  { "videotest", 1024, 768, 0x1, 256, 16, 2, 0, 5, 5, 6, 11, 5, 0, 0 /* 1024x768xbgr565 */, (grub_uint32_t []) { 0x145ad698, 0x145ad698, 0x145ad698, 0x145ad698, 0x145ad698, }, 5 },

+  { "videotest", 640, 480, 0x1, 256, 24, 3, 0, 8, 8, 8, 16, 8, 0, 0 /* 640x480xbgr888 */, (grub_uint32_t []) { 0x4af6b480, 0x923db79c, 0xfe8cc449, 0x2647c755, 0x27ee23e3, }, 5 },

+  { "videotest", 800, 600, 0x1, 256, 24, 3, 0, 8, 8, 8, 16, 8, 0, 0 /* 800x600xbgr888 */, (grub_uint32_t []) { 0x121d5e29, 0xf66c0aed, 0xdf138150, 0x3b62d594, 0x8dec962a, }, 5 },

+  { "videotest", 1024, 768, 0x1, 256, 24, 3, 0, 8, 8, 8, 16, 8, 0, 0 /* 1024x768xbgr888 */, (grub_uint32_t []) { 0xae86a12c, 0x4dabbe89, 0x6d30e897, 0x8e1df732, 0x2c0644ab, }, 5 },

+  { "videotest", 640, 480, 0x1, 256, 32, 4, 0, 8, 8, 8, 16, 8, 24, 8 /* 640x480xbgr888 */, (grub_uint32_t []) { 0x2605d280, 0xc06e3172, 0xef3e6395, 0x9558067, 0xb19ec65b, }, 5 },

+  { "videotest", 800, 600, 0x1, 256, 32, 4, 0, 8, 8, 8, 16, 8, 24, 8 /* 800x600xbgr888 */, (grub_uint32_t []) { 0x9404ef3b, 0xa4fdf18, 0xad7ef98c, 0x3335c9af, 0xe6f0c255, }, 5 },

+  { "videotest", 1024, 768, 0x1, 256, 32, 4, 0, 8, 8, 8, 16, 8, 24, 8 /* 1024x768xbgr888 */, (grub_uint32_t []) { 0xa008b770, 0xb98eb0d8, 0x9304b820, 0x8a82bf88, 0xc610a9d0, }, 5 },

diff --git a/grub-core/tests/fake_input.c b/grub-core/tests/fake_input.c

new file mode 100644

index 0000000..b514c2a

--- /dev/null

+++ b/grub-core/tests/fake_input.c

@@ -0,0 +1,67 @@

+/*

+ *  GRUB  --  GRand Unified Bootloader

+ *  Copyright (C) 2013  Free Software Foundation, Inc.

+ *

+ *  GRUB is free software: you can redistribute it and/or modify

+ *  it under the terms of the GNU General Public License as published by

+ *  the Free Software Foundation, either version 3 of the License, or

+ *  (at your option) any later version.

+ *

+ *  GRUB 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 General Public License for more details.

+ *

+ *  You should have received a copy of the GNU General Public License

+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.

+ */

+

+#include <grub/term.h>

+#include <grub/mm.h>

+#include <grub/dl.h>

+#include <grub/test.h>

+

+GRUB_MOD_LICENSE ("GPLv3+");

+

+static int *seq;

+static int seqptr, nseq;

+static struct grub_term_input *saved;

+

+static int

+fake_getkey (struct grub_term_input *term __attribute__ ((unused)))

+{

+  if (seq && seqptr < nseq)

+    return seq[seqptr++];

+  return -1;

+}

+

+static struct grub_term_input fake_input_term =

+  {

+    .name = "fake",

+    .getkey = fake_getkey

+  };

+

+void

+grub_terminal_input_fake_sequence (int *seq_in, int nseq_in)

+{

+  if (!saved)

+    saved = grub_term_inputs;

+  if (seq)

+    grub_free (seq);

+  seq = grub_malloc (nseq_in * sizeof (seq[0]));

+  if (seq)

+    {

+      grub_term_inputs = &fake_input_term;

+      grub_memcpy (seq, seq_in, nseq_in * sizeof (seq[0]));

+    }

+  nseq = nseq_in;

+}

+

+void

+grub_terminal_input_fake_sequence_end (void)

+{

+  grub_term_inputs = saved;

+  grub_free (seq);

+  seq = 0;

+  nseq = 0;

+}

diff --git a/grub-core/tests/lib/functional_test.c b/grub-core/tests/lib/functional_test.c

index fd199bd..da4d5f8 100644

--- a/grub-core/tests/lib/functional_test.c

+++ b/grub-core/tests/lib/functional_test.c

@@ -30,9 +30,34 @@ grub_functional_test (grub_extcmd_context_t ctxt __attribute__ ((unused)),

 		      char **args __attribute__ ((unused)))

 {

   grub_test_t test;

+  int ok = 1;

   FOR_LIST_ELEMENTS (test, grub_test_list)

-    grub_test_run (test);

+    ok = ok && !grub_test_run (test);

+  if (ok)

+    grub_printf ("ALL TESTS PASSED\n");

+  else

+    grub_printf ("TEST FAILURE\n");

+  return GRUB_ERR_NONE;

+}

+

+static grub_err_t

+grub_functional_all_tests (grub_extcmd_context_t ctxt __attribute__ ((unused)),

+			   int argc __attribute__ ((unused)),

+			   char **args __attribute__ ((unused)))

+{

+  grub_test_t test;

+  int ok = 1;

+

+  grub_dl_load ("exfctest");

+  grub_dl_load ("videotest_checksum");

+

+  FOR_LIST_ELEMENTS (test, grub_test_list)

+    ok = ok && !grub_test_run (test);

+  if (ok)

+    grub_printf ("ALL TESTS PASSED\n");

+  else

+    grub_printf ("TEST FAILURE\n");

   return GRUB_ERR_NONE;

 }

@@ -41,6 +66,8 @@ static grub_extcmd_t cmd;

 GRUB_MOD_INIT (functional_test)

 {

   cmd = grub_register_extcmd ("functional_test", grub_functional_test, 0, 0,

+			      "Run all loaded functional tests.", 0);

+  cmd = grub_register_extcmd ("all_functional_test", grub_functional_all_tests, 0, 0,

 			      "Run all functional tests.", 0);

 }

diff --git a/grub-core/tests/video_checksum.c b/grub-core/tests/video_checksum.c

new file mode 100644

index 0000000..b2aab79

--- /dev/null

+++ b/grub-core/tests/video_checksum.c

@@ -0,0 +1,435 @@

+/*

+ *  GRUB  --  GRand Unified Bootloader

+ *  Copyright (C) 2013 Free Software Foundation, Inc.

+ *

+ *  GRUB is free software: you can redistribute it and/or modify

+ *  it under the terms of the GNU General Public License as published by

+ *  the Free Software Foundation, either version 3 of the License, or

+ *  (at your option) any later version.

+ *

+ *  GRUB 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 General Public License for more details.

+ *

+ *  You should have received a copy of the GNU General Public License

+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.

+ */

+

+/* All tests need to include test.h for GRUB testing framework.  */

+#include <grub/test.h>

+#include <grub/dl.h>

+#include <grub/video.h>

+#include <grub/lib/crc.h>

+#include <grub/mm.h>

+

+GRUB_MOD_LICENSE ("GPLv3+");

+

+static int ctr;

+static int nchk;

+static char *basename;

+static const grub_uint32_t *checksums;

+static struct grub_video_mode_info capt_mode_info;

+

+#ifdef GRUB_MACHINE_EMU

+#include <grub/emu/misc.h>

+#include <sys/types.h>

+#include <sys/stat.h>

+#include <fcntl.h>

+#include <unistd.h>

+#include <errno.h>

+#include <string.h>

+#include <stdlib.h>

+

+struct bmp_header

+{

+  grub_uint8_t magic[2];

+  grub_uint32_t filesize;

+  grub_uint32_t reserved;

+  grub_uint32_t bmp_off;

+  grub_uint32_t head_size;

+  grub_uint16_t width;

+  grub_uint16_t height;

+  grub_uint16_t planes;

+  grub_uint16_t bpp;

+} __attribute__ ((packed));

+

+static void

+grub_video_capture_write_bmp (const char *fname,

+			      void *ptr,

+			      const struct grub_video_mode_info *mode_info)

+{

+  int fd = open (fname, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);

+  struct bmp_header head;

+

+  if (fd < 0)

+    {

+      grub_printf (_("cannot open `%s': %s"),

+		   fname, strerror (errno));

+    }

+

+  grub_memset (&head, 0, sizeof (head));

+

+  head.magic[0] = 'B';

+  head.magic[1] = 'M';

+

+  if (mode_info->mode_type & GRUB_VIDEO_MODE_TYPE_RGB)

+    {

+      head.filesize = grub_cpu_to_le32 (sizeof (head) + mode_info->width * mode_info->height * 3);

+      head.bmp_off = grub_cpu_to_le32 (sizeof (head));

+      head.bpp = grub_cpu_to_le16_compile_time (24);

+    }

+  else

+    {

+      head.filesize = grub_cpu_to_le32 (sizeof (head) + 3 * 256 + mode_info->width * mode_info->height);

+      head.bmp_off = grub_cpu_to_le32 (sizeof (head) + 3 * 256);

+      head.bpp = grub_cpu_to_le16_compile_time (8);

+    }

+  head.head_size = grub_cpu_to_le32 (sizeof (head) - 14);

+  head.width = grub_cpu_to_le16 (mode_info->width);

+  head.height = grub_cpu_to_le16 (mode_info->height);

+  head.planes = grub_cpu_to_le16_compile_time (1);

+

+  head.width = grub_cpu_to_le16 (mode_info->width);

+  head.height = grub_cpu_to_le16 (mode_info->height);

+

+  write (fd, &head, sizeof (head));

+

+  if (!(mode_info->mode_type & GRUB_VIDEO_MODE_TYPE_RGB))

+    {

+      struct grub_video_palette_data palette_data[256];

+      int i;

+      int palette_len = mode_info->number_of_colors;

+      grub_memset (palette_data, 0, sizeof (palette_data));

+      if (palette_len > 256)

+	palette_len = 256;

+      grub_video_get_palette (0, palette_len, palette_data);

+      for (i = 0; i < 256; i++)

+	{

+	  grub_uint8_t r, g, b;

+	  r = palette_data[i].r;

+	  g = palette_data[i].g;

+	  b = palette_data[i].b;

+

+	  write (fd, &b, 1);

+	  write (fd, &g, 1);

+	  write (fd, &r, 1);

+	}

+    }

+

+  /* This does essentialy the same as some fbblit functions yet using

+     them would mean testing them against themselves so keep this

+     implemetation separate.  */

+  switch (mode_info->bytes_per_pixel)

+    {

+    case 4:

+      {

+	grub_uint8_t *buffer = xmalloc (mode_info->width * 3);

+	grub_uint32_t rmask = ((1 << mode_info->red_mask_size) - 1);

+	grub_uint32_t gmask = ((1 << mode_info->green_mask_size) - 1);

+	grub_uint32_t bmask = ((1 << mode_info->blue_mask_size) - 1);

+	int rshift = mode_info->red_field_pos;

+	int gshift = mode_info->green_field_pos;

+	int bshift = mode_info->blue_field_pos;

+	int mulrshift = (8 - mode_info->red_mask_size);

+	int mulgshift = (8 - mode_info->green_mask_size);

+	int mulbshift = (8 - mode_info->blue_mask_size);

+	int y;

+

+	for (y = mode_info->height - 1; y >= 0; y--)

+	  {

+	    grub_uint32_t *iptr = (grub_uint32_t *) ((grub_uint8_t *) ptr + mode_info->pitch * y);

+	    int x;

+	    grub_uint8_t *optr = buffer;

+	    for (x = 0; x < (int) mode_info->width; x++)

+	      {

+		grub_uint32_t val = *iptr++;

+		*optr++ = ((val >> bshift) & bmask) << mulbshift;

+		*optr++ = ((val >> gshift) & gmask) << mulgshift;

+		*optr++ = ((val >> rshift) & rmask) << mulrshift;

+	      }

+	    write (fd, buffer, mode_info->width * 3);

+	  }

+	grub_free (buffer);

+	break;

+      }

+    case 3:

+      {

+	grub_uint8_t *buffer = xmalloc (mode_info->width * 3);

+	grub_uint32_t rmask = ((1 << mode_info->red_mask_size) - 1);

+	grub_uint32_t gmask = ((1 << mode_info->green_mask_size) - 1);

+	grub_uint32_t bmask = ((1 << mode_info->blue_mask_size) - 1);

+	int rshift = mode_info->red_field_pos;

+	int gshift = mode_info->green_field_pos;

+	int bshift = mode_info->blue_field_pos;

+	int mulrshift = (8 - mode_info->red_mask_size);

+	int mulgshift = (8 - mode_info->green_mask_size);

+	int mulbshift = (8 - mode_info->blue_mask_size);

+	int y;

+

+	for (y = mode_info->height - 1; y >= 0; y--)

+	  {

+	    grub_uint8_t *iptr = ((grub_uint8_t *) ptr + mode_info->pitch * y);

+	    int x;

+	    grub_uint8_t *optr = buffer;

+	    for (x = 0; x < (int) mode_info->width; x++)

+	      {

+		grub_uint32_t val = 0;

+#ifdef GRUB_CPU_WORDS_BIGENDIAN

+		val |= *iptr++ << 16;

+		val |= *iptr++ << 8;

+		val |= *iptr++;

+#else

+		val |= *iptr++;

+		val |= *iptr++ << 8;

+		val |= *iptr++ << 16;

+#endif

+		*optr++ = ((val >> bshift) & bmask) << mulbshift;

+		*optr++ = ((val >> gshift) & gmask) << mulgshift;

+		*optr++ = ((val >> rshift) & rmask) << mulrshift;

+	      }

+	    write (fd, buffer, mode_info->width * 3);

+	  }

+	grub_free (buffer);

+	break;

+      }

+    case 2:

+      {

+	grub_uint8_t *buffer = xmalloc (mode_info->width * 3);

+	grub_uint16_t rmask = ((1 << mode_info->red_mask_size) - 1);

+	grub_uint16_t gmask = ((1 << mode_info->green_mask_size) - 1);

+	grub_uint16_t bmask = ((1 << mode_info->blue_mask_size) - 1);

+	int rshift = mode_info->red_field_pos;

+	int gshift = mode_info->green_field_pos;

+	int bshift = mode_info->blue_field_pos;

+	int mulrshift = (8 - mode_info->red_mask_size);

+	int mulgshift = (8 - mode_info->green_mask_size);

+	int mulbshift = (8 - mode_info->blue_mask_size);

+	int y;

+

+	for (y = mode_info->height - 1; y >= 0; y--)

+	  {

+	    grub_uint16_t *iptr = (grub_uint16_t *) ((grub_uint8_t *) ptr + mode_info->pitch * y);

+	    int x;

+	    grub_uint8_t *optr = buffer;

+	    for (x = 0; x < (int) mode_info->width; x++)

+	      {

+		grub_uint16_t val = *iptr++;

+		*optr++ = ((val >> bshift) & bmask) << mulbshift;

+		*optr++ = ((val >> gshift) & gmask) << mulgshift;

+		*optr++ = ((val >> rshift) & rmask) << mulrshift;

+	      }

+	    write (fd, buffer, mode_info->width * 3);

+	  }

+	grub_free (buffer);

+	break;

+      }

+    case 1:

+      {

+	int y;

+

+	for (y = mode_info->height - 1; y >= 0; y--)

+	  write (fd, ((grub_uint8_t *) ptr + mode_info->pitch * y), mode_info->width);

+	break;

+      }

+    }

+  close (fd);

+}

+

+#endif

+

+static const char *

+get_modename (void)

+{

+  static char buf[40];

+  if (capt_mode_info.mode_type & GRUB_VIDEO_MODE_TYPE_INDEX_COLOR)

+    {

+      grub_snprintf (buf, sizeof (buf), "i%d", capt_mode_info.number_of_colors);

+      return buf;

+    }

+  if (capt_mode_info.red_field_pos == 0)

+    {

+      grub_snprintf (buf, sizeof (buf), "bgr%d%d%d", capt_mode_info.blue_mask_size,

+		     capt_mode_info.green_mask_size,

+		     capt_mode_info.red_mask_size);

+      return buf;

+    }

+  grub_snprintf (buf, sizeof (buf), "rgb%d%d%d", capt_mode_info.red_mask_size,

+		 capt_mode_info.green_mask_size,

+		 capt_mode_info.blue_mask_size);

+  return buf;

+}

+

+//#define GENERATE_MODE 1

+

+#if defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU)

+int genfd = -1;

+#endif

+

+static void

+checksum (void)

+{

+  void *ptr;

+  grub_uint32_t crc;

+

+  ptr = grub_video_capture_get_framebuffer ();

+

+  crc = grub_getcrc32c (0, ptr, capt_mode_info.pitch * capt_mode_info.height);

+  if (!checksums || ctr >= nchk)

+    {

+      grub_test_assert (0, "Unexpected checksum %s_%dx%dx%s:%d: 0x%x",

+			basename, 			

+			capt_mode_info.width,

+			capt_mode_info.height, get_modename (), ctr, crc);

+    }

+  else if (crc != checksums[ctr])

+    {

+      grub_test_assert (0, "Checksum %s_%dx%dx%s:%d failed: 0x%x vs 0x%x",

+			basename,

+			capt_mode_info.width,

+			capt_mode_info.height, get_modename (),

+			ctr, crc, checksums[ctr]);

+    }

+  else

+    {

+#if !(defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU))

+      ctr++;

+      return;

+#endif

+    }

+#ifdef GRUB_MACHINE_EMU

+  char *name = grub_xasprintf ("%s_%dx%dx%s_%d.bmp", basename, 

+			       capt_mode_info.width,

+			       capt_mode_info.height, get_modename (),

+			       ctr);

+  grub_video_capture_write_bmp (name, ptr, &capt_mode_info);

+#endif

+

+#if defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU)

+  if (genfd >= 0)

+    {

+      char buf[20];

+      grub_snprintf (buf, sizeof (buf), "0x%x, ", crc);

+      write (genfd, buf, grub_strlen (buf));

+    }

+#endif

+

+  ctr++;

+}

+

+struct checksum_desc

+{

+  const char *name;

+  unsigned width;

+  unsigned height;

+  unsigned mode_type;

+  unsigned number_of_colors;

+  unsigned bpp;

+  unsigned bytes_per_pixel;

+  unsigned red_field_pos;

+  unsigned red_mask_size;

+  unsigned green_field_pos;

+  unsigned green_mask_size;

+  unsigned blue_field_pos;

+  unsigned blue_mask_size;

+  unsigned reserved_field_pos;

+  unsigned reserved_mask_size;

+  const grub_uint32_t *checksums;

+  int nchk;

+};

+

+const struct checksum_desc checksum_table[] = {

+#include "checksums.c"

+};

+

+void

+grub_video_checksum (const char *basename_in)

+{

+  unsigned i;

+

+  grub_video_get_info (&capt_mode_info);

+

+#if defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU)

+  if (genfd < 0)

+    genfd = open ("checksums.c", O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);

+  if (genfd >= 0)

+    {

+      char buf[400];

+

+      grub_snprintf (buf, sizeof (buf), "\", %d, %d, 0x%x, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d /* %dx%dx%s */, (grub_uint32_t []) { ",

+		     capt_mode_info.width,

+		     capt_mode_info.height,

+		     capt_mode_info.mode_type,

+		     capt_mode_info.number_of_colors,

+		     capt_mode_info.bpp,

+		     capt_mode_info.bytes_per_pixel,

+		     capt_mode_info.red_field_pos,

+		     capt_mode_info.red_mask_size,

+		     capt_mode_info.green_field_pos,

+		     capt_mode_info.green_mask_size,

+		     capt_mode_info.blue_field_pos,

+		     capt_mode_info.blue_mask_size,

+		     capt_mode_info.reserved_field_pos,

+		     capt_mode_info.reserved_mask_size,

+		     capt_mode_info.width,

+		     capt_mode_info.height, get_modename ());

+

+      write (genfd, "  { \"", 5);

+      write (genfd, basename_in, grub_strlen (basename_in));

+      write (genfd, buf, grub_strlen (buf));

+    }

+#endif

+

+  basename = grub_strdup (basename_in);

+  nchk = 0;

+  checksums = 0;

+  /* FIXME: optimize this.  */

+  for (i = 0; i < ARRAY_SIZE (checksum_table); i++)

+    if (grub_strcmp (checksum_table[i].name, basename_in) == 0

+	&& capt_mode_info.width == checksum_table[i].width

+	&& capt_mode_info.height == checksum_table[i].height

+	&& capt_mode_info.mode_type == checksum_table[i].mode_type

+	&& capt_mode_info.number_of_colors == checksum_table[i].number_of_colors

+	&& capt_mode_info.bpp == checksum_table[i].bpp

+	&& capt_mode_info.bytes_per_pixel == checksum_table[i].bytes_per_pixel

+	&& capt_mode_info.red_field_pos == checksum_table[i].red_field_pos

+	&& capt_mode_info.red_mask_size == checksum_table[i].red_mask_size

+	&& capt_mode_info.green_field_pos == checksum_table[i].green_field_pos

+	&& capt_mode_info.green_mask_size == checksum_table[i].green_mask_size

+	&& capt_mode_info.blue_field_pos == checksum_table[i].blue_field_pos

+	&& capt_mode_info.blue_mask_size == checksum_table[i].blue_mask_size

+	&& capt_mode_info.reserved_field_pos == checksum_table[i].reserved_field_pos

+	&& capt_mode_info.reserved_mask_size == checksum_table[i].reserved_mask_size)

+      {

+	nchk = checksum_table[i].nchk;

+	checksums = checksum_table[i].checksums;

+	break;

+      }

+

+  ctr = 0;

+  grub_video_capture_refresh_cb = checksum;

+}

+

+void

+grub_video_checksum_end (void)

+{

+#if defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU)

+  if (genfd >= 0)

+    {

+      char buf[40];

+      grub_snprintf (buf, sizeof (buf), "}, %x },\n", ctr);

+      write (genfd, buf, grub_strlen (buf));

+    }

+#endif

+  grub_test_assert (ctr == nchk, "Not enough checksums %s_%dx%dx%s: %d vs %d",

+		    basename,

+		    capt_mode_info.width,

+		    capt_mode_info.height, get_modename (),

+		    ctr, nchk);

+  grub_free (basename);

+  basename = 0;

+  nchk = 0;

+  checksums = 0;

+  ctr = 0;

+  grub_video_capture_refresh_cb = 0;

+}

diff --git a/grub-core/tests/videotest_checksum.c b/grub-core/tests/videotest_checksum.c

new file mode 100644

index 0000000..e57dae7

--- /dev/null

+++ b/grub-core/tests/videotest_checksum.c

@@ -0,0 +1,286 @@

+/*

+ *  GRUB  --  GRand Unified Bootloader

+ *  Copyright (C) 2013 Free Software Foundation, Inc.

+ *

+ *  GRUB is free software: you can redistribute it and/or modify

+ *  it under the terms of the GNU General Public License as published by

+ *  the Free Software Foundation, either version 3 of the License, or

+ *  (at your option) any later version.

+ *

+ *  GRUB 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 General Public License for more details.

+ *

+ *  You should have received a copy of the GNU General Public License

+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.

+ */

+

+/* All tests need to include test.h for GRUB testing framework.  */

+#include <grub/test.h>

+#include <grub/dl.h>