mirror of
https://github.com/dart-lang/sdk
synced 2024-09-19 14:51:30 +00:00
56d59dd967
Change-Id: If8e2ec2ca1ac4f533dcb56b0c95d55e4a13e0598 Reviewed-on: https://dart-review.googlesource.com/39881 Reviewed-by: Paul Berry <paulberry@google.com>
304 lines
5.3 KiB
Dart
304 lines
5.3 KiB
Dart
// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
// Dart test program to test check that we don't fail to compile when an
|
|
// inlinable method contains a throw.
|
|
|
|
import 'package:expect/expect.dart';
|
|
|
|
dynamic x = false;
|
|
|
|
bool called;
|
|
|
|
bool callMeTrue() {
|
|
called = true;
|
|
return true;
|
|
}
|
|
|
|
bool callMeFalse() {
|
|
called = true;
|
|
return false;
|
|
}
|
|
|
|
void callMe() {
|
|
called = true;
|
|
}
|
|
|
|
testCallThenThrow(fn) {
|
|
called = false;
|
|
Expect.throws(() => fn());
|
|
Expect.isTrue(called);
|
|
}
|
|
|
|
testCall(fn) {
|
|
called = false;
|
|
fn();
|
|
Expect.isTrue(called);
|
|
}
|
|
|
|
testNoThrow(fn) {
|
|
called = false;
|
|
Expect.throws(() => fn());
|
|
Expect.isFalse(called);
|
|
}
|
|
|
|
kast(x) {
|
|
throw x;
|
|
}
|
|
|
|
ternary(a, b, c) {
|
|
if (x == 2) throw "ternary";
|
|
}
|
|
|
|
hest() => kast("hest");
|
|
hest2() {
|
|
return kast("hest2");
|
|
}
|
|
|
|
foo() => true || kast("foo");
|
|
bar() => false || kast("foo");
|
|
barc() => callMeTrue() || kast("foo");
|
|
barCallThrow() => callMeFalse() || kast("foo");
|
|
baz(x) => x ? kast("baz") : 0;
|
|
bazc() => callMeFalse() ? kast("baz") : 0;
|
|
bazCallThrow() => callMeTrue() ? kast("baz") : 0;
|
|
fizz(x) => x ? 0 : kast("baz");
|
|
fizzc() => callMeTrue() ? 0 : kast("baz");
|
|
fizzCallThrow() => callMeFalse() ? 0 : kast("baz");
|
|
fuzz() => kast("baz") ? 0 : 1;
|
|
farce() => !kast("baz");
|
|
unary() => ~(kast("baz"));
|
|
boo() {
|
|
callMe();
|
|
x = kast("boo");
|
|
}
|
|
|
|
yo() {
|
|
throw kast("yo");
|
|
}
|
|
|
|
bin() {
|
|
return 5 * kast("bin");
|
|
}
|
|
|
|
binCallThrow() {
|
|
return (callMe() as dynamic) * kast("binct");
|
|
}
|
|
|
|
hoo() {
|
|
x[kast("hoo")] = 0;
|
|
x[kast("hoo")];
|
|
kast("hoo").x = 0;
|
|
kast("hoo").x;
|
|
}
|
|
|
|
switcheroo() {
|
|
switch (kast("switcheroo")) {
|
|
case 0:
|
|
boo();
|
|
}
|
|
}
|
|
|
|
class ThrowConstructor {
|
|
ThrowConstructor()
|
|
: foo = callMeTrue(),
|
|
bar = kast("ThrowConstructor") {
|
|
called = false;
|
|
}
|
|
|
|
bool foo;
|
|
var bar;
|
|
}
|
|
|
|
throwConstructor() {
|
|
called = false;
|
|
return new ThrowConstructor();
|
|
}
|
|
|
|
cascade() {
|
|
return new List()..add(callMeTrue())..add(kast("cascade"));
|
|
}
|
|
|
|
interpole() => "inter${kast('tada!')}pole";
|
|
interpoleCallThrow() => "inter${callMeTrue()}...${kast('tada!')}pole";
|
|
|
|
call1() => ternary(0, kast("call1"), 1);
|
|
call2() => ternary(kast("call2"), 0, 1);
|
|
call3() => ternary(0, 1, kast("call3"));
|
|
call1c() => ternary(callMe() as dynamic, kast("call1"), 1);
|
|
call3c() => ternary(callMeTrue(), 1, kast("call3"));
|
|
call4c() => ternary(0, callMeTrue(), kast("call3"));
|
|
|
|
sendSet() {
|
|
var x = kast("sendSet");
|
|
}
|
|
|
|
sendSetCallThrow() {
|
|
var x = callMe() as dynamic, y = kast("sendSet");
|
|
}
|
|
|
|
isSend() => kast("isSend") is int;
|
|
|
|
vile() {
|
|
while (kast("vile")) {
|
|
callMe();
|
|
}
|
|
}
|
|
|
|
dovile() {
|
|
var x = 0;
|
|
do {
|
|
callMe();
|
|
x = 1;
|
|
} while (kast("vile"));
|
|
print(x);
|
|
}
|
|
|
|
dovileBreak() {
|
|
var x = 0;
|
|
do {
|
|
callMe();
|
|
x = 1;
|
|
break;
|
|
} while (kast("vile"));
|
|
return (x);
|
|
}
|
|
|
|
dovileContinue() {
|
|
var x = 0;
|
|
do {
|
|
callMe();
|
|
x = 1;
|
|
continue;
|
|
} while (kast("vile"));
|
|
return (x);
|
|
}
|
|
|
|
dovileBreakContinue(x) {
|
|
do {
|
|
callMe();
|
|
if (x == 1) break;
|
|
continue;
|
|
} while (kast("vile"));
|
|
return (x);
|
|
}
|
|
|
|
faar1() {
|
|
callMe();
|
|
for (kast("faar"); called = false; called = false) {
|
|
called = false;
|
|
}
|
|
}
|
|
|
|
faar2() {
|
|
for (callMe(); kast("faar"); called = false) {
|
|
called = false;
|
|
}
|
|
}
|
|
|
|
faar3() {
|
|
for (; true; kast("faar")) {
|
|
callMe();
|
|
}
|
|
called = false;
|
|
}
|
|
|
|
faar4() {
|
|
callMe();
|
|
for (kast("faar"); called = false; called = false) {
|
|
called = false;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
faar5() {
|
|
for (callMe(); kast("faar"); called = false) {
|
|
called = false;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
faar6() {
|
|
for (; true; kast("faar")) {
|
|
callMe();
|
|
continue;
|
|
}
|
|
called = false;
|
|
}
|
|
|
|
faar7() {
|
|
callMe();
|
|
for (kast("faar"); called = false; called = false) {
|
|
called = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
faar8() {
|
|
for (callMe(); kast("faar"); called = false) {
|
|
called = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
faar9() {
|
|
for (; true; kast("faar")) {
|
|
callMe();
|
|
break;
|
|
called = false;
|
|
}
|
|
}
|
|
|
|
main() {
|
|
Expect.throws(hest);
|
|
Expect.throws(hest2);
|
|
foo();
|
|
Expect.throws(bar);
|
|
testCall(barc);
|
|
testCallThenThrow(barCallThrow);
|
|
Expect.equals(0, baz(false));
|
|
Expect.throws(() => baz(true));
|
|
testCall(bazc);
|
|
testCallThenThrow(bazCallThrow);
|
|
Expect.throws(() => fizz(false));
|
|
testCall(fizzc);
|
|
testCallThenThrow(fizzCallThrow);
|
|
Expect.throws(fuzz);
|
|
Expect.throws(farce);
|
|
Expect.throws(unary);
|
|
testCallThenThrow(boo);
|
|
Expect.throws(yo);
|
|
Expect.throws(bin);
|
|
testCallThenThrow(binCallThrow);
|
|
Expect.throws(hoo);
|
|
Expect.throws(switcheroo);
|
|
Expect.throws(interpole);
|
|
testCallThenThrow(interpoleCallThrow);
|
|
Expect.throws(call1);
|
|
Expect.throws(call2);
|
|
Expect.throws(call3);
|
|
testCallThenThrow(call1c);
|
|
testCallThenThrow(call3c);
|
|
testCallThenThrow(call4c);
|
|
Expect.throws(sendSet);
|
|
testCallThenThrow(sendSetCallThrow);
|
|
Expect.throws(isSend);
|
|
testNoThrow(vile);
|
|
testCallThenThrow(dovile);
|
|
testCall(dovileBreak);
|
|
testCallThenThrow(dovileContinue);
|
|
testCallThenThrow(throwConstructor);
|
|
testCallThenThrow(cascade);
|
|
dovileBreakContinue(1);
|
|
testCallThenThrow(faar1);
|
|
testCallThenThrow(faar2);
|
|
testCallThenThrow(faar3);
|
|
testCallThenThrow(faar4);
|
|
testCallThenThrow(faar5);
|
|
testCallThenThrow(faar6);
|
|
testCallThenThrow(faar7);
|
|
testCallThenThrow(faar8);
|
|
testCall(faar9);
|
|
}
|