Adding upstream version 2.06.upstream/2.06upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

48 files changed, 4319 insertions, 0 deletions

diff --git a/grub-core/tests/boot/kbsd.init-i386.S b/grub-core/tests/boot/kbsd.init-i386.S
new file mode 100644
index 0000000..72ddb7c
--- /dev/null
+++ b/grub-core/tests/boot/kbsd.init-i386.S
@@ -0,0 +1,107 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010  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/>.
+ */
+
+#ifdef TARGET_NETBSD
+#define SYSCALL_RESET 208
+#elif defined (TARGET_OPENBSD)
+#define SYSCALL_RESET 55
+#else
+#error unknown target
+#endif
+
+#define MODE_RDRW 2
+#define FLAGS_NONE 0
+#define SYSCALL_OPEN 5
+#define SYSCALL_WRITE 4
+#define SYSCALL_EXIT 1
+#define SYSCALL_ARCH 165
+#define SYSCALL_INT 0x80
+#define SYSCALL_ARCH_IOPL	2
+
+#define RESET_NOSYNC 0x4
+#define RESET_HALT 0x8
+#define RESET_POWEROFF 0x800
+
+	.section ".init", "ax"
+	.global start,_start
+start:
+_start:
+	/* open.  */
+	movl $SYSCALL_OPEN, %eax
+	pushl $FLAGS_NONE
+	pushl $MODE_RDRW
+	leal device, %ebx
+	pushl %ebx
+	pushl $0
+	int $SYSCALL_INT
+	addl $16, %esp
+	movl %eax, %ecx
+
+	/* write.  */
+	movl $SYSCALL_WRITE, %eax
+	pushl $(messageend-message)
+	leal message, %ebx
+	pushl %ebx
+	pushl %ecx
+	pushl $0
+	int $SYSCALL_INT
+	addl $16, %esp
+
+	/* IOPL.  */
+	movl $SYSCALL_ARCH, %eax
+	pushl $iopl_arg
+	pushl $SYSCALL_ARCH_IOPL
+	pushl $0
+	int $SYSCALL_INT
+	addl $12, %esp
+
+#include "qemu-shutdown-x86.S"
+
+	/* shutdown.  */
+	movl $SYSCALL_RESET, %eax
+	pushl $0
+	pushl $(RESET_POWEROFF|RESET_HALT|RESET_NOSYNC)
+	pushl $0
+	int $SYSCALL_INT
+	addl $8, %esp
+
+	/* exit (1). Shouldn't be reached.  */
+	movl $SYSCALL_EXIT, %eax
+	pushl $1
+	pushl $0
+	int $SYSCALL_INT
+	.section ".fini", "ax"
+1:	jmp 1b
+	.section ".text", "ax"
+1:	jmp 1b
+	/* This section is needed for NetBSD to identify the binary.  */
+	.section ".note.netbsd.ident", "a"
+	.long 0x7
+	.long 0x4
+	.long 0x1
+	.ascii "NetBSD"
+	.byte 0
+	.data
+device:
+	.ascii "/dev/console"
+	.byte 0
+message:
+	.ascii "Boot Test Passed Successfully\n" SUCCESSFUL_BOOT_STRING "\n"
+messageend:
+iopl_arg:
+	.long 3
diff --git a/grub-core/tests/boot/kbsd.init-x86_64.S b/grub-core/tests/boot/kbsd.init-x86_64.S
new file mode 100644
index 0000000..7486bc3
--- /dev/null
+++ b/grub-core/tests/boot/kbsd.init-x86_64.S
@@ -0,0 +1,94 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010  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/>.
+ */
+
+#define MODE_RDRW 2
+#define FLAGS_NONE 0
+#define SYSCALL_OPEN 5
+#define SYSCALL_WRITE 4
+#ifdef TARGET_NETBSD
+#define SYSCALL_RESET 208
+#elif defined (TARGET_OPENBSD)
+#define SYSCALL_RESET 55
+#else
+#error unknown target
+#endif
+#define SYSCALL_EXIT 1
+#define SYSCALL_ARCH 165
+#define SYSCALL_INT 0x80
+#define SYSCALL_ARCH_IOPL	2
+
+#define RESET_NOSYNC 0x4
+#define RESET_HALT 0x8
+#define RESET_POWEROFF 0x800
+
+	.section ".init", "ax"
+	.global start,_start
+start:
+_start:
+	/* open.  */
+	movq $SYSCALL_OPEN, %rax
+	leaq device, %rdi
+	movq $MODE_RDRW, %rsi
+	movq $FLAGS_NONE, %rdx
+	syscall
+	movq %rax, %rdi
+
+	/* write.  */
+	movq $SYSCALL_WRITE, %rax
+	movq $(messageend-message), %rdx
+	leaq message, %rsi
+	syscall
+
+	/* IOPL.  */
+	movq $SYSCALL_ARCH, %rax
+	movq $SYSCALL_ARCH_IOPL, %rdi
+	leaq iopl_arg, %rsi
+	syscall
+
+#include "qemu-shutdown-x86.S"
+
+	/* shutdown.  */
+	movq $SYSCALL_RESET, %rax
+	movq $(RESET_POWEROFF|RESET_HALT|RESET_NOSYNC), %rdi
+	movq $0, %rsi
+	syscall
+
+	/* exit (1). Shouldn't be reached.  */
+	movq $SYSCALL_EXIT, %rax
+	movq $1, %rdi
+	syscall
+	.section ".fini", "ax"
+1:	jmp 1b
+	.section ".text", "ax"
+1:	jmp 1b
+	/* This section is needed for NetBSD to identify the binary.  */
+	.section ".note.netbsd.ident", "a"
+	.long 0x7
+	.long 0x4
+	.long 0x1
+	.ascii "NetBSD"
+	.byte 0
+	.data
+device:
+	.ascii "/dev/console"
+	.byte 0
+message:
+	.ascii "Boot Test Passed Successfully\n" SUCCESSFUL_BOOT_STRING "\n"
+messageend:
+iopl_arg:
+	.long 3
diff --git a/grub-core/tests/boot/kbsd.spec.txt b/grub-core/tests/boot/kbsd.spec.txt
new file mode 100644
index 0000000..af171bc
--- /dev/null
+++ b/grub-core/tests/boot/kbsd.spec.txt
@@ -0,0 +1,3 @@
+. type=dir
+	dev type=dir
+		console type=char device=0 mode=666 gid=0 uid=0
diff --git a/grub-core/tests/boot/kernel-8086.S b/grub-core/tests/boot/kernel-8086.S
new file mode 100644
index 0000000..5ec5368
--- /dev/null
+++ b/grub-core/tests/boot/kernel-8086.S
@@ -0,0 +1,50 @@
+
+	.text
+	.globl _start
+_start:
+base:	
+	.code16
+	jmp cont
+
+serialmsg:	
+1:	
+	movb 0(%si), %bl
+	testb %bl, %bl
+	jz 1f
+	movw $0x3fd, %dx
+2:	
+	inb %dx, %al
+	testb $0x20, %al
+	jz   2b
+
+	movw $0x3f8, %dx
+	movb %bl, %al
+	outb %al, %dx
+	incw %si
+	jmp 1b
+1:
+	ret
+
+cont:
+#ifdef TARGET_NTLDR
+	movw $0x2000, %ax
+#elif defined (TARGET_CHAINLOADER)
+	xorw %ax, %ax
+#else
+#error unsupported target
+#endif
+	movw %ax, %ds
+	lea message, %si
+	call serialmsg
+#include "qemu-shutdown-x86.S"
+
+1:
+	hlt
+	jmp 1b
+
+message:
+	.ascii "Boot Test Passed Successfully\n" SUCCESSFUL_BOOT_STRING "\n"
+	.byte 0
+
+	.org 510
+	.short 0xaa55
diff --git a/grub-core/tests/boot/kernel-i386.S b/grub-core/tests/boot/kernel-i386.S
new file mode 100644
index 0000000..2154d3b
--- /dev/null
+++ b/grub-core/tests/boot/kernel-i386.S
@@ -0,0 +1,72 @@
+#define ASM_FILE	1
+#ifdef TARGET_MULTIBOOT2
+#include <multiboot2.h>
+#elif defined (TARGET_MULTIBOOT)
+#include <multiboot.h>
+#endif
+
+	.text
+	/* Align 32 bits boundary.  */
+	.align	8
+
+#ifdef TARGET_MULTIBOOT2
+	/* Multiboot header.  */
+multiboot_header:
+	/* magic */
+	.long	MULTIBOOT2_HEADER_MAGIC
+	/* ISA: i386 */
+	.long   MULTIBOOT_ARCHITECTURE_I386
+	/* Header length.  */
+	.long	multiboot_header_end - multiboot_header
+	/* checksum */
+	.long	-(MULTIBOOT2_HEADER_MAGIC + MULTIBOOT_ARCHITECTURE_I386 + (multiboot_header_end - multiboot_header))
+	.short MULTIBOOT_HEADER_TAG_END
+	.short 0
+	.long 8
+multiboot_header_end:
+#elif defined (TARGET_MULTIBOOT)
+	/* Multiboot header.  */
+multiboot_header:
+	/* magic */
+	.long	MULTIBOOT_HEADER_MAGIC
+	/* flags */
+	.long	0
+	/* checksum */
+	.long	-MULTIBOOT_HEADER_MAGIC
+#endif
+	
+	.global start
+
+serialmsg:	
+1:	
+	movb 0(%esi), %bl
+	testb %bl, %bl
+	jz 1f
+	movw $0x3fd, %dx
+2:	
+	inb %dx, %al
+	testb $0x20, %al
+	jz   2b
+
+	movw $0x3f8, %dx
+	movb %bl, %al
+	outb %al, %dx
+	incl %esi
+	jmp 1b
+1:
+	ret
+
+	.globl _start
+_start:
+	lea message, %esi
+	call serialmsg
+
+#include "qemu-shutdown-x86.S"
+
+1:
+	hlt
+	jmp 1b
+
+message:
+	.ascii "Boot Test Passed Successfully\n" SUCCESSFUL_BOOT_STRING "\n"
+	.byte 0
diff --git a/grub-core/tests/boot/kfreebsd-aout.cfg b/grub-core/tests/boot/kfreebsd-aout.cfg
new file mode 100644
index 0000000..31e34b4
--- /dev/null
+++ b/grub-core/tests/boot/kfreebsd-aout.cfg
@@ -0,0 +1,4 @@
+kfreebsd /kfreebsd.aout
+boot
+# Shouln't happen
+halt
diff --git a/grub-core/tests/boot/kfreebsd.cfg b/grub-core/tests/boot/kfreebsd.cfg
new file mode 100644
index 0000000..f28ee79
--- /dev/null
+++ b/grub-core/tests/boot/kfreebsd.cfg
@@ -0,0 +1,8 @@
+kfreebsd /kfreebsd -hv
+kfreebsd_loadenv /kfreebsd_env
+kfreebsd_module /mfsroot.gz type=mfs_root
+set kFreeBSD.hw.hasbrokenint12=1
+fakebios
+boot
+# Shouln't happen
+halt
diff --git a/grub-core/tests/boot/kfreebsd.init-i386.S b/grub-core/tests/boot/kfreebsd.init-i386.S
new file mode 100644
index 0000000..7a4baba
--- /dev/null
+++ b/grub-core/tests/boot/kfreebsd.init-i386.S
@@ -0,0 +1,109 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010  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/>.
+ */
+
+#define MODE_RDRW 2
+#define FLAGS_NONE 0
+#define SYSCALL_OPEN 5
+#define SYSCALL_WRITE 4
+#define SYSCALL_RESET 55
+#define SYSCALL_FSYNC 95
+#define SYSCALL_ARCH 165
+#define SYSCALL_EXIT 1
+#define SYSCALL_ARCH_IOPERM	4
+#define SYSCALL_INT 0x80
+
+#define RESET_NOSYNC 0x4
+#define RESET_HALT 0x8
+#define RESET_POWEROFF 0x4000
+
+	.section ".init", "ax"
+	.global start,_start
+start:
+_start:
+	/* open.  */
+	movl $SYSCALL_OPEN, %eax
+	pushl $FLAGS_NONE
+	pushl $MODE_RDRW
+	leal device, %ebx
+	pushl %ebx
+	pushl $0
+	int $SYSCALL_INT
+	addl $16, %esp
+	movl %eax, %ecx
+
+	/* write.  */
+	movl $SYSCALL_WRITE, %eax
+	pushl $(messageend-message)
+	leal message, %ebx
+	pushl %ebx
+	pushl %ecx
+	pushl $0
+	int $SYSCALL_INT
+	addl $16, %esp
+
+	/* fsync.  */
+	movl $SYSCALL_FSYNC, %eax
+	pushl %ecx
+	pushl $0
+	int $SYSCALL_INT
+	addl $8, %esp
+
+	/* IOPERM.  */
+	movl $SYSCALL_ARCH, %eax
+	pushl $ioperm_arg1
+	pushl $SYSCALL_ARCH_IOPERM
+	pushl $0
+	int $SYSCALL_INT
+	addl $12, %esp
+
+	/* IOPERM.  */
+	movl $SYSCALL_ARCH, %eax
+	pushl $ioperm_arg2
+	pushl $SYSCALL_ARCH_IOPERM
+	pushl $0
+	int $SYSCALL_INT
+	addl $12, %esp
+
+#include "qemu-shutdown-x86.S"
+	
+	/* shutdown.  */
+	movl $SYSCALL_RESET, %eax
+	pushl $(RESET_POWEROFF|RESET_HALT|RESET_NOSYNC)
+	pushl $0
+	int $SYSCALL_INT
+	addl $8, %esp
+
+	/* exit (1). Shouldn't be reached.  */
+	movl $SYSCALL_EXIT, %eax
+	pushl $1
+	pushl $0
+	int $SYSCALL_INT
+device:
+	.ascii "/dev/console"
+	.byte 0
+message:
+	.ascii "Boot Test Passed Successfully\n" SUCCESSFUL_BOOT_STRING "\n"
+messageend:
+ioperm_arg1:
+	.long 0xcf8
+	.long 8
+	.long 1
+ioperm_arg2:
+	.long 0x7000
+	.long 8
+	.long 1
diff --git a/grub-core/tests/boot/kfreebsd.init-x86_64.S b/grub-core/tests/boot/kfreebsd.init-x86_64.S
new file mode 100644
index 0000000..05e5760
--- /dev/null
+++ b/grub-core/tests/boot/kfreebsd.init-x86_64.S
@@ -0,0 +1,90 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010  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/>.
+ */
+
+#define MODE_RDRW 2
+#define FLAGS_NONE 0
+#define SYSCALL_ARCH 165
+#define SYSCALL_OPEN 5
+#define SYSCALL_WRITE 4
+#define SYSCALL_RESET 55
+#define SYSCALL_EXIT 1
+#define SYSCALL_ARCH_IOPERM	4
+#define SYSCALL_FSYNC 95
+
+#define RESET_NOSYNC 0x4
+#define RESET_HALT 0x8
+#define RESET_POWEROFF 0x4000
+
+	.section ".init", "ax"
+	.global start,_start
+start:
+_start:
+	/* open.  */
+	movq $SYSCALL_OPEN, %rax
+	leaq device, %rdi
+	movq $MODE_RDRW, %rsi
+	movq $FLAGS_NONE, %rdx
+	syscall
+	movq %rax, %rdi
+
+	/* write.  */
+	leaq message, %rsi
+	movq $SYSCALL_WRITE, %rax
+	movq $(messageend - message), %rdx
+	syscall
+
+	/* fsync.  */
+	movq $SYSCALL_FSYNC, %rax
+	syscall
+
+	/* IOPERM.  */
+	movq $SYSCALL_ARCH, %rax
+	movq $SYSCALL_ARCH_IOPERM, %rdi
+	leaq ioperm_arg1, %rsi
+	syscall
+
+	movq $SYSCALL_ARCH, %rax
+	movq $SYSCALL_ARCH_IOPERM, %rdi
+	leaq ioperm_arg2, %rsi
+	syscall
+
+#include "qemu-shutdown-x86.S"
+	
+	/* shutdown.  */
+	movq $SYSCALL_RESET, %rax
+	movq $(RESET_POWEROFF|RESET_HALT|RESET_NOSYNC), %rdi
+	syscall
+
+	/* exit (1). Shouldn't be reached.  */
+	movq $SYSCALL_EXIT, %rax
+	movq $1, %rdi
+	syscall
+device:
+	.ascii "/dev/console"
+	.byte 0
+message:
+	.ascii "Boot Test Passed Successfully\n" SUCCESSFUL_BOOT_STRING "\n"
+messageend:
+ioperm_arg1:
+	.long 0xcf8
+	.long 8
+	.long 1
+ioperm_arg2:
+	.long 0x7000
+	.long 8
+	.long 1
diff --git a/grub-core/tests/boot/knetbsd.cfg b/grub-core/tests/boot/knetbsd.cfg
new file mode 100644
index 0000000..f88a846
--- /dev/null
+++ b/grub-core/tests/boot/knetbsd.cfg
@@ -0,0 +1,5 @@
+knetbsd /knetbsd -h
+knetbsd_module_elf /miniroot.gz
+boot
+# Shouln't happen
+halt
diff --git a/grub-core/tests/boot/kopenbsd.cfg b/grub-core/tests/boot/kopenbsd.cfg
new file mode 100644
index 0000000..132bec4
--- /dev/null
+++ b/grub-core/tests/boot/kopenbsd.cfg
@@ -0,0 +1,5 @@
+kopenbsd /kopenbsd -h
+kopenbsd_ramdisk /ramdisk
+boot
+# Shouln't happen
+halt
diff --git a/grub-core/tests/boot/kopenbsdlabel.txt b/grub-core/tests/boot/kopenbsdlabel.txt
new file mode 100644
index 0000000..bb14113
--- /dev/null
+++ b/grub-core/tests/boot/kopenbsdlabel.txt
@@ -0,0 +1,3 @@
+#        size   offset    fstype   [fsize bsize bps/cpg]
+  a:      256        0    4.2BSD        0     0     1 
+  c:      256        0    unused        0     0         # "raw" part, don't edit
diff --git a/grub-core/tests/boot/linux-ppc.cfg b/grub-core/tests/boot/linux-ppc.cfg
new file mode 100644
index 0000000..3ceabc3
--- /dev/null
+++ b/grub-core/tests/boot/linux-ppc.cfg
@@ -0,0 +1,5 @@
+linux /linux console=ttyPZ1 root=/dev/ram0
+initrd /initrd
+boot
+# Shouln't happen
+halt
diff --git a/grub-core/tests/boot/linux.cfg b/grub-core/tests/boot/linux.cfg
new file mode 100644
index 0000000..f5bf6ac
--- /dev/null
+++ b/grub-core/tests/boot/linux.cfg
@@ -0,0 +1,5 @@
+linux /linux console=ttyS0 root=/dev/ram0
+initrd /initrd
+boot
+# Shouln't happen
+halt
diff --git a/grub-core/tests/boot/linux.init-i386.S b/grub-core/tests/boot/linux.init-i386.S
new file mode 100644
index 0000000..c0983ac
--- /dev/null
+++ b/grub-core/tests/boot/linux.init-i386.S
@@ -0,0 +1,61 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010  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/>.
+ */
+
+#define SYSCALL_WRITE 4
+#define SYSCALL_RESET 88
+#define SYSCALL_IOPL 110
+#define SYSCALL_EXIT 1
+#define SYSCALL_INT 0x80
+
+#define STDOUT 1
+#define SHUTDOWN_MAGIC1 0xfee1dead
+#define SHUTDOWN_MAGIC2 0x28121969
+#define SHUTDOWN_MAGIC3 0x4321fedc
+
+	.text
+	.global start, _start
+_start:
+start:
+	/* write.  */
+	movl $SYSCALL_WRITE, %eax
+	movl $STDOUT, %ebx
+	leal message, %ecx
+	movl $(messageend-message), %edx
+	int $SYSCALL_INT
+
+	movl $SYSCALL_IOPL, %eax
+	movl $3, %ebx
+	int $SYSCALL_INT
+
+#include "qemu-shutdown-x86.S"
+	
+	/* shutdown.  */
+	movl $SYSCALL_RESET, %eax
+	movl $SHUTDOWN_MAGIC1, %ebx
+	movl $SHUTDOWN_MAGIC2, %ecx
+	movl $SHUTDOWN_MAGIC3, %edx
+	int $SYSCALL_INT
+
+	/* exit (1). Shouldn't be reached.  */
+	movl $SYSCALL_EXIT, %eax
+	movl $1, %ebx
+	int $SYSCALL_INT
+	.data
+message:
+	.ascii "Boot Test Passed Successfully\n" SUCCESSFUL_BOOT_STRING "\n"
+messageend:
diff --git a/grub-core/tests/boot/linux.init-mips.S b/grub-core/tests/boot/linux.init-mips.S
new file mode 100644
index 0000000..5ef4c37
--- /dev/null
+++ b/grub-core/tests/boot/linux.init-mips.S
@@ -0,0 +1,61 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010  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/>.
+ */
+
+#define SYSCALL_WRITE 4004
+#define SYSCALL_RESET 4088
+#define SYSCALL_EXIT 4001
+
+#define STDOUT 1
+#define SHUTDOWN_MAGIC1 0xfee1dead
+#define SHUTDOWN_MAGIC2 0x28121969
+#ifdef REBOOT
+#define SHUTDOWN_MAGIC3 0x01234567
+#else
+#define SHUTDOWN_MAGIC3 0x4321fedc
+#endif
+	.text
+	.global start, _start, __start
+__start:	
+_start:
+start:
+	/* write.  */
+	li $v0, SYSCALL_WRITE
+	li $a0, STDOUT
+	lui $a1, %hi(message)
+	addiu $a1, %lo(message)
+	lui $a2, %hi(messageend)
+	addiu $a2, %lo(messageend)
+	subu $a2, $a2, $a1
+	syscall
+
+	/* shutdown.  */
+	li $v0, SYSCALL_RESET
+	li $a0, SHUTDOWN_MAGIC1
+	li $a1, SHUTDOWN_MAGIC2
+	li $a2, SHUTDOWN_MAGIC3
+	syscall
+
+	/* exit(1). Shouldn't be reached.  */
+	li $v0, SYSCALL_EXIT
+	li $a0, 1
+	syscall
+
+	.data
+message:
+	.ascii "Boot Test Passed Successfully\n" SUCCESSFUL_BOOT_STRING "\n"
+messageend:
diff --git a/grub-core/tests/boot/linux.init-ppc.S b/grub-core/tests/boot/linux.init-ppc.S
new file mode 100644
index 0000000..8c9aa44
--- /dev/null
+++ b/grub-core/tests/boot/linux.init-ppc.S
@@ -0,0 +1,61 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2012  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/>.
+ */
+
+#define SYSCALL_WRITE 4
+#define SYSCALL_RESET 88
+#define SYSCALL_EXIT 1
+
+#define STDOUT 1
+#define SHUTDOWN_MAGIC1 0xfee1dead
+#define SHUTDOWN_MAGIC2 0x28121969
+#define SHUTDOWN_MAGIC3 0x4321fedc
+
+	.text
+	.global start, _start, __start
+__start:	
+_start:
+start:
+	/* write.  */
+	li %r0, SYSCALL_WRITE
+	li %r3, STDOUT
+	lis %r4, message@h
+	ori %r4, %r4, message@l
+	lis %r5, messageend@h
+	ori %r5, %r5, messageend@l
+	sub %r5, %r5, %r4
+	sc
+
+	/* shutdown.  */
+	li %r0, SYSCALL_RESET
+	lis %r3, SHUTDOWN_MAGIC1@h
+	ori %r3, %r3, SHUTDOWN_MAGIC1@l
+	lis %r4, SHUTDOWN_MAGIC2@h
+	ori %r4, %r4, SHUTDOWN_MAGIC2@l
+	lis %r5, SHUTDOWN_MAGIC3@h
+	ori %r5, %r5, SHUTDOWN_MAGIC3@l
+	sc
+
+	/* exit(1). Shouldn't be reached.  */
+	li %r0, SYSCALL_EXIT
+	li %r3, 1
+	sc
+
+	.data
+message:
+	.ascii "Boot Test Passed Successfully\n" SUCCESSFUL_BOOT_STRING "\n"
+messageend:
diff --git a/grub-core/tests/boot/linux.init-x86_64.S b/grub-core/tests/boot/linux.init-x86_64.S
new file mode 100644
index 0000000..90bdcc3
--- /dev/null
+++ b/grub-core/tests/boot/linux.init-x86_64.S
@@ -0,0 +1,60 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010  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/>.
+ */
+
+#define SYSCALL_WRITE 1
+#define SYSCALL_RESET 169
+#define SYSCALL_IOPL 172
+#define SYSCALL_EXIT 60
+
+#define STDOUT 1
+#define SHUTDOWN_MAGIC1 0xfee1dead
+#define SHUTDOWN_MAGIC2 0x28121969
+#define SHUTDOWN_MAGIC3 0x4321fedc
+
+	.text
+	.global start, _start
+_start:
+start:
+	/* write.  */
+	movq $SYSCALL_WRITE, %rax
+	movq $STDOUT, %rdi
+	leaq message, %rsi
+	movq $(messageend-message), %rdx
+	syscall
+
+	movq $SYSCALL_IOPL, %rax
+	movq $3, %rdi
+	syscall
+
+#include "qemu-shutdown-x86.S"
+	
+	/* shutdown.  */
+	movq $SYSCALL_RESET, %rax
+	movq $SHUTDOWN_MAGIC1, %rdi
+	movq $SHUTDOWN_MAGIC2, %rsi
+	movq $SHUTDOWN_MAGIC3, %rdx
+	syscall
+
+	/* exit(1). Shouldn't be reached.  */
+	movq $SYSCALL_EXIT, %rax
+	movq $1, %rdi
+	syscall
+	.data
+message:
+	.ascii "Boot Test Passed Successfully\n" SUCCESSFUL_BOOT_STRING "\n"
+messageend:
diff --git a/grub-core/tests/boot/linux16.cfg b/grub-core/tests/boot/linux16.cfg
new file mode 100644
index 0000000..d7fbf96
--- /dev/null
+++ b/grub-core/tests/boot/linux16.cfg
@@ -0,0 +1,5 @@
+linux16 /linux console=ttyS0 root=/dev/ram0
+initrd16 /initrd
+boot
+# Shouln't happen
+halt
diff --git a/grub-core/tests/boot/multiboot.cfg b/grub-core/tests/boot/multiboot.cfg
new file mode 100644
index 0000000..0942ec6
--- /dev/null
+++ b/grub-core/tests/boot/multiboot.cfg
@@ -0,0 +1,4 @@
+multiboot /multiboot.elf
+boot
+# Shouln't happen
+halt
diff --git a/grub-core/tests/boot/multiboot2.cfg b/grub-core/tests/boot/multiboot2.cfg
new file mode 100644
index 0000000..2bec9e6
--- /dev/null
+++ b/grub-core/tests/boot/multiboot2.cfg
@@ -0,0 +1,4 @@
+multiboot2 /multiboot2.elf
+boot
+# Shouln't happen
+halt
diff --git a/grub-core/tests/boot/ntldr.cfg b/grub-core/tests/boot/ntldr.cfg
new file mode 100644
index 0000000..cd438a4
--- /dev/null
+++ b/grub-core/tests/boot/ntldr.cfg
@@ -0,0 +1,4 @@
+ntldr /ntldr.bin
+boot
+# Shouln't happen
+halt
diff --git a/grub-core/tests/boot/pc-chainloader.cfg b/grub-core/tests/boot/pc-chainloader.cfg
new file mode 100644
index 0000000..1e80a5b
--- /dev/null
+++ b/grub-core/tests/boot/pc-chainloader.cfg
@@ -0,0 +1,4 @@
+chainloader /pc-chainloader.bin
+boot
+# Shouln't happen
+halt
diff --git a/grub-core/tests/boot/qemu-shutdown-x86.S b/grub-core/tests/boot/qemu-shutdown-x86.S
new file mode 100644
index 0000000..e37f5df
--- /dev/null
+++ b/grub-core/tests/boot/qemu-shutdown-x86.S
@@ -0,0 +1,17 @@
+	movl $0x80000b80, %eax
+	movw $0xcf8, %dx
+	outl  %eax, %dx
+	movw $0xcfc, %dx
+	inb  %dx, %al
+	orb  $1, %al
+	outb  %al, %dx
+
+	movl $0x80000b40, %eax
+	movw $0xcf8, %dx
+	outl  %eax, %dx
+	movl $0x7001, %eax
+	movw $0xcfc, %dx
+	outl  %eax, %dx
+	movw $0x2000, %ax
+	movw $0x7004, %dx	
+	outw  %ax, %dx
diff --git a/grub-core/tests/bswap_test.c b/grub-core/tests/bswap_test.c
new file mode 100644
index 0000000..4eb3a98
--- /dev/null
+++ b/grub-core/tests/bswap_test.c
@@ -0,0 +1,121 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2015 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/test.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static grub_uint64_t vectors[] = {
+  0xffffffffffffffffULL, 1, 2, 0, 0x0102030405060708ULL
+};
+
+static void
+test16 (grub_uint16_t a)
+{
+  grub_uint16_t b, c;
+  grub_uint8_t *ap, *bp;
+  int i;
+  b = grub_swap_bytes16 (a);
+  c = grub_swap_bytes16 (b);
+  grub_test_assert (a == c, "bswap not idempotent: 0x%llx, 0x%llx, 0x%llx",
+		    (long long) a, (long long) b, (long long) c);
+  ap = (grub_uint8_t *) &a;
+  bp = (grub_uint8_t *) &b;
+  for (i = 0; i < 2; i++)
+    {
+      grub_test_assert (ap[i] == bp[1 - i],
+			"bswap bytes wrong: 0x%llx, 0x%llx",
+			(long long) a, (long long) b);
+    }
+}
+
+static void
+test32 (grub_uint32_t a)
+{
+  grub_uint32_t b, c;
+  grub_uint8_t *ap, *bp;
+  int i;
+  b = grub_swap_bytes32 (a);
+  c = grub_swap_bytes32 (b);
+  grub_test_assert (a == c, "bswap not idempotent: 0x%llx, 0x%llx, 0x%llx",
+		    (long long) a, (long long) b, (long long) c);
+  ap = (grub_uint8_t *) &a;
+  bp = (grub_uint8_t *) &b;
+  for (i = 0; i < 4; i++)
+    {
+      grub_test_assert (ap[i] == bp[3 - i],
+			"bswap bytes wrong: 0x%llx, 0x%llx",
+			(long long) a, (long long) b);
+    }
+}
+
+static void
+test64 (grub_uint64_t a)
+{
+  grub_uint64_t b, c;
+  grub_uint8_t *ap, *bp;
+  int i;
+  b = grub_swap_bytes64 (a);
+  c = grub_swap_bytes64 (b);
+  grub_test_assert (a == c, "bswap not idempotent: 0x%llx, 0x%llx, 0x%llx",
+		    (long long) a, (long long) b, (long long) c);
+  ap = (grub_uint8_t *) &a;
+  bp = (grub_uint8_t *) &b;
+  for (i = 0; i < 4; i++)
+    {
+      grub_test_assert (ap[i] == bp[7 - i],
+			"bswap bytes wrong: 0x%llx, 0x%llx",
+			(long long) a, (long long) b);
+    }
+}
+
+static void
+test_all(grub_uint64_t a)
+{
+  test64 (a);
+  test32 (a);
+  test16 (a);
+}
+
+static void
+bswap_test (void)
+{
+  grub_uint64_t a = 404, b = 7;
+  grub_size_t i;
+
+  for (i = 0; i < ARRAY_SIZE (vectors); i++)
+    {
+      test_all (vectors[i]);
+    }
+  for (i = 0; i < 40000; i++)
+    {
+      a = 17 * a + 13 * b;
+      b = 23 * a + 29 * b;
+      if (b == 0)
+	b = 1;
+      if (a == 0)
+	a = 1;
+      test_all (a);
+      test_all (b);
+    }
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (bswap_test, bswap_test);
diff --git a/grub-core/tests/checksums.h b/grub-core/tests/checksums.h
new file mode 100644
index 0000000..8273bd1
--- /dev/null
+++ b/grub-core/tests/checksums.h
@@ -0,0 +1,129 @@
+  { "cmdline_cat", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xc69be699, 0xc69be699, 0xe17fc97c, 0xe17fc97c, 0xc2512486, 0xc2512486, 0x20260761, 0x20260761, 0xe3485349, 0xe3485349, 0x6020b4d9, 0x6020b4d9, 0x1605db98, 0x1605db98, 0xdca51b58, 0xdca51b58, 0xf3d66441, 0xf3d66441, 0x18cb7ce2, 0x18cb7ce2, 0x23b616d9, 0x23b616d9, 0xa1bf5dbf, 0xa1bf5dbf, 0x5e4a8b3d, 0x5e4a8b3d, 0x9933b3d8, 0x9933b3d8, 0xce7be2de, 0xce7be2de, 0x62531729, 0x62531729, 0xc39d3788, 0xc39d3788, 0xf7aee2fe, 0xf7aee2fe, 0xc66f4903, 0xc66f4903, 0x536c922f, 0x536c922f, 0xcb231652, 0x4ae07b67, 0x146816d5, 0x146816d5, }, 45 },
+  { "cmdline_cat", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x29d0cfb7, 0x29d0cfb7, 0x4d57ad88, 0x4d57ad88, 0xaf7591cb, 0xaf7591cb, 0xb88e3c0, 0xb88e3c0, 0x5d55a031, 0x5d55a031, 0x4363bcff, 0x4363bcff, 0xe1142833, 0xe1142833, 0x9578c80d, 0x9578c80d, 0xff1f5174, 0xff1f5174, 0x6828d47, 0x6828d47, 0x2a849ae3, 0x2a849ae3, 0x27a811d9, 0x27a811d9, 0x6c42e1cb, 0x6c42e1cb, 0x5bba61f5, 0x5bba61f5, 0xc02ab705, 0xc02ab705, 0xeb3e0e05, 0xeb3e0e05, 0x6f4ce3c, 0x6f4ce3c, 0x2075c50e, 0x2075c50e, 0x54ac7fba, 0x54ac7fba, 0x335d1c21, 0x335d1c21, 0xf923fbd1, 0x1b489d4d, 0x1253eb5e, 0x1253eb5e, }, 45 },
+  { "cmdline_cat", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x6ff92a98, 0x6ff92a98, 0xbd8264b3, 0xbd8264b3, 0x5c50282c, 0x5c50282c, 0xd18d6a5a, 0xd18d6a5a, 0x99cea139, 0x99cea139, 0x2590c545, 0x2590c545, 0x55c86045, 0x55c86045, 0xad53ef1e, 0xad53ef1e, 0x5b44a23a, 0x5b44a23a, 0xa255f863, 0xa255f863, 0x85b0bdca, 0x85b0bdca, 0x4220ee1f, 0x4220ee1f, 0xeb991a9f, 0xeb991a9f, 0x86f366dd, 0x86f366dd, 0xfa176b7d, 0xfa176b7d, 0xd7384ca9, 0xd7384ca9, 0xceebf5c1, 0xceebf5c1, 0xae62b268, 0xae62b268, 0x6e89bbd6, 0x6e89bbd6, 0x3fe07c8e, 0x3fe07c8e, 0xee5358fe, 0x162d1a8a, 0x876f8d10, 0x876f8d10, }, 45 },
+  { "cmdline_cat", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xb96afaea, 0xb96afaea, 0xaa16ab1e, 0xaa16ab1e, 0x51ff382, 0x51ff382, 0xec74f127, 0xec74f127, 0xde4bca99, 0xde4bca99, 0x8ef3e8a5, 0x8ef3e8a5, 0x2daeb0b4, 0x2daeb0b4, 0x7cf5e243, 0x7cf5e243, 0x11fd57c6, 0x11fd57c6, 0x140723af, 0x140723af, 0x2bd93833, 0x2bd93833, 0xd731f4ac, 0xd731f4ac, 0x5fcd7114, 0x5fcd7114, 0xd1fea24a, 0xd1fea24a, 0x4083d53a, 0x4083d53a, 0x2e372605, 0x2e372605, 0x8e6316a7, 0x8e6316a7, 0x283ef6cc, 0x283ef6cc, 0x20cee9de, 0x20cee9de, 0xad6fa187, 0xad6fa187, 0xd691f438, 0xf3257e63, 0x4786ba7, 0x4786ba7, }, 45 },
+  { "cmdline_cat", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x48acf1bf, 0x48acf1bf, 0xb8777469, 0xb8777469, 0xad2fad44, 0xad2fad44, 0xa415ac59, 0xa415ac59, 0x5a7bfb26, 0x5a7bfb26, 0xccb6016, 0xccb6016, 0x77a80cb3, 0x77a80cb3, 0x2034c102, 0x2034c102, 0x444b4ccd, 0x444b4ccd, 0xe6c31bea, 0xe6c31bea, 0x8408036e, 0x8408036e, 0x9e7c556f, 0x9e7c556f, 0x445dc388, 0x445dc388, 0x94b3f850, 0x94b3f850, 0xf6f15341, 0xf6f15341, 0xcb939b5f, 0xcb939b5f, 0xbe88067d, 0xbe88067d, 0x1efc4734, 0x1efc4734, 0x7f5dfca8, 0x7f5dfca8, 0xb7b10eb9, 0xb7b10eb9, 0xb94cb441, 0x9571329, 0x8a26912b, 0x8a26912b, }, 45 },
+  { "cmdline_cat", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xc508d04e, 0xc508d04e, 0x6dbccbfe, 0x6dbccbfe, 0xbf06ff60, 0xbf06ff60, 0xbc5ab06, 0xbc5ab06, 0x97eeab3c, 0x97eeab3c, 0x62663589, 0x62663589, 0xb03e21e2, 0xb03e21e2, 0xea196bb6, 0xea196bb6, 0x672c16c4, 0x672c16c4, 0xefbca2cd, 0xefbca2cd, 0x1af5b410, 0x1af5b410, 0xc7a80569, 0xc7a80569, 0x4926a16, 0x4926a16, 0xee29c99c, 0xee29c99c, 0xffb15985, 0xffb15985, 0x4f608e46, 0x4f608e46, 0x3e450fd2, 0x3e450fd2, 0xac45215f, 0xac45215f, 0x789b0ce7, 0x789b0ce7, 0x4cedfe22, 0x4cedfe22, 0xa005588c, 0x701da05c, 0x6f25cec1, 0x6f25cec1, }, 45 },
+  { "cmdline_cat", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x29e7a7f, 0x29e7a7f, 0xbd221052, 0xbd221052, 0x3b18b64, 0x3b18b64, 0x7f1e8462, 0x7f1e8462, 0xf28d5124, 0xf28d5124, 0xc336f170, 0xc336f170, 0xfe3bf988, 0xfe3bf988, 0x7bf89e05, 0x7bf89e05, 0x7857a3f8, 0x7857a3f8, 0x272c1a36, 0x272c1a36, 0xe8adb445, 0xe8adb445, 0x70cfe280, 0x70cfe280, 0x4f2b6120, 0x4f2b6120, 0xbaf5caa5, 0xbaf5caa5, 0x4b6bcab2, 0x4b6bcab2, 0x2bef7b92, 0x2bef7b92, 0x17b381dc, 0x17b381dc, 0x884c9c35, 0x884c9c35, 0x2f9eb909, 0x2f9eb909, 0xa811b3af, 0xa811b3af, 0x4c39478f, 0x5a72c3ab, 0x8071678a, 0x8071678a, }, 45 },
+  { "gfxterm_menu", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xd9f04953, 0xbf3fa5d0, 0xd9f04953, 0x9a068414, 0x59c36f00, 0x59c36f00, 0x620c0067, 0x620c0067, 0x620c0067, 0x1c8c6d01, 0x1c8c6d01, 0x1c8c6d01, 0xc3269013, 0xc3269013, 0xc3269013, 0x59c36f00, 0x9a068414, 0x9a068414, 0x59c36f00, }, 20 },
+  { "gfxterm_menu", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x9254157f, 0x367e92c7, 0x9254157f, 0xbc519000, 0xaa4593fe, 0xaa4593fe, 0xa8a596c8, 0xa8a596c8, 0xa8a596c8, 0xe509baf, 0xe509baf, 0xe509baf, 0x16f0dc06, 0x16f0dc06, 0x16f0dc06, 0xaa4593fe, 0xbc519000, 0xbc519000, 0xaa4593fe, }, 20 },
+  { "gfxterm_menu", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x354b1976, 0x8fc746ae, 0x354b1976, 0x685c74f2, 0xc9cbf769, 0xc9cbf769, 0x3ce35e1d, 0x3ce35e1d, 0x3ce35e1d, 0xc23b9fd1, 0xc23b9fd1, 0xc23b9fd1, 0x5b18528e, 0x5b18528e, 0x5b18528e, 0xc9cbf769, 0x685c74f2, 0x685c74f2, 0xc9cbf769, }, 20 },
+  { "gfxterm_menu", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x1c9ec014, 0xaf3ec923, 0x1c9ec014, 0x43f5296, 0x9813a416, 0x9813a416, 0x43fda3fa, 0x43fda3fa, 0x43fda3fa, 0xd22625c9, 0xd22625c9, 0xd22625c9, 0x76a62c0a, 0x76a62c0a, 0x76a62c0a, 0x9813a416, 0x43f5296, 0x43f5296, 0x9813a416, }, 20 },
+  { "gfxterm_menu", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xa704f7ea, 0xb7f2ec8b, 0xa704f7ea, 0xb279bf59, 0x5fcf013d, 0x5fcf013d, 0xf3582c48, 0xf3582c48, 0xf3582c48, 0x2148343e, 0x2148343e, 0x2148343e, 0x9c719024, 0x9c719024, 0x9c719024, 0x5fcf013d, 0xb279bf59, 0xb279bf59, 0x5fcf013d, }, 20 },
+  { "gfxterm_menu", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xf293ce36, 0xa6eb6ae8, 0xf293ce36, 0xcd87647e, 0xdd28f52b, 0xdd28f52b, 0xb3c7ef80, 0xb3c7ef80, 0xb3c7ef80, 0x92fb1664, 0x92fb1664, 0x92fb1664, 0xd15b5e2e, 0xd15b5e2e, 0xd15b5e2e, 0xdd28f52b, 0xcd87647e, 0xcd87647e, 0xdd28f52b, }, 20 },
+  { "gfxterm_menu", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x31e75bd7, 0x9a768c6a, 0x31e75bd7, 0xa8fc31a6, 0x43d1f34, 0x43d1f34, 0xa0717008, 0xa0717008, 0xa0717008, 0xdf7bd9a0, 0xdf7bd9a0, 0xdf7bd9a0, 0x8e5a9312, 0x8e5a9312, 0x8e5a9312, 0x43d1f34, 0xa8fc31a6, 0xa8fc31a6, 0x43d1f34, }, 20 },
+  { "gfxmenu", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x1ce7bd78, 0x682580f5, 0x1ce7bd78, 0x490ad6fe, 0x9a2e0d26, 0x64eb71ba, 0x64eb71ba, 0x64eb71ba, 0x3833877a, 0x3833877a, 0x3833877a, 0xcfc14f0a, 0xcfc14f0a, 0xcfc14f0a, 0x59c36f00, 0x490ad6fe, 0x490ad6fe, }, 18 },
+  { "gfxmenu", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x2b6ff87d, 0x63ce2ca2, 0x2b6ff87d, 0xf00f044e, 0xa9d58ccd, 0xe2c46577, 0xe2c46577, 0xe2c46577, 0xb79bcf7d, 0xb79bcf7d, 0xb79bcf7d, 0xbc30ed71, 0xbc30ed71, 0xbc30ed71, 0xaa4593fe, 0xf00f044e, 0xf00f044e, }, 18 },
+  { "gfxmenu", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xe61cadba, 0x9880b727, 0xe61cadba, 0xdf5f2fc0, 0x5411be8b, 0x4449774e, 0x4449774e, 0x4449774e, 0x3bf7d1da, 0x3bf7d1da, 0x3bf7d1da, 0xd2ddee01, 0xd2ddee01, 0xd2ddee01, 0xc9cbf769, 0xdf5f2fc0, 0xdf5f2fc0, }, 18 },
+  { "gfxmenu", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x1c3742c9, 0xbe54acf7, 0x9b4ce770, 0xbe54acf7, 0x3111489, 0x740d78cf, 0x314c4c59, 0x314c4c59, 0x314c4c59, 0xdae9a625, 0xdae9a625, 0xdae9a625, 0xcbf8af57, 0xcbf8af57, 0xcbf8af57, 0x1c3742c9, 0x3111489, 0x3111489, }, 18 },
+  { "gfxmenu", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0xcc5a7bed, 0xee571de5, 0x568aaeff, 0xee571de5, 0xe328b7a7, 0xbcda144c, 0xf56e1b60, 0xf56e1b60, 0xf56e1b60, 0x9a27c771, 0x9a27c771, 0x9a27c771, 0xd6d05397, 0xd6d05397, 0xd6d05397, 0xcc5a7bed, 0xe328b7a7, 0xe328b7a7, }, 18 },
+  { "gfxmenu", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xef4a3312, 0x1db9877c, 0x7e1afeae, 0x1db9877c, 0x8fc0c430, 0x5d55a141, 0x96f335c6, 0x96f335c6, 0x96f335c6, 0x504171d8, 0x504171d8, 0x504171d8, 0x69f71c0, 0x69f71c0, 0x69f71c0, 0xef4a3312, 0x8fc0c430, 0x8fc0c430, }, 18 },
+  { "gfxmenu", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x54e48d80, 0x151819bd, 0xea8d4865, 0x151819bd, 0x11d75fd2, 0x6d6bb4bc, 0x650ccd09, 0x650ccd09, 0x650ccd09, 0xe4ff3bd8, 0xe4ff3bd8, 0xe4ff3bd8, 0xc5308b73, 0xc5308b73, 0xc5308b73, 0x54e48d80, 0x11d75fd2, 0x11d75fd2, }, 18 },
+  { "gfxterm_ar", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xd0b06c3d, 0xde50d1a5, 0xd0b06c3d, 0x9346a17a, 0x59c36f00, 0x59c36f00, 0xacff5d47, 0xacff5d47, 0xacff5d47, 0xd27f3021, 0xd27f3021, 0xd27f3021, 0xdd5cd33, 0xdd5cd33, 0xdd5cd33, 0x59c36f00, 0x9346a17a, 0x9346a17a, 0x59c36f00, }, 20 },
+  { "gfxterm_ar", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0xf32d50c1, 0x730a7ed, 0xf32d50c1, 0xdd28d5be, 0xaa4593fe, 0xaa4593fe, 0xba8a2d4c, 0xba8a2d4c, 0xba8a2d4c, 0x1c7f202b, 0x1c7f202b, 0x1c7f202b, 0x4df6782, 0x4df6782, 0x4df6782, 0xaa4593fe, 0xdd28d5be, 0xdd28d5be, 0xaa4593fe, }, 20 },
+  { "gfxterm_ar", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x711a4ac1, 0x6396f14c, 0x711a4ac1, 0x2c0d2745, 0xc9cbf769, 0xc9cbf769, 0x6b6ccbb0, 0x6b6ccbb0, 0x6b6ccbb0, 0x95b40a7c, 0x95b40a7c, 0x95b40a7c, 0xc97c723, 0xc97c723, 0xc97c723, 0xc9cbf769, 0x2c0d2745, 0x2c0d2745, 0xc9cbf769, }, 20 },
+  { "gfxterm_ar", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x29baad6a, 0x348b1f2b, 0x29baad6a, 0x311b3fe8, 0x9813a416, 0x9813a416, 0xe8e982cc, 0xe8e982cc, 0xe8e982cc, 0x793204ff, 0x793204ff, 0x793204ff, 0xddb20d3c, 0xddb20d3c, 0xddb20d3c, 0x9813a416, 0x311b3fe8, 0x311b3fe8, 0x9813a416, }, 20 },
+  { "gfxterm_ar", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xf834b3bb, 0x3951bd1a, 0xf834b3bb, 0xed49fb08, 0x5fcf013d, 0x5fcf013d, 0x5aefa2a7, 0x5aefa2a7, 0x5aefa2a7, 0x88ffbad1, 0x88ffbad1, 0x88ffbad1, 0x35c61ecb, 0x35c61ecb, 0x35c61ecb, 0x5fcf013d, 0xed49fb08, 0xed49fb08, 0x5fcf013d, }, 20 },
+  { "gfxterm_ar", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x7e9a7a47, 0xb1651b5a, 0x7e9a7a47, 0x418ed00f, 0xdd28f52b, 0xdd28f52b, 0x83f9db69, 0x83f9db69, 0x83f9db69, 0xa2c5228d, 0xa2c5228d, 0xa2c5228d, 0xe1656ac7, 0xe1656ac7, 0xe1656ac7, 0xdd28f52b, 0x418ed00f, 0x418ed00f, 0xdd28f52b, }, 20 },
+  { "gfxterm_ar", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xc6a0340, 0x7dd5855c, 0xc6a0340, 0x95716931, 0x43d1f34, 0x43d1f34, 0x5f1c24c0, 0x5f1c24c0, 0x5f1c24c0, 0x20168d68, 0x20168d68, 0x20168d68, 0x7137c7da, 0x7137c7da, 0x7137c7da, 0x43d1f34, 0x95716931, 0x95716931, 0x43d1f34, }, 20 },
+  { "gfxterm_cyr", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xd3798aaa, 0xab48784c, 0xd3798aaa, 0x908f47ed, 0x59c36f00, 0x59c36f00, 0x1688ec7c, 0x1688ec7c, 0x1688ec7c, 0x6808811a, 0x6808811a, 0x6808811a, 0xb7a27c08, 0xb7a27c08, 0xb7a27c08, 0x59c36f00, 0x908f47ed, 0x908f47ed, 0x59c36f00, }, 20 },
+  { "gfxterm_cyr", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0xc30d9d2a, 0x60b9ed26, 0xc30d9d2a, 0xed081855, 0xaa4593fe, 0xaa4593fe, 0x3eba2192, 0x3eba2192, 0x3eba2192, 0x984f2cf5, 0x984f2cf5, 0x984f2cf5, 0x80ef6b5c, 0x80ef6b5c, 0x80ef6b5c, 0xaa4593fe, 0xed081855, 0xed081855, 0xaa4593fe, }, 20 },
+  { "gfxterm_cyr", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xe469e6af, 0x46ac2012, 0xe469e6af, 0xb97e8b2b, 0xc9cbf769, 0xc9cbf769, 0x60f0d993, 0x60f0d993, 0x60f0d993, 0x9e28185f, 0x9e28185f, 0x9e28185f, 0x70bd500, 0x70bd500, 0x70bd500, 0xc9cbf769, 0xb97e8b2b, 0xb97e8b2b, 0xc9cbf769, }, 20 },
+  { "gfxterm_cyr", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x8538d2ef, 0xab143284, 0x8538d2ef, 0x9d99406d, 0x9813a416, 0x9813a416, 0x7e8326ec, 0x7e8326ec, 0x7e8326ec, 0xef58a0df, 0xef58a0df, 0xef58a0df, 0x4bd8a91c, 0x4bd8a91c, 0x4bd8a91c, 0x9813a416, 0x9d99406d, 0x9d99406d, 0x9813a416, }, 20 },
+  { "gfxterm_cyr", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x8115198c, 0x1abdaee1, 0x8115198c, 0x9468513f, 0x5fcf013d, 0x5fcf013d, 0xa5e86484, 0xa5e86484, 0xa5e86484, 0x77f87cf2, 0x77f87cf2, 0x77f87cf2, 0xcac1d8e8, 0xcac1d8e8, 0xcac1d8e8, 0x5fcf013d, 0x9468513f, 0x9468513f, 0x5fcf013d, }, 20 },
+  { "gfxterm_cyr", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xea03b805, 0x74148290, 0xea03b805, 0xd517124d, 0xdd28f52b, 0xdd28f52b, 0x8f6eee40, 0x8f6eee40, 0x8f6eee40, 0xae5217a4, 0xae5217a4, 0xae5217a4, 0xedf25fee, 0xedf25fee, 0xedf25fee, 0xdd28f52b, 0xd517124d, 0xd517124d, 0xdd28f52b, }, 20 },
+  { "gfxterm_cyr", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xa044490f, 0xe23458db, 0xa044490f, 0x395f237e, 0x43d1f34, 0x43d1f34, 0xe1ca82c2, 0xe1ca82c2, 0xe1ca82c2, 0x9ec02b6a, 0x9ec02b6a, 0x9ec02b6a, 0xcfe161d8, 0xcfe161d8, 0xcfe161d8, 0x43d1f34, 0x395f237e, 0x395f237e, 0x43d1f34, }, 20 },
+  { "gfxterm_heb", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xf3259b30, 0xf1f01411, 0xf3259b30, 0xb0d35677, 0x59c36f00, 0x59c36f00, 0x97895f8e, 0x97895f8e, 0x97895f8e, 0xe90932e8, 0xe90932e8, 0xe90932e8, 0x36a3cffa, 0x36a3cffa, 0x36a3cffa, 0x59c36f00, 0xb0d35677, 0xb0d35677, 0x59c36f00, }, 20 },
+  { "gfxterm_heb", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x53a43759, 0xe0f26bfa, 0x53a43759, 0x7da1b226, 0xaa4593fe, 0xaa4593fe, 0xbf482a4e, 0xbf482a4e, 0xbf482a4e, 0x19bd2729, 0x19bd2729, 0x19bd2729, 0x11d6080, 0x11d6080, 0x11d6080, 0xaa4593fe, 0x7da1b226, 0x7da1b226, 0xaa4593fe, }, 20 },
+  { "gfxterm_heb", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xd7ff8d53, 0x665b2728, 0xd7ff8d53, 0x8ae8e0d7, 0xc9cbf769, 0xc9cbf769, 0x5a693e73, 0x5a693e73, 0x5a693e73, 0xa4b1ffbf, 0xa4b1ffbf, 0xa4b1ffbf, 0x3d9232e0, 0x3d9232e0, 0x3d9232e0, 0xc9cbf769, 0x8ae8e0d7, 0x8ae8e0d7, 0xc9cbf769, }, 20 },
+  { "gfxterm_heb", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x99fddcbe, 0x6d5c8895, 0x99fddcbe, 0x815c4e3c, 0x9813a416, 0x9813a416, 0x9bcf9821, 0x9bcf9821, 0x9bcf9821, 0xa141e12, 0xa141e12, 0xa141e12, 0xae9417d1, 0xae9417d1, 0xae9417d1, 0x9813a416, 0x815c4e3c, 0x815c4e3c, 0x9813a416, }, 20 },
+  { "gfxterm_heb", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x5797846, 0x25a6ad40, 0x5797846, 0x100430f5, 0x5fcf013d, 0x5fcf013d, 0xddc86daf, 0xddc86daf, 0xddc86daf, 0xfd875d9, 0xfd875d9, 0xfd875d9, 0xb2e1d1c3, 0xb2e1d1c3, 0xb2e1d1c3, 0x5fcf013d, 0x100430f5, 0x100430f5, 0x5fcf013d, }, 20 },
+  { "gfxterm_heb", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x30653ae8, 0x7fcd187, 0x30653ae8, 0xf7190a0, 0xdd28f52b, 0xdd28f52b, 0x24c3d325, 0x24c3d325, 0x24c3d325, 0x5ff2ac1, 0x5ff2ac1, 0x5ff2ac1, 0x465f628b, 0x465f628b, 0x465f628b, 0xdd28f52b, 0xf7190a0, 0xf7190a0, 0xdd28f52b, }, 20 },
+  { "gfxterm_heb", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x3bd91638, 0x1d74dd4a, 0x3bd91638, 0xa2c27c49, 0x43d1f34, 0x43d1f34, 0x53d1ad3d, 0x53d1ad3d, 0x53d1ad3d, 0x2cdb0495, 0x2cdb0495, 0x2cdb0495, 0x7dfa4e27, 0x7dfa4e27, 0x7dfa4e27, 0x43d1f34, 0xa2c27c49, 0xa2c27c49, 0x43d1f34, }, 20 },
+  { "gfxterm_gre", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xbe2c351a, 0x2692720, 0xbe2c351a, 0xfddaf85d, 0x59c36f00, 0x59c36f00, 0x1b2e2301, 0x1b2e2301, 0x1b2e2301, 0x65ae4e67, 0x65ae4e67, 0x65ae4e67, 0xba04b375, 0xba04b375, 0xba04b375, 0x59c36f00, 0xfddaf85d, 0xfddaf85d, 0x59c36f00, }, 20 },
+  { "gfxterm_gre", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x1eca82e1, 0xe8fa59cc, 0x1eca82e1, 0x30cf079e, 0xaa4593fe, 0xaa4593fe, 0xaf27ddc5, 0xaf27ddc5, 0xaf27ddc5, 0x9d2d0a2, 0x9d2d0a2, 0x9d2d0a2, 0x1172970b, 0x1172970b, 0x1172970b, 0xaa4593fe, 0x30cf079e, 0x30cf079e, 0xaa4593fe, }, 20 },
+  { "gfxterm_gre", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xa9ccd435, 0x1ac646eb, 0xa9ccd435, 0xf4dbb9b1, 0xc9cbf769, 0xc9cbf769, 0x86d69aa0, 0x86d69aa0, 0x86d69aa0, 0x780e5b6c, 0x780e5b6c, 0x780e5b6c, 0xe12d9633, 0xe12d9633, 0xe12d9633, 0xc9cbf769, 0xf4dbb9b1, 0xf4dbb9b1, 0xc9cbf769, }, 20 },
+  { "gfxterm_gre", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xf96d568, 0x7ad05c1b, 0xf96d568, 0x173747ea, 0x9813a416, 0x9813a416, 0xacf9792a, 0xacf9792a, 0xacf9792a, 0x3d22ff19, 0x3d22ff19, 0x3d22ff19, 0x99a2f6da, 0x99a2f6da, 0x99a2f6da, 0x9813a416, 0x173747ea, 0x173747ea, 0x9813a416, }, 20 },
+  { "gfxterm_gre", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xa0dc6b9c, 0xc2761148, 0xa0dc6b9c, 0xb5a1232f, 0x5fcf013d, 0x5fcf013d, 0x4e05748b, 0x4e05748b, 0x4e05748b, 0x9c156cfd, 0x9c156cfd, 0x9c156cfd, 0x212cc8e7, 0x212cc8e7, 0x212cc8e7, 0x5fcf013d, 0xb5a1232f, 0xb5a1232f, 0x5fcf013d, }, 20 },
+  { "gfxterm_gre", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xcd722f7d, 0xe4df8d6b, 0xcd722f7d, 0xf2668535, 0xdd28f52b, 0xdd28f52b, 0xbdbb8019, 0xbdbb8019, 0xbdbb8019, 0x9c8779fd, 0x9c8779fd, 0x9c8779fd, 0xdf2731b7, 0xdf2731b7, 0xdf2731b7, 0xdd28f52b, 0xf2668535, 0xf2668535, 0xdd28f52b, }, 20 },
+  { "gfxterm_gre", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xa6c99d2f, 0x1de04317, 0xa6c99d2f, 0x3fd2f75e, 0x43d1f34, 0x43d1f34, 0x3f85b7d3, 0x3f85b7d3, 0x3f85b7d3, 0x408f1e7b, 0x408f1e7b, 0x408f1e7b, 0x11ae54c9, 0x11ae54c9, 0x11ae54c9, 0x43d1f34, 0x3fd2f75e, 0x3fd2f75e, 0x43d1f34, }, 20 },
+  { "gfxterm_ru", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x1e35b709, 0x2683bf92, 0x1e35b709, 0x5dc37a4e, 0x59c36f00, 0x59c36f00, 0xd697967f, 0xd697967f, 0xd697967f, 0xa817fb19, 0xa817fb19, 0xa817fb19, 0x77bd060b, 0x77bd060b, 0x77bd060b, 0x59c36f00, 0x5dc37a4e, 0x5dc37a4e, 0x59c36f00, }, 20 },
+  { "gfxterm_ru", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x53ff7735, 0x8cbf197c, 0x53ff7735, 0x7dfaf24a, 0xaa4593fe, 0xaa4593fe, 0x389a922, 0x389a922, 0x389a922, 0xa57ca445, 0xa57ca445, 0xa57ca445, 0xbddce3ec, 0xbddce3ec, 0xbddce3ec, 0xaa4593fe, 0x7dfaf24a, 0x7dfaf24a, 0xaa4593fe, }, 20 },
+  { "gfxterm_ru", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x5217c47d, 0x7c8ae63e, 0x5217c47d, 0xf00a9f9, 0xc9cbf769, 0xc9cbf769, 0x3995409, 0x3995409, 0x3995409, 0xfd4195c5, 0xfd4195c5, 0xfd4195c5, 0x6462589a, 0x6462589a, 0x6462589a, 0xc9cbf769, 0xf00a9f9, 0xf00a9f9, 0xc9cbf769, }, 20 },
+  { "gfxterm_ru", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x45b67706, 0x375fb5db, 0x45b67706, 0x5d17e584, 0x9813a416, 0x9813a416, 0x8195719b, 0x8195719b, 0x8195719b, 0x104ef7a8, 0x104ef7a8, 0x104ef7a8, 0xb4cefe6b, 0xb4cefe6b, 0xb4cefe6b, 0x9813a416, 0x5d17e584, 0x5d17e584, 0x9813a416, }, 20 },
+  { "gfxterm_ru", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xfc209a25, 0xd5c20779, 0xfc209a25, 0xe95dd296, 0x5fcf013d, 0x5fcf013d, 0xe5699efe, 0xe5699efe, 0xe5699efe, 0x37798688, 0x37798688, 0x37798688, 0x8a402292, 0x8a402292, 0x8a402292, 0x5fcf013d, 0xe95dd296, 0xe95dd296, 0x5fcf013d, }, 20 },
+  { "gfxterm_ru", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x77f956f0, 0xfb0cc079, 0x77f956f0, 0x48edfcb8, 0xdd28f52b, 0xdd28f52b, 0xd51b1dc9, 0xd51b1dc9, 0xd51b1dc9, 0xf427e42d, 0xf427e42d, 0xf427e42d, 0xb787ac67, 0xb787ac67, 0xb787ac67, 0xdd28f52b, 0x48edfcb8, 0x48edfcb8, 0xdd28f52b, }, 20 },
+  { "gfxterm_ru", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x1d9ac82a, 0xa254aa53, 0x1d9ac82a, 0x8481a25b, 0x43d1f34, 0x43d1f34, 0xc304df68, 0xc304df68, 0xc304df68, 0xbc0e76c0, 0xbc0e76c0, 0xbc0e76c0, 0xed2f3c72, 0xed2f3c72, 0xed2f3c72, 0x43d1f34, 0x8481a25b, 0x8481a25b, 0x43d1f34, }, 20 },
+  { "gfxterm_fr", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xa6239a89, 0x8dc4bfbb, 0xa6239a89, 0xe5d557ce, 0x59c36f00, 0x59c36f00, 0x244cf807, 0x244cf807, 0x244cf807, 0x5acc9561, 0x5acc9561, 0x5acc9561, 0x85666873, 0x85666873, 0x85666873, 0x59c36f00, 0xe5d557ce, 0xe5d557ce, 0x59c36f00, }, 20 },
+  { "gfxterm_fr", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x742cede9, 0x83bb7a50, 0x742cede9, 0x5a296896, 0xaa4593fe, 0xaa4593fe, 0xd83f8aeb, 0xd83f8aeb, 0xd83f8aeb, 0x7eca878c, 0x7eca878c, 0x7eca878c, 0x666ac025, 0x666ac025, 0x666ac025, 0xaa4593fe, 0x5a296896, 0x5a296896, 0xaa4593fe, }, 20 },
+  { "gfxterm_fr", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xe20a98b0, 0x7e8cedef, 0xe20a98b0, 0xbf1df534, 0xc9cbf769, 0xc9cbf769, 0x2748b88c, 0x2748b88c, 0x2748b88c, 0xd9907940, 0xd9907940, 0xd9907940, 0x40b3b41f, 0x40b3b41f, 0x40b3b41f, 0xc9cbf769, 0xbf1df534, 0xbf1df534, 0xc9cbf769, }, 20 },
+  { "gfxterm_fr", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x8f911ca4, 0xcbf1d895, 0x8f911ca4, 0x97308e26, 0x9813a416, 0x9813a416, 0x5b359bf4, 0x5b359bf4, 0x5b359bf4, 0xcaee1dc7, 0xcaee1dc7, 0xcaee1dc7, 0x6e6e1404, 0x6e6e1404, 0x6e6e1404, 0x9813a416, 0x97308e26, 0x97308e26, 0x9813a416, }, 20 },
+  { "gfxterm_fr", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x1bf82c82, 0xc7b39627, 0x1bf82c82, 0xe856431, 0x5fcf013d, 0x5fcf013d, 0xa9dbae99, 0xa9dbae99, 0xa9dbae99, 0x7bcbb6ef, 0x7bcbb6ef, 0x7bcbb6ef, 0xc6f212f5, 0xc6f212f5, 0xc6f212f5, 0x5fcf013d, 0xe856431, 0xe856431, 0x5fcf013d, }, 20 },
+  { "gfxterm_fr", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xfae19a5c, 0xd1e8fabb, 0xfae19a5c, 0xc5f53014, 0xdd28f52b, 0xdd28f52b, 0xfa2c5565, 0xfa2c5565, 0xfa2c5565, 0xdb10ac81, 0xdb10ac81, 0xdb10ac81, 0x98b0e4cb, 0x98b0e4cb, 0x98b0e4cb, 0xdd28f52b, 0xc5f53014, 0xc5f53014, 0xdd28f52b, }, 20 },
+  { "gfxterm_fr", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x9a18f7bc, 0x5fcecc43, 0x9a18f7bc, 0x3039dcd, 0x43d1f34, 0x43d1f34, 0x287a2b96, 0x287a2b96, 0x287a2b96, 0x5770823e, 0x5770823e, 0x5770823e, 0x651c88c, 0x651c88c, 0x651c88c, 0x43d1f34, 0x3039dcd, 0x3039dcd, 0x43d1f34, }, 20 },
+  { "gfxterm_quot", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x65112dfc, 0x3dec17f, 0x65112dfc, 0x26e7e0bb, 0x59c36f00, 0x59c36f00, 0x620c0067, 0x620c0067, 0x620c0067, 0x1c8c6d01, 0x1c8c6d01, 0x1c8c6d01, 0xc3269013, 0xc3269013, 0xc3269013, 0x59c36f00, 0x26e7e0bb, 0x26e7e0bb, 0x59c36f00, }, 20 },
+  { "gfxterm_quot", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x2b3430fb, 0x8f1eb743, 0x2b3430fb, 0x531b584, 0xaa4593fe, 0xaa4593fe, 0xa8a596c8, 0xa8a596c8, 0xa8a596c8, 0xe509baf, 0xe509baf, 0xe509baf, 0x16f0dc06, 0x16f0dc06, 0x16f0dc06, 0xaa4593fe, 0x531b584, 0x531b584, 0xaa4593fe, }, 20 },
+  { "gfxterm_quot", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xb523e920, 0xfafb6f8, 0xb523e920, 0xe83484a4, 0xc9cbf769, 0xc9cbf769, 0x3ce35e1d, 0x3ce35e1d, 0x3ce35e1d, 0xc23b9fd1, 0xc23b9fd1, 0xc23b9fd1, 0x5b18528e, 0x5b18528e, 0x5b18528e, 0xc9cbf769, 0xe83484a4, 0xe83484a4, 0xc9cbf769, }, 20 },
+  { "gfxterm_quot", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xa9bf7336, 0x1a1f7a01, 0xa9bf7336, 0xb11ee1b4, 0x9813a416, 0x9813a416, 0x43fda3fa, 0x43fda3fa, 0x43fda3fa, 0xd22625c9, 0xd22625c9, 0xd22625c9, 0x76a62c0a, 0x76a62c0a, 0x76a62c0a, 0x9813a416, 0xb11ee1b4, 0xb11ee1b4, 0x9813a416, }, 20 },
+  { "gfxterm_quot", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xe5271912, 0xf5d10273, 0xe5271912, 0xf05a51a1, 0x5fcf013d, 0x5fcf013d, 0xf3582c48, 0xf3582c48, 0xf3582c48, 0x2148343e, 0x2148343e, 0x2148343e, 0x9c719024, 0x9c719024, 0x9c719024, 0x5fcf013d, 0xf05a51a1, 0xf05a51a1, 0x5fcf013d, }, 20 },
+  { "gfxterm_quot", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x66a34f49, 0x32dbeb97, 0x66a34f49, 0x59b7e501, 0xdd28f52b, 0xdd28f52b, 0xb3c7ef80, 0xb3c7ef80, 0xb3c7ef80, 0x92fb1664, 0x92fb1664, 0x92fb1664, 0xd15b5e2e, 0xd15b5e2e, 0xd15b5e2e, 0xdd28f52b, 0x59b7e501, 0x59b7e501, 0xdd28f52b, }, 20 },
+  { "gfxterm_quot", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x7c2f19da, 0xd7bece67, 0x7c2f19da, 0xe53473ab, 0x43d1f34, 0x43d1f34, 0xa0717008, 0xa0717008, 0xa0717008, 0xdf7bd9a0, 0xdf7bd9a0, 0xdf7bd9a0, 0x8e5a9312, 0x8e5a9312, 0x8e5a9312, 0x43d1f34, 0xe53473ab, 0xe53473ab, 0x43d1f34, }, 20 },
+  { "gfxterm_piglatin", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x37943894, 0x78248c70, 0x37943894, 0x7462f5d3, 0x59c36f00, 0x59c36f00, 0xf4be229a, 0xf4be229a, 0xf4be229a, 0x8a3e4ffc, 0x8a3e4ffc, 0x8a3e4ffc, 0x5594b2ee, 0x5594b2ee, 0x5594b2ee, 0x59c36f00, 0x7462f5d3, 0x7462f5d3, 0x59c36f00, }, 20 },
+  { "gfxterm_piglatin", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0xd5158e6c, 0xdc71ba0f, 0xd5158e6c, 0xfb100b13, 0xaa4593fe, 0xaa4593fe, 0xd3ed72a3, 0xd3ed72a3, 0xd3ed72a3, 0x75187fc4, 0x75187fc4, 0x75187fc4, 0x6db8386d, 0x6db8386d, 0x6db8386d, 0xaa4593fe, 0xfb100b13, 0xfb100b13, 0xaa4593fe, }, 20 },
+  { "gfxterm_piglatin", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x6277a9e6, 0xa3265ffb, 0x6277a9e6, 0x3f60c462, 0xc9cbf769, 0xc9cbf769, 0x2dcf8a8d, 0x2dcf8a8d, 0x2dcf8a8d, 0xd3174b41, 0xd3174b41, 0xd3174b41, 0x4a34861e, 0x4a34861e, 0x4a34861e, 0xc9cbf769, 0x3f60c462, 0x3f60c462, 0xc9cbf769, }, 20 },
+  { "gfxterm_piglatin", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x81115dc4, 0xddf3f768, 0x81115dc4, 0x99b0cf46, 0x9813a416, 0x9813a416, 0x9b9d96df, 0x9b9d96df, 0x9b9d96df, 0xa4610ec, 0xa4610ec, 0xa4610ec, 0xaec6192f, 0xaec6192f, 0xaec6192f, 0x9813a416, 0x99b0cf46, 0x99b0cf46, 0x9813a416, }, 20 },
+  { "gfxterm_piglatin", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x5e96a904, 0x27864d3d, 0x5e96a904, 0x4bebe1b7, 0x5fcf013d, 0x5fcf013d, 0x18cae7f4, 0x18cae7f4, 0x18cae7f4, 0xcadaff82, 0xcadaff82, 0xcadaff82, 0x77e35b98, 0x77e35b98, 0x77e35b98, 0x5fcf013d, 0x4bebe1b7, 0x4bebe1b7, 0x5fcf013d, }, 20 },
+  { "gfxterm_piglatin", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xd00b19f8, 0xba73a9c6, 0xd00b19f8, 0xef1fb3b0, 0xdd28f52b, 0xdd28f52b, 0xb660046d, 0xb660046d, 0xb660046d, 0x975cfd89, 0x975cfd89, 0x975cfd89, 0xd4fcb5c3, 0xd4fcb5c3, 0xd4fcb5c3, 0xdd28f52b, 0xef1fb3b0, 0xef1fb3b0, 0xdd28f52b, }, 20 },
+  { "gfxterm_piglatin", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x8b4b98cd, 0x78ddc6e4, 0x8b4b98cd, 0x1250f2bc, 0x43d1f34, 0x43d1f34, 0x4889d3fd, 0x4889d3fd, 0x4889d3fd, 0x37837a55, 0x37837a55, 0x37837a55, 0x66a230e7, 0x66a230e7, 0x66a230e7, 0x43d1f34, 0x1250f2bc, 0x1250f2bc, 0x43d1f34, }, 20 },
+  { "gfxterm_ch", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xfecb570e, 0xccb97a7a, 0xfecb570e, 0xbd3d9a49, 0x59c36f00, 0x59c36f00, 0x40281258, 0x40281258, 0x40281258, 0x3ea87f3e, 0x3ea87f3e, 0x3ea87f3e, 0xe102822c, 0xe102822c, 0xe102822c, 0x59c36f00, 0xbd3d9a49, 0xbd3d9a49, 0x59c36f00, }, 20 },
+  { "gfxterm_ch", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x897d1fac, 0xaa982529, 0x897d1fac, 0xa7789ad3, 0xaa4593fe, 0xaa4593fe, 0xa482510, 0xa482510, 0xa482510, 0xacbd2877, 0xacbd2877, 0xacbd2877, 0xb41d6fde, 0xb41d6fde, 0xb41d6fde, 0xaa4593fe, 0xa7789ad3, 0xa7789ad3, 0xaa4593fe, }, 20 },
+  { "gfxterm_ch", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xd02a5297, 0xe627ab58, 0xd02a5297, 0x8d3d3f13, 0xc9cbf769, 0xc9cbf769, 0xbf0a8b7f, 0xbf0a8b7f, 0xbf0a8b7f, 0x41d24ab3, 0x41d24ab3, 0x41d24ab3, 0xd8f187ec, 0xd8f187ec, 0xd8f187ec, 0xc9cbf769, 0x8d3d3f13, 0x8d3d3f13, 0xc9cbf769, }, 20 },
+  { "gfxterm_ch", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xa653dcda, 0x3392e976, 0xa653dcda, 0xbef24e58, 0x9813a416, 0x9813a416, 0x4f2bc106, 0x4f2bc106, 0x4f2bc106, 0xdef04735, 0xdef04735, 0xdef04735, 0x7a704ef6, 0x7a704ef6, 0x7a704ef6, 0x9813a416, 0xbef24e58, 0xbef24e58, 0x9813a416, }, 20 },
+  { "gfxterm_ch", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xe2d7b585, 0x35241f36, 0xe2d7b585, 0xf7aafd36, 0x5fcf013d, 0x5fcf013d, 0xf2bd04db, 0xf2bd04db, 0xf2bd04db, 0x20ad1cad, 0x20ad1cad, 0x20ad1cad, 0x9d94b8b7, 0x9d94b8b7, 0x9d94b8b7, 0x5fcf013d, 0xf7aafd36, 0xf7aafd36, 0x5fcf013d, }, 20 },
+  { "gfxterm_ch", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x72ff749c, 0xeda8c283, 0x72ff749c, 0x4debded4, 0xdd28f52b, 0xdd28f52b, 0xb8c9cc22, 0xb8c9cc22, 0xb8c9cc22, 0x99f535c6, 0x99f535c6, 0x99f535c6, 0xda557d8c, 0xda557d8c, 0xda557d8c, 0xdd28f52b, 0x4debded4, 0x4debded4, 0xdd28f52b, }, 20 },
+  { "gfxterm_ch", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xb7cac764, 0xeb4bf417, 0xb7cac764, 0x2ed1ad15, 0x43d1f34, 0x43d1f34, 0xce718801, 0xce718801, 0xce718801, 0xb17b21a9, 0xb17b21a9, 0xb17b21a9, 0xe05a6b1b, 0xe05a6b1b, 0xe05a6b1b, 0x43d1f34, 0x2ed1ad15, 0x2ed1ad15, 0x43d1f34, }, 20 },
+  { "gfxterm_red", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x930e8e13, 0xf5c16290, 0x930e8e13, 0x27f5f1c0, 0x59c36f00, 0x59c36f00, 0xbad4e11, 0xbad4e11, 0xbad4e11, 0x752d2377, 0x752d2377, 0x752d2377, 0xaa87de65, 0xaa87de65, 0xaa87de65, 0x59c36f00, 0x27f5f1c0, 0x27f5f1c0, 0x59c36f00, }, 20 },
+  { "gfxterm_red", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0xff9301f2, 0x5bb9864a, 0xff9301f2, 0x31c145de, 0xaa4593fe, 0xaa4593fe, 0x23bf2c32, 0x23bf2c32, 0x23bf2c32, 0x854a2155, 0x854a2155, 0x854a2155, 0x9dea66fc, 0x9dea66fc, 0x9dea66fc, 0xaa4593fe, 0x31c145de, 0x31c145de, 0xaa4593fe, }, 20 },
+  { "gfxterm_red", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xfc5938ef, 0x46d56737, 0xfc5938ef, 0x23cf2668, 0xc9cbf769, 0xc9cbf769, 0xa8c549aa, 0xa8c549aa, 0xa8c549aa, 0x561d8866, 0x561d8866, 0x561d8866, 0xcf3e4539, 0xcf3e4539, 0xcf3e4539, 0xc9cbf769, 0x23cf2668, 0x23cf2668, 0xc9cbf769, }, 20 },
+  { "gfxterm_red", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xe7160822, 0x54b60115, 0xe7160822, 0x168efa6f, 0x9813a416, 0x9813a416, 0xb774a5aa, 0xb774a5aa, 0xb774a5aa, 0x26af2399, 0x26af2399, 0x26af2399, 0x822f2a5a, 0x822f2a5a, 0x822f2a5a, 0x9813a416, 0x168efa6f, 0x168efa6f, 0x9813a416, }, 20 },
+  { "gfxterm_red", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xf655f9b2, 0xe6a3e2d3, 0xf655f9b2, 0xd1d7405f, 0x5fcf013d, 0x5fcf013d, 0x2accaa08, 0x2accaa08, 0x2accaa08, 0xf8dcb27e, 0xf8dcb27e, 0xf8dcb27e, 0x45e51664, 0x45e51664, 0x45e51664, 0x5fcf013d, 0xd1d7405f, 0xd1d7405f, 0x5fcf013d, }, 20 },
+  { "gfxterm_red", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x2d85ebdc, 0x79fd4f02, 0x2d85ebdc, 0xc48ae2b6, 0xdd28f52b, 0xdd28f52b, 0x76b28a95, 0x76b28a95, 0x76b28a95, 0x578e7371, 0x578e7371, 0x578e7371, 0x142e3b3b, 0x142e3b3b, 0x142e3b3b, 0xdd28f52b, 0xc48ae2b6, 0xc48ae2b6, 0xdd28f52b, }, 20 },
+  { "gfxterm_red", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x29c00f98, 0x8251d825, 0x29c00f98, 0x35a750d1, 0x43d1f34, 0x43d1f34, 0x48b70bc8, 0x48b70bc8, 0x48b70bc8, 0x37bda260, 0x37bda260, 0x37bda260, 0x669ce8d2, 0x669ce8d2, 0x669ce8d2, 0x43d1f34, 0x35a750d1, 0x35a750d1, 0x43d1f34, }, 20 },
+  { "gfxterm_high", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x4afab717, 0x2c355b94, 0x4afab717, 0x1166d9d0, 0x59c36f00, 0x59c36f00, 0x620c0067, 0x620c0067, 0x620c0067, 0x1c8c6d01, 0x1c8c6d01, 0x1c8c6d01, 0xc3269013, 0xc3269013, 0xc3269013, 0x59c36f00, 0x1166d9d0, 0x1166d9d0, 0x59c36f00, }, 20 },
+  { "gfxterm_high", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0xe3daadd4, 0x47f02a6c, 0xe3daadd4, 0x5ea9fb21, 0xaa4593fe, 0xaa4593fe, 0xa8a596c8, 0xa8a596c8, 0xa8a596c8, 0xe509baf, 0xe509baf, 0xe509baf, 0x16f0dc06, 0x16f0dc06, 0x16f0dc06, 0xaa4593fe, 0x5ea9fb21, 0x5ea9fb21, 0xaa4593fe, }, 20 },
+  { "gfxterm_high", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xf140d1df, 0x4bcc8e07, 0xf140d1df, 0x7c962dcb, 0xc9cbf769, 0xc9cbf769, 0x3ce35e1d, 0x3ce35e1d, 0x3ce35e1d, 0xc23b9fd1, 0xc23b9fd1, 0xc23b9fd1, 0x5b18528e, 0x5b18528e, 0x5b18528e, 0xc9cbf769, 0x7c962dcb, 0x7c962dcb, 0xc9cbf769, }, 20 },
+  { "gfxterm_high", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xe709a12d, 0x54a9a81a, 0xe709a12d, 0xde04d65c, 0x9813a416, 0x9813a416, 0x43fda3fa, 0x43fda3fa, 0x43fda3fa, 0xd22625c9, 0xd22625c9, 0xd22625c9, 0x76a62c0a, 0x76a62c0a, 0x76a62c0a, 0x9813a416, 0xde04d65c, 0xde04d65c, 0x9813a416, }, 20 },
+  { "gfxterm_high", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x65eff77c, 0x7519ec1d, 0x65eff77c, 0x1cd7d353, 0x5fcf013d, 0x5fcf013d, 0xf3582c48, 0xf3582c48, 0xf3582c48, 0x2148343e, 0x2148343e, 0x2148343e, 0x9c719024, 0x9c719024, 0x9c719024, 0x5fcf013d, 0x1cd7d353, 0x1cd7d353, 0x5fcf013d, }, 20 },
+  { "gfxterm_high", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x7318831a, 0x276027c4, 0x7318831a, 0xd7e4f5bb, 0xdd28f52b, 0xdd28f52b, 0xb3c7ef80, 0xb3c7ef80, 0xb3c7ef80, 0x92fb1664, 0x92fb1664, 0x92fb1664, 0xd15b5e2e, 0xd15b5e2e, 0xd15b5e2e, 0xdd28f52b, 0xd7e4f5bb, 0xd7e4f5bb, 0xdd28f52b, }, 20 },
+  { "gfxterm_high", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x6927a7d4, 0xc2b67069, 0x6927a7d4, 0xfc345163, 0x43d1f34, 0x43d1f34, 0xa0717008, 0xa0717008, 0xa0717008, 0xdf7bd9a0, 0xdf7bd9a0, 0xdf7bd9a0, 0x8e5a9312, 0x8e5a9312, 0x8e5a9312, 0x43d1f34, 0xfc345163, 0xfc345163, 0x43d1f34, }, 20 },
+  { "videotest", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0xe6012f70, 0xe6012f70, 0xe6012f70, 0xe6012f70, 0xe6012f70, }, 5 },
+  { "videotest", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xfb6be77b, 0xfb6be77b, 0xfb6be77b, 0xfb6be77b, 0xfb6be77b, }, 5 },
+  { "videotest", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0x67c0629f, 0x67c0629f, 0x67c0629f, 0x67c0629f, 0x67c0629f, }, 5 },
+  { "videotest", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x8f20afbb, 0xd8f7abc, 0x8f937344, 0xd3ca643, 0x8e471645, }, 5 },
+  { "videotest", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0xdca764da, 0x9f76da9a, 0x5b04185a, 0x18d5a61a, 0xd60deb2b, }, 5 },
+  { "videotest", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0x7b87af36, 0x7cb96093, 0x75fa307c, 0x72c4ffd9, 0x677c91a2, }, 5 },
+  { "videotest", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x72981c65, 0x50120635, 0x378c28c5, 0x15063295, 0xf8b07525, }, 5 },
+  { "videotest", 640, 480, 0x2, 256, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi256 */, (grub_uint32_t []) { 0xc8f64b58, 0xc8f64b58, 0xc8f64b58, 0xc8f64b58, 0xc8f64b58, }, 5 },
+  { "videotest", 800, 600, 0x2, 256, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi256 */, (grub_uint32_t []) { 0x2b499dfa, 0x2b499dfa, 0x2b499dfa, 0x2b499dfa, 0x2b499dfa, }, 5 },
+  { "videotest", 1024, 768, 0x2, 256, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi256 */, (grub_uint32_t []) { 0x6156b420, 0x6156b420, 0x6156b420, 0x6156b420, 0x6156b420, }, 5 },
+  { "videotest", 640, 480, 0x1, 256, 15, 2, 10, 5, 5, 5, 0, 5, 0, 0 /* 640x480xrgba5550 */, (grub_uint32_t []) { 0x363285ca, 0x363285ca, 0x363285ca, 0x363285ca, 0x363285ca, }, 5 },
+  { "videotest", 800, 600, 0x1, 256, 15, 2, 10, 5, 5, 5, 0, 5, 0, 0 /* 800x600xrgba5550 */, (grub_uint32_t []) { 0x25bb37f4, 0x25bb37f4, 0x25bb37f4, 0x25bb37f4, 0x25bb37f4, }, 5 },
+  { "videotest", 1024, 768, 0x1, 256, 15, 2, 10, 5, 5, 5, 0, 5, 0, 0 /* 1024x768xrgba5550 */, (grub_uint32_t []) { 0xeeab9e91, 0xeeab9e91, 0xeeab9e91, 0xeeab9e91, 0xeeab9e91, }, 5 },
+  { "videotest", 640, 480, 0x1, 256, 16, 2, 11, 5, 5, 6, 0, 5, 0, 0 /* 640x480xrgba5650 */, (grub_uint32_t []) { 0x26a9a50b, 0x26a9a50b, 0x26a9a50b, 0x26a9a50b, 0x26a9a50b, }, 5 },
+  { "videotest", 800, 600, 0x1, 256, 16, 2, 11, 5, 5, 6, 0, 5, 0, 0 /* 800x600xrgba5650 */, (grub_uint32_t []) { 0x2c0f4fe7, 0x2c0f4fe7, 0x2c0f4fe7, 0x2c0f4fe7, 0x2c0f4fe7, }, 5 },
+  { "videotest", 1024, 768, 0x1, 256, 16, 2, 11, 5, 5, 6, 0, 5, 0, 0 /* 1024x768xrgba5650 */, (grub_uint32_t []) { 0x46c11052, 0x46c11052, 0x46c11052, 0x46c11052, 0x46c11052, }, 5 },
+  { "videotest", 640, 480, 0x1, 256, 24, 3, 16, 8, 8, 8, 0, 8, 0, 0 /* 640x480xrgba8880 */, (grub_uint32_t []) { 0xe56cf615, 0xcd2be572, 0xb5e2d0db, 0x9da5c3bc, 0x4470bb89, }, 5 },
+  { "videotest", 800, 600, 0x1, 256, 24, 3, 16, 8, 8, 8, 0, 8, 0, 0 /* 800x600xrgba8880 */, (grub_uint32_t []) { 0x2a25b871, 0x4bf85361, 0xe99e6e51, 0x88438541, 0xa8be62c0, }, 5 },
+  { "videotest", 1024, 768, 0x1, 256, 24, 3, 16, 8, 8, 8, 0, 8, 0, 0 /* 1024x768xrgba8880 */, (grub_uint32_t []) { 0x81523037, 0xd8c0bfd3, 0x32772fff, 0x6be5a01b, 0xe2f47956, }, 5 },
+  { "videotest", 640, 480, 0x1, 256, 15, 2, 0, 5, 5, 5, 10, 5, 0, 0 /* 640x480xbgra5550 */, (grub_uint32_t []) { 0x1833bb41, 0x1833bb41, 0x1833bb41, 0x1833bb41, 0x1833bb41, }, 5 },
+  { "videotest", 800, 600, 0x1, 256, 15, 2, 0, 5, 5, 5, 10, 5, 0, 0 /* 800x600xbgra5550 */, (grub_uint32_t []) { 0x2c39a0e8, 0x2c39a0e8, 0x2c39a0e8, 0x2c39a0e8, 0x2c39a0e8, }, 5 },
+  { "videotest", 1024, 768, 0x1, 256, 15, 2, 0, 5, 5, 5, 10, 5, 0, 0 /* 1024x768xbgra5550 */, (grub_uint32_t []) { 0xf0d4c23, 0xf0d4c23, 0xf0d4c23, 0xf0d4c23, 0xf0d4c23, }, 5 },
+  { "videotest", 640, 480, 0x1, 256, 16, 2, 0, 5, 5, 6, 11, 5, 0, 0 /* 640x480xbgra5650 */, (grub_uint32_t []) { 0x456d063c, 0x456d063c, 0x456d063c, 0x456d063c, 0x456d063c, }, 5 },
+  { "videotest", 800, 600, 0x1, 256, 16, 2, 0, 5, 5, 6, 11, 5, 0, 0 /* 800x600xbgra5650 */, (grub_uint32_t []) { 0x47e15a2e, 0x47e15a2e, 0x47e15a2e, 0x47e15a2e, 0x47e15a2e, }, 5 },
+  { "videotest", 1024, 768, 0x1, 256, 16, 2, 0, 5, 5, 6, 11, 5, 0, 0 /* 1024x768xbgra5650 */, (grub_uint32_t []) { 0x54d7300d, 0x54d7300d, 0x54d7300d, 0x54d7300d, 0x54d7300d, }, 5 },
+  { "videotest", 640, 480, 0x1, 256, 24, 3, 0, 8, 8, 8, 16, 8, 0, 0 /* 640x480xbgra8880 */, (grub_uint32_t []) { 0x770da211, 0x8ef2528e, 0x811e35de, 0x78e1c541, 0x9ec6fb7e, }, 5 },
+  { "videotest", 800, 600, 0x1, 256, 24, 3, 0, 8, 8, 8, 16, 8, 0, 0 /* 800x600xbgra8880 */, (grub_uint32_t []) { 0xeb181fbc, 0xae648cc1, 0x61e13946, 0x249daa3b, 0xfb0624b9, }, 5 },
+  { "videotest", 1024, 768, 0x1, 256, 24, 3, 0, 8, 8, 8, 16, 8, 0, 0 /* 1024x768xbgra8880 */, (grub_uint32_t []) { 0x2b6f64dc, 0xc25f8431, 0xfce2d3f7, 0x15d2331a, 0x81987c7b, }, 5 },
+  { "videotest", 640, 480, 0x1, 256, 32, 4, 0, 8, 8, 8, 16, 8, 24, 8 /* 640x480xbgra8888 */, (grub_uint32_t []) { 0xa260f7dd, 0x3e2f4980, 0x9f13fd96, 0x35c43cb, 0xd886e34b, }, 5 },
+  { "videotest", 800, 600, 0x1, 256, 32, 4, 0, 8, 8, 8, 16, 8, 24, 8 /* 800x600xbgra8888 */, (grub_uint32_t []) { 0x41a9bff8, 0xa0d3f7c3, 0x86b1597f, 0x67cb1144, 0xca740407, }, 5 },
+  { "videotest", 1024, 768, 0x1, 256, 32, 4, 0, 8, 8, 8, 16, 8, 24, 8 /* 1024x768xbgra8888 */, (grub_uint32_t []) { 0x8f7a3b6d, 0xcb84c6e3, 0x687c071, 0x42793dff, 0x996dbba4, }, 5 },
diff --git a/grub-core/tests/cmdline_cat_test.c b/grub-core/tests/cmdline_cat_test.c
new file mode 100644
index 0000000..baea768
--- /dev/null
+++ b/grub-core/tests/cmdline_cat_test.c
@@ -0,0 +1,125 @@
+/*
+ *  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/video_fb.h>
+#include <grub/command.h>
+#include <grub/font.h>
+#include <grub/procfs.h>
+#include <grub/env.h>
+#include <grub/normal.h>
+#include <grub/time.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+
+static const char testfile[] =
+  /* Chinese & UTF-8 test from Carbon Jiao. */
+  "从硬盘的第一主分区启动\n"
+  "The quick brown fox jumped over the lazy dog.\n"
+  /* Characters used:
+     Code point  Description                    UTF-8 encoding
+     ----------- ------------------------------ --------------
+     U+263A      unfilled smiley face           E2 98 BA
+     U+00A1      inverted exclamation point     C2 A1
+     U+00A3      British pound currency symbol  C2 A3
+     U+03C4      Greek tau                      CF 84
+     U+00E4      lowercase letter a with umlaut C3 A4
+     U+2124      set 'Z' symbol (integers)      E2 84 A4
+     U+2286      subset symbol                  E2 8A 86
+     U+211D      set 'R' symbol (real numbers)  E2 84 9D  */
+  "Unicode test: happy\xE2\x98\xBA \xC2\xA3 5.00"
+  " \xC2\xA1\xCF\x84\xC3\xA4u! "
+  " \xE2\x84\xA4\xE2\x8A\x86\xE2\x84\x9D\n"
+  /* Test handling of bad (non-UTF8) sequences*/
+  "\x99Hello\xc2Hello\xc1\x81Hello\n";
+;
+
+static char *
+get_test_txt (grub_size_t *sz)
+{
+  *sz = grub_strlen (testfile);
+  return grub_strdup (testfile);
+}
+
+struct grub_procfs_entry test_txt = 
+{
+  .name = "test.txt",
+  .get_contents = get_test_txt
+};
+
+#define FONT_NAME "Unknown Regular 16"
+
+/* Functional test main method.  */
+static void
+cmdline_cat_test (void)
+{
+  unsigned i;
+  grub_font_t font;
+
+  grub_dl_load ("gfxterm");
+  grub_errno = GRUB_ERR_NONE;
+
+  font = grub_font_get (FONT_NAME);
+  if (font && grub_strcmp (font->name, FONT_NAME) != 0)
+    font = 0;
+  if (!font)
+    font = grub_font_load ("unicode");
+
+  if (!font)
+    {
+      grub_test_assert (0, "unicode font not found: %s", grub_errmsg);
+      return;
+    }
+
+  grub_procfs_register ("test.txt", &test_txt);
+  
+  for (i = 0; i < GRUB_TEST_VIDEO_SMALL_N_MODES; i++)
+    {
+      grub_video_capture_start (&grub_test_video_modes[i],
+				grub_video_fbstd_colors,
+				grub_test_video_modes[i].number_of_colors);
+      grub_terminal_input_fake_sequence ((int []) 
+					 {  'c', 'a', 't', ' ', 
+					     '(', 'p', 'r', 'o', 'c', ')',
+					     '/', 't', 'e', 's', 't', '.',
+					     't', 'x', 't', '\n',
+					     GRUB_TERM_NO_KEY,
+					     GRUB_TERM_NO_KEY, GRUB_TERM_ESC},
+					 23);
+
+      grub_video_checksum ("cmdline_cat");
+
+      if (!grub_test_use_gfxterm ())
+	grub_cmdline_run (1, 0);
+
+      grub_test_use_gfxterm_end ();
+
+      grub_terminal_input_fake_sequence_end ();
+      grub_video_checksum_end ();
+      grub_video_capture_end ();
+    }
+
+  grub_procfs_unregister (&test_txt);
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (cmdline_cat_test, cmdline_cat_test);
diff --git a/grub-core/tests/cmp_test.c b/grub-core/tests/cmp_test.c
new file mode 100644
index 0000000..af5b395
--- /dev/null
+++ b/grub-core/tests/cmp_test.c
@@ -0,0 +1,190 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2015 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/test.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static grub_uint64_t vectors[][2] = {
+  { 0xffffffffffffffffULL, 1},
+  { 1, 0xffffffffffffffffULL},
+  { 0xffffffffffffffffULL, 0xffffffffffffffffULL},
+  { 1, 1 },
+  { 2, 1 }
+};
+
+/* Don't change those to use shift as shift may call to compile rt
+   functions and we're not testing them now.
+ */
+static int
+leading_bit64 (grub_uint64_t a)
+{
+  return !!(a & 0x8000000000000000LL);
+}
+
+static int
+leading_bit32 (grub_uint32_t a)
+{
+  return !!(a & 0x80000000);
+}
+
+/* Computes (a < b) without involving comparison operator.  */
+static int
+is_less32 (grub_uint32_t a, grub_uint32_t b)
+{
+  if (leading_bit32(a) && !leading_bit32(b))
+    return 0;
+  if (!leading_bit32(a) && leading_bit32(b))
+    return 1;
+  return leading_bit32(a - b);
+}
+
+static void
+test32 (grub_uint32_t a, grub_uint32_t b)
+{
+  grub_test_assert ((a < b) == is_less32(a, b), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((a > b) == is_less32(b, a), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((b < a) == is_less32(b, a), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((b > a) == is_less32(a, b), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert (!(is_less32(a, b) && is_less32(b, a)), "comparison inconsistent: %lld, %lld",
+		    (long long) a, (long long) b);
+}
+
+/* Computes (a > b) without involving comparison operator.  */
+static int
+is_less32s (grub_int32_t a, grub_int32_t b)
+{
+  if (leading_bit32(a) && !leading_bit32(b))
+    return 1; /* a < 0 && b >= 0. */
+  if (!leading_bit32(a) && leading_bit32(b))
+    return 0; /* b < 0 && a >= 0. */
+  return leading_bit32(a - b);
+}
+
+static void
+test32s (grub_int32_t a, grub_int32_t b)
+{
+  grub_test_assert ((a < b) == is_less32s(a, b), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((a > b) == is_less32s(b, a), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((b < a) == is_less32s(b, a), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((b > a) == is_less32s(a, b), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert (!(is_less32s(a, b) && is_less32s(b, a)), "comparison inconsistent: %lld, %lld",
+		    (long long) a, (long long) b);
+}
+
+/* Computes (a > b) without involving comparison operator.  */
+static int
+is_less64 (grub_uint64_t a, grub_uint64_t b)
+{
+  if (leading_bit64(a) && !leading_bit64(b))
+    return 0;
+  if (!leading_bit64(a) && leading_bit64(b))
+    return 1;
+  return leading_bit64(a - b);
+}
+
+static void
+test64 (grub_uint64_t a, grub_uint64_t b)
+{
+  grub_test_assert ((a < b) == is_less64(a, b), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((a > b) == is_less64(b, a), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((b < a) == is_less64(b, a), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((b > a) == is_less64(a, b), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert (!(is_less64(a, b) && is_less64(b, a)), "comparison inconsistent: %lld, %lld",
+		    (long long) a, (long long) b);
+}
+
+/* Computes (a > b) without involving comparison operator.  */
+static int
+is_less64s (grub_int64_t a, grub_int64_t b)
+{
+  if (leading_bit64(a) && !leading_bit64(b))
+    return 1; /* a < 0 && b >= 0. */
+  if (!leading_bit64(a) && leading_bit64(b))
+    return 0; /* b < 0 && a >= 0. */
+  return leading_bit64(a - b);
+}
+
+static void
+test64s (grub_int64_t a, grub_int64_t b)
+{
+  grub_test_assert ((a < b) == is_less64s(a, b), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((a > b) == is_less64s(b, a), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((b < a) == is_less64s(b, a), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert ((b > a) == is_less64s(a, b), "comparison result mismatch: %lld, %lld",
+		    (long long) a, (long long) b);
+  grub_test_assert (!(is_less64s(a, b) && is_less64s(b, a)), "comparison inconsistent: %lld, %lld",
+		    (long long) a, (long long) b);
+}
+
+static void
+test_all(grub_uint64_t a, grub_uint64_t b)
+{
+  test64 (a, b);
+  test32 (a, b);
+  test64s (a, b);
+  test32s (a, b);
+  test64s (a, -b);
+  test32s (a, -b);
+  test64s (-a, b);
+  test32s (-a, b);
+  test64s (-a, -b);
+  test32s (-a, -b);
+}
+
+static void
+cmp_test (void)
+{
+  grub_uint64_t a = 404, b = 7;
+  grub_size_t i;
+
+  for (i = 0; i < ARRAY_SIZE (vectors); i++)
+    {
+      test_all (vectors[i][0], vectors[i][1]);
+    }
+  for (i = 0; i < 40000; i++)
+    {
+      a = 17 * a + 13 * b;
+      b = 23 * a + 29 * b;
+      if (b == 0)
+	b = 1;
+      if (a == 0)
+	a = 1;
+      test_all (a, b);
+    }
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (cmp_test, cmp_test);
diff --git a/grub-core/tests/ctz_test.c b/grub-core/tests/ctz_test.c
new file mode 100644
index 0000000..eb7a1df
--- /dev/null
+++ b/grub-core/tests/ctz_test.c
@@ -0,0 +1,111 @@
+/*
+ *  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/test.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+/* ull version is not used on i386 other than in this test.
+   Avoid requiring extra function.
+  */
+#if defined (__i386__)
+#define SKIP_ULL 1
+#endif
+
+static grub_uint64_t vectors[] = {
+  0xffffffffffffffffULL, 1, 2, 0, 0x0102030405060708ULL
+};
+
+static void
+test_ui (unsigned int a)
+{
+  int i;
+  a |= 1;
+  for (i = 0; i < (int) (8 * sizeof (a)); i++)
+    {
+      grub_test_assert (__builtin_ctz(a << i) == i,
+			"ctz mismatch: ctz(0x%llx) != 0x%x",
+			(long long) (a << i), __builtin_ctz(a << i));
+    }
+}
+
+static void
+test_ul (unsigned long a)
+{
+  int i;
+  a |= 1;
+  for (i = 0; i < (int) (8 * sizeof (a)); i++)
+    {
+      grub_test_assert (__builtin_ctzl(a << i) == i,
+			"ctzl mismatch: ctzl(0x%llx) != 0x%x",
+			(long long) (a << i), __builtin_ctz(a << i));
+    }
+}
+
+#ifndef SKIP_ULL
+static void
+test_ull (unsigned long long a)
+{
+  int i;
+  a |= 1;
+  for (i = 0; i < (int) (8 * sizeof (a)); i++)
+    {
+      grub_test_assert (__builtin_ctzll(a << i) == i,
+			"ctzll mismatch: ctzll(0x%llx) != 0x%x",
+			(long long) (a << i), __builtin_ctz(a << i));
+    }
+}
+#endif
+
+static void
+test_all(grub_uint64_t a)
+{
+  test_ui (a);
+  test_ul (a);
+#ifndef SKIP_ULL
+  test_ull (a);
+#endif
+}
+
+static void
+ctz_test (void)
+{
+  grub_uint64_t a = 404, b = 7;
+  grub_size_t i;
+
+  for (i = 0; i < ARRAY_SIZE (vectors); i++)
+    {
+      test_all (vectors[i]);
+    }
+  for (i = 0; i < 40000; i++)
+    {
+      a = 17 * a + 13 * b;
+      b = 23 * a + 29 * b;
+      if (b == 0)
+	b = 1;
+      if (a == 0)
+	a = 1;
+      test_all (a);
+      test_all (b);
+    }
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (ctz_test, ctz_test);
diff --git a/grub-core/tests/div_test.c b/grub-core/tests/div_test.c
new file mode 100644
index 0000000..9abc6d5
--- /dev/null
+++ b/grub-core/tests/div_test.c
@@ -0,0 +1,189 @@
+/*
+ *  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/test.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static grub_uint64_t vectors[][2] = {
+  { 0xffffffffffffffffULL, 1},
+  { 1, 0xffffffffffffffffULL},
+  { 0xffffffffffffffffULL, 0xffffffffffffffffULL},
+  { 1, 1 },
+  { 2, 1 }
+};
+
+static void
+test32 (grub_uint32_t a, grub_uint32_t b)
+{
+  grub_uint64_t q, r;
+  if (b == 0)
+    return;
+  q = grub_divmod64 (a, b, &r);
+  grub_test_assert (r < b, "remainder is larger than dividend: 0x%llx %% 0x%llx = 0x%llx",
+		    (long long) a, (long long) b, (long long) r);
+  grub_test_assert (q * b + r == a, "division doesn't satisfy base property: 0x%llx * 0x%llx + 0x%llx != 0x%llx", (long long) q, (long long) b, (long long) r,
+		    (long long) a);
+  /* Overflow check.  */
+  grub_test_assert ((q >> 32) == 0,
+		    "division overflow in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  grub_test_assert ((r >> 32) == 0,
+		    "division overflow in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  /* q * b + r is at most:
+     0xffffffff * 0xffffffff + 0xffffffff = 0xffffffff00000000
+     so no overflow
+   */
+  grub_test_assert (q == (a / b),
+		    "C compiler division failure in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  grub_test_assert (r == (a % b),
+		    "C compiler modulo failure in 0x%llx, 0x%llx", (long long) a, (long long) b);
+}
+
+static void
+test64 (grub_uint64_t a, grub_uint64_t b)
+{
+  grub_uint64_t q, r;
+  grub_uint64_t x1, x2;
+  q = grub_divmod64 (a, b, &r);
+  grub_test_assert (r < b, "remainder is larger than dividend: 0x%llx %% 0x%llx = 0x%llx",
+		    (long long) a, (long long) b, (long long) r);
+  grub_test_assert (q * b + r == a, "division doesn't satisfy base property: 0x%llx * 0x%llx + 0x%llx != 0x%llx", (long long) q, (long long) b, (long long) r,
+		    (long long) a);
+  /* Overflow checks.  */
+  grub_test_assert ((q >> 32) * (b >> 32) == 0,
+		    "division overflow in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  x1 = (q >> 32) * (b & 0xffffffff);
+  grub_test_assert (x1 < (1LL << 32),
+		    "division overflow in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  x1 <<= 32;
+  x2 = (b >> 32) * (q & 0xffffffff);
+  grub_test_assert (x2 < (1LL << 32),
+		    "division overflow in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  x2 <<= 32;
+  grub_test_assert (x1 <= ~x2,
+		    "division overflow in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  x1 += x2;
+  x2 = (q & 0xffffffff) * (b & 0xffffffff);
+  grub_test_assert (x1 <= ~x2,
+		    "division overflow in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  x1 += x2;
+  grub_test_assert (x1 <= ~r,
+		    "division overflow in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  x1 += r;
+  grub_test_assert (a == x1,
+		    "division overflow test failure in 0x%llx, 0x%llx", (long long) a, (long long) b);
+#if GRUB_TARGET_SIZEOF_VOID_P == 8
+  grub_test_assert (q == (a / b),
+		    "C compiler division failure in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  grub_test_assert (r == (a % b),
+		    "C compiler modulo failure in 0x%llx, 0x%llx", (long long) a, (long long) b);
+#endif
+}
+
+static grub_int64_t
+abs64(grub_int64_t a)
+{
+  return a > 0 ? a : -a;
+}
+
+static void
+test32s (grub_int32_t a, grub_int32_t b)
+{
+  grub_int64_t q, r;
+  if (b == 0)
+    return;
+
+  q = grub_divmod64s (a, b, &r);
+  grub_test_assert (a > 0 ? r >= 0 : r <= 0, "remainder sign mismatch: %lld %% %lld = %lld",
+		    (long long) a, (long long) b, (long long) r);
+  grub_test_assert (((a > 0) == (b > 0)) ? q >= 0 : q <= 0, "quotient sign mismatch: %lld / %lld = %lld",
+		    (long long) a, (long long) b, (long long) q);
+  grub_test_assert (abs64(r) < abs64(b), "remainder is larger than dividend: %lld %% %lld = %lld",
+		    (long long) a, (long long) b, (long long) r);
+  grub_test_assert (q * b + r == a, "division doesn't satisfy base property: %lld * %lld + %lld != %lld", (long long) q, (long long) b, (long long) r,
+		    (long long) a);
+  if (0) {  grub_test_assert (q == (a / b),
+		    "C compiler division failure in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  grub_test_assert (r == (a % b),
+		    "C compiler modulo failure in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  }
+}
+
+static void
+test64s (grub_int64_t a, grub_int64_t b)
+{
+  grub_int64_t q, r;
+  q = grub_divmod64s (a, b, &r);
+
+  grub_test_assert (a > 0 ? r >= 0 : r <= 0, "remainder sign mismatch: %lld %% %lld = %lld",
+		    (long long) a, (long long) b, (long long) r);
+  grub_test_assert (((a > 0) == (b > 0)) ? q >= 0 : q <= 0, "quotient sign mismatch: %lld / %lld = %lld",
+		    (long long) a, (long long) b, (long long) q);
+  grub_test_assert (abs64(r) < abs64(b), "remainder is larger than dividend: %lld %% %lld = %lld",
+		    (long long) a, (long long) b, (long long) r);
+  grub_test_assert (q * b + r == a, "division doesn't satisfy base property: 0x%llx * 0x%llx + 0x%llx != 0x%llx", (long long) q, (long long) b, (long long) r,
+		    (long long) a);
+#if GRUB_TARGET_SIZEOF_VOID_P == 8
+  grub_test_assert (q == (a / b),
+		    "C compiler division failure in 0x%llx, 0x%llx", (long long) a, (long long) b);
+  grub_test_assert (r == (a % b),
+		    "C compiler modulo failure in 0x%llx, 0x%llx", (long long) a, (long long) b);
+#endif
+}
+
+static void
+test_all(grub_uint64_t a, grub_uint64_t b)
+{
+  test64 (a, b);
+  test32 (a, b);
+  test64s (a, b);
+  test32s (a, b);
+  test64s (a, -b);
+  test32s (a, -b);
+  test64s (-a, b);
+  test32s (-a, b);
+  test64s (-a, -b);
+  test32s (-a, -b);
+}
+
+static void
+div_test (void)
+{
+  grub_uint64_t a = 404, b = 7;
+  grub_size_t i;
+
+  for (i = 0; i < ARRAY_SIZE (vectors); i++)
+    {
+      test_all (vectors[i][0], vectors[i][1]);
+    }
+  for (i = 0; i < 40000; i++)
+    {
+      a = 17 * a + 13 * b;
+      b = 23 * a + 29 * b;
+      if (b == 0)
+	b = 1;
+      if (a == 0)
+	a = 1;
+      test_all (a, b);
+    }
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (div_test, div_test);
diff --git a/grub-core/tests/example_functional_test.c b/grub-core/tests/example_functional_test.c
new file mode 100644
index 0000000..999f6d2
--- /dev/null
+++ b/grub-core/tests/example_functional_test.c
@@ -0,0 +1,38 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010 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>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+/* Functional test main method.  */
+static void
+example_test (void)
+{
+  /* Check if 1st argument is true and report with default error message.  */
+  grub_test_assert (1 == 1, "1 equal 1 expected");
+
+  /* Check if 1st argument is true and report with custom error message.  */
+  grub_test_assert (2 == 2, "2 equal 2 expected");
+  grub_test_assert (2 != 3, "2 matches %d", 3);
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (exfctest, example_test);
diff --git a/grub-core/tests/fake_input.c b/grub-core/tests/fake_input.c
new file mode 100644
index 0000000..b5eb516
--- /dev/null
+++ b/grub-core/tests/fake_input.c
@@ -0,0 +1,75 @@
+/*
+ *  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_input;
+
+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 (!fake_input)
+    saved = grub_term_inputs;
+  if (seq)
+    grub_free (seq);
+  seq = grub_calloc (nseq_in, sizeof (seq[0]));
+  if (!seq)
+    return;
+
+  grub_term_inputs = &fake_input_term;
+  grub_memcpy (seq, seq_in, nseq_in * sizeof (seq[0]));
+
+  nseq = nseq_in;
+  seqptr = 0;
+  fake_input = 1;
+}
+
+void
+grub_terminal_input_fake_sequence_end (void)
+{
+  if (!fake_input)
+    return;
+  fake_input = 0;
+  grub_term_inputs = saved;
+  grub_free (seq);
+  seq = 0;
+  nseq = 0;
+  seqptr = 0;
+}
diff --git a/grub-core/tests/gfxterm_menu.c b/grub-core/tests/gfxterm_menu.c
new file mode 100644
index 0000000..12836fb
--- /dev/null
+++ b/grub-core/tests/gfxterm_menu.c
@@ -0,0 +1,180 @@
+/*
+ *  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/video_fb.h>
+#include <grub/command.h>
+#include <grub/font.h>
+#include <grub/procfs.h>
+#include <grub/env.h>
+#include <grub/normal.h>
+#include <grub/time.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+
+static const char testfile[] =
+  "menuentry \"test\" {\n"
+  "\ttrue\n"
+  "}\n"
+  "menuentry \"s̛ ơ t o̒ s̒ u o̕̚ 8.04 m̂ñåh̊z̆x̣ a̡ b̢g̢ u᷎ô᷎ ô᷎ O̷ a̖̣ ȃ̐\" --class ubuntu --class linux --class os {\n"
+  "\ttrue\n"
+  "}\n"
+  "menuentry \" הַרמלל(טוֹבָ) לֶךְ\" --class opensuse --class linux --class os {\n"
+  "\ttrue\n"
+  "}\n"
+  "menuentry \"الرملل جِداً لِكَ\" --class gentoo --class linux --class os {\n"
+  "\ttrue\n"
+  "}\n"
+  "menuentry \"ὑπόγυͅον\" --class kubuntu --class linux --class os {\n"
+  "\ttrue\n"
+  "}\n"
+  "menuentry \"سَّ نِّ نَّ نٌّ نّْ\" --class linuxmint --class linux --class os {\n"
+  "\ttrue\n"
+  "}\n"
+  /* Chinese & UTF-8 test from Carbon Jiao. */
+  "menuentry \"从硬盘的第一主分区启动\" --class \"windows xp\" --class windows --class os {\n"
+  "\ttrue\n"
+  "}\n"
+  "timeout=3\n";
+
+static char *
+get_test_cfg (grub_size_t *sz)
+{
+  *sz = grub_strlen (testfile);
+  return grub_strdup (testfile);
+}
+
+struct grub_procfs_entry test_cfg = 
+{
+  .name = "test.cfg",
+  .get_contents = get_test_cfg
+};
+
+struct
+{
+  const char *name;
+  const char *var;
+  const char *val;  
+} tests[] =
+  {
+    { "gfxterm_menu", NULL, NULL },
+    { "gfxmenu", "theme", "starfield/theme.txt" },
+    { "gfxterm_ar", "lang", "en@arabic" },
+    { "gfxterm_cyr", "lang", "en@cyrillic" },
+    { "gfxterm_heb", "lang", "en@hebrew" },
+    { "gfxterm_gre", "lang", "en@greek" },
+    { "gfxterm_ru", "lang", "ru" },
+    { "gfxterm_fr", "lang", "fr" },
+    { "gfxterm_quot", "lang", "en@quot" },
+    { "gfxterm_piglatin", "lang", "en@piglatin" },
+    { "gfxterm_ch", "lang", "de_CH" },
+    { "gfxterm_red", "menu_color_normal", "red/blue" },
+    { "gfxterm_high", "menu_color_highlight", "blue/red" },
+  };
+
+#define FONT_NAME "Unknown Regular 16"
+
+/* Functional test main method.  */
+static void
+gfxterm_menu (void)
+{
+  unsigned i, j;
+  grub_font_t font;
+
+  grub_dl_load ("png");
+  grub_dl_load ("gettext");
+  grub_dl_load ("gfxterm");
+
+  grub_errno = GRUB_ERR_NONE;
+
+  grub_dl_load ("gfxmenu");
+
+  font = grub_font_get (FONT_NAME);
+  if (font && grub_strcmp (font->name, FONT_NAME) != 0)
+    font = 0;
+  if (!font)
+    font = grub_font_load ("unicode");
+
+  if (!font)
+    {
+      grub_test_assert (0, "unicode font not found: %s", grub_errmsg);
+      return;
+    }
+
+  grub_procfs_register ("test.cfg", &test_cfg);
+  
+  for (j = 0; j < ARRAY_SIZE (tests); j++)
+    for (i = 0; i < GRUB_TEST_VIDEO_SMALL_N_MODES; i++)
+      {
+	grub_uint64_t start;
+
+#if defined (GRUB_MACHINE_MIPS_QEMU_MIPS) || defined (GRUB_MACHINE_IEEE1275)
+	if (grub_test_video_modes[i].width > 1024)
+	  continue;
+	if (grub_strcmp (tests[j].name, "gfxmenu") == 0
+	    && grub_test_video_modes[i].width > 800)
+	  continue;
+#endif
+	start = grub_get_time_ms ();
+
+	grub_video_capture_start (&grub_test_video_modes[i],
+				  grub_video_fbstd_colors,
+				  grub_test_video_modes[i].number_of_colors);
+	if (grub_errno)
+	  {
+	    grub_test_assert (0, "can't start capture: %d: %s",
+			      grub_errno, grub_errmsg);
+	    return;
+	  }
+	grub_terminal_input_fake_sequence ((int []) { -1, -1, -1, GRUB_TERM_KEY_DOWN, -1, 'e',
+	      -1, GRUB_TERM_KEY_RIGHT, -1, 'x', -1,  GRUB_TERM_ESC, -1, GRUB_TERM_ESC }, 14);
+
+	grub_video_checksum (tests[j].name);
+
+	if (grub_test_use_gfxterm ())
+	  return;
+
+	grub_env_context_open ();
+	if (tests[j].var)
+	  grub_env_set (tests[j].var, tests[j].val);
+	grub_normal_execute ("(proc)/test.cfg", 1, 0);
+	grub_env_context_close ();
+
+	grub_test_use_gfxterm_end ();
+
+	grub_terminal_input_fake_sequence_end ();
+	grub_video_checksum_end ();
+	grub_video_capture_end ();
+
+	if (tests[j].var)
+	  grub_env_unset (tests[j].var);
+	grub_printf ("%s %dx%dx%s done %lld ms\n", tests[j].name,
+		     grub_test_video_modes[i].width,
+		     grub_test_video_modes[i].height,
+		     grub_video_checksum_get_modename (), (long long) (grub_get_time_ms () - start));
+      }
+
+  grub_procfs_unregister (&test_cfg);
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (gfxterm_menu, gfxterm_menu);
diff --git a/grub-core/tests/legacy_password_test.c b/grub-core/tests/legacy_password_test.c
new file mode 100644
index 0000000..2546033
--- /dev/null
+++ b/grub-core/tests/legacy_password_test.c
@@ -0,0 +1,68 @@
+/*
+ *  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/test.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/crypto.h>
+#include <grub/legacy_parse.h>
+#include <grub/auth.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static struct
+{
+  char **args;
+  int argc;
+  char entered[GRUB_AUTH_MAX_PASSLEN];
+  int exp;
+} vectors[] = {
+  { (char * []) { (char *) "hello", NULL }, 1, "hello", 1 },
+  { (char * []) { (char *) "hello", NULL }, 1, "hi", 0 },
+  { (char * []) { (char *) "hello", NULL }, 1, "hillo", 0 },
+  { (char * []) { (char *) "hello", NULL }, 1, "hellw", 0 },
+  { (char * []) { (char *) "hello", NULL }, 1, "hell", 0 },
+  { (char * []) { (char *) "hello", NULL }, 1, "h", 0 },
+  { (char * []) { (char *) "--md5", (char *) "$1$maL$OKEF0PD2k6eQ0Po8u4Gjr/",
+		  NULL }, 2, "hello", 1 },
+  { (char * []) { (char *) "--md5", (char *) "$1$maL$OKEF0PD2k6eQ0Po8u4Gjr/",
+		  NULL }, 2, "hell", 0 },
+  { (char * []) { (char *) "--md5", (char *) "$1$naL$BaFO8zGgmss1E76GsrAec1",
+		  NULL }, 2, "hello", 1 },
+  { (char * []) { (char *) "--md5", (char *) "$1$naL$BaFO8zGgmss1E76GsrAec1",
+		  NULL }, 2, "hell", 0 },
+  { (char * []) { (char *) "--md5", (char *) "$1$oaL$eyrazuM7TkxVkKgBim1WH1",
+		  NULL }, 2, "hi", 1 },
+  { (char * []) { (char *) "--md5", (char *) "$1$oaL$eyrazuM7TkxVkKgBim1WH1",
+		  NULL }, 2, "hello", 0 },
+};
+
+static void
+legacy_password_test (void)
+{
+  grub_size_t i;
+
+  for (i = 0; i < ARRAY_SIZE (vectors); i++)
+    grub_test_assert (grub_legacy_check_md5_password (vectors[i].argc,
+						      vectors[i].args,
+						      vectors[i].entered)
+		      == vectors[i].exp, "Bad password check (%d)", (int) i);
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (legacy_password_test, legacy_password_test);
diff --git a/grub-core/tests/lib/functional_test.c b/grub-core/tests/lib/functional_test.c
new file mode 100644
index 0000000..96781fb
--- /dev/null
+++ b/grub-core/tests/lib/functional_test.c
@@ -0,0 +1,105 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010 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/mm.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+#include <grub/test.h>
+#include <grub/dl.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static grub_err_t
+grub_functional_test (grub_extcmd_context_t ctxt __attribute__ ((unused)),
+		      int argc,
+		      char **args)
+{
+  grub_test_t test;
+  int ok = 1;
+  int i;
+
+  FOR_LIST_ELEMENTS (test, grub_test_list)
+    {
+      if (argc != 0)
+	{
+	  for (i = 0; i < argc; i++)
+	    if (grub_strcmp(args[i], test->name) == 0)
+	      break;
+	  if (i == argc)
+	    continue;
+	}
+      grub_errno = 0;
+      ok = ok && !grub_test_run (test);
+      grub_errno = 0;
+    }
+  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 ("legacy_password_test");
+  grub_errno = GRUB_ERR_NONE;
+  grub_dl_load ("exfctest");
+  grub_dl_load ("videotest_checksum");
+  grub_dl_load ("gfxterm_menu");
+  grub_dl_load ("setjmp_test");
+  grub_dl_load ("cmdline_cat_test");
+  grub_dl_load ("div_test");
+  grub_dl_load ("xnu_uuid_test");
+  grub_dl_load ("pbkdf2_test");
+  grub_dl_load ("signature_test");
+  grub_dl_load ("sleep_test");
+  grub_dl_load ("bswap_test");
+  grub_dl_load ("ctz_test");
+  grub_dl_load ("cmp_test");
+  grub_dl_load ("mul_test");
+  grub_dl_load ("shift_test");
+
+  FOR_LIST_ELEMENTS (test, grub_test_list)
+    ok = !grub_test_run (test) && ok;
+  if (ok)
+    grub_printf ("ALL TESTS PASSED\n");
+  else
+    grub_printf ("TEST FAILURE\n");
+  return GRUB_ERR_NONE;
+}
+
+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);
+}
+
+GRUB_MOD_FINI (functional_test)
+{
+  grub_unregister_extcmd (cmd);
+}
diff --git a/grub-core/tests/lib/test.c b/grub-core/tests/lib/test.c
new file mode 100644
index 0000000..3000fc8
--- /dev/null
+++ b/grub-core/tests/lib/test.c
@@ -0,0 +1,239 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010 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/mm.h>
+#include <grub/misc.h>
+#include <grub/test.h>
+
+struct grub_test_failure
+{
+  /* The next failure.  */
+  struct grub_test_failure *next;
+  struct grub_test_failure **prev;
+
+  /* The test source file name.  */
+  char *file;
+
+  /* The test function name.  */
+  char *funp;
+
+  /* The test call line number.  */
+  grub_uint32_t line;
+
+  /* The test failure message.  */
+  char *message;
+};
+typedef struct grub_test_failure *grub_test_failure_t;
+
+grub_test_t grub_test_list;
+static grub_test_failure_t failure_list;
+
+static grub_test_failure_t
+failure_start(const char *file, const char *funp, grub_uint32_t line);
+static grub_test_failure_t
+failure_start(const char *file, const char *funp, grub_uint32_t line)
+{
+  grub_test_failure_t failure;
+
+  failure = (grub_test_failure_t) grub_malloc (sizeof (*failure));
+  if (!failure)
+    return NULL;
+
+  failure->file = grub_strdup (file ? : "<unknown_file>");
+  if (!failure->file)
+    {
+      grub_free(failure);
+      return NULL;
+    }
+
+  failure->funp = grub_strdup (funp ? : "<unknown_function>");
+  if (!failure->funp)
+    {
+      grub_free(failure->file);
+      grub_free(failure);
+      return NULL;
+    }
+
+  failure->line = line;
+
+  failure->message = NULL;
+
+  return failure;
+}
+
+static void
+failure_append_vtext(grub_test_failure_t failure, const char *fmt, va_list args);
+static void
+failure_append_vtext(grub_test_failure_t failure, const char *fmt, va_list args)
+{
+  char *msg = grub_xvasprintf(fmt, args);
+  if (failure->message)
+    {
+      char *oldmsg = failure->message;
+
+      failure->message = grub_xasprintf("%s%s", oldmsg, msg);
+      grub_free (oldmsg);
+      grub_free (msg);
+    }
+  else
+    {
+      failure->message = msg;
+    }
+}
+
+static void
+failure_append_text(grub_test_failure_t failure, const char *fmt, ...)
+{
+  va_list args;
+
+  va_start(args, fmt);
+  failure_append_vtext(failure, fmt, args);
+  va_end(args);
+}
+
+static void
+add_failure (const char *file,
+	     const char *funp,
+	     grub_uint32_t line, const char *fmt, va_list args)
+{
+  grub_test_failure_t failure = failure_start(file, funp, line);
+  failure_append_text(failure, fmt, args);
+  grub_list_push (GRUB_AS_LIST_P (&failure_list), GRUB_AS_LIST (failure));
+}
+
+static void
+free_failures (void)
+{
+  grub_test_failure_t item;
+
+  while (failure_list)
+    {
+      item = failure_list;
+      failure_list = item->next;
+      if (item->message)
+	grub_free (item->message);
+
+      if (item->funp)
+	grub_free (item->funp);
+
+      if (item->file)
+	grub_free (item->file);
+
+      grub_free (item);
+    }
+  failure_list = 0;
+}
+
+void
+grub_test_nonzero (int cond,
+		   const char *file,
+		   const char *funp, grub_uint32_t line, const char *fmt, ...)
+{
+  va_list ap;
+
+  if (cond)
+    return;
+
+  va_start (ap, fmt);
+  add_failure (file, funp, line, fmt, ap);
+  va_end (ap);
+}
+
+void
+grub_test_assert_helper (int cond, const char *file, const char *funp,
+			 grub_uint32_t line, const char *condstr,
+			 const char *fmt, ...)
+{
+  va_list ap;
+  grub_test_failure_t failure;
+
+  if (cond)
+    return;
+
+  failure = failure_start(file, funp, line);
+  failure_append_text(failure, "assert failed: %s ", condstr);
+
+  va_start(ap, fmt);
+
+  failure_append_vtext(failure, fmt, ap);
+
+  va_end(ap);
+
+  grub_list_push (GRUB_AS_LIST_P (&failure_list), GRUB_AS_LIST (failure));
+}
+
+void
+grub_test_register (const char *name, void (*test_main) (void))
+{
+  grub_test_t test;
+
+  test = (grub_test_t) grub_malloc (sizeof (*test));
+  if (!test)
+    return;
+
+  test->name = grub_strdup (name);
+  test->main = test_main;
+
+  grub_list_push (GRUB_AS_LIST_P (&grub_test_list), GRUB_AS_LIST (test));
+}
+
+void
+grub_test_unregister (const char *name)
+{
+  grub_test_t test;
+
+  test = (grub_test_t) grub_named_list_find
+    (GRUB_AS_NAMED_LIST (grub_test_list), name);
+
+  if (test)
+    {
+      grub_list_remove (GRUB_AS_LIST (test));
+
+      if (test->name)
+	grub_free (test->name);
+
+      grub_free (test);
+    }
+}
+
+int
+grub_test_run (grub_test_t test)
+{
+  grub_test_failure_t failure;
+
+  test->main ();
+
+  grub_printf ("%s:\n", test->name);
+  FOR_LIST_ELEMENTS (failure, failure_list)
+    grub_printf (" %s:%s:%u: %s\n",
+		 (failure->file ? : "<unknown_file>"),
+		 (failure->funp ? : "<unknown_function>"),
+		 failure->line, (failure->message ? : "<no message>"));
+
+  if (!failure_list)
+    {
+      grub_printf ("%s: PASS\n", test->name);
+      return GRUB_ERR_NONE;
+    }
+  else
+    {
+      grub_printf ("%s: FAIL\n", test->name);
+      free_failures ();
+      return GRUB_ERR_TEST_FAILURE;
+    }
+}
diff --git a/grub-core/tests/mul_test.c b/grub-core/tests/mul_test.c
new file mode 100644
index 0000000..cd64231
--- /dev/null
+++ b/grub-core/tests/mul_test.c
@@ -0,0 +1,73 @@
+/*
+ *  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/test.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static grub_uint64_t vectors[][2] = {
+  { 0xffffffffffffffffULL, 1},
+  { 1, 0xffffffffffffffffULL},
+  { 0xffffffffffffffffULL, 0xffffffffffffffffULL},
+  { 1, 1 },
+  { 2, 1 }
+};
+
+static void
+test64(grub_uint64_t a, grub_uint64_t b)
+{
+  grub_uint64_t r1 = a * b, r2 = 0, r3;
+  int i;
+  for (i = 0; i < 64; i++)
+    if ((a & (1LL << i)))
+      r2 += b << i;
+  r3 = ((grub_int64_t) a) * ((grub_int64_t) b);
+  grub_test_assert (r1 == r2,
+		    "multiplication mismatch (u): 0x%llx x 0x%llx = 0x%llx != 0x%llx",
+		    (long long) a, (long long) b, (long long) r2, (long long) r1);
+  grub_test_assert (r3 == r2,
+		    "multiplication mismatch (s): 0x%llx x 0x%llx = 0x%llx != 0x%llx",
+		    (long long) a, (long long) b, (long long) r2, (long long) r3);
+}
+
+static void
+mul_test (void)
+{
+  grub_uint64_t a = 404, b = 7;
+  grub_size_t i;
+
+  for (i = 0; i < ARRAY_SIZE (vectors); i++)
+    {
+      test64 (vectors[i][0], vectors[i][1]);
+    }
+  for (i = 0; i < 40000; i++)
+    {
+      a = 17 * a + 13 * b;
+      b = 23 * a + 29 * b;
+      if (b == 0)
+	b = 1;
+      if (a == 0)
+	a = 1;
+      test64 (a, b);
+    }
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (mul_test, mul_test);
diff --git a/grub-core/tests/pbkdf2_test.c b/grub-core/tests/pbkdf2_test.c
new file mode 100644
index 0000000..4eeb8b8
--- /dev/null
+++ b/grub-core/tests/pbkdf2_test.c
@@ -0,0 +1,97 @@
+/*
+ *  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/test.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/crypto.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static struct
+{
+  const char *P;
+  grub_size_t Plen;
+  const char *S;
+  grub_size_t Slen;
+  unsigned int c;
+  grub_size_t dkLen;
+  const char *DK;
+} vectors[] = {
+  /* RFC6070. */
+  {
+    "password", 8,
+    "salt", 4,
+    1, 20,
+    "\x0c\x60\xc8\x0f\x96\x1f\x0e\x71\xf3\xa9\xb5\x24\xaf\x60\x12"
+    "\x06\x2f\xe0\x37\xa6"
+  },
+  {
+    "password", 8,
+    "salt", 4,
+    2, 20,
+    "\xea\x6c\x01\x4d\xc7\x2d\x6f\x8c"
+    "\xcd\x1e\xd9\x2a\xce\x1d\x41\xf0"
+    "\xd8\xde\x89\x57"
+  },
+  {
+    "password", 8,
+    "salt", 4,
+    4096, 20,
+    "\x4b\x00\x79\x01\xb7\x65\x48\x9a\xbe\xad\x49\xd9\x26\xf7"
+    "\x21\xd0\x65\xa4\x29\xc1"
+  },
+  {
+    "passwordPASSWORDpassword", 24,
+    "saltSALTsaltSALTsaltSALTsaltSALTsalt", 36,
+    4096, 25,
+    "\x3d\x2e\xec\x4f\xe4\x1c\x84\x9b\x80\xc8\xd8\x36\x62\xc0"
+    "\xe4\x4a\x8b\x29\x1a\x96\x4c\xf2\xf0\x70\x38"
+  },
+  {
+    "pass\0word", 9,
+    "sa\0lt", 5,
+    4096, 16,
+    "\x56\xfa\x6a\xa7\x55\x48\x09\x9d\xcc\x37\xd7\xf0\x34\x25\xe0\xc3"
+  }
+};
+
+static void
+pbkdf2_test (void)
+{
+  grub_size_t i;
+
+  for (i = 0; i < ARRAY_SIZE (vectors); i++)
+    {
+      gcry_err_code_t err;
+      grub_uint8_t DK[32];
+      err = grub_crypto_pbkdf2 (GRUB_MD_SHA1,
+				(const grub_uint8_t *) vectors[i].P,
+				vectors[i].Plen,
+				(const grub_uint8_t *) vectors[i].S,
+				vectors[i].Slen,
+				vectors[i].c,
+				DK, vectors[i].dkLen);
+      grub_test_assert (err == 0, "gcry error %d", err);
+      grub_test_assert (grub_memcmp (DK, vectors[i].DK, vectors[i].dkLen) == 0,
+			"PBKDF2 mismatch");
+    }
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (pbkdf2_test, pbkdf2_test);
diff --git a/grub-core/tests/setjmp_test.c b/grub-core/tests/setjmp_test.c
new file mode 100644
index 0000000..604a6ce
--- /dev/null
+++ b/grub-core/tests/setjmp_test.c
@@ -0,0 +1,80 @@
+/*
+ *  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/test.h>
+#include <grub/dl.h>
+#include <grub/setjmp.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static grub_jmp_buf jmp_point;
+static int expected, ctr;
+
+/* This fixes GCC7 "unintentional fallthrough" warning */
+static void jmp0 (void) __attribute__ ((noreturn));
+static void jmp1 (void) __attribute__ ((noreturn));
+static void jmp2 (void) __attribute__ ((noreturn));
+
+static void
+jmp0 (void)
+{
+  grub_longjmp (jmp_point, 0);
+}
+
+static void
+jmp1 (void)
+{
+  grub_longjmp (jmp_point, 1);
+}
+
+static void
+jmp2 (void)
+{
+  grub_longjmp (jmp_point, 2);
+}
+
+static void
+setjmp_test (void)
+{
+  int val;
+
+  expected = 0;
+  ctr = 0;
+  val = grub_setjmp (jmp_point);
+
+  grub_test_assert (val == expected, "setjmp returned %d instead of %d",
+		    val, expected);
+  switch (ctr++)
+    {
+    case 0:
+      expected = 1;
+      jmp0 ();
+    case 1:
+      expected = 1;
+      jmp1 ();
+    case 2:
+      expected = 2;
+      jmp2 ();
+    case 3:
+      return;
+    }
+  grub_test_assert (0, "setjmp didn't return enough times");
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (setjmp_test, setjmp_test);
diff --git a/grub-core/tests/shift_test.c b/grub-core/tests/shift_test.c
new file mode 100644
index 0000000..4120f52
--- /dev/null
+++ b/grub-core/tests/shift_test.c
@@ -0,0 +1,157 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2015 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/test.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static grub_uint64_t vectors[] = {
+  0xffffffffffffffffULL, 1, 2, 0, 0x0102030405060708ULL
+};
+
+/* We're testing shifts, don't replace access to this with a shift.  */
+static const grub_uint8_t bitmask[] =
+  { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
+
+typedef union {
+  grub_uint64_t v64;
+  grub_uint8_t v8[8];
+} grub_raw_u64_t;
+
+static int
+get_bit64 (grub_uint64_t v, int b)
+{
+  grub_raw_u64_t vr = { .v64 = v };
+  grub_uint8_t *p = vr.v8;
+  if (b >= 64)
+    return 0;
+#ifdef GRUB_CPU_WORDS_BIGENDIAN
+  p += 7 - b / 8;
+#else
+  p += b / 8;
+#endif
+  return !!(*p & bitmask[b % 8]);
+}
+
+static grub_uint64_t
+set_bit64 (grub_uint64_t v, int b)
+{
+  grub_raw_u64_t vr = { .v64 = v };
+  grub_uint8_t *p = vr.v8;
+  if (b >= 64)
+    return v;
+#ifdef GRUB_CPU_WORDS_BIGENDIAN
+  p += 7 - b / 8;
+#else
+  p += b / 8;
+#endif
+  *p |= bitmask[b % 8];
+  return vr.v64;
+}
+
+static grub_uint64_t
+left_shift64 (grub_uint64_t v, int s)
+{
+  grub_uint64_t r = 0;
+  int i;
+  for (i = 0; i + s < 64; i++)
+    if (get_bit64 (v, i))
+      r = set_bit64 (r, i + s);
+  return r;
+}
+
+static grub_uint64_t
+right_shift64 (grub_uint64_t v, int s)
+{
+  grub_uint64_t r = 0;
+  int i;
+  for (i = s; i < 64; i++)
+    if (get_bit64 (v, i))
+      r = set_bit64 (r, i - s);
+  return r;
+}
+
+static grub_uint64_t
+arithmetic_right_shift64 (grub_uint64_t v, int s)
+{
+  grub_uint64_t r = 0;
+  int i;
+  for (i = s; i < 64; i++)
+    if (get_bit64 (v, i))
+      r = set_bit64 (r, i - s);
+  if (get_bit64 (v, 63))
+    for (i -= s; i < 64; i++)
+	r = set_bit64 (r, i);
+    
+  return r;
+}
+
+static void
+test64 (grub_uint64_t v)
+{
+  int i;
+  for (i = 0; i < 64; i++)
+    {
+      grub_test_assert ((v << i) == left_shift64 (v, i),
+			"lshift wrong: 0x%llx << %d: 0x%llx, 0x%llx",
+			(long long) v, i,
+			(long long) (v << i), (long long) left_shift64 (v, i));
+      grub_test_assert ((v >> i) == right_shift64 (v, i),
+			"rshift wrong: 0x%llx >> %d: 0x%llx, 0x%llx",
+			(long long) v, i,
+			(long long) (v >> i), (long long) right_shift64 (v, i));
+      grub_test_assert ((((grub_int64_t) v) >> i) == (grub_int64_t) arithmetic_right_shift64 (v, i),
+			"arithmetic rshift wrong: ((grub_int64_t) 0x%llx) >> %d: 0x%llx, 0x%llx",
+			(long long) v, i,
+			(long long) (((grub_int64_t) v) >> i), (long long) arithmetic_right_shift64 (v, i));
+    }
+}
+
+static void
+test_all(grub_uint64_t a)
+{
+  test64 (a);
+}
+
+static void
+shift_test (void)
+{
+  grub_uint64_t a = 404, b = 7;
+  grub_size_t i;
+
+  for (i = 0; i < ARRAY_SIZE (vectors); i++)
+    {
+      test_all (vectors[i]);
+    }
+  for (i = 0; i < 4000; i++)
+    {
+      a = 17 * a + 13 * b;
+      b = 23 * a + 29 * b;
+      if (b == 0)
+	b = 1;
+      if (a == 0)
+	a = 1;
+      test_all (a);
+      test_all (b);
+    }
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (shift_test, shift_test);
diff --git a/grub-core/tests/signature_test.c b/grub-core/tests/signature_test.c
new file mode 100644
index 0000000..aa49393
--- /dev/null
+++ b/grub-core/tests/signature_test.c
@@ -0,0 +1,170 @@
+/*
+ *  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/time.h>
+#include <grub/misc.h>
+#include <grub/dl.h>
+#include <grub/command.h>
+#include <grub/env.h>
+#include <grub/test.h>
+#include <grub/mm.h>
+#include <grub/procfs.h>
+
+#include "signatures.h"
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static char *
+get_hi_dsa_sig (grub_size_t *sz)
+{
+  char *ret;
+  *sz = sizeof (hi_dsa_sig);
+  ret = grub_malloc (sizeof (hi_dsa_sig));
+  if (ret)
+    grub_memcpy (ret, hi_dsa_sig, sizeof (hi_dsa_sig));
+  return ret;
+}
+
+static struct grub_procfs_entry hi_dsa_sig_entry = 
+{
+  .name = "hi_dsa.sig",
+  .get_contents = get_hi_dsa_sig
+};
+
+static char *
+get_hi_dsa_pub (grub_size_t *sz)
+{
+  char *ret;
+  *sz = sizeof (hi_dsa_pub);
+  ret = grub_malloc (sizeof (hi_dsa_pub));
+  if (ret)
+    grub_memcpy (ret, hi_dsa_pub, sizeof (hi_dsa_pub));
+  return ret;
+}
+
+static struct grub_procfs_entry hi_dsa_pub_entry = 
+{
+  .name = "hi_dsa.pub",
+  .get_contents = get_hi_dsa_pub
+};
+
+static char *
+get_hi_rsa_sig (grub_size_t *sz)
+{
+  char *ret;
+  *sz = sizeof (hi_rsa_sig);
+  ret = grub_malloc (sizeof (hi_rsa_sig));
+  if (ret)
+    grub_memcpy (ret, hi_rsa_sig, sizeof (hi_rsa_sig));
+  return ret;
+}
+
+static struct grub_procfs_entry hi_rsa_sig_entry = 
+{
+  .name = "hi_rsa.sig",
+  .get_contents = get_hi_rsa_sig
+};
+
+static char *
+get_hi_rsa_pub (grub_size_t *sz)
+{
+  char *ret;
+  *sz = sizeof (hi_rsa_pub);
+  ret = grub_malloc (sizeof (hi_rsa_pub));
+  if (ret)
+    grub_memcpy (ret, hi_rsa_pub, sizeof (hi_rsa_pub));
+  return ret;
+}
+
+static struct grub_procfs_entry hi_rsa_pub_entry = 
+{
+  .name = "hi_rsa.pub",
+  .get_contents = get_hi_rsa_pub
+};
+
+static char *
+get_hi (grub_size_t *sz)
+{
+  *sz = 3;
+  return grub_strdup ("hi\n");
+}
+
+struct grub_procfs_entry hi = 
+{
+  .name = "hi",
+  .get_contents = get_hi
+};
+
+static char *
+get_hj (grub_size_t *sz)
+{
+  *sz = 3;
+  return grub_strdup ("hj\n");
+}
+
+struct grub_procfs_entry hj = 
+{
+  .name = "hj",
+  .get_contents = get_hj
+};
+
+static void
+do_verify (const char *f, const char *sig, const char *pub, int is_valid)
+{
+  grub_command_t cmd;
+  char *args[] = { (char *) f, (char *) sig,
+		   (char *) pub, NULL };
+  grub_err_t err;
+
+  cmd = grub_command_find ("verify_detached");
+  if (!cmd)
+    {
+      grub_test_assert (0, "can't find command `%s'", "verify_detached");
+      return;
+    }
+  err = (cmd->func) (cmd, 3, args);
+
+  grub_test_assert (err == (is_valid ? 0 : GRUB_ERR_BAD_SIGNATURE),
+		    "verification failed: %d: %s", grub_errno, grub_errmsg);
+  grub_errno = GRUB_ERR_NONE;
+
+}
+static void
+signature_test (void)
+{
+  grub_procfs_register ("hi", &hi);
+  grub_procfs_register ("hj", &hj);
+  grub_procfs_register ("hi_dsa.pub", &hi_dsa_pub_entry);
+  grub_procfs_register ("hi_dsa.sig", &hi_dsa_sig_entry);
+  grub_procfs_register ("hi_rsa.pub", &hi_rsa_pub_entry);
+  grub_procfs_register ("hi_rsa.sig", &hi_rsa_sig_entry);
+
+  do_verify ("(proc)/hi", "(proc)/hi_dsa.sig", "(proc)/hi_dsa.pub", 1);
+  do_verify ("(proc)/hi", "(proc)/hi_dsa.sig", "(proc)/hi_dsa.pub", 1);
+  do_verify ("(proc)/hj", "(proc)/hi_dsa.sig", "(proc)/hi_dsa.pub", 0);
+
+  do_verify ("(proc)/hi", "(proc)/hi_rsa.sig", "(proc)/hi_rsa.pub", 1);
+  do_verify ("(proc)/hj", "(proc)/hi_rsa.sig", "(proc)/hi_rsa.pub", 0);
+
+  grub_procfs_unregister (&hi);
+  grub_procfs_unregister (&hj);
+  grub_procfs_unregister (&hi_dsa_sig_entry);
+  grub_procfs_unregister (&hi_dsa_pub_entry);
+}
+
+GRUB_FUNCTIONAL_TEST (signature_test, signature_test);
diff --git a/grub-core/tests/signatures.h b/grub-core/tests/signatures.h
new file mode 100644
index 0000000..d78c2b6
--- /dev/null
+++ b/grub-core/tests/signatures.h
@@ -0,0 +1,211 @@
+static unsigned char hi_rsa_sig[] =
+{
+0x89, 0x02, 0x1c, 0x04, 0x00, 0x01, 0x02, 0x00, 0x06, 0x05, 0x02, 0x52, 0x82, 0x2d, 0x16, 0x00,
+0x0a, 0x09, 0x10, 0x0f, 0xcc, 0xf3, 0x21, 0x77, 0x83, 0x6a, 0x0d, 0xdb, 0x5e, 0x10, 0x00, 0x80,
+0x36, 0x2c, 0xb0, 0xbf, 0x26, 0x36, 0xf2, 0x9d, 0x93, 0xa0, 0xbf, 0xcb, 0xa7, 0x0d, 0xbe, 0x67,
+0x33, 0xf6, 0xba, 0xec, 0x2b, 0xe9, 0x7e, 0x0e, 0xec, 0x51, 0xd5, 0xdd, 0x2d, 0x9a, 0x96, 0x09,
+0x8a, 0x7f, 0x02, 0xd5, 0xbc, 0xdb, 0xc9, 0xef, 0xd8, 0x90, 0x8a, 0xa8, 0x71, 0x6f, 0xaf, 0x8c,
+0xe5, 0x6a, 0xc4, 0xda, 0x2a, 0x1f, 0x17, 0xb1, 0x70, 0x69, 0x06, 0x2b, 0x2f, 0x18, 0x72, 0x72,
+0x28, 0xd6, 0x32, 0xa1, 0x96, 0x14, 0xd5, 0x2a, 0x52, 0x35, 0x4a, 0x3b, 0x8b, 0x6f, 0x0c, 0x24,
+0x97, 0xb7, 0x7f, 0xf6, 0x15, 0x8c, 0xbf, 0x69, 0x73, 0xee, 0x15, 0x0f, 0x07, 0x7e, 0x5e, 0x07,
+0x9b, 0x81, 0x28, 0x74, 0x49, 0x94, 0xd3, 0x05, 0xeb, 0xc9, 0x63, 0x70, 0x89, 0x91, 0x68, 0xe6,
+0x20, 0x32, 0x95, 0x00, 0x00, 0xc8, 0xba, 0xbd, 0x45, 0x77, 0x6b, 0x60, 0xa4, 0xa3, 0x05, 0x6b,
+0x70, 0x38, 0x07, 0x08, 0x8d, 0x09, 0xff, 0x5a, 0x55, 0xb2, 0x1f, 0xe2, 0xdf, 0xf0, 0x1b, 0x8d,
+0x40, 0xed, 0x52, 0x16, 0x3a, 0x7b, 0xb2, 0xbc, 0x3f, 0x21, 0x14, 0x58, 0xb0, 0x64, 0x6c, 0x33,
+0xcf, 0xdb, 0x93, 0x5a, 0x56, 0xa4, 0x3a, 0xd2, 0xcd, 0x22, 0x4a, 0x2f, 0x8e, 0x77, 0x2b, 0x0a,
+0x57, 0x43, 0x4b, 0x15, 0xab, 0xee, 0x3e, 0xa5, 0xf8, 0xff, 0xb9, 0xb2, 0x7d, 0x59, 0x84, 0x36,
+0x0a, 0x3b, 0x17, 0xda, 0x78, 0x50, 0x66, 0x62, 0xb9, 0x78, 0xad, 0x61, 0x3b, 0x26, 0xe9, 0x00,
+0x67, 0xd7, 0x3c, 0x75, 0xa4, 0xf3, 0x3a, 0x51, 0x4f, 0xd3, 0x0d, 0x04, 0xb8, 0x07, 0x7c, 0x06,
+0xcb, 0x22, 0x23, 0x4c, 0x1c, 0xa3, 0xb0, 0x03, 0x23, 0xdd, 0x50, 0xee, 0xd1, 0xc8, 0xff, 0xa0,
+0xc4, 0xa4, 0x68, 0x0d, 0xfc, 0xc5, 0x2e, 0x53, 0x33, 0x30, 0xb0, 0x56, 0x62, 0xb3, 0x9b, 0xa6,
+0x7f, 0x68, 0xb0, 0xbb, 0x67, 0x02, 0x41, 0x52, 0x05, 0x49, 0x9b, 0x4f, 0x61, 0x63, 0x48, 0xc4,
+0x5d, 0x62, 0x65, 0xef, 0xd1, 0xbf, 0xb5, 0x46, 0x96, 0xdc, 0x9a, 0xdf, 0xb9, 0xe9, 0x8f, 0xd3,
+0x6e, 0x12, 0x96, 0x31, 0x3c, 0x1a, 0xab, 0x04, 0xcf, 0x5e, 0x8d, 0x8c, 0xe4, 0x09, 0x6f, 0xcf,
+0xd7, 0xe8, 0x2e, 0x43, 0x53, 0x6a, 0x84, 0x3e, 0x28, 0x5b, 0xcc, 0x03, 0xb2, 0xae, 0xff, 0xc3,
+0xe4, 0x8a, 0x37, 0xa1, 0x88, 0xca, 0x0d, 0xa0, 0x2b, 0x64, 0xbd, 0x78, 0x78, 0x2a, 0x6e, 0x26,
+0x8f, 0x85, 0x69, 0x6a, 0xa9, 0xf2, 0xc4, 0xba, 0xf0, 0xed, 0xe9, 0xb9, 0x74, 0xbb, 0x95, 0xde,
+0x1c, 0xdc, 0x80, 0xf3, 0x46, 0x28, 0xf6, 0x4c, 0x01, 0x7a, 0x6d, 0x9a, 0x9a, 0xe1, 0xb8, 0x1b,
+0x9e, 0x4a, 0x28, 0x6c, 0x96, 0x59, 0xc6, 0x53, 0xe3, 0xc9, 0x7c, 0xaf, 0xf0, 0x22, 0x08, 0xb5,
+0xef, 0xad, 0xc8, 0x8d, 0x3a, 0x6c, 0x27, 0xf7, 0xfb, 0x3c, 0x4f, 0x9d, 0x05, 0x9a, 0x4b, 0x6b,
+0x88, 0xb3, 0x74, 0xca, 0xac, 0x9d, 0x76, 0x00, 0x58, 0x97, 0x69, 0x0d, 0x98, 0xe3, 0x40, 0x42,
+0xfc, 0xe8, 0x42, 0x38, 0xae, 0x04, 0x3b, 0xc1, 0x96, 0xf1, 0xd9, 0x19, 0x92, 0xc4, 0xb5, 0xeb,
+0x39, 0xd0, 0x7a, 0x5a, 0x3e, 0xf0, 0x0d, 0xba, 0x2f, 0x1e, 0x6e, 0xc7, 0xe4, 0x46, 0xe6, 0x3d,
+0x7c, 0x08, 0x6b, 0xea, 0xff, 0xf1, 0x78, 0xdf, 0x3b, 0xe9, 0xcb, 0x06, 0x5e, 0x30, 0xbd, 0x47,
+0xe3, 0x5c, 0xe2, 0x18, 0x01, 0xa5, 0xd5, 0x80, 0x74, 0x4e, 0x93, 0xe5, 0x86, 0xdb, 0x7c, 0x5f,
+0x0d, 0xd2, 0x6b, 0xdc, 0xa9, 0x91, 0x24, 0x2c, 0x09, 0x4f, 0xd1, 0xfa, 0xab, 0x96, 0x99, 0x2b,
+0x91, 0xda, 0xe1, 0x69, 0x6f, 0xd8, 0x1b, 0x28, 0x73, 0xb2, 0x51, 0xfa, 0xcf, 0xa7, 0x9e
+};
+
+static unsigned char hi_rsa_pub[] =
+{
+0x99, 0x02, 0x0d, 0x04, 0x52, 0x82, 0x2c, 0xee, 0x01, 0x10, 0x00, 0xbe, 0x0d, 0x60, 0xa0, 0x12,
+0x2f, 0x3c, 0x6a, 0x72, 0x29, 0x61, 0x26, 0xdd, 0x2e, 0x4e, 0x62, 0xad, 0xa6, 0xb3, 0x2b, 0x45,
+0x94, 0x94, 0x99, 0x2a, 0x6e, 0xd0, 0xda, 0x5f, 0xf6, 0x99, 0xee, 0xbe, 0x0e, 0x10, 0x42, 0xea,
+0x0b, 0x44, 0xac, 0x76, 0x06, 0x0b, 0x30, 0xd0, 0x2e, 0xd9, 0xe9, 0x2d, 0xfb, 0x5a, 0x3f, 0xfb,
+0xb5, 0xbc, 0xea, 0x8a, 0x2a, 0xfa, 0xe9, 0xef, 0x77, 0x94, 0x81, 0xc6, 0xbb, 0x4b, 0x12, 0x78,
+0xf3, 0xfe, 0x06, 0x93, 0x37, 0xa7, 0x38, 0x52, 0xab, 0xaa, 0xa3, 0xb4, 0x11, 0xbe, 0x5e, 0x77,
+0xdd, 0xe4, 0x98, 0x4c, 0x74, 0x4e, 0x1c, 0x62, 0xa8, 0x7a, 0x65, 0x6b, 0x09, 0xd7, 0x29, 0xae,
+0xaf, 0xe9, 0x7f, 0x94, 0x07, 0x01, 0x76, 0xfb, 0x7d, 0x2c, 0xf8, 0xe5, 0xce, 0x33, 0xb2, 0x7e,
+0x4c, 0x28, 0x41, 0x2c, 0xba, 0x73, 0x83, 0x2f, 0x61, 0x5e, 0xd9, 0x5c, 0xa6, 0x44, 0x54, 0x40,
+0xae, 0x7c, 0xa8, 0x0b, 0x01, 0x0f, 0x84, 0x1f, 0xfe, 0x72, 0x06, 0x51, 0xda, 0x15, 0x88, 0xa4,
+0x9e, 0x85, 0x06, 0x21, 0x2c, 0xe4, 0xe7, 0x2a, 0x04, 0x66, 0x3c, 0x31, 0x13, 0x02, 0x08, 0x1f,
+0x6c, 0x9b, 0xab, 0x97, 0xf8, 0x29, 0x51, 0xb5, 0x85, 0x76, 0x53, 0x83, 0x1f, 0x08, 0x46, 0xe7,
+0x03, 0x96, 0xa2, 0x64, 0x8a, 0xef, 0xc2, 0x52, 0xd8, 0x7e, 0xb9, 0x96, 0xc7, 0xbe, 0xbe, 0x81,
+0x4f, 0x22, 0x6a, 0xa6, 0xa9, 0xf8, 0x68, 0x11, 0x72, 0xb1, 0x5d, 0x5b, 0xe4, 0xc2, 0xeb, 0x09,
+0xb3, 0xb7, 0x0d, 0xc9, 0x1b, 0xfe, 0x39, 0x7b, 0x45, 0x96, 0xec, 0xd6, 0x37, 0x34, 0x4d, 0x1d,
+0xcc, 0x86, 0xfa, 0x2b, 0x69, 0x9c, 0x67, 0x55, 0x55, 0x56, 0xb4, 0x68, 0xf2, 0x0c, 0xf2, 0x84,
+0xd8, 0x27, 0x53, 0x4d, 0xae, 0xb1, 0xec, 0x5e, 0xdc, 0x24, 0x09, 0xb9, 0x2b, 0x3d, 0x28, 0x79,
+0xa0, 0x5d, 0x14, 0x4a, 0xe7, 0xff, 0x8b, 0x6f, 0xdf, 0xaf, 0x8b, 0x01, 0xc0, 0xac, 0xb6, 0xfb,
+0x6f, 0x98, 0xca, 0x20, 0x89, 0x22, 0x4e, 0x7d, 0x20, 0x62, 0x2a, 0xa0, 0x7c, 0xe2, 0xf4, 0xa7,
+0x1c, 0xfa, 0x3f, 0xc8, 0x8e, 0xd0, 0x54, 0x07, 0x73, 0xec, 0x8c, 0xb5, 0x4b, 0x4c, 0x50, 0x38,
+0x86, 0x27, 0x53, 0x39, 0x9f, 0x71, 0x3c, 0x5e, 0xd4, 0x03, 0x59, 0x22, 0x24, 0x62, 0x5d, 0x28,
+0x1b, 0x69, 0x75, 0x98, 0xfe, 0x01, 0xc2, 0x8c, 0x12, 0xc0, 0x25, 0x9c, 0x1e, 0xa0, 0x89, 0x15,
+0x26, 0x19, 0x15, 0x76, 0x2d, 0xdc, 0x69, 0x44, 0x49, 0x3e, 0x2d, 0xca, 0x1a, 0x14, 0x98, 0xf4,
+0x12, 0x52, 0xff, 0x38, 0x2e, 0x46, 0xfc, 0xed, 0x01, 0x4d, 0x40, 0x8a, 0x39, 0x57, 0x8e, 0x65,
+0xe9, 0x26, 0x0e, 0x27, 0x8a, 0x10, 0x99, 0x5d, 0x1f, 0xbd, 0xec, 0xbc, 0x63, 0xf8, 0x85, 0xcf,
+0xa0, 0x34, 0xb8, 0xe9, 0xd5, 0x4b, 0xf1, 0x4a, 0x47, 0xe7, 0xbe, 0x27, 0x9e, 0xe8, 0x3f, 0x96,
+0xcd, 0x6d, 0x11, 0x03, 0xd3, 0x08, 0xab, 0xdf, 0x32, 0x59, 0x16, 0x9c, 0xda, 0x68, 0xd7, 0x5d,
+0x30, 0x48, 0xbe, 0xa3, 0xe4, 0x0d, 0x95, 0xde, 0x5b, 0x54, 0xee, 0x10, 0x39, 0x5a, 0xc8, 0xb4,
+0x82, 0xde, 0x1c, 0xe5, 0x32, 0xc0, 0x73, 0x31, 0x3a, 0x25, 0xfe, 0xae, 0x1c, 0xca, 0x0d, 0x6d,
+0x5e, 0xf2, 0x1b, 0x95, 0x18, 0x88, 0xc3, 0x0a, 0x21, 0xc3, 0x5e, 0x0d, 0x2f, 0xc0, 0x30, 0xf5,
+0x53, 0xee, 0x0b, 0x0d, 0xb1, 0x99, 0x52, 0x47, 0xf0, 0x26, 0x4a, 0xfa, 0x61, 0x15, 0x2a, 0xbb,
+0xc4, 0x60, 0x23, 0xbe, 0x21, 0x2f, 0xff, 0x21, 0x34, 0x64, 0xb0, 0x17, 0x28, 0x61, 0x31, 0xf8,
+0xe4, 0xb2, 0x00, 0x3e, 0xb6, 0x89, 0x5f, 0x19, 0x03, 0x2e, 0x67, 0x00, 0x11, 0x01, 0x00, 0x01,
+0xb4, 0x22, 0x47, 0x4e, 0x55, 0x20, 0x47, 0x52, 0x55, 0x42, 0x20, 0x52, 0x53, 0x41, 0x20, 0x73,
+0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, 0x65, 0x20, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67,
+0x20, 0x6b, 0x65, 0x79, 0x89, 0x02, 0x38, 0x04, 0x13, 0x01, 0x02, 0x00, 0x22, 0x05, 0x02, 0x52,
+0x82, 0x2c, 0xee, 0x02, 0x1b, 0x03, 0x06, 0x0b, 0x09, 0x08, 0x07, 0x03, 0x02, 0x06, 0x15, 0x08,
+0x02, 0x09, 0x0a, 0x0b, 0x04, 0x16, 0x02, 0x03, 0x01, 0x02, 0x1e, 0x01, 0x02, 0x17, 0x80, 0x00,
+0x0a, 0x09, 0x10, 0x0f, 0xcc, 0xf3, 0x21, 0x77, 0x83, 0x6a, 0x0d, 0x14, 0x0a, 0x0f, 0xff, 0x45,
+0x11, 0xf5, 0x1a, 0x37, 0x13, 0xe8, 0x9a, 0x51, 0x1d, 0x77, 0x67, 0xa4, 0x71, 0xf1, 0x74, 0xaa,
+0xcf, 0xc7, 0xab, 0x34, 0x11, 0x01, 0x9b, 0xab, 0x45, 0x6d, 0xf6, 0x5e, 0xd4, 0x74, 0x42, 0x37,
+0x22, 0x8b, 0x8b, 0xb3, 0xf1, 0x36, 0x33, 0x25, 0xf0, 0x7d, 0x9b, 0xa7, 0xb6, 0x9b, 0x4e, 0xc2,
+0x22, 0xab, 0x02, 0x66, 0x60, 0x4a, 0xd3, 0xe9, 0xcb, 0xe6, 0xde, 0x72, 0x7a, 0x33, 0x62, 0x84,
+0x5e, 0x7b, 0xd8, 0x1f, 0xce, 0x7d, 0x37, 0x17, 0xee, 0xbe, 0x4b, 0x31, 0xe2, 0x1a, 0xf9, 0x8e,
+0x9b, 0xec, 0xc2, 0x9f, 0x35, 0xa6, 0x28, 0xc1, 0x81, 0x76, 0xdd, 0x0d, 0xaf, 0xc3, 0x62, 0xe8,
+0xf3, 0xa5, 0xd0, 0x4c, 0x10, 0x4c, 0xa4, 0x0b, 0x3e, 0xab, 0xd7, 0xcf, 0x7d, 0x99, 0x5a, 0x44,
+0xdd, 0xda, 0x62, 0x22, 0x41, 0x7f, 0x3f, 0x92, 0x9f, 0x49, 0xb0, 0xb7, 0x2d, 0x01, 0x1f, 0xbc,
+0xc9, 0xf7, 0x0a, 0xab, 0xe3, 0xe6, 0x17, 0xac, 0x4b, 0xcf, 0x65, 0x6d, 0xae, 0x51, 0x3d, 0xf1,
+0x0c, 0x94, 0x07, 0xfe, 0xc2, 0x4c, 0x10, 0x95, 0x5c, 0x9b, 0xfd, 0xfe, 0xed, 0x05, 0x4a, 0xfe,
+0xdf, 0xe6, 0x21, 0x12, 0x6f, 0x37, 0x5e, 0x52, 0xee, 0x15, 0x0b, 0x18, 0xf7, 0x74, 0x39, 0xac,
+0xab, 0x31, 0xfa, 0x52, 0x4c, 0x72, 0xa5, 0xb0, 0x5e, 0xc5, 0x69, 0xf2, 0x20, 0xd5, 0x0b, 0x4c,
+0x4c, 0xe8, 0xf0, 0xbc, 0xf6, 0x4f, 0x33, 0x75, 0x64, 0xcf, 0x93, 0x1b, 0x01, 0xdb, 0x02, 0xfb,
+0x81, 0x42, 0xa0, 0x24, 0x18, 0x21, 0x16, 0xb0, 0xe5, 0x3b, 0x22, 0xe4, 0xd7, 0x91, 0x1e, 0x07,
+0x37, 0x36, 0x52, 0x22, 0x8e, 0x49, 0x7a, 0xcf, 0xf2, 0x85, 0x20, 0x09, 0xc2, 0xc5, 0x31, 0x6b,
+0xcd, 0xe1, 0x87, 0x8b, 0xc1, 0xae, 0x20, 0x27, 0xa8, 0x59, 0x9f, 0x37, 0xc3, 0xe0, 0xbf, 0x40,
+0xe9, 0x9c, 0xe2, 0x77, 0xca, 0xa8, 0x5e, 0x46, 0x20, 0x88, 0xbd, 0x45, 0xbf, 0x60, 0xa7, 0x40,
+0x80, 0x28, 0x74, 0xd6, 0x34, 0x4c, 0xd4, 0x5c, 0x60, 0x1e, 0xf9, 0xbc, 0xa7, 0x6a, 0x8d, 0x08,
+0x99, 0xec, 0xb6, 0x5c, 0xdb, 0x1f, 0xf9, 0xe0, 0x06, 0x26, 0x1d, 0x04, 0x6f, 0x1d, 0x84, 0x0c,
+0x8b, 0x6e, 0x8d, 0x06, 0xc0, 0x83, 0x2b, 0x7c, 0xdf, 0x2c, 0x4a, 0xac, 0x2d, 0xe4, 0xcd, 0xa4,
+0x55, 0xd1, 0xcd, 0x54, 0x8a, 0xaa, 0x04, 0x53, 0x23, 0xa8, 0x9c, 0x67, 0x28, 0xa7, 0x11, 0x76,
+0xd3, 0x2f, 0x17, 0x2a, 0x40, 0xac, 0x06, 0xe1, 0x47, 0x30, 0xd0, 0x9c, 0xba, 0x9c, 0x9c, 0xaf,
+0x22, 0xe0, 0x68, 0xa5, 0x72, 0xf0, 0xf1, 0x8c, 0xe3, 0xbe, 0xc6, 0xed, 0xfa, 0xad, 0x72, 0xf8,
+0xab, 0x49, 0x5e, 0x4d, 0xed, 0x88, 0x41, 0xb2, 0x7c, 0x95, 0x69, 0x63, 0x1c, 0xd8, 0x90, 0x9d,
+0xc6, 0x4a, 0x42, 0x30, 0x91, 0x7b, 0x58, 0x30, 0xfa, 0x32, 0xf6, 0xd6, 0xc2, 0xe9, 0x74, 0xfa,
+0xe8, 0x81, 0x3d, 0xdc, 0xb6, 0x3f, 0xbc, 0x88, 0x3e, 0x01, 0xbc, 0x47, 0x75, 0x36, 0xf0, 0x28,
+0x4f, 0x14, 0xd6, 0xa1, 0xc5, 0x3d, 0xb2, 0x74, 0x82, 0xfd, 0xad, 0x94, 0xb3, 0x14, 0x16, 0x61,
+0xef, 0x77, 0x77, 0x25, 0x03, 0xc1, 0x8e, 0x71, 0x55, 0xa5, 0x31, 0x40, 0x50, 0x49, 0x3f, 0xf5,
+0x40, 0x7f, 0x97, 0x4f, 0xef, 0x47, 0xa2, 0x12, 0x0c, 0x1d, 0x23, 0x51, 0x47, 0x53, 0x0b, 0x72,
+0xc2, 0xd3, 0x39, 0xbb, 0xa9, 0xea, 0x8c, 0x16, 0x93, 0x67, 0xb1, 0xcf, 0x8a, 0x96, 0xba, 0x1e,
+0xef, 0x20, 0x3f, 0xee, 0xda, 0x69, 0xd1, 0x4d, 0xf4, 0x9c, 0x41, 0x73, 0xcb, 0xaf, 0x1b, 0x29,
+0x22, 0x1f, 0x94, 0xa4, 0x67, 0xd7, 0x53, 0xb1, 0x65, 0x23, 0x69, 0x05, 0x31, 0x2e, 0xd4
+};
+
+static unsigned char hi_dsa_sig[] =
+{
+0x88, 0x5e, 0x04, 0x00, 0x11, 0x08, 0x00, 0x06, 0x05, 0x02, 0x52, 0x82, 0x2c, 0x7f, 0x00, 0x0a,
+0x09, 0x10, 0xef, 0xe0, 0xfc, 0x1f, 0xf6, 0xe7, 0xf5, 0xad, 0xb0, 0x47, 0x01, 0x00, 0xcd, 0xfd,
+0x1f, 0x8b, 0x16, 0x7f, 0x31, 0x7f, 0xc3, 0xe1, 0x6d, 0xcd, 0xc5, 0x4f, 0xf4, 0x1b, 0xf5, 0x4e,
+0x61, 0x79, 0xb5, 0x14, 0xdd, 0xf5, 0xe5, 0x27, 0x21, 0xf6, 0xc7, 0x95, 0xc6, 0x9b, 0x00, 0xff,
+0x61, 0x4d, 0x01, 0x6f, 0xbb, 0x88, 0xf9, 0x38, 0x84, 0x00, 0xab, 0xab, 0x2f, 0x16, 0x53, 0x5c,
+0xe9, 0x3d, 0x85, 0x34, 0x0d, 0x36, 0x80, 0x77, 0x62, 0x4e, 0x4f, 0xdb, 0x48, 0x64, 0x58, 0x82
+};
+
+static unsigned char hi_dsa_pub[] =
+{
+0x99, 0x04, 0xae, 0x04, 0x52, 0x82, 0x2b, 0xe6, 0x11, 0x0c, 0x00, 0xcc, 0x6b, 0xfe, 0xc3, 0xed,
+0x23, 0xb8, 0x09, 0xa8, 0xcd, 0x00, 0x8a, 0xd7, 0x4d, 0xe5, 0x37, 0x03, 0xab, 0x99, 0x64, 0xc5,
+0xde, 0xef, 0x47, 0xfd, 0x06, 0xe1, 0xc2, 0x70, 0x77, 0x5f, 0x78, 0x46, 0x62, 0x9e, 0x5e, 0x84,
+0x48, 0xdf, 0xc2, 0xef, 0xd3, 0xf3, 0xc3, 0x97, 0x92, 0x83, 0xa7, 0xad, 0xf7, 0x4e, 0x43, 0xac,
+0x06, 0xcb, 0x18, 0x4b, 0xe4, 0x05, 0x45, 0x01, 0x3d, 0x34, 0x51, 0x59, 0xf5, 0xfb, 0x42, 0xad,
+0xe5, 0x7c, 0xf4, 0xe3, 0xd6, 0x6d, 0x4e, 0xd7, 0x3d, 0xbc, 0x87, 0x0b, 0x94, 0xe7, 0x70, 0x55,
+0x3c, 0x7c, 0xef, 0x1e, 0x9c, 0xa1, 0x0b, 0x17, 0x8c, 0x0d, 0x62, 0x08, 0x8f, 0x5a, 0x93, 0x2a,
+0x0e, 0xde, 0xad, 0x7d, 0x60, 0xe7, 0x5c, 0xe7, 0xf3, 0xb0, 0x2f, 0xef, 0xc1, 0xc9, 0x5f, 0x71,
+0xf9, 0xa7, 0x33, 0x30, 0x78, 0x3a, 0xb2, 0x83, 0xd9, 0xe5, 0xc1, 0x6b, 0xb4, 0xaa, 0x13, 0xe0,
+0xdb, 0x2a, 0xd8, 0x81, 0xfc, 0x96, 0xd6, 0x3a, 0x73, 0xba, 0x34, 0xe4, 0xf8, 0xc1, 0xf5, 0xac,
+0x2e, 0x4c, 0x95, 0x52, 0x28, 0x03, 0xe7, 0x01, 0xc8, 0x5e, 0x1c, 0x1c, 0xbd, 0xd3, 0xe5, 0xf8,
+0xf2, 0xc5, 0xbf, 0x61, 0x01, 0x22, 0x3c, 0x57, 0xd5, 0x6a, 0x17, 0x29, 0x3e, 0x00, 0xfc, 0xb4,
+0x97, 0x7f, 0x45, 0xa4, 0x6c, 0x53, 0xd5, 0xd2, 0x56, 0xce, 0x4f, 0x1b, 0xcf, 0xc2, 0x0b, 0x83,
+0x09, 0xf6, 0xc1, 0x95, 0xea, 0x2a, 0x47, 0xe0, 0xa6, 0x8e, 0xc5, 0x74, 0x6e, 0x8e, 0xa4, 0x10,
+0x3a, 0x99, 0xfb, 0x9e, 0xcc, 0x06, 0xa7, 0x70, 0xef, 0xe8, 0xf6, 0x72, 0xba, 0xd4, 0x0c, 0x11,
+0x47, 0x17, 0x6b, 0x2d, 0xde, 0xa1, 0xfd, 0x41, 0x87, 0x18, 0x33, 0x6c, 0x26, 0xd2, 0xdc, 0xc7,
+0x8f, 0x4f, 0x91, 0xc1, 0x02, 0x38, 0x42, 0xe5, 0x35, 0xaf, 0xef, 0x90, 0xde, 0x94, 0xa3, 0x3c,
+0xde, 0x61, 0x67, 0xb3, 0x26, 0xe2, 0xfc, 0x2d, 0x96, 0x35, 0xfd, 0x00, 0xb1, 0x02, 0xe7, 0xb4,
+0xd4, 0xf4, 0xb7, 0x67, 0xaa, 0xd4, 0x00, 0xfa, 0xcf, 0x9b, 0xbe, 0xbb, 0xad, 0xac, 0x8e, 0xe3,
+0xab, 0xf1, 0x80, 0xaf, 0xe2, 0xb1, 0x93, 0x09, 0xd0, 0x40, 0xde, 0xab, 0x53, 0xcf, 0xa7, 0x45,
+0x1a, 0x8b, 0xdb, 0x0f, 0xff, 0xd4, 0xdf, 0x6b, 0xe9, 0x2c, 0x40, 0x8e, 0x24, 0x03, 0x62, 0x75,
+0x0f, 0x2c, 0x8b, 0x8e, 0x9e, 0xd0, 0x91, 0x5a, 0x91, 0x68, 0xcb, 0x16, 0x45, 0xca, 0x8f, 0xdd,
+0x5e, 0x61, 0x71, 0xa7, 0x8d, 0xa3, 0xf4, 0xf7, 0xa3, 0xee, 0x5d, 0x4c, 0x8a, 0xee, 0x5b, 0x5f,
+0x1e, 0xfc, 0xbe, 0x3d, 0x94, 0xab, 0x30, 0x02, 0x6f, 0x72, 0x57, 0x03, 0x2a, 0xaf, 0x9c, 0x28,
+0x12, 0x55, 0x00, 0xd5, 0x0a, 0x2a, 0x02, 0x4e, 0xf0, 0xc0, 0x67, 0x01, 0x00, 0xd3, 0xaf, 0x3f,
+0xcf, 0x8c, 0x64, 0x59, 0x9d, 0xe5, 0x7b, 0x0b, 0xa0, 0xa0, 0x46, 0xb3, 0xc0, 0xf6, 0x25, 0xde,
+0x2d, 0xfa, 0x27, 0xf6, 0xf1, 0xca, 0x3c, 0xd3, 0x56, 0x6e, 0xc0, 0xd4, 0x49, 0x0b, 0xfc, 0x0f,
+0x23, 0xbf, 0xe1, 0x00, 0x63, 0xb5, 0x04, 0x40, 0x04, 0x5c, 0x9e, 0xce, 0x0b, 0x75, 0xca, 0xfe,
+0xd9, 0xb7, 0xe1, 0xcc, 0x27, 0x20, 0xf4, 0x4c, 0x61, 0x10, 0x17, 0x2b, 0xb7, 0x5d, 0x0d, 0xc2,
+0xac, 0x37, 0x4e, 0x7f, 0x81, 0x4a, 0xde, 0x06, 0x6f, 0xb7, 0x61, 0xcc, 0x9e, 0xdd, 0x6a, 0x3e,
+0x88, 0x55, 0x66, 0x8a, 0x87, 0xc1, 0x26, 0xf3, 0xe2, 0xd8, 0xdf, 0x80, 0xfa, 0x82, 0x6f, 0x25,
+0x89, 0x94, 0xe7, 0xff, 0x79, 0xb6, 0x08, 0x5e, 0x45, 0x46, 0x9a, 0x74, 0xde, 0xa8, 0xa3, 0xc8,
+0x8f, 0x6f, 0x8f, 0x8e, 0xf5, 0x1f, 0xab, 0x3d, 0x21, 0xd5, 0xec, 0x34, 0x86, 0x6c, 0xbd, 0x92,
+0x44, 0x9d, 0x73, 0x46, 0xcb, 0xa0, 0x5c, 0x05, 0xd5, 0x12, 0xf0, 0xe9, 0xc7, 0x65, 0xa7, 0xe3,
+0x4d, 0x82, 0x8f, 0x54, 0x7e, 0x7b, 0x51, 0x46, 0xca, 0x50, 0x22, 0x24, 0x2e, 0x90, 0x5e, 0x33,
+0xd7, 0x0f, 0xca, 0x42, 0x82, 0x7e, 0x74, 0x20, 0xae, 0x49, 0xa4, 0x0a, 0xc5, 0x90, 0xd5, 0xf8,
+0x45, 0x32, 0x5f, 0xda, 0xf8, 0xf5, 0xb0, 0xa2, 0x43, 0x77, 0x7a, 0x65, 0xf9, 0x59, 0xaa, 0x91,
+0xe1, 0xd9, 0x7f, 0xbc, 0x8c, 0xa6, 0xb6, 0x71, 0x68, 0xc3, 0xe5, 0x36, 0xee, 0xa3, 0x47, 0xe0,
+0x4f, 0x48, 0xb3, 0xf1, 0x8d, 0x41, 0xb0, 0xbc, 0x14, 0xb0, 0x15, 0x21, 0x35, 0xc3, 0x2c, 0xc7,
+0x37, 0x23, 0x03, 0xb9, 0xfb, 0xb9, 0xdc, 0x7b, 0x7a, 0x89, 0x44, 0x01, 0x1b, 0xa7, 0x87, 0x5f,
+0xe2, 0xc1, 0x02, 0x53, 0xcd, 0xd5, 0x56, 0xcd, 0x8c, 0x56, 0x6d, 0xa6, 0x90, 0xf6, 0x26, 0xff,
+0x8e, 0x6d, 0x5f, 0x60, 0x9e, 0x8f, 0x2c, 0x71, 0xa5, 0xff, 0xd9, 0x77, 0x67, 0x9e, 0x09, 0x93,
+0xa4, 0x7c, 0x23, 0x1d, 0x55, 0x18, 0x5a, 0x54, 0x41, 0x88, 0x8e, 0x2d, 0xc6, 0x87, 0x67, 0x43,
+0xd4, 0x3d, 0xaf, 0x85, 0x3b, 0xda, 0x46, 0x02, 0x4a, 0x33, 0x46, 0x62, 0x1e, 0x9e, 0x66, 0xc9,
+0x5a, 0x96, 0xf8, 0xa9, 0xbd, 0x4a, 0x81, 0x92, 0x40, 0x9e, 0xc3, 0xa5, 0x3d, 0x99, 0xc5, 0xf1,
+0xd7, 0x6d, 0xc9, 0x29, 0x7d, 0x2c, 0xdf, 0x1e, 0xc9, 0xe4, 0x6d, 0x83, 0xd1, 0xc4, 0xaa, 0x9f,
+0xe3, 0x0e, 0x0a, 0x87, 0x49, 0x89, 0x6a, 0xc0, 0xc7, 0x73, 0x19, 0x91, 0x2d, 0xa5, 0x0b, 0xbf,
+0x4f, 0x52, 0x46, 0x54, 0xd7, 0x9c, 0x97, 0x77, 0x32, 0xab, 0xd3, 0x74, 0x14, 0x9d, 0xbc, 0xa9,
+0x4a, 0xd9, 0x5f, 0x8b, 0xd7, 0xf8, 0x63, 0xf4, 0x3e, 0xde, 0x79, 0x8a, 0xae, 0x65, 0x0c, 0x18,
+0xe3, 0x8d, 0x21, 0x7d, 0x95, 0x59, 0xf1, 0xe0, 0xb6, 0xa3, 0x52, 0xa3, 0x46, 0x91, 0x94, 0x31,
+0x0e, 0x6c, 0xb3, 0x84, 0xa2, 0x26, 0x49, 0x06, 0xb7, 0x2b, 0x4c, 0x93, 0xf3, 0x60, 0xaa, 0x0c,
+0x00, 0x97, 0x4f, 0x05, 0x06, 0xc3, 0x97, 0x32, 0x4b, 0xbe, 0x18, 0x84, 0x7a, 0x51, 0x1b, 0xb0,
+0xe6, 0x94, 0x3a, 0xd7, 0x7b, 0xa8, 0xd0, 0x21, 0x19, 0x54, 0x78, 0x19, 0x2b, 0xe5, 0xc6, 0x92,
+0xb7, 0xc5, 0x1e, 0x72, 0x33, 0x78, 0xe8, 0x13, 0x11, 0x14, 0x43, 0x9e, 0x3c, 0x6b, 0x3f, 0x25,
+0x67, 0xe4, 0x6e, 0x5e, 0xe0, 0x7a, 0x3c, 0x06, 0xdc, 0x2e, 0x06, 0x6e, 0x9c, 0x8e, 0xf0, 0xc6,
+0xfb, 0xc6, 0x2d, 0x63, 0x1b, 0x4f, 0x66, 0x72, 0x7d, 0xc9, 0x0e, 0x38, 0xc4, 0x17, 0x07, 0x49,
+0xc9, 0x7d, 0xab, 0x3a, 0xed, 0xf2, 0xeb, 0xeb, 0x6d, 0xa7, 0xb0, 0x97, 0x88, 0x08, 0x0d, 0x0b,
+0xdc, 0x07, 0x32, 0xe2, 0x62, 0xf5, 0x4e, 0x46, 0xe7, 0x13, 0x85, 0x01, 0x92, 0xee, 0x26, 0x67,
+0x0d, 0xb0, 0x85, 0xa8, 0xa1, 0x26, 0x49, 0x14, 0xa3, 0xde, 0x95, 0xd7, 0xeb, 0xcf, 0x85, 0xb2,
+0xdf, 0x3f, 0x76, 0x16, 0x75, 0x20, 0x47, 0xb1, 0x80, 0x04, 0x1e, 0x2f, 0xa2, 0xde, 0xb2, 0x5f,
+0x50, 0x83, 0xd2, 0x45, 0xad, 0x8d, 0x08, 0xf4, 0xe2, 0xfb, 0xac, 0x13, 0x2b, 0x6f, 0x3a, 0xfe,
+0xa7, 0x18, 0xfc, 0x11, 0xe0, 0x46, 0xdd, 0x53, 0x82, 0x3b, 0xd4, 0x0b, 0xf2, 0xec, 0x6c, 0xd0,
+0xbd, 0xea, 0xdf, 0xfa, 0xd2, 0x52, 0xf8, 0xa5, 0x4a, 0x49, 0xae, 0x2f, 0x1e, 0xb0, 0x9d, 0x61,
+0x7a, 0x26, 0x6f, 0x0e, 0x97, 0xe6, 0x74, 0xa8, 0x39, 0x51, 0x6d, 0xe6, 0x4a, 0xbf, 0x7f, 0xb1,
+0x4f, 0xa1, 0x2e, 0xaf, 0x1d, 0x0c, 0x20, 0x69, 0xac, 0xd1, 0x0c, 0xa0, 0x5e, 0x97, 0x8f, 0xa0,
+0x9c, 0x22, 0x72, 0x96, 0x05, 0x34, 0xf2, 0x7c, 0xc8, 0xda, 0x71, 0x00, 0xf4, 0x82, 0x5f, 0xac,
+0x36, 0x8e, 0x2b, 0xf7, 0xa6, 0xac, 0x94, 0x97, 0x75, 0xef, 0x8b, 0xfa, 0xaf, 0xb7, 0x19, 0x7f,
+0x10, 0xaa, 0x38, 0x11, 0x2b, 0x81, 0x81, 0xbf, 0x78, 0x93, 0xa7, 0x8e, 0xda, 0x57, 0xc8, 0xfc,
+0xbc, 0x85, 0xa6, 0x26, 0x0b, 0xcd, 0xce, 0xbf, 0xa5, 0x3f, 0x29, 0x03, 0x85, 0x2d, 0xd4, 0xa0,
+0x26, 0xad, 0x9c, 0x9a, 0x6b, 0xb3, 0x01, 0xd0, 0x1c, 0x7a, 0xf2, 0x48, 0x31, 0x04, 0x40, 0x09,
+0x02, 0x0b, 0xe3, 0x3c, 0x65, 0xf5, 0x39, 0xae, 0x25, 0x2e, 0x42, 0xa3, 0x43, 0x50, 0x80, 0xbb,
+0x36, 0x4c, 0xf9, 0x04, 0xec, 0x52, 0x37, 0xc1, 0x00, 0x92, 0x4a, 0x5a, 0x56, 0xfb, 0x50, 0x54,
+0x26, 0x3c, 0xa5, 0x3a, 0x22, 0x4f, 0x6b, 0x17, 0x5b, 0x64, 0xd5, 0xfd, 0xa4, 0x1b, 0x32, 0x22,
+0x16, 0x97, 0x0e, 0xfd, 0x92, 0xae, 0x5e, 0xd0, 0x5b, 0x4b, 0xf9, 0x26, 0x2e, 0x46, 0x12, 0x8d,
+0x91, 0x80, 0xe8, 0x71, 0xbf, 0xf7, 0xc2, 0x8e, 0xed, 0x60, 0xd2, 0x17, 0x53, 0xd1, 0x8b, 0xc9,
+0x08, 0xb4, 0x1d, 0x47, 0x4e, 0x55, 0x20, 0x47, 0x52, 0x55, 0x42, 0x20, 0x44, 0x53, 0x41, 0x20,
+0x73, 0x69, 0x67, 0x6e, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x65, 0x73, 0x74, 0x20, 0x6b, 0x65, 0x79,
+0x88, 0x7a, 0x04, 0x13, 0x11, 0x08, 0x00, 0x22, 0x05, 0x02, 0x52, 0x82, 0x2b, 0xe6, 0x02, 0x1b,
+0x03, 0x06, 0x0b, 0x09, 0x08, 0x07, 0x03, 0x02, 0x06, 0x15, 0x08, 0x02, 0x09, 0x0a, 0x0b, 0x04,
+0x16, 0x02, 0x03, 0x01, 0x02, 0x1e, 0x01, 0x02, 0x17, 0x80, 0x00, 0x0a, 0x09, 0x10, 0xef, 0xe0,
+0xfc, 0x1f, 0xf6, 0xe7, 0xf5, 0xad, 0xd6, 0x91, 0x01, 0x00, 0x94, 0x10, 0x43, 0xf9, 0xc9, 0x37,
+0x40, 0x47, 0xe1, 0xba, 0xf7, 0x92, 0x4b, 0xe1, 0xea, 0x94, 0xee, 0x81, 0x90, 0x8f, 0xe7, 0x76,
+0xc8, 0x30, 0x3d, 0x7e, 0xa0, 0xf5, 0xad, 0x2a, 0x52, 0x60, 0x00, 0xff, 0x75, 0x6c, 0x2d, 0xf5,
+0xab, 0x41, 0x83, 0x29, 0x4f, 0x37, 0x16, 0x1b, 0x26, 0x28, 0x55, 0x03, 0xfe, 0x30, 0x89, 0xce,
+0x70, 0x6e, 0x1a, 0x11, 0x4a, 0xb6, 0xa5, 0x17, 0x9f, 0xbe, 0x3d, 0x1d
+};
diff --git a/grub-core/tests/sleep_test.c b/grub-core/tests/sleep_test.c
new file mode 100644
index 0000000..ffb2681
--- /dev/null
+++ b/grub-core/tests/sleep_test.c
@@ -0,0 +1,51 @@
+/*
+ *  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/time.h>
+#include <grub/misc.h>
+#include <grub/dl.h>
+#include <grub/command.h>
+#include <grub/env.h>
+#include <grub/test.h>
+#include <grub/mm.h>
+#include <grub/datetime.h>
+#include <grub/time.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static void
+sleep_test (void)
+{
+  struct grub_datetime st, en;
+  grub_int64_t stu = 0, enu = 0;
+  int is_delayok;
+  grub_test_assert (!grub_get_datetime (&st), "Couldn't retrieve start time");
+  grub_millisleep (10000);
+  grub_test_assert (!grub_get_datetime (&en), "Couldn't retrieve end time");
+  grub_test_assert (grub_datetime2unixtime (&st, &stu), "Invalid date");
+  grub_test_assert (grub_datetime2unixtime (&en, &enu), "Invalid date");
+  is_delayok = (enu - stu >= 9 && enu - stu <= 11);
+#ifdef __arm__
+  /* Ignore QEMU bug */
+  if (enu - stu >= 15 && enu - stu <= 17)
+    is_delayok = 1;
+#endif
+  grub_test_assert (is_delayok, "Interval out of range: %" PRIdGRUB_INT64_T, enu - stu);
+}
+
+GRUB_FUNCTIONAL_TEST (sleep_test, sleep_test);
diff --git a/grub-core/tests/strtoull_test.c b/grub-core/tests/strtoull_test.c
new file mode 100644
index 0000000..5488ab2
--- /dev/null
+++ b/grub-core/tests/strtoull_test.c
@@ -0,0 +1,63 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2016 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/test.h>
+#include <grub/dl.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static void
+strtoull_testcase (const char *input, int base, unsigned long long expected,
+		   int num_digits, grub_err_t error)
+{
+  const char *output;
+  unsigned long long value;
+  grub_errno = 0;
+  value = grub_strtoull(input, &output, base);
+  grub_test_assert (grub_errno == error,
+		    "unexpected error. Expected %d, got %d. Input \"%s\"",
+		    error, grub_errno, input);
+  if (grub_errno)
+    {
+      grub_errno = 0;
+      return;
+    }
+  grub_test_assert (input + num_digits == output,
+		    "unexpected number of digits. Expected %d, got %d, input \"%s\"",
+		    num_digits, (int) (output - input), input);
+  grub_test_assert (value == expected,
+		    "unexpected return value. Expected %llu, got %llu, input \"\%s\"",
+		    expected, value, input);
+}
+
+static void
+strtoull_test (void)
+{
+  strtoull_testcase ("9", 0, 9, 1, GRUB_ERR_NONE);
+  strtoull_testcase ("0xaa", 0, 0xaa, 4, GRUB_ERR_NONE);
+  strtoull_testcase ("0xff", 0, 0xff, 4, GRUB_ERR_NONE);
+  strtoull_testcase ("0", 10, 0, 1, GRUB_ERR_NONE);
+  strtoull_testcase ("8", 8, 0, 0, GRUB_ERR_BAD_NUMBER);
+  strtoull_testcase ("38", 8, 3, 1, GRUB_ERR_NONE);
+  strtoull_testcase ("7", 8, 7, 1, GRUB_ERR_NONE);
+  strtoull_testcase ("1]", 16, 1, 1, GRUB_ERR_NONE);
+  strtoull_testcase ("18446744073709551616", 10, 0, 0, GRUB_ERR_OUT_OF_RANGE);
+}
+
+
+GRUB_FUNCTIONAL_TEST (strtoull_test, strtoull_test);
diff --git a/grub-core/tests/test_blockarg.c b/grub-core/tests/test_blockarg.c
new file mode 100644
index 0000000..88bd968
--- /dev/null
+++ b/grub-core/tests/test_blockarg.c
@@ -0,0 +1,55 @@
+/* test_blockarg.c - print and execute block argument  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2010  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/dl.h>
+#include <grub/err.h>
+#include <grub/misc.h>
+#include <grub/i18n.h>
+#include <grub/extcmd.h>
+#include <grub/script_sh.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static grub_err_t
+test_blockarg (grub_extcmd_context_t ctxt, int argc, char **args)
+{
+  if (! ctxt->script)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no block parameter");
+
+  grub_printf ("%s\n", args[argc - 1]);
+  grub_script_execute (ctxt->script);
+  return GRUB_ERR_NONE;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(test_blockarg)
+{
+  cmd = grub_register_extcmd ("test_blockarg", test_blockarg,
+			      GRUB_COMMAND_FLAG_BLOCKS,
+			      N_("BLOCK"),
+			      /* TRANSLATORS: this is the BLOCK-argument, not
+			       environment block.  */
+			      N_("Print and execute block argument."), 0);
+}
+
+GRUB_MOD_FINI(test_blockarg)
+{
+  grub_unregister_extcmd (cmd);
+}
diff --git a/grub-core/tests/video_checksum.c b/grub-core/tests/video_checksum.c
new file mode 100644
index 0000000..44d0810
--- /dev/null
+++ b/grub-core/tests/video_checksum.c
@@ -0,0 +1,813 @@
+/*
+ *  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 <config.h>
+
+#include <grub/test.h>
+#include <grub/dl.h>
+#include <grub/video.h>
+#include <grub/lib/crc.h>
+#include <grub/mm.h>
+#include <grub/term.h>
+#ifdef GRUB_MACHINE_EMU
+#include <grub/emu/hostdisk.h>
+#include <grub/emu/misc.h>
+#endif
+
+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;
+
+struct grub_video_mode_info grub_test_video_modes[GRUB_TEST_VIDEO_ALL_N_MODES] = {
+  {
+    .width = 640,
+    .height = 480,
+    .pitch = 640,
+    .mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR,
+    .bpp = 8,
+    .bytes_per_pixel = 1,
+    .number_of_colors = GRUB_VIDEO_FBSTD_NUMCOLORS
+  },
+  {
+    .width = 800,
+    .height = 600,
+    .pitch = 800,
+    .mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR,
+    .bpp = 8,
+    .bytes_per_pixel = 1,
+    .number_of_colors = GRUB_VIDEO_FBSTD_NUMCOLORS
+  },
+  {
+    .width = 1024,
+    .height = 768,
+    .pitch = 1024,
+    .mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR,
+    .bpp = 8,
+    .bytes_per_pixel = 1,
+    .number_of_colors = GRUB_VIDEO_FBSTD_NUMCOLORS
+  },
+  {
+    .width = 640,
+    .height = 480,
+    .pitch = 640 * 4,
+    GRUB_VIDEO_MI_RGBA8888()
+  },
+  {
+    .width = 800,
+    .height = 600,
+    .pitch = 800 * 4,
+    GRUB_VIDEO_MI_RGBA8888()
+  },
+  {
+    .width = 1024,
+    .height = 768,
+    .pitch = 1024 * 4,
+    GRUB_VIDEO_MI_RGBA8888()
+  },
+  {
+    .width = 2560,
+    .height = 1440,
+    .pitch = 2560 * 4,
+    GRUB_VIDEO_MI_RGBA8888()
+  },
+  {
+    .width = 640,
+    .height = 480,
+    .pitch = 640,
+    .mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR,
+    .bpp = 8,
+    .bytes_per_pixel = 1,
+    .number_of_colors = GRUB_VIDEO_FBSTD_EXT_NUMCOLORS
+  },
+  {
+    .width = 800,
+    .height = 600,
+    .pitch = 800,
+    .mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR,
+    .bpp = 8,
+    .bytes_per_pixel = 1,
+    .number_of_colors = GRUB_VIDEO_FBSTD_EXT_NUMCOLORS
+  },
+  {
+    .width = 1024,
+    .height = 768,
+    .pitch = 1024,
+    .mode_type = GRUB_VIDEO_MODE_TYPE_INDEX_COLOR,
+    .bpp = 8,
+    .bytes_per_pixel = 1,
+    .number_of_colors = GRUB_VIDEO_FBSTD_EXT_NUMCOLORS
+  },
+
+
+
+
+  {
+    .width = 640,
+    .height = 480,
+    .pitch = 1280,
+    GRUB_VIDEO_MI_RGB555 ()
+  },
+  {
+    .width = 800,
+    .height = 600,
+    .pitch = 1600,
+    GRUB_VIDEO_MI_RGB555 ()
+  },
+  {
+    .width = 1024,
+    .height = 768,
+    .pitch = 2048,
+    GRUB_VIDEO_MI_RGB555 ()
+  },
+  {
+    .width = 640,
+    .height = 480,
+    .pitch = 1280,
+    GRUB_VIDEO_MI_RGB565 ()
+  },
+  {
+    .width = 800,
+    .height = 600,
+    .pitch = 1600,
+    GRUB_VIDEO_MI_RGB565 ()
+  },
+  {
+    .width = 1024,
+    .height = 768,
+    .pitch = 2048,
+    GRUB_VIDEO_MI_RGB565 ()
+  },
+  {
+    .width = 640,
+    .height = 480,
+    .pitch = 640 * 3,
+    GRUB_VIDEO_MI_RGB888 ()
+  },
+  {
+    .width = 800,
+    .height = 600,
+    .pitch = 800 * 3,
+    GRUB_VIDEO_MI_RGB888 ()
+  },
+  {
+    .width = 1024,
+    .height = 768,
+    .pitch = 1024 * 3,
+    GRUB_VIDEO_MI_RGB888 ()
+  },
+  {
+    .width = 640,
+    .height = 480,
+    .pitch = 1280,
+    GRUB_VIDEO_MI_BGR555 ()
+  },
+  {
+    .width = 800,
+    .height = 600,
+    .pitch = 1600,
+    GRUB_VIDEO_MI_BGR555 ()
+  },
+  {
+    .width = 1024,
+    .height = 768,
+    .pitch = 2048,
+    GRUB_VIDEO_MI_BGR555 ()
+  },
+  {
+    .width = 640,
+    .height = 480,
+    .pitch = 1280,
+    GRUB_VIDEO_MI_BGR565 ()
+  },
+  {
+    .width = 800,
+    .height = 600,
+    .pitch = 1600,
+    GRUB_VIDEO_MI_BGR565 ()
+  },
+  {
+    .width = 1024,
+    .height = 768,
+    .pitch = 2048,
+    GRUB_VIDEO_MI_BGR565 ()
+  },
+  {
+    .width = 640,
+    .height = 480,
+    .pitch = 640 * 3,
+    GRUB_VIDEO_MI_BGR888 ()
+  },
+  {
+    .width = 800,
+    .height = 600,
+    .pitch = 800 * 3,
+    GRUB_VIDEO_MI_BGR888 ()
+  },
+  {
+    .width = 1024,
+    .height = 768,
+    .pitch = 1024 * 3,
+    GRUB_VIDEO_MI_BGR888 ()
+  },
+  {
+    .width = 640,
+    .height = 480,
+    .pitch = 640 * 4,
+    GRUB_VIDEO_MI_BGRA8888()
+  },
+  {
+    .width = 800,
+    .height = 600,
+    .pitch = 800 * 4,
+    GRUB_VIDEO_MI_BGRA8888()
+  },
+  {
+    .width = 1024,
+    .height = 768,
+    .pitch = 1024 * 4,
+    GRUB_VIDEO_MI_BGRA8888()
+  },
+};
+
+#ifdef GRUB_MACHINE_EMU
+#include <grub/emu/hostfile.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;
+} GRUB_PACKED;
+
+static void
+grub_video_capture_write_bmp (const char *fname,
+			      void *ptr,
+			      const struct grub_video_mode_info *mode_info)
+{
+  grub_util_fd_t fd = grub_util_fd_open (fname, GRUB_UTIL_FD_O_WRONLY | GRUB_UTIL_FD_O_CREATTRUNC);
+  struct bmp_header head;
+
+  if (!GRUB_UTIL_FD_IS_VALID (fd))
+    {
+      grub_printf (_("cannot open `%s': %s"),
+		   fname, grub_util_fd_strerror ());
+    }
+
+  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_compile_time (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_compile_time (sizeof (head) + 3 * 256);
+      head.bpp = grub_cpu_to_le16_compile_time (8);
+    }
+  head.head_size = grub_cpu_to_le32_compile_time (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);
+
+  grub_util_fd_write (fd, (char *) &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;
+
+	  grub_util_fd_write (fd, (char *) &b, 1);
+	  grub_util_fd_write (fd, (char *) &g, 1);
+	  grub_util_fd_write (fd, (char *) &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 = xcalloc (3, mode_info->width);
+	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 *) ptr + (mode_info->pitch / 4) * 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;
+	      }
+	    grub_util_fd_write (fd, (char *) buffer, mode_info->width * 3);
+	  }
+	grub_free (buffer);
+	break;
+      }
+    case 3:
+      {
+	grub_uint8_t *buffer = xcalloc (3, mode_info->width);
+	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;
+	      }
+	    grub_util_fd_write (fd, (char *) buffer, mode_info->width * 3);
+	  }
+	grub_free (buffer);
+	break;
+      }
+    case 2:
+      {
+	grub_uint8_t *buffer = xcalloc (3, mode_info->width);
+	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 *) ptr + (mode_info->pitch / 2) * 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;
+	      }
+	    grub_util_fd_write (fd, (char *) buffer, mode_info->width * 3);
+	  }
+	grub_free (buffer);
+	break;
+      }
+    case 1:
+      {
+	int y;
+
+	for (y = mode_info->height - 1; y >= 0; y--)
+	  grub_util_fd_write (fd, ((char *) ptr + mode_info->pitch * y),
+			      mode_info->width);
+	break;
+      }
+    }
+  grub_util_fd_close (fd);
+}
+
+#endif
+
+const char *
+grub_video_checksum_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), "bgra%d%d%d%d", capt_mode_info.blue_mask_size,
+		     capt_mode_info.green_mask_size,
+		     capt_mode_info.red_mask_size,
+		     capt_mode_info.reserved_mask_size);
+      return buf;
+    }
+  grub_snprintf (buf, sizeof (buf), "rgba%d%d%d%d", capt_mode_info.red_mask_size,
+		 capt_mode_info.green_mask_size,
+		 capt_mode_info.blue_mask_size,
+		 capt_mode_info.reserved_mask_size);
+  return buf;
+}
+
+#define GENERATE_MODE 1
+//#define SAVE_ALL_IMAGES
+//#define COLLECT_TIME_STATISTICS 1
+
+#if defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU)
+grub_util_fd_t genfd = GRUB_UTIL_FD_INVALID;
+#endif
+
+#include <grub/time.h>
+
+static void
+write_time (void)
+{
+#if defined (GRUB_MACHINE_EMU) && defined (COLLECT_TIME_STATISTICS)
+  char buf[60];
+  static grub_uint64_t prev;
+  grub_uint64_t cur;
+  static grub_util_fd_t tmrfd = GRUB_UTIL_FD_INVALID;
+  if (!GRUB_UTIL_FD_IS_VALID (tmrfd))
+    tmrfd = grub_util_fd_open ("time.txt", GRUB_UTIL_FD_O_WRONLY
+			       | GRUB_UTIL_FD_O_CREATTRUNC);
+
+  cur = grub_util_get_cpu_time_ms ();
+  grub_snprintf (buf, sizeof (buf), "%s_%dx%dx%s:%d: %" PRIuGRUB_UINT64_T " ms\n",
+		 basename, 			
+		 capt_mode_info.width,
+		 capt_mode_info.height, 
+		 grub_video_checksum_get_modename (), ctr,
+		 cur - prev);
+  prev = cur;
+  if (GRUB_UTIL_FD_IS_VALID (tmrfd))
+    grub_util_fd_write (tmrfd, buf, grub_strlen (buf));
+#endif
+}
+
+
+static void
+checksum (void)
+{
+  void *ptr;
+  grub_uint32_t crc = 0;
+
+  ptr = grub_video_capture_get_framebuffer ();
+
+  write_time ();
+
+#ifdef GRUB_CPU_WORDS_BIGENDIAN
+  switch (capt_mode_info.bytes_per_pixel)
+    {
+    case 1:
+      crc = grub_getcrc32c (0, ptr, capt_mode_info.pitch
+			    * capt_mode_info.height);
+      break;
+    case 2:
+      {
+	unsigned x, y, rowskip;
+	grub_uint8_t *iptr = ptr;
+	crc = 0;
+	rowskip = capt_mode_info.pitch - capt_mode_info.width * 2;
+	for (y = 0; y < capt_mode_info.height; y++)
+	  {
+	    for (x = 0; x < capt_mode_info.width; x++)
+	      {
+		crc = grub_getcrc32c (crc, iptr + 1, 1);
+		crc = grub_getcrc32c (crc, iptr, 1);
+		iptr += 2;
+	      }
+	    crc = grub_getcrc32c (crc, iptr, rowskip);
+	    iptr += rowskip;
+	  }
+	break;
+      }
+    case 3:
+      {
+	unsigned x, y, rowskip;
+	grub_uint8_t *iptr = ptr;
+	crc = 0;
+	rowskip = capt_mode_info.pitch - capt_mode_info.width * 3;
+	for (y = 0; y < capt_mode_info.height; y++)
+	  {
+	    for (x = 0; x < capt_mode_info.width; x++)
+	      {
+		crc = grub_getcrc32c (crc, iptr + 2, 1);
+		crc = grub_getcrc32c (crc, iptr + 1, 1);
+		crc = grub_getcrc32c (crc, iptr, 1);
+		iptr += 3;
+	      }
+	    crc = grub_getcrc32c (crc, iptr, rowskip);
+	    iptr += rowskip;
+	  }
+	break;
+      }
+    case 4:
+      {
+	unsigned x, y, rowskip;
+	grub_uint8_t *iptr = ptr;
+	crc = 0;
+	rowskip = capt_mode_info.pitch - capt_mode_info.width * 4;
+	for (y = 0; y < capt_mode_info.height; y++)
+	  {
+	    for (x = 0; x < capt_mode_info.width; x++)
+	      {
+		crc = grub_getcrc32c (crc, iptr + 3, 1);
+		crc = grub_getcrc32c (crc, iptr + 2, 1);
+		crc = grub_getcrc32c (crc, iptr + 1, 1);
+		crc = grub_getcrc32c (crc, iptr, 1);
+		iptr += 4;
+	      }
+	    crc = grub_getcrc32c (crc, iptr, rowskip);
+	    iptr += rowskip;
+	  }
+	break;
+      }
+    }
+#else
+  crc = grub_getcrc32c (0, ptr, capt_mode_info.pitch * capt_mode_info.height);
+#endif
+
+#if defined (GENERATE_MODE) && defined (GRUB_MACHINE_EMU)
+  if (GRUB_UTIL_FD_IS_VALID (genfd))
+    {
+      char buf[20];
+      grub_snprintf (buf, sizeof (buf), "0x%x, ", crc);
+      grub_util_fd_write (genfd, buf, grub_strlen (buf));
+    }
+#endif
+
+  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, 
+			grub_video_checksum_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,
+			grub_video_checksum_get_modename (),
+			ctr, crc, checksums[ctr]);
+    }
+#if !(defined (SAVE_ALL_IMAGES) && defined (GRUB_MACHINE_EMU))
+  else
+    {
+      write_time ();
+      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,
+			       grub_video_checksum_get_modename (),
+			       ctr);
+  grub_video_capture_write_bmp (name, ptr, &capt_mode_info);
+  grub_free (name);
+#endif
+
+  write_time ();
+
+  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.h"
+};
+
+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 (!GRUB_UTIL_FD_IS_VALID (genfd))
+    genfd = grub_util_fd_open ("checksums.h", GRUB_UTIL_FD_O_WRONLY
+			       | GRUB_UTIL_FD_O_CREATTRUNC);
+  if (GRUB_UTIL_FD_IS_VALID (genfd))
+    {
+      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,
+		     grub_video_checksum_get_modename ());
+
+      grub_util_fd_write (genfd, "  { \"", 5);
+      grub_util_fd_write (genfd, basename_in, grub_strlen (basename_in));
+      grub_util_fd_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 (GRUB_UTIL_FD_IS_VALID (genfd))
+    {
+      char buf[40];
+      grub_snprintf (buf, sizeof (buf), "}, %d },\n", ctr);
+      grub_util_fd_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,
+		    grub_video_checksum_get_modename (),
+		    ctr, nchk);
+  grub_free (basename);
+  basename = 0;
+  nchk = 0;
+  checksums = 0;
+  ctr = 0;
+  grub_video_capture_refresh_cb = 0;
+}
+
+static struct grub_term_output *saved_outputs;
+static struct grub_term_output *saved_gfxnext;
+static struct grub_term_output *gfxterm;
+static int use_gfxterm = 0;
+
+int
+grub_test_use_gfxterm (void)
+{
+  FOR_ACTIVE_TERM_OUTPUTS (gfxterm)
+    if (grub_strcmp (gfxterm->name, "gfxterm") == 0)
+      break;
+  if (!gfxterm)
+    FOR_DISABLED_TERM_OUTPUTS (gfxterm)
+      if (grub_strcmp (gfxterm->name, "gfxterm") == 0)
+	break;
+
+  if (!gfxterm)
+    {
+      grub_test_assert (0, "terminal `%s' isn't found", "gfxterm");
+      return 1;
+    }
+
+  if (gfxterm->init (gfxterm))
+    { 
+      grub_test_assert (0, "terminal `%s' failed: %s", "gfxterm", grub_errmsg);
+      return 1;
+    }
+
+  saved_outputs = grub_term_outputs;
+  saved_gfxnext = gfxterm->next;
+  grub_term_outputs = gfxterm;
+  gfxterm->next = 0;
+  use_gfxterm = 1;
+
+  return 0;
+}
+
+void
+grub_test_use_gfxterm_end (void)
+{
+  if (!use_gfxterm)
+    return;
+  use_gfxterm = 0;
+  gfxterm->fini (gfxterm);
+  gfxterm->next = saved_gfxnext;
+  grub_term_outputs = saved_outputs;
+  saved_outputs = 0;
+  saved_gfxnext = 0;
+}
diff --git a/grub-core/tests/videotest_checksum.c b/grub-core/tests/videotest_checksum.c
new file mode 100644
index 0000000..a4bff5e
--- /dev/null
+++ b/grub-core/tests/videotest_checksum.c
@@ -0,0 +1,80 @@
+/*
+ *  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/video_fb.h>
+#include <grub/command.h>
+#include <grub/font.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+#define FONT_NAME "Unknown Regular 16"
+
+/* Functional test main method.  */
+static void
+videotest_checksum (void)
+{
+  unsigned i;
+  grub_font_t font;
+
+  font = grub_font_get (FONT_NAME);
+  if (font && grub_strcmp (font->name, FONT_NAME) != 0)
+    font = 0;
+  if (!font)
+    font = grub_font_load ("unicode");
+
+  if (!font)
+    {
+      grub_test_assert (0, "unicode font not found: %s", grub_errmsg);
+      return;
+    }
+
+  for (i = 0; i < ARRAY_SIZE (grub_test_video_modes); i++)
+    {
+      grub_err_t err;
+#if defined (GRUB_MACHINE_MIPS_QEMU_MIPS) || defined (GRUB_MACHINE_IEEE1275)
+      if (grub_test_video_modes[i].width > 1024)
+	continue;
+#endif
+      err = grub_video_capture_start (&grub_test_video_modes[i],
+				      grub_video_fbstd_colors,
+				      grub_test_video_modes[i].number_of_colors);
+      if (err)
+	{
+	  grub_test_assert (0, "can't start capture: %s", grub_errmsg);
+	  grub_print_error ();
+	  continue;
+	}
+      grub_terminal_input_fake_sequence ((int []) { '\n' }, 1);
+
+      grub_video_checksum ("videotest");
+
+      char *args[] = { 0 };
+      grub_command_execute ("videotest", 0, args);
+
+      grub_terminal_input_fake_sequence_end ();
+      grub_video_checksum_end ();
+      grub_video_capture_end ();
+    }
+}
+
+/* Register example_test method as a functional test.  */
+GRUB_FUNCTIONAL_TEST (videotest_checksum, videotest_checksum);
diff --git a/grub-core/tests/xnu_uuid_test.c b/grub-core/tests/xnu_uuid_test.c
new file mode 100644
index 0000000..d500145
--- /dev/null
+++ b/grub-core/tests/xnu_uuid_test.c
@@ -0,0 +1,58 @@
+/*
+ *  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/time.h>
+#include <grub/misc.h>
+#include <grub/dl.h>
+#include <grub/command.h>
+#include <grub/env.h>
+#include <grub/test.h>
+#include <grub/mm.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+static void
+xnu_uuid_test (void)
+{
+  grub_command_t cmd;
+  cmd = grub_command_find ("xnu_uuid");
+  char *args[] = { (char *) "fedcba98", (char *) "tstvar", NULL };
+  const char *val;
+
+  if (!cmd)
+    {
+      grub_test_assert (0, "can't find command `%s'", "xnu_uuid");
+      return;
+    }
+  if ((cmd->func) (cmd, 2, args))
+    {
+      grub_test_assert (0, "%d: %s", grub_errno, grub_errmsg);
+      return;
+    }
+
+  val = grub_env_get ("tstvar");
+  if (!val)
+    {
+      grub_test_assert (0, "tstvar isn't set");
+      return;
+    }
+  grub_test_assert (grub_strcmp (val, "944F9DED-DBED-391C-9402-77C8CEE04173")
+		    == 0, "UUIDs don't match");
+}
+
+GRUB_FUNCTIONAL_TEST (xnu_uuid_test, xnu_uuid_test);