1
2
3
4
5
6
7
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
|
#!/bin/bash
#
# Copyright 2015 The Bazel Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Test rules provided in Bazel not tested by examples
#
# Load test environment
source $(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/test-setup.sh \
|| { echo "test-setup.sh not found!" >&2; exit 1; }
function test_sh_test() {
mkdir -p a
cat > a/BUILD <<EOF
package(default_visibility = ["//visibility:public"])
sh_test(
name = 'success_test',
srcs = [ 'success_test.sh' ],
)
sh_test(
name = 'fail_test',
srcs = [ 'fail_test.sh' ],
)
EOF
cat > a/success_test.sh <<EOF
#!/bin/sh
echo success-marker
exit 0
EOF
cat > a/fail_test.sh <<EOF
#!/bin/sh
echo failure-message
exit 1
EOF
chmod +x a/*.sh
assert_test_ok //a:success_test
assert_test_fails //a:fail_test
expect_log 'failure-message'
}
function test_extra_action() {
mkdir -p mypkg
# Make a program to run on each action that just prints the path to the extra
# action file. This file is a proto, but I don't want to bother implementing
# a program that parses the proto here.
cat > mypkg/echoer.sh <<EOF
#!/bin/bash
echo EXTRA ACTION FILE: \$1
EOF
chmod +x mypkg/echoer.sh
cat > mypkg/Hello.java <<EOF
public class Hello {
public void sayHi() {
System.out.println("hi");
}
}
EOF
cat > mypkg/BUILD <<EOF
package(default_visibility = ["//visibility:public"])
extra_action(
name = "echo-filename",
cmd = "\$(location :echoer) \$(EXTRA_ACTION_FILE)",
tools = [":echoer"],
)
action_listener(
name = "al",
extra_actions = [":echo-filename"],
mnemonics = ["Javac"],
)
sh_binary(
name = "echoer",
srcs = ["echoer.sh"],
)
java_library(
name = "hello",
srcs = ["Hello.java"],
)
EOF
bazel build --experimental_action_listener=//mypkg:al //mypkg:hello >& $TEST_log \
|| fail "Building with action listener failed"
expect_log "EXTRA ACTION FILE"
}
function test_with_arguments() {
mkdir -p mypkg
cat > mypkg/BUILD <<EOF
sh_test(
name = "expected_arg_test",
srcs = ["check_expected_argument.sh"],
args = ["expected_value"],
)
sh_test(
name = "unexpected_arg_test",
srcs = ["check_expected_argument.sh"],
args = ["unexpected_value"],
)
EOF
cat > mypkg/check_expected_argument.sh <<EOF
#!/bin/sh
[ "expected_value" = "\$1" ] || exit 1
EOF
chmod +x mypkg/check_expected_argument.sh
assert_test_ok //mypkg:expected_arg_test
assert_test_fails //mypkg:unexpected_arg_test
}
function test_top_level_test() {
cat > BUILD <<EOF
sh_test(
name = "trivial_test",
srcs = ["true.sh"],
)
EOF
cat > true.sh <<EOF
#!/bin/sh
exit 0
EOF
chmod +x true.sh
assert_test_ok //:trivial_test
}
# Regression test for https://github.com/bazelbuild/bazel/issues/67
# C++ library depedending on C++ library fails to compile on Darwin
function test_cpp_libdeps() {
mkdir -p pkg
cat <<'EOF' >pkg/BUILD
cc_library(
name = "a",
srcs = ["a.cc"],
)
cc_library(
name = "b",
srcs = ["b.cc"],
deps = [":a"],
)
cc_binary(
name = "main",
srcs = ["main.cc"],
deps = [":b"],
)
EOF
cat <<'EOF' >pkg/a.cc
#include <string>
std::string get_hello(std::string world) {
return "Hello, " + world + "!";
}
EOF
cat <<'EOF' >pkg/b.cc
#include <string>
#include <iostream>
std::string get_hello(std::string);
void print_hello(std::string world) {
std::cout << get_hello(world) << std::endl;
}
EOF
cat <<'EOF' >pkg/main.cc
#include <string>
void print_hello(std::string);
int main() {
print_hello(std::string("World"));
}
EOF
bazel build //pkg:a >& $TEST_log \
|| fail "Failed to build //pkg:a"
bazel build //pkg:b >& $TEST_log \
|| fail "Failed to build //pkg:b"
bazel run //pkg:main >& $TEST_log \
|| fail "Failed to run //pkg:main"
expect_log "Hello, World!"
./bazel-bin/pkg/main >& $TEST_log \
|| fail "Failed to run //pkg:main"
expect_log "Hello, World!"
}
function test_genrule_default_env() {
mkdir -p pkg
cat <<'EOF' >pkg/BUILD
genrule(
name = "test",
outs = ["test.out"],
cmd = "(echo \"PATH=$$PATH\"; echo \"TMPDIR=$$TMPDIR\") > $@",
)
EOF
local old_path="${PATH-}"
local old_tmpdir="${TMPDIR-}"
export PATH=":/bin:/usr/bin:/random/path"
export TMPDIR="/some/path"
# batch mode to force reload of the environment
bazel --batch build //pkg:test || fail "Failed to build //pkg:test"
export PATH="$old_path"
export TMPDIR="$old_tmpdir"
assert_contains "PATH=:/bin:/usr/bin:/random/path" \
bazel-genfiles/pkg/test.out
assert_contains "TMPDIR=/some/path" \
bazel-genfiles/pkg/test.out
}
run_suite "rules test"
|
