From 6e7a315eb67cb6c113cf37e1d66c4f11a51a2b3e Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 18:29:51 +0200 Subject: Adding upstream version 2.06. Signed-off-by: Daniel Baumann --- grub-core/tests/boot/kbsd.init-i386.S | 107 ++++ grub-core/tests/boot/kbsd.init-x86_64.S | 94 ++++ grub-core/tests/boot/kbsd.spec.txt | 3 + grub-core/tests/boot/kernel-8086.S | 50 ++ grub-core/tests/boot/kernel-i386.S | 72 +++ grub-core/tests/boot/kfreebsd-aout.cfg | 4 + grub-core/tests/boot/kfreebsd.cfg | 8 + grub-core/tests/boot/kfreebsd.init-i386.S | 109 ++++ grub-core/tests/boot/kfreebsd.init-x86_64.S | 90 +++ grub-core/tests/boot/knetbsd.cfg | 5 + grub-core/tests/boot/kopenbsd.cfg | 5 + grub-core/tests/boot/kopenbsdlabel.txt | 3 + grub-core/tests/boot/linux-ppc.cfg | 5 + grub-core/tests/boot/linux.cfg | 5 + grub-core/tests/boot/linux.init-i386.S | 61 +++ grub-core/tests/boot/linux.init-mips.S | 61 +++ grub-core/tests/boot/linux.init-ppc.S | 61 +++ grub-core/tests/boot/linux.init-x86_64.S | 60 ++ grub-core/tests/boot/linux16.cfg | 5 + grub-core/tests/boot/multiboot.cfg | 4 + grub-core/tests/boot/multiboot2.cfg | 4 + grub-core/tests/boot/ntldr.cfg | 4 + grub-core/tests/boot/pc-chainloader.cfg | 4 + grub-core/tests/boot/qemu-shutdown-x86.S | 17 + grub-core/tests/bswap_test.c | 121 +++++ grub-core/tests/checksums.h | 129 +++++ grub-core/tests/cmdline_cat_test.c | 125 +++++ grub-core/tests/cmp_test.c | 190 +++++++ grub-core/tests/ctz_test.c | 111 ++++ grub-core/tests/div_test.c | 189 +++++++ grub-core/tests/example_functional_test.c | 38 ++ grub-core/tests/fake_input.c | 75 +++ grub-core/tests/gfxterm_menu.c | 180 ++++++ grub-core/tests/legacy_password_test.c | 68 +++ grub-core/tests/lib/functional_test.c | 105 ++++ grub-core/tests/lib/test.c | 239 ++++++++ grub-core/tests/mul_test.c | 73 +++ grub-core/tests/pbkdf2_test.c | 97 ++++ grub-core/tests/setjmp_test.c | 80 +++ grub-core/tests/shift_test.c | 157 ++++++ grub-core/tests/signature_test.c | 170 ++++++ grub-core/tests/signatures.h | 211 ++++++++ grub-core/tests/sleep_test.c | 51 ++ grub-core/tests/strtoull_test.c | 63 +++ grub-core/tests/test_blockarg.c | 55 ++ grub-core/tests/video_checksum.c | 813 ++++++++++++++++++++++++++++ grub-core/tests/videotest_checksum.c | 80 +++ grub-core/tests/xnu_uuid_test.c | 58 ++ 48 files changed, 4319 insertions(+) create mode 100644 grub-core/tests/boot/kbsd.init-i386.S create mode 100644 grub-core/tests/boot/kbsd.init-x86_64.S create mode 100644 grub-core/tests/boot/kbsd.spec.txt create mode 100644 grub-core/tests/boot/kernel-8086.S create mode 100644 grub-core/tests/boot/kernel-i386.S create mode 100644 grub-core/tests/boot/kfreebsd-aout.cfg create mode 100644 grub-core/tests/boot/kfreebsd.cfg create mode 100644 grub-core/tests/boot/kfreebsd.init-i386.S create mode 100644 grub-core/tests/boot/kfreebsd.init-x86_64.S create mode 100644 grub-core/tests/boot/knetbsd.cfg create mode 100644 grub-core/tests/boot/kopenbsd.cfg create mode 100644 grub-core/tests/boot/kopenbsdlabel.txt create mode 100644 grub-core/tests/boot/linux-ppc.cfg create mode 100644 grub-core/tests/boot/linux.cfg create mode 100644 grub-core/tests/boot/linux.init-i386.S create mode 100644 grub-core/tests/boot/linux.init-mips.S create mode 100644 grub-core/tests/boot/linux.init-ppc.S create mode 100644 grub-core/tests/boot/linux.init-x86_64.S create mode 100644 grub-core/tests/boot/linux16.cfg create mode 100644 grub-core/tests/boot/multiboot.cfg create mode 100644 grub-core/tests/boot/multiboot2.cfg create mode 100644 grub-core/tests/boot/ntldr.cfg create mode 100644 grub-core/tests/boot/pc-chainloader.cfg create mode 100644 grub-core/tests/boot/qemu-shutdown-x86.S create mode 100644 grub-core/tests/bswap_test.c create mode 100644 grub-core/tests/checksums.h create mode 100644 grub-core/tests/cmdline_cat_test.c create mode 100644 grub-core/tests/cmp_test.c create mode 100644 grub-core/tests/ctz_test.c create mode 100644 grub-core/tests/div_test.c create mode 100644 grub-core/tests/example_functional_test.c create mode 100644 grub-core/tests/fake_input.c create mode 100644 grub-core/tests/gfxterm_menu.c create mode 100644 grub-core/tests/legacy_password_test.c create mode 100644 grub-core/tests/lib/functional_test.c create mode 100644 grub-core/tests/lib/test.c create mode 100644 grub-core/tests/mul_test.c create mode 100644 grub-core/tests/pbkdf2_test.c create mode 100644 grub-core/tests/setjmp_test.c create mode 100644 grub-core/tests/shift_test.c create mode 100644 grub-core/tests/signature_test.c create mode 100644 grub-core/tests/signatures.h create mode 100644 grub-core/tests/sleep_test.c create mode 100644 grub-core/tests/strtoull_test.c create mode 100644 grub-core/tests/test_blockarg.c create mode 100644 grub-core/tests/video_checksum.c create mode 100644 grub-core/tests/videotest_checksum.c create mode 100644 grub-core/tests/xnu_uuid_test.c (limited to 'grub-core/tests') 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 . + */ + +#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 . + */ + +#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 +#elif defined (TARGET_MULTIBOOT) +#include +#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 . + */ + +#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 . + */ + +#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 . + */ + +#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 . + */ + +#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 . + */ + +#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 . + */ + +#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 . + */ + +#include +#include +#include + +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 . + */ + +/* All tests need to include test.h for GRUB testing framework. */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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 . + */ + +#include +#include +#include + +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 . + */ + +#include +#include +#include + +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 . + */ + +#include +#include +#include + +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 . + */ + +/* All tests need to include test.h for GRUB testing framework. */ +#include +#include + +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 . + */ + +#include +#include +#include +#include + +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 . + */ + +/* All tests need to include test.h for GRUB testing framework. */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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 . + */ + +#include +#include +#include +#include +#include +#include + +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 . + */ + +#include +#include +#include +#include +#include + +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 . + */ + +#include +#include +#include + +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 ? : ""); + if (!failure->file) + { + grub_free(failure); + return NULL; + } + + failure->funp = grub_strdup (funp ? : ""); + 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 ? : ""), + (failure->funp ? : ""), + failure->line, (failure->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 . + */ + +#include +#include +#include + +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 . + */ + +#include +#include +#include +#include + +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 . + */ + +#include +#include +#include + +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 . + */ + +#include +#include +#include + +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 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#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 . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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 . + */ + +#include +#include + +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 . + */ + +#include +#include +#include +#include +#include +#include + +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 . + */ + +/* All tests need to include test.h for GRUB testing framework. */ + +#include + +#include +#include +#include +#include +#include +#include +#ifdef GRUB_MACHINE_EMU +#include +#include +#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 + +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 + +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 . + */ + +/* All tests need to include test.h for GRUB testing framework. */ +#include +#include +#include +#include +#include +#include + +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 . + */ + +#include +#include +#include +#include +#include +#include +#include + +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); -- cgit v1.2.3