Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 1 | // Copyright 2019 Google Inc. All rights reserved. |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | // you may not use this file except in compliance with the License. |
| 5 | // You may obtain a copy of the License at |
| 6 | // |
| 7 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | // See the License for the specific language governing permissions and |
| 13 | // limitations under the License. |
| 14 | |
| 15 | package android |
| 16 | |
| 17 | import ( |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 18 | "fmt" |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 19 | "path/filepath" |
| 20 | "reflect" |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 21 | "strings" |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 22 | "testing" |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 23 | |
| 24 | "github.com/google/blueprint" |
| 25 | |
| 26 | "android/soong/shared" |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 27 | ) |
| 28 | |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 29 | func pathContext() PathContext { |
| 30 | return PathContextForTesting(TestConfig("out", nil), |
| 31 | map[string][]byte{ |
| 32 | "ld": nil, |
| 33 | "a.o": nil, |
| 34 | "b.o": nil, |
| 35 | "cp": nil, |
| 36 | "a": nil, |
| 37 | "b": nil, |
| 38 | "ls": nil, |
| 39 | "turbine": nil, |
| 40 | "java": nil, |
| 41 | }) |
| 42 | } |
| 43 | |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 44 | func ExampleRuleBuilder() { |
| 45 | rule := NewRuleBuilder() |
| 46 | |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 47 | ctx := pathContext() |
| 48 | |
| 49 | rule.Command(). |
| 50 | Tool(PathForSource(ctx, "ld")). |
| 51 | Inputs(PathsForTesting("a.o", "b.o")). |
| 52 | FlagWithOutput("-o ", PathForOutput(ctx, "linked")) |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 53 | rule.Command().Text("echo success") |
| 54 | |
| 55 | // To add the command to the build graph: |
| 56 | // rule.Build(pctx, ctx, "link", "link") |
| 57 | |
| 58 | fmt.Printf("commands: %q\n", strings.Join(rule.Commands(), " && ")) |
| 59 | fmt.Printf("tools: %q\n", rule.Tools()) |
| 60 | fmt.Printf("inputs: %q\n", rule.Inputs()) |
| 61 | fmt.Printf("outputs: %q\n", rule.Outputs()) |
| 62 | |
| 63 | // Output: |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 64 | // commands: "ld a.o b.o -o out/linked && echo success" |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 65 | // tools: ["ld"] |
| 66 | // inputs: ["a.o" "b.o"] |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 67 | // outputs: ["out/linked"] |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 68 | } |
| 69 | |
Colin Cross | 5cb5b09 | 2019-02-02 21:25:18 -0800 | [diff] [blame] | 70 | func ExampleRuleBuilder_Temporary() { |
| 71 | rule := NewRuleBuilder() |
| 72 | |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 73 | ctx := pathContext() |
| 74 | |
| 75 | rule.Command(). |
| 76 | Tool(PathForSource(ctx, "cp")). |
| 77 | Input(PathForSource(ctx, "a")). |
| 78 | Output(PathForOutput(ctx, "b")) |
| 79 | rule.Command(). |
| 80 | Tool(PathForSource(ctx, "cp")). |
| 81 | Input(PathForOutput(ctx, "b")). |
| 82 | Output(PathForOutput(ctx, "c")) |
| 83 | rule.Temporary(PathForOutput(ctx, "b")) |
Colin Cross | 5cb5b09 | 2019-02-02 21:25:18 -0800 | [diff] [blame] | 84 | |
| 85 | fmt.Printf("commands: %q\n", strings.Join(rule.Commands(), " && ")) |
| 86 | fmt.Printf("tools: %q\n", rule.Tools()) |
| 87 | fmt.Printf("inputs: %q\n", rule.Inputs()) |
| 88 | fmt.Printf("outputs: %q\n", rule.Outputs()) |
| 89 | |
| 90 | // Output: |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 91 | // commands: "cp a out/b && cp out/b out/c" |
Colin Cross | 5cb5b09 | 2019-02-02 21:25:18 -0800 | [diff] [blame] | 92 | // tools: ["cp"] |
| 93 | // inputs: ["a"] |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 94 | // outputs: ["out/c"] |
Colin Cross | 5cb5b09 | 2019-02-02 21:25:18 -0800 | [diff] [blame] | 95 | } |
| 96 | |
| 97 | func ExampleRuleBuilder_DeleteTemporaryFiles() { |
| 98 | rule := NewRuleBuilder() |
| 99 | |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 100 | ctx := pathContext() |
| 101 | |
| 102 | rule.Command(). |
| 103 | Tool(PathForSource(ctx, "cp")). |
| 104 | Input(PathForSource(ctx, "a")). |
| 105 | Output(PathForOutput(ctx, "b")) |
| 106 | rule.Command(). |
| 107 | Tool(PathForSource(ctx, "cp")). |
| 108 | Input(PathForOutput(ctx, "b")). |
| 109 | Output(PathForOutput(ctx, "c")) |
| 110 | rule.Temporary(PathForOutput(ctx, "b")) |
Colin Cross | 5cb5b09 | 2019-02-02 21:25:18 -0800 | [diff] [blame] | 111 | rule.DeleteTemporaryFiles() |
| 112 | |
| 113 | fmt.Printf("commands: %q\n", strings.Join(rule.Commands(), " && ")) |
| 114 | fmt.Printf("tools: %q\n", rule.Tools()) |
| 115 | fmt.Printf("inputs: %q\n", rule.Inputs()) |
| 116 | fmt.Printf("outputs: %q\n", rule.Outputs()) |
| 117 | |
| 118 | // Output: |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 119 | // commands: "cp a out/b && cp out/b out/c && rm -f out/b" |
Colin Cross | 5cb5b09 | 2019-02-02 21:25:18 -0800 | [diff] [blame] | 120 | // tools: ["cp"] |
| 121 | // inputs: ["a"] |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 122 | // outputs: ["out/c"] |
Colin Cross | 5cb5b09 | 2019-02-02 21:25:18 -0800 | [diff] [blame] | 123 | } |
| 124 | |
Colin Cross | deabb94 | 2019-02-11 14:11:09 -0800 | [diff] [blame] | 125 | func ExampleRuleBuilder_Installs() { |
| 126 | rule := NewRuleBuilder() |
| 127 | |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 128 | ctx := pathContext() |
| 129 | |
| 130 | out := PathForOutput(ctx, "linked") |
| 131 | |
| 132 | rule.Command(). |
| 133 | Tool(PathForSource(ctx, "ld")). |
| 134 | Inputs(PathsForTesting("a.o", "b.o")). |
| 135 | FlagWithOutput("-o ", out) |
| 136 | rule.Install(out, "/bin/linked") |
| 137 | rule.Install(out, "/sbin/linked") |
Colin Cross | deabb94 | 2019-02-11 14:11:09 -0800 | [diff] [blame] | 138 | |
| 139 | fmt.Printf("rule.Installs().String() = %q\n", rule.Installs().String()) |
| 140 | |
| 141 | // Output: |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 142 | // rule.Installs().String() = "out/linked:/bin/linked out/linked:/sbin/linked" |
Colin Cross | deabb94 | 2019-02-11 14:11:09 -0800 | [diff] [blame] | 143 | } |
| 144 | |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 145 | func ExampleRuleBuilderCommand() { |
| 146 | rule := NewRuleBuilder() |
| 147 | |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 148 | ctx := pathContext() |
| 149 | |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 150 | // chained |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 151 | rule.Command(). |
| 152 | Tool(PathForSource(ctx, "ld")). |
| 153 | Inputs(PathsForTesting("a.o", "b.o")). |
| 154 | FlagWithOutput("-o ", PathForOutput(ctx, "linked")) |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 155 | |
| 156 | // unchained |
| 157 | cmd := rule.Command() |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 158 | cmd.Tool(PathForSource(ctx, "ld")) |
| 159 | cmd.Inputs(PathsForTesting("a.o", "b.o")) |
| 160 | cmd.FlagWithOutput("-o ", PathForOutput(ctx, "linked")) |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 161 | |
| 162 | // mixed: |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 163 | cmd = rule.Command().Tool(PathForSource(ctx, "ld")) |
| 164 | cmd.Inputs(PathsForTesting("a.o", "b.o")) |
| 165 | cmd.FlagWithOutput("-o ", PathForOutput(ctx, "linked")) |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 166 | } |
| 167 | |
| 168 | func ExampleRuleBuilderCommand_Flag() { |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 169 | ctx := pathContext() |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 170 | fmt.Println(NewRuleBuilder().Command(). |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 171 | Tool(PathForSource(ctx, "ls")).Flag("-l")) |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 172 | // Output: |
| 173 | // ls -l |
| 174 | } |
| 175 | |
Colin Cross | 92b7d58 | 2019-03-29 15:32:51 -0700 | [diff] [blame] | 176 | func ExampleRuleBuilderCommand_Flags() { |
| 177 | ctx := pathContext() |
| 178 | fmt.Println(NewRuleBuilder().Command(). |
| 179 | Tool(PathForSource(ctx, "ls")).Flags([]string{"-l", "-a"})) |
| 180 | // Output: |
| 181 | // ls -l -a |
| 182 | } |
| 183 | |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 184 | func ExampleRuleBuilderCommand_FlagWithArg() { |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 185 | ctx := pathContext() |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 186 | fmt.Println(NewRuleBuilder().Command(). |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 187 | Tool(PathForSource(ctx, "ls")). |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 188 | FlagWithArg("--sort=", "time")) |
| 189 | // Output: |
| 190 | // ls --sort=time |
| 191 | } |
| 192 | |
Colin Cross | c7ed004 | 2019-02-11 14:11:09 -0800 | [diff] [blame] | 193 | func ExampleRuleBuilderCommand_FlagForEachArg() { |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 194 | ctx := pathContext() |
Colin Cross | c7ed004 | 2019-02-11 14:11:09 -0800 | [diff] [blame] | 195 | fmt.Println(NewRuleBuilder().Command(). |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 196 | Tool(PathForSource(ctx, "ls")). |
Colin Cross | c7ed004 | 2019-02-11 14:11:09 -0800 | [diff] [blame] | 197 | FlagForEachArg("--sort=", []string{"time", "size"})) |
| 198 | // Output: |
| 199 | // ls --sort=time --sort=size |
| 200 | } |
| 201 | |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 202 | func ExampleRuleBuilderCommand_FlagForEachInput() { |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 203 | ctx := pathContext() |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 204 | fmt.Println(NewRuleBuilder().Command(). |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 205 | Tool(PathForSource(ctx, "turbine")). |
| 206 | FlagForEachInput("--classpath ", PathsForTesting("a.jar", "b.jar"))) |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 207 | // Output: |
| 208 | // turbine --classpath a.jar --classpath b.jar |
| 209 | } |
| 210 | |
| 211 | func ExampleRuleBuilderCommand_FlagWithInputList() { |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 212 | ctx := pathContext() |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 213 | fmt.Println(NewRuleBuilder().Command(). |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 214 | Tool(PathForSource(ctx, "java")). |
| 215 | FlagWithInputList("-classpath=", PathsForTesting("a.jar", "b.jar"), ":")) |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 216 | // Output: |
| 217 | // java -classpath=a.jar:b.jar |
| 218 | } |
| 219 | |
| 220 | func ExampleRuleBuilderCommand_FlagWithInput() { |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 221 | ctx := pathContext() |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 222 | fmt.Println(NewRuleBuilder().Command(). |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 223 | Tool(PathForSource(ctx, "java")). |
| 224 | FlagWithInput("-classpath=", PathForSource(ctx, "a"))) |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 225 | // Output: |
| 226 | // java -classpath=a |
| 227 | } |
| 228 | |
| 229 | func ExampleRuleBuilderCommand_FlagWithList() { |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 230 | ctx := pathContext() |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 231 | fmt.Println(NewRuleBuilder().Command(). |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 232 | Tool(PathForSource(ctx, "ls")). |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 233 | FlagWithList("--sort=", []string{"time", "size"}, ",")) |
| 234 | // Output: |
| 235 | // ls --sort=time,size |
| 236 | } |
| 237 | |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 238 | func TestRuleBuilder(t *testing.T) { |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 239 | fs := map[string][]byte{ |
Colin Cross | 1d2cf04 | 2019-03-29 15:33:06 -0700 | [diff] [blame] | 240 | "dep_fixer": nil, |
| 241 | "input": nil, |
| 242 | "Implicit": nil, |
| 243 | "Input": nil, |
| 244 | "Tool": nil, |
| 245 | "input2": nil, |
| 246 | "tool2": nil, |
| 247 | "input3": nil, |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 248 | } |
| 249 | |
| 250 | ctx := PathContextForTesting(TestConfig("out", nil), fs) |
| 251 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 252 | addCommands := func(rule *RuleBuilder) { |
| 253 | cmd := rule.Command(). |
| 254 | DepFile(PathForOutput(ctx, "DepFile")). |
| 255 | Flag("Flag"). |
| 256 | FlagWithArg("FlagWithArg=", "arg"). |
| 257 | FlagWithDepFile("FlagWithDepFile=", PathForOutput(ctx, "depfile")). |
| 258 | FlagWithInput("FlagWithInput=", PathForSource(ctx, "input")). |
| 259 | FlagWithOutput("FlagWithOutput=", PathForOutput(ctx, "output")). |
| 260 | Implicit(PathForSource(ctx, "Implicit")). |
| 261 | ImplicitDepFile(PathForOutput(ctx, "ImplicitDepFile")). |
| 262 | ImplicitOutput(PathForOutput(ctx, "ImplicitOutput")). |
| 263 | Input(PathForSource(ctx, "Input")). |
| 264 | Output(PathForOutput(ctx, "Output")). |
| 265 | Text("Text"). |
| 266 | Tool(PathForSource(ctx, "Tool")) |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 267 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 268 | rule.Command(). |
| 269 | Text("command2"). |
| 270 | DepFile(PathForOutput(ctx, "depfile2")). |
| 271 | Input(PathForSource(ctx, "input2")). |
| 272 | Output(PathForOutput(ctx, "output2")). |
| 273 | Tool(PathForSource(ctx, "tool2")) |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 274 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 275 | // Test updates to the first command after the second command has been started |
| 276 | cmd.Text("after command2") |
| 277 | // Test updating a command when the previous update did not replace the cmd variable |
| 278 | cmd.Text("old cmd") |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 279 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 280 | // Test a command that uses the output of a previous command as an input |
| 281 | rule.Command(). |
| 282 | Text("command3"). |
| 283 | Input(PathForSource(ctx, "input3")). |
| 284 | Input(PathForOutput(ctx, "output2")). |
| 285 | Output(PathForOutput(ctx, "output3")) |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 286 | } |
Colin Cross | 1d2cf04 | 2019-03-29 15:33:06 -0700 | [diff] [blame] | 287 | |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 288 | wantInputs := PathsForSource(ctx, []string{"Implicit", "Input", "input", "input2", "input3"}) |
| 289 | wantOutputs := PathsForOutput(ctx, []string{"ImplicitOutput", "Output", "output", "output2", "output3"}) |
Colin Cross | 1d2cf04 | 2019-03-29 15:33:06 -0700 | [diff] [blame] | 290 | wantDepFiles := PathsForOutput(ctx, []string{"DepFile", "depfile", "ImplicitDepFile", "depfile2"}) |
Colin Cross | 69f59a3 | 2019-02-15 10:39:37 -0800 | [diff] [blame] | 291 | wantTools := PathsForSource(ctx, []string{"Tool", "tool2"}) |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 292 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 293 | t.Run("normal", func(t *testing.T) { |
| 294 | rule := NewRuleBuilder() |
| 295 | addCommands(rule) |
Colin Cross | 1d2cf04 | 2019-03-29 15:33:06 -0700 | [diff] [blame] | 296 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 297 | wantCommands := []string{ |
| 298 | "out/DepFile Flag FlagWithArg=arg FlagWithDepFile=out/depfile FlagWithInput=input FlagWithOutput=out/output Input out/Output Text Tool after command2 old cmd", |
| 299 | "command2 out/depfile2 input2 out/output2 tool2", |
| 300 | "command3 input3 out/output2 out/output3", |
| 301 | } |
Colin Cross | 1d2cf04 | 2019-03-29 15:33:06 -0700 | [diff] [blame] | 302 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 303 | wantDepMergerCommand := "out/host/" + ctx.Config().PrebuiltOS() + "/bin/dep_fixer out/DepFile out/depfile out/ImplicitDepFile out/depfile2" |
| 304 | |
| 305 | if g, w := rule.Commands(), wantCommands; !reflect.DeepEqual(g, w) { |
| 306 | t.Errorf("\nwant rule.Commands() = %#v\n got %#v", w, g) |
| 307 | } |
| 308 | |
| 309 | if g, w := rule.Inputs(), wantInputs; !reflect.DeepEqual(w, g) { |
| 310 | t.Errorf("\nwant rule.Inputs() = %#v\n got %#v", w, g) |
| 311 | } |
| 312 | if g, w := rule.Outputs(), wantOutputs; !reflect.DeepEqual(w, g) { |
| 313 | t.Errorf("\nwant rule.Outputs() = %#v\n got %#v", w, g) |
| 314 | } |
| 315 | if g, w := rule.DepFiles(), wantDepFiles; !reflect.DeepEqual(w, g) { |
| 316 | t.Errorf("\nwant rule.DepFiles() = %#v\n got %#v", w, g) |
| 317 | } |
| 318 | if g, w := rule.Tools(), wantTools; !reflect.DeepEqual(w, g) { |
| 319 | t.Errorf("\nwant rule.Tools() = %#v\n got %#v", w, g) |
| 320 | } |
| 321 | |
| 322 | if g, w := rule.depFileMergerCmd(ctx, rule.DepFiles()).String(), wantDepMergerCommand; g != w { |
| 323 | t.Errorf("\nwant rule.depFileMergerCmd() = %#v\n got %#v", w, g) |
| 324 | } |
| 325 | }) |
| 326 | |
| 327 | t.Run("sbox", func(t *testing.T) { |
| 328 | rule := NewRuleBuilder().Sbox(PathForOutput(ctx)) |
| 329 | addCommands(rule) |
| 330 | |
| 331 | wantCommands := []string{ |
| 332 | "__SBOX_OUT_DIR__/DepFile Flag FlagWithArg=arg FlagWithDepFile=__SBOX_OUT_DIR__/depfile FlagWithInput=input FlagWithOutput=__SBOX_OUT_DIR__/output Input __SBOX_OUT_DIR__/Output Text Tool after command2 old cmd", |
| 333 | "command2 __SBOX_OUT_DIR__/depfile2 input2 __SBOX_OUT_DIR__/output2 tool2", |
| 334 | "command3 input3 __SBOX_OUT_DIR__/output2 __SBOX_OUT_DIR__/output3", |
| 335 | } |
| 336 | |
| 337 | wantDepMergerCommand := "out/host/" + ctx.Config().PrebuiltOS() + "/bin/dep_fixer __SBOX_OUT_DIR__/DepFile __SBOX_OUT_DIR__/depfile __SBOX_OUT_DIR__/ImplicitDepFile __SBOX_OUT_DIR__/depfile2" |
| 338 | |
| 339 | if g, w := rule.Commands(), wantCommands; !reflect.DeepEqual(g, w) { |
| 340 | t.Errorf("\nwant rule.Commands() = %#v\n got %#v", w, g) |
| 341 | } |
| 342 | |
| 343 | if g, w := rule.Inputs(), wantInputs; !reflect.DeepEqual(w, g) { |
| 344 | t.Errorf("\nwant rule.Inputs() = %#v\n got %#v", w, g) |
| 345 | } |
| 346 | if g, w := rule.Outputs(), wantOutputs; !reflect.DeepEqual(w, g) { |
| 347 | t.Errorf("\nwant rule.Outputs() = %#v\n got %#v", w, g) |
| 348 | } |
| 349 | if g, w := rule.DepFiles(), wantDepFiles; !reflect.DeepEqual(w, g) { |
| 350 | t.Errorf("\nwant rule.DepFiles() = %#v\n got %#v", w, g) |
| 351 | } |
| 352 | if g, w := rule.Tools(), wantTools; !reflect.DeepEqual(w, g) { |
| 353 | t.Errorf("\nwant rule.Tools() = %#v\n got %#v", w, g) |
| 354 | } |
| 355 | |
| 356 | if g, w := rule.depFileMergerCmd(ctx, rule.DepFiles()).String(), wantDepMergerCommand; g != w { |
| 357 | t.Errorf("\nwant rule.depFileMergerCmd() = %#v\n got %#v", w, g) |
| 358 | } |
| 359 | }) |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 360 | } |
| 361 | |
| 362 | func testRuleBuilderFactory() Module { |
| 363 | module := &testRuleBuilderModule{} |
| 364 | module.AddProperties(&module.properties) |
| 365 | InitAndroidModule(module) |
| 366 | return module |
| 367 | } |
| 368 | |
| 369 | type testRuleBuilderModule struct { |
| 370 | ModuleBase |
| 371 | properties struct { |
| 372 | Src string |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 373 | |
| 374 | Restat bool |
| 375 | Sbox bool |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 376 | } |
| 377 | } |
| 378 | |
| 379 | func (t *testRuleBuilderModule) GenerateAndroidBuildActions(ctx ModuleContext) { |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 380 | in := PathForSource(ctx, t.properties.Src) |
| 381 | out := PathForModuleOut(ctx, ctx.ModuleName()) |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 382 | outDep := PathForModuleOut(ctx, ctx.ModuleName()+".d") |
| 383 | outDir := PathForModuleOut(ctx) |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 384 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 385 | testRuleBuilder_Build(ctx, in, out, outDep, outDir, t.properties.Restat, t.properties.Sbox) |
Colin Cross | 786cd6d | 2019-02-01 16:41:11 -0800 | [diff] [blame] | 386 | } |
| 387 | |
| 388 | type testRuleBuilderSingleton struct{} |
| 389 | |
| 390 | func testRuleBuilderSingletonFactory() Singleton { |
| 391 | return &testRuleBuilderSingleton{} |
| 392 | } |
| 393 | |
| 394 | func (t *testRuleBuilderSingleton) GenerateBuildActions(ctx SingletonContext) { |
| 395 | in := PathForSource(ctx, "bar") |
| 396 | out := PathForOutput(ctx, "baz") |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 397 | outDep := PathForOutput(ctx, "baz.d") |
| 398 | outDir := PathForOutput(ctx) |
| 399 | testRuleBuilder_Build(ctx, in, out, outDep, outDir, true, false) |
Colin Cross | 786cd6d | 2019-02-01 16:41:11 -0800 | [diff] [blame] | 400 | } |
| 401 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 402 | func testRuleBuilder_Build(ctx BuilderContext, in Path, out, outDep, outDir WritablePath, restat, sbox bool) { |
Colin Cross | 758290d | 2019-02-01 16:42:32 -0800 | [diff] [blame] | 403 | rule := NewRuleBuilder() |
Colin Cross | 786cd6d | 2019-02-01 16:41:11 -0800 | [diff] [blame] | 404 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 405 | if sbox { |
| 406 | rule.Sbox(outDir) |
| 407 | } |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 408 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 409 | rule.Command().Tool(PathForSource(ctx, "cp")).Input(in).Output(out).ImplicitDepFile(outDep) |
| 410 | |
| 411 | if restat { |
| 412 | rule.Restat() |
| 413 | } |
Colin Cross | baa676f | 2019-02-25 14:56:01 -0800 | [diff] [blame] | 414 | |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 415 | rule.Build(pctx, ctx, "rule", "desc") |
| 416 | } |
| 417 | |
| 418 | func TestRuleBuilder_Build(t *testing.T) { |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 419 | bp := ` |
| 420 | rule_builder_test { |
| 421 | name: "foo", |
| 422 | src: "bar", |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 423 | restat: true, |
| 424 | } |
| 425 | rule_builder_test { |
| 426 | name: "foo_sbox", |
| 427 | src: "bar", |
| 428 | sbox: true, |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 429 | } |
| 430 | ` |
| 431 | |
| 432 | config := TestConfig(buildDir, nil) |
| 433 | ctx := NewTestContext() |
| 434 | ctx.MockFileSystem(map[string][]byte{ |
| 435 | "Android.bp": []byte(bp), |
| 436 | "bar": nil, |
| 437 | "cp": nil, |
| 438 | }) |
| 439 | ctx.RegisterModuleType("rule_builder_test", ModuleFactoryAdaptor(testRuleBuilderFactory)) |
Colin Cross | 786cd6d | 2019-02-01 16:41:11 -0800 | [diff] [blame] | 440 | ctx.RegisterSingletonType("rule_builder_test", SingletonFactoryAdaptor(testRuleBuilderSingletonFactory)) |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 441 | ctx.Register() |
| 442 | |
| 443 | _, errs := ctx.ParseFileList(".", []string{"Android.bp"}) |
| 444 | FailIfErrored(t, errs) |
| 445 | _, errs = ctx.PrepareBuildActions(config) |
| 446 | FailIfErrored(t, errs) |
| 447 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 448 | check := func(t *testing.T, params TestingBuildParams, wantCommand, wantOutput, wantDepfile string, wantRestat bool, extraCmdDeps []string) { |
| 449 | if params.RuleParams.Command != wantCommand { |
| 450 | t.Errorf("\nwant RuleParams.Command = %q\n got %q", wantCommand, params.RuleParams.Command) |
| 451 | } |
| 452 | |
| 453 | wantDeps := append([]string{"cp"}, extraCmdDeps...) |
| 454 | if !reflect.DeepEqual(params.RuleParams.CommandDeps, wantDeps) { |
| 455 | t.Errorf("\nwant RuleParams.CommandDeps = %q\n got %q", wantDeps, params.RuleParams.CommandDeps) |
| 456 | } |
| 457 | |
| 458 | if params.RuleParams.Restat != wantRestat { |
| 459 | t.Errorf("want RuleParams.Restat = %v, got %v", wantRestat, params.RuleParams.Restat) |
Colin Cross | 4c83e5c | 2019-02-25 14:54:28 -0800 | [diff] [blame] | 460 | } |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 461 | |
Colin Cross | 4c83e5c | 2019-02-25 14:54:28 -0800 | [diff] [blame] | 462 | if len(params.Implicits) != 1 || params.Implicits[0].String() != "bar" { |
| 463 | t.Errorf("want Implicits = [%q], got %q", "bar", params.Implicits.Strings()) |
| 464 | } |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 465 | |
Colin Cross | 1d2cf04 | 2019-03-29 15:33:06 -0700 | [diff] [blame] | 466 | if params.Output.String() != wantOutput { |
| 467 | t.Errorf("want Output = %q, got %q", wantOutput, params.Output) |
Colin Cross | 4c83e5c | 2019-02-25 14:54:28 -0800 | [diff] [blame] | 468 | } |
Colin Cross | baa676f | 2019-02-25 14:56:01 -0800 | [diff] [blame] | 469 | |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 470 | if len(params.ImplicitOutputs) != 0 { |
| 471 | t.Errorf("want ImplicitOutputs = [], got %q", params.ImplicitOutputs.Strings()) |
| 472 | } |
| 473 | |
| 474 | if params.Depfile.String() != wantDepfile { |
| 475 | t.Errorf("want Depfile = %q, got %q", wantDepfile, params.Depfile) |
| 476 | } |
| 477 | |
| 478 | if params.Deps != blueprint.DepsGCC { |
| 479 | t.Errorf("want Deps = %q, got %q", blueprint.DepsGCC, params.Deps) |
Colin Cross | baa676f | 2019-02-25 14:56:01 -0800 | [diff] [blame] | 480 | } |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 481 | } |
| 482 | |
Colin Cross | 4c83e5c | 2019-02-25 14:54:28 -0800 | [diff] [blame] | 483 | t.Run("module", func(t *testing.T) { |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 484 | outFile := filepath.Join(buildDir, ".intermediates", "foo", "foo") |
Colin Cross | 4c83e5c | 2019-02-25 14:54:28 -0800 | [diff] [blame] | 485 | check(t, ctx.ModuleForTests("foo", "").Rule("rule"), |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 486 | "cp bar "+outFile, |
| 487 | outFile, outFile+".d", true, nil) |
| 488 | }) |
| 489 | t.Run("sbox", func(t *testing.T) { |
| 490 | outDir := filepath.Join(buildDir, ".intermediates", "foo_sbox") |
| 491 | outFile := filepath.Join(outDir, "foo_sbox") |
| 492 | sbox := filepath.Join(buildDir, "host", config.PrebuiltOS(), "bin/sbox") |
| 493 | sandboxPath := shared.TempDirForOutDir(buildDir) |
| 494 | |
| 495 | cmd := sbox + ` -c 'cp bar __SBOX_OUT_DIR__/foo_sbox' --sandbox-path ` + sandboxPath + " --output-root " + outDir + " __SBOX_OUT_DIR__/foo_sbox __SBOX_OUT_DIR__/foo_sbox.d" |
| 496 | |
| 497 | check(t, ctx.ModuleForTests("foo_sbox", "").Rule("rule"), |
| 498 | cmd, outFile, outFile+".d", false, []string{sbox}) |
Colin Cross | 4c83e5c | 2019-02-25 14:54:28 -0800 | [diff] [blame] | 499 | }) |
| 500 | t.Run("singleton", func(t *testing.T) { |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 501 | outFile := filepath.Join(buildDir, "baz") |
Colin Cross | 4c83e5c | 2019-02-25 14:54:28 -0800 | [diff] [blame] | 502 | check(t, ctx.SingletonForTests("rule_builder_test").Rule("rule"), |
Dan Willemsen | 633c502 | 2019-04-12 11:11:38 -0700 | [diff] [blame] | 503 | "cp bar "+outFile, outFile, outFile+".d", true, nil) |
Colin Cross | 4c83e5c | 2019-02-25 14:54:28 -0800 | [diff] [blame] | 504 | }) |
Colin Cross | feec25b | 2019-01-30 17:32:39 -0800 | [diff] [blame] | 505 | } |