view release on metacpan or  search on metacpan

t/00-basic.t  view on Meta::CPAN

8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
use ELF::Writer;
use ELF::Writer::Linux_x86;
use ELF::Writer::Linux_x86_64;
 
subtest enums => \&test_enums;
sub test_enums {
        my $elf;
         
        for (qw: executable shared relocatable core :) {
                $elf= ELF::Writer->new(type => $_);
                is( $elf->type_sym, $_, "enum type=$_ decoded" );
                is( $elf->type, $ELF::Writer::type_from_sym{$_}, "enum type=$_ correct value" );
        }
        $elf= ELF::Writer->new(type => 42);
        is( $elf->type, 42, "enum type=42 allowed" );
        is( $elf->type_sym, 42, "enum type=42 decoded as self" );
         
        for (qw: 32bit 64bit :) {
                $elf= ELF::Writer->new(class => $_);
                is( $elf->class_sym, $_, "enum class=$_ decoded" );
                is( $elf->class, $ELF::Writer::class_from_sym{$_}, "enum class=$_ correct value" );
        }
         
        for (qw: 2LSB 2MSB :) {
                $elf= ELF::Writer->new(data => $_);
                is( $elf->data_sym, $_, "enum data=$_ decoded" );
                is( $elf->data, $ELF::Writer::data_from_sym{$_}, "enum data=$_ correct value" );
        }
         
        for (qw: Linux Solaris :) {
                $elf= ELF::Writer->new(osabi => $_);
                is( $elf->osabi_sym, $_, "enum osabi=$_ decoded" );
                is( $elf->osabi, $ELF::Writer::osabi_from_sym{$_}, "enum osabi=$_ correct value" );
        }
         
        for (qw: x86-64 :) {
                $elf= ELF::Writer->new(machine => $_);
                is( $elf->machine_sym, $_, "enum machine=$_ decoded" );
                is( $elf->machine, $ELF::Writer::machine_from_sym{$_}, "enum machine=$_ correct value" );
        }
         
        for (qw: note :) {
                my $seg= ELF::Writer::Segment->new(type => $_);
                is( $seg->type_sym, $_, "enum segment.type=$_ decoded" );
                is( $seg->type, $ELF::Writer::Segment::type_from_sym{$_}, "enum segment.type=$_ correct value" );
        }
};
 
subtest simple_x86_64_elf => \&test_return_42;
sub test_return_42 {
        my $elf= ELF::Writer::Linux_x86_64->new(
                type => 'executable',
                segments => [{
                        offset      => 0, # overlap segment with elf header