tests.build source code

1 module tests.build;
2 
3 import unit_threaded;
4 import reggae;
5 
6 
7 void testIsLeaf() {
8     Target("tgt").isLeaf.shouldBeTrue;
9     Target("other", "", [Target("foo"), Target("bar")]).isLeaf.shouldBeFalse;
10     Target("implicits", "", [], [Target("foo")]).isLeaf.shouldBeFalse;
11 }
12 
13 
14 void testInOut() {
15     //Tests that specifying $in and $out in the command string gets substituted correctly
16     {
17         const target = Target("foo",
18                               "createfoo -o $out $in",
19                               [Target("bar.txt"), Target("baz.txt")]);
20         target.expandCommand.shouldEqual("createfoo -o foo bar.txt baz.txt");
21     }
22     {
23         const target = Target("tgt",
24                               "gcc -o $out $in",
25                               [
26                                   Target("src1.o", "gcc -c -o $out $in", [Target("src1.c")]),
27                                   Target("src2.o", "gcc -c -o $out $in", [Target("src2.c")])
28                                   ],
29             );
30         target.expandCommand.shouldEqual("gcc -o tgt src1.o src2.o");
31     }
32 
33     {
34         const target = Target(["proto.h", "proto.c"],
35                               "protocompile $out -i $in",
36                               [Target("proto.idl")]);
37         target.expandCommand.shouldEqual("protocompile proto.h proto.c -i proto.idl");
38     }
39 
40     {
41         const target = Target("lib1.a",
42                               "ar -o$out $in",
43                               [Target(["foo1.o", "foo2.o"], "cmd", [Target("tmp")]),
44                                Target("bar.o"),
45                                Target("baz.o")]);
46         target.expandCommand.shouldEqual("ar -olib1.a foo1.o foo2.o bar.o baz.o");
47     }
48 }
49 
50 
51 void testProject() {
52     const target = Target("foo",
53                           "makefoo -i $in -o $out -p $project",
54                           [Target("bar"), Target("baz")]);
55     target.expandCommand("/tmp").shouldEqual("makefoo -i /tmp/bar /tmp/baz -o foo -p /tmp");
56 }
57 
58 
59 void testMultipleOutputs() {
60     const target = Target(["foo.hpp", "foo.cpp"], "protocomp $in", [Target("foo.proto")]);
61     target.outputs.shouldEqual(["foo.hpp", "foo.cpp"]);
62     target.expandCommand("myproj").shouldEqual("protocomp myproj/foo.proto");
63 
64     const bld = Build(target);
65     bld.targets[0].outputs.shouldEqual(["foo.hpp", "foo.cpp"]);
66 }
67 
68 
69 void testEnclose() {
70 
71     Target("foo.o", "", [Target("foo.c")]).enclose(Target("theapp")).shouldEqual(
72             Target("objs/theapp.objs/foo.o", "", [Target("foo.c")]));
73 
74     Target("$builddir/bar.o", "", [Target("bar.c")]).enclose(Target("theapp")).shouldEqual(
75         Target("bar.o", "", [Target("bar.c")]));
76 
77     const leafTarget = Target("foo.c");
78     leafTarget.enclose(Target("theapp")).shouldEqual(leafTarget);
79 }
80 
81 
82 void testMultipleOutputsImplicits() {
83     const protoSrcs = Target([`$builddir/gen/protocol.c`, `$builddir/gen/protocol.h`],
84                              `./compiler $in`,
85                              [Target(`protocol.proto`)]);
86     const protoObj = Target(`$builddir/bin/protocol.o`,
87                             `gcc -o $out -c $builddir/gen/protocol.c`,
88                             [], [protoSrcs]);
89     const protoD = Target(`$builddir/gen/protocol.d`,
90                           `echo "extern(C) " > $out; cat $builddir/gen/protocol.h >> $out`,
91                           [], [protoSrcs]);
92     const app = Target(`app`,
93                        `dmd -of$out $in`,
94                        [Target(`src/main.d`), protoObj, protoD]);
95     const build = Build(app);
96 
97     const newProtoSrcs = Target([`gen/protocol.c`, `gen/protocol.h`],
98                                 `./compiler $in`,
99                                 [Target(`protocol.proto`)]);
100     const newProtoD = Target(`gen/protocol.d`,
101                              `echo "extern(C) " > $out; cat gen/protocol.h >> $out`,
102                              [], [newProtoSrcs]);
103 
104     build.targets.shouldEqual(
105         [Target("app", "dmd -of$out $in",
106                 [Target("src/main.d"),
107                  Target("bin/protocol.o", "gcc -o $out -c gen/protocol.c",
108                         [], [newProtoSrcs]),
109                  newProtoD])]
110         );
111 }