1191 lines
27 KiB
D
1191 lines
27 KiB
D
// PERMUTE_ARGS: -inline -g -O
|
|
|
|
extern(C) int printf(const char*, ...);
|
|
|
|
/*******************************************/
|
|
|
|
class A
|
|
{
|
|
int x = 7;
|
|
|
|
int foo(int i)
|
|
in
|
|
{
|
|
printf("A.foo.in %d\n", i);
|
|
assert(i == 2);
|
|
assert(x == 7);
|
|
printf("A.foo.in pass\n");
|
|
}
|
|
out (result)
|
|
{
|
|
assert(result & 1);
|
|
assert(x == 7);
|
|
}
|
|
do
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
class B : A
|
|
{
|
|
override int foo(int i)
|
|
in
|
|
{
|
|
float f;
|
|
printf("B.foo.in %d\n", i);
|
|
assert(i == 4);
|
|
assert(x == 7);
|
|
f = f + i;
|
|
}
|
|
out (result)
|
|
{
|
|
assert(result < 8);
|
|
assert(x == 7);
|
|
}
|
|
do
|
|
{
|
|
return i - 1;
|
|
}
|
|
}
|
|
|
|
void test1()
|
|
{
|
|
auto b = new B();
|
|
b.foo(2);
|
|
b.foo(4);
|
|
}
|
|
|
|
/*******************************************/
|
|
|
|
class A2
|
|
{
|
|
int x = 7;
|
|
|
|
int foo(int i)
|
|
in
|
|
{
|
|
printf("A2.foo.in %d\n", i);
|
|
assert(i == 2);
|
|
assert(x == 7);
|
|
printf("A2.foo.in pass\n");
|
|
}
|
|
out (result)
|
|
{
|
|
assert(result & 1);
|
|
assert(x == 7);
|
|
}
|
|
do
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
|
|
class B2 : A2
|
|
{
|
|
override int foo(int i)
|
|
in
|
|
{
|
|
float f;
|
|
printf("B2.foo.in %d\n", i);
|
|
assert(i == 4);
|
|
assert(x == 7);
|
|
f = f + i;
|
|
}
|
|
out (result)
|
|
{
|
|
assert(result < 8);
|
|
assert(x == 7);
|
|
}
|
|
do
|
|
{
|
|
return i - 1;
|
|
}
|
|
}
|
|
|
|
class C : B2
|
|
{
|
|
override int foo(int i)
|
|
in
|
|
{
|
|
float f;
|
|
printf("C.foo.in %d\n", i);
|
|
assert(i == 6);
|
|
assert(x == 7);
|
|
f = f + i;
|
|
}
|
|
out (result)
|
|
{
|
|
assert(result == 1 || result == 3 || result == 5);
|
|
assert(x == 7);
|
|
}
|
|
do
|
|
{
|
|
return i - 1;
|
|
}
|
|
}
|
|
|
|
void test2()
|
|
{
|
|
auto c = new C();
|
|
c.foo(2);
|
|
c.foo(4);
|
|
c.foo(6);
|
|
}
|
|
|
|
/*******************************************/
|
|
|
|
void fun(int x)
|
|
in {
|
|
if (x < 0) throw new Exception("a");
|
|
}
|
|
do {
|
|
}
|
|
|
|
void test3()
|
|
{
|
|
fun(1);
|
|
}
|
|
|
|
/*******************************************/
|
|
|
|
interface Stack {
|
|
int pop()
|
|
// in { printf("pop.in\n"); }
|
|
out(result) {
|
|
printf("pop.out\n");
|
|
assert(result == 3);
|
|
}
|
|
}
|
|
|
|
class CC : Stack
|
|
{
|
|
int pop()
|
|
//out (result) { printf("CC.pop.out\n"); } do
|
|
{
|
|
printf("CC.pop.in\n");
|
|
return 3;
|
|
}
|
|
}
|
|
|
|
void test4()
|
|
{
|
|
auto cc = new CC();
|
|
cc.pop();
|
|
}
|
|
|
|
/*******************************************/
|
|
|
|
int mul100(int n)
|
|
out(result)
|
|
{
|
|
assert(result == 500);
|
|
}
|
|
do
|
|
{
|
|
return n * 100;
|
|
}
|
|
|
|
void test5()
|
|
{
|
|
mul100(5);
|
|
}
|
|
|
|
/*******************************************/
|
|
// 3273
|
|
|
|
// original case
|
|
struct Bug3273
|
|
{
|
|
~this() {}
|
|
invariant() {}
|
|
}
|
|
|
|
// simplest case
|
|
ref int func3273()
|
|
out(r)
|
|
{
|
|
// Regression check of issue 3390
|
|
static assert(!__traits(compiles, r = 1));
|
|
}
|
|
do
|
|
{
|
|
static int dummy;
|
|
return dummy;
|
|
}
|
|
|
|
void test6()
|
|
{
|
|
func3273() = 1;
|
|
assert(func3273() == 1);
|
|
}
|
|
|
|
/*******************************************/
|
|
|
|
/+
|
|
// http://d.puremagic.com/issues/show_bug.cgi?id=3722
|
|
|
|
class Bug3722A
|
|
{
|
|
void fun() {}
|
|
}
|
|
class Bug3722B : Bug3722A
|
|
{
|
|
override void fun() in { assert(false); } do {}
|
|
}
|
|
|
|
void test6()
|
|
{
|
|
auto x = new Bug3722B();
|
|
x.fun();
|
|
}
|
|
+/
|
|
|
|
/*******************************************/
|
|
|
|
auto test7foo()
|
|
in{
|
|
++cnt;
|
|
}do{
|
|
++cnt;
|
|
return "str";
|
|
}
|
|
|
|
void test7()
|
|
{
|
|
cnt = 0;
|
|
assert(test7foo() == "str");
|
|
assert(cnt == 2);
|
|
}
|
|
|
|
/*******************************************/
|
|
|
|
auto foo8()
|
|
out(r){
|
|
++cnt;
|
|
assert(r == 10);
|
|
}do{
|
|
++cnt;
|
|
return 10;
|
|
}
|
|
|
|
auto bar8()
|
|
out{
|
|
++cnt;
|
|
}do{
|
|
++cnt;
|
|
}
|
|
|
|
void test8()
|
|
{
|
|
cnt = 0;
|
|
assert(foo8() == 10);
|
|
assert(cnt == 2);
|
|
|
|
cnt = 0;
|
|
bar8();
|
|
assert(cnt == 2);
|
|
}
|
|
|
|
/*******************************************/
|
|
// from fail317
|
|
|
|
void test9()
|
|
{
|
|
{
|
|
auto f1 = function() do { }; // fine
|
|
auto f2 = function() in { } do { }; // fine
|
|
auto f3 = function() out { } do { }; // error
|
|
auto f4 = function() in { } out { } do { }; // error
|
|
|
|
auto d1 = delegate() do { }; // fine
|
|
auto d2 = delegate() in { } do { }; // fine
|
|
auto d3 = delegate() out { } do { }; // error
|
|
auto d4 = delegate() in { } out { } do { }; // error
|
|
}
|
|
{
|
|
auto f1 = function() body { }; // fine
|
|
auto f2 = function() in { } body { }; // fine
|
|
auto f3 = function() out { } body { }; // error
|
|
auto f4 = function() in { } out { } body { }; // error
|
|
|
|
auto d1 = delegate() body { }; // fine
|
|
auto d2 = delegate() in { } body { }; // fine
|
|
auto d3 = delegate() out { } body { }; // error
|
|
auto d4 = delegate() in { } out { } body { }; // error
|
|
}
|
|
}
|
|
|
|
/*******************************************/
|
|
|
|
auto test10() body { return 3; }
|
|
auto test11()() body { return 3; }
|
|
|
|
auto test12()
|
|
{
|
|
auto test10() body { return 3; }
|
|
auto test11()() body { return 3; }
|
|
return 3;
|
|
}
|
|
|
|
|
|
void test13()
|
|
{
|
|
int function() fp13;
|
|
}
|
|
|
|
/*******************************************/
|
|
// 4785
|
|
|
|
int cnt;
|
|
|
|
auto foo4785()
|
|
in{
|
|
int r;
|
|
++cnt;
|
|
}
|
|
out(r){
|
|
assert(r == 10);
|
|
++cnt;
|
|
}do{
|
|
++cnt;
|
|
int r = 10;
|
|
return r;
|
|
}
|
|
void test4785()
|
|
{
|
|
cnt = 0;
|
|
assert(foo4785() == 10);
|
|
assert(cnt == 3);
|
|
}
|
|
|
|
/*******************************************/
|
|
// 5039
|
|
|
|
class C5039 {
|
|
int x;
|
|
|
|
invariant() {
|
|
assert( x < int.max );
|
|
}
|
|
|
|
auto foo() {
|
|
return x;
|
|
}
|
|
}
|
|
|
|
/*******************************************/
|
|
// 5204
|
|
|
|
interface IFoo5204
|
|
{
|
|
IFoo5204 bar()
|
|
out {}
|
|
}
|
|
class Foo5204 : IFoo5204
|
|
{
|
|
Foo5204 bar() { return null; }
|
|
}
|
|
|
|
/*******************************************/
|
|
// 6417
|
|
|
|
class Bug6417
|
|
{
|
|
void bar()
|
|
in
|
|
{
|
|
int i = 14;
|
|
assert(i == 14);
|
|
auto dg = (){
|
|
//printf("in: i = %d\n", i);
|
|
assert(i == 14, "in contract failure");
|
|
};
|
|
dg();
|
|
}
|
|
out
|
|
{
|
|
int j = 10;
|
|
assert(j == 10);
|
|
auto dg = (){
|
|
//printf("out: j = %d\n", j);
|
|
assert(j == 10, "out contract failure");
|
|
};
|
|
dg();
|
|
}
|
|
do {}
|
|
}
|
|
|
|
void test6417()
|
|
{
|
|
(new Bug6417).bar();
|
|
}
|
|
|
|
/*******************************************/
|
|
// 6549
|
|
|
|
class C6549
|
|
{
|
|
static int ocount = 0;
|
|
static int icount = 0;
|
|
|
|
abstract int foo(int)
|
|
in { ++icount; }
|
|
out { ++ocount; }
|
|
}
|
|
|
|
class CD6549 : C6549
|
|
{
|
|
override int foo(int)
|
|
in { assert(false); }
|
|
do { return 10; }
|
|
}
|
|
|
|
abstract class D6549
|
|
{
|
|
static int icount = 0;
|
|
static int ocount = 0;
|
|
|
|
int foo(int)
|
|
in { ++icount; }
|
|
out { ++ocount; }
|
|
}
|
|
|
|
class DD6549 : D6549
|
|
{
|
|
override int foo(int)
|
|
in { assert(false); }
|
|
do { return 10; }
|
|
}
|
|
|
|
void test6549()
|
|
{
|
|
auto c = new CD6549;
|
|
c.foo(10);
|
|
assert(C6549.icount == 1);
|
|
assert(C6549.ocount == 1);
|
|
|
|
auto d = new DD6549;
|
|
d.foo(10);
|
|
assert(D6549.icount == 1);
|
|
assert(D6549.ocount == 1);
|
|
}
|
|
|
|
/*******************************************/
|
|
// 7218
|
|
|
|
void test7218()
|
|
{
|
|
{
|
|
size_t foo() in{} out{} do{ return 0; } // OK
|
|
size_t bar() in{}/*out{}*/do{ return 0; } // OK
|
|
size_t hoo()/*in{}*/out{} do{ return 0; } // NG1
|
|
size_t baz()/*in{} out{}*/do{ return 0; } // NG2
|
|
}
|
|
{
|
|
size_t goo() in{} out{} body{ return 0; } // OK
|
|
size_t gar() in{}/*out{}*/body{ return 0; } // OK
|
|
size_t gob()/*in{}*/out{} body{ return 0; } // NG1
|
|
size_t gaz()/*in{} out{}*/body{ return 0; } // NG2
|
|
}
|
|
}
|
|
|
|
/*******************************************/
|
|
// 7517
|
|
|
|
void test7517()
|
|
{
|
|
static string result;
|
|
|
|
interface I
|
|
{
|
|
static I self;
|
|
|
|
void setEnable()
|
|
in
|
|
{
|
|
assert(self is this);
|
|
result ~= "I.setEnable.in/";
|
|
assert(!enabled);
|
|
}
|
|
out
|
|
{
|
|
assert(self is this);
|
|
result ~= "I.setEnable.out/";
|
|
assert( enabled);
|
|
}
|
|
|
|
void setDisable()
|
|
in
|
|
{
|
|
assert(self is this);
|
|
result ~= "I.setDisable.in/";
|
|
assert( enabled);
|
|
}
|
|
out
|
|
{
|
|
assert(self is this);
|
|
result ~= "I.setDisable.out/";
|
|
assert(!enabled);
|
|
}
|
|
|
|
@property bool enabled() const;
|
|
}
|
|
|
|
class C : I
|
|
{
|
|
static C self;
|
|
|
|
void setEnable()
|
|
in {} // supply in-contract to invoke I.setEnable.in
|
|
do
|
|
{
|
|
assert(self is this);
|
|
result ~= "C.setEnable/";
|
|
_enabled = true;
|
|
}
|
|
|
|
void setDisable()
|
|
{
|
|
assert(self is this);
|
|
result ~= "C.setDisable/";
|
|
_enabled = false;
|
|
}
|
|
|
|
@property bool enabled() const
|
|
{
|
|
assert(self is this);
|
|
result ~= "C.enabled/";
|
|
return _enabled;
|
|
}
|
|
|
|
bool _enabled;
|
|
}
|
|
|
|
C c = C.self = new C;
|
|
I i = I.self = c;
|
|
|
|
result = null;
|
|
i.setEnable();
|
|
assert(result == "I.setEnable.in/C.enabled/C.setEnable/I.setEnable.out/C.enabled/");
|
|
|
|
result = null;
|
|
i.setDisable();
|
|
assert(result == "C.setDisable/I.setDisable.out/C.enabled/");
|
|
}
|
|
|
|
/*******************************************/
|
|
// 7699
|
|
|
|
class P7699
|
|
{
|
|
void f(int n) in {
|
|
assert (n);
|
|
} do { }
|
|
}
|
|
class D7699 : P7699
|
|
{
|
|
override void f(int n) in { } do { }
|
|
}
|
|
|
|
/*******************************************/
|
|
// 7883
|
|
|
|
// Segmentation fault
|
|
class AA7883
|
|
{
|
|
int foo()
|
|
out (r1) { }
|
|
do { return 1; }
|
|
}
|
|
|
|
class BA7883 : AA7883
|
|
{
|
|
override int foo()
|
|
out (r2) { }
|
|
do { return 1; }
|
|
}
|
|
|
|
class CA7883 : BA7883
|
|
{
|
|
override int foo()
|
|
do { return 1; }
|
|
}
|
|
|
|
// Error: undefined identifier r2, did you mean variable r3?
|
|
class AB7883
|
|
{
|
|
int foo()
|
|
out (r1) { }
|
|
do { return 1; }
|
|
}
|
|
|
|
class BB7883 : AB7883
|
|
{
|
|
override int foo()
|
|
out (r2) { }
|
|
do { return 1; }
|
|
|
|
}
|
|
|
|
class CB7883 : BB7883
|
|
{
|
|
override int foo()
|
|
out (r3) { }
|
|
do { return 1; }
|
|
}
|
|
|
|
// Error: undefined identifier r3, did you mean variable r4?
|
|
class AC7883
|
|
{
|
|
int foo()
|
|
out (r1) { }
|
|
do { return 1; }
|
|
}
|
|
|
|
class BC7883 : AC7883
|
|
{
|
|
override int foo()
|
|
out (r2) { }
|
|
do { return 1; }
|
|
}
|
|
|
|
class CC7883 : BC7883
|
|
{
|
|
override int foo()
|
|
out (r3) { }
|
|
do { return 1; }
|
|
}
|
|
|
|
class DC7883 : CC7883
|
|
{
|
|
override int foo()
|
|
out (r4) { }
|
|
do { return 1; }
|
|
}
|
|
|
|
/*******************************************/
|
|
// 7892
|
|
|
|
struct S7892
|
|
{
|
|
@disable this();
|
|
this(int x) {}
|
|
}
|
|
|
|
S7892 f7892()
|
|
out (result) {} // case 1
|
|
do
|
|
{
|
|
return S7892(1);
|
|
}
|
|
|
|
interface I7892
|
|
{
|
|
S7892 f();
|
|
}
|
|
class C7892
|
|
{
|
|
invariant() {} // case 2
|
|
|
|
S7892 f()
|
|
{
|
|
return S7892(1);
|
|
}
|
|
}
|
|
|
|
/*******************************************/
|
|
// 8066
|
|
|
|
struct CLCommandQueue
|
|
{
|
|
invariant() {}
|
|
|
|
//private:
|
|
int enqueueNativeKernel()
|
|
{
|
|
assert(0, "implement me");
|
|
}
|
|
}
|
|
|
|
/*******************************************/
|
|
// 8073
|
|
|
|
struct Container8073
|
|
{
|
|
int opApply (int delegate(ref int) dg) { return 0; }
|
|
}
|
|
|
|
class Bug8073
|
|
{
|
|
static int test;
|
|
int foo()
|
|
out(r) { test = 7; } do
|
|
{
|
|
Container8073 ww;
|
|
foreach( xxx ; ww ) { }
|
|
return 7;
|
|
}
|
|
|
|
ref int bar()
|
|
out { } do
|
|
{
|
|
Container8073 ww;
|
|
foreach( xxx ; ww ) { }
|
|
test = 7;
|
|
return test;
|
|
}
|
|
}
|
|
void test8073()
|
|
{
|
|
auto c = new Bug8073();
|
|
assert(c.foo() == 7);
|
|
assert(c.test == 7);
|
|
|
|
auto p = &c.bar();
|
|
assert(p == &c.test);
|
|
assert(*p == 7);
|
|
}
|
|
|
|
/*******************************************/
|
|
// 8093
|
|
|
|
void test8093()
|
|
{
|
|
static int g = 10;
|
|
static int* p;
|
|
|
|
enum fdo = q{
|
|
static struct S {
|
|
int opApply(scope int delegate(ref int) dg) { return dg(g); }
|
|
}
|
|
S s;
|
|
foreach (ref e; s)
|
|
return g;
|
|
assert(0);
|
|
};
|
|
|
|
ref int foo_ref1() out(r) { assert(&r is &g && r == 10); }
|
|
do { mixin(fdo); }
|
|
|
|
ref int foo_ref2()
|
|
do { mixin(fdo); }
|
|
|
|
{ auto q = &foo_ref1(); assert(q is &g && *q == 10); }
|
|
{ auto q = &foo_ref2(); assert(q is &g && *q == 10); }
|
|
|
|
int foo_val1() out(r) { assert(&r !is &g && r == 10); }
|
|
do { mixin(fdo); }
|
|
|
|
int foo_val2()
|
|
do { mixin(fdo); }
|
|
|
|
{ auto n = foo_val1(); assert(&n !is &g && n == 10); }
|
|
{ auto n = foo_val2(); assert(&n !is &g && n == 10); }
|
|
}
|
|
|
|
/*******************************************/
|
|
// 9383
|
|
|
|
class A9383
|
|
{
|
|
static void delegate() dg;
|
|
static int val;
|
|
|
|
void failInBase() { assert(typeid(this) is typeid(A9383)); }
|
|
|
|
// in-contract tests
|
|
void foo1(int i) in { A9383.val = i; failInBase; } do { } // no closure
|
|
void foo2(int i) in { A9383.val = i; failInBase; } do { int x; dg = { ++x; }; } // closure [local]
|
|
void foo3(int i) in { A9383.val = i; failInBase; } do { dg = { ++i; }; } // closure [parameter]
|
|
void foo4(int i) in { A9383.val = i; failInBase; } do { } // no closure
|
|
void foo5(int i) in { A9383.val = i; failInBase; } do { } // no closure
|
|
void foo6(int i) in { A9383.val = i; failInBase; } do { int x; dg = { ++x; }; } // closure [local]
|
|
void foo7(int i) in { A9383.val = i; failInBase; } do { dg = { ++i; }; } // closure [parameter]
|
|
|
|
// out-contract tests
|
|
void bar1(int i) out { A9383.val = i; } do { } // no closure
|
|
void bar2(int i) out { A9383.val = i; } do { int x; dg = { ++x; }; } // closure [local]
|
|
void bar3(int i) out { A9383.val = i; } do { dg = { ++i; }; } // closure [parameter]
|
|
void bar4(int i) out { A9383.val = i; } do { } // no closure
|
|
void bar5(int i) out { A9383.val = i; } do { } // no closure
|
|
void bar6(int i) out { A9383.val = i; } do { int x; dg = { ++x; }; } // closure [local]
|
|
void bar7(int i) out { A9383.val = i; } do { dg = { ++i; }; } // closure [parameter]
|
|
}
|
|
|
|
class B9383 : A9383
|
|
{
|
|
static int val;
|
|
|
|
// in-contract tests
|
|
override void foo1(int i) in { B9383.val = i; } do { } // -> no closure
|
|
override void foo2(int i) in { B9383.val = i; } do { int x; dg = { ++x; }; } // -> closure [local] appears
|
|
override void foo3(int i) in { B9383.val = i; } do { dg = { ++i; }; } // -> closure [parameter]
|
|
override void foo4(int i) in { B9383.val = i; } do { int x; dg = { ++x; }; } // -> closure [local] appears
|
|
override void foo5(int i) in { B9383.val = i; } do { dg = { ++i; }; } // -> closure [parameter] appears
|
|
override void foo6(int i) in { B9383.val = i; } do { } // -> closure [local] disappears
|
|
override void foo7(int i) in { B9383.val = i; } do { } // -> closure [parameter] disappears
|
|
|
|
// out-contract tests
|
|
override void bar1(int i) out { B9383.val = i; } do { } // -> no closure
|
|
override void bar2(int i) out { B9383.val = i; } do { int x; dg = { ++x; }; } // -> closure [local] appears
|
|
override void bar3(int i) out { B9383.val = i; } do { dg = { ++i; }; } // -> closure [parameter]
|
|
override void bar4(int i) out { B9383.val = i; } do { int x; dg = { ++x; }; } // -> closure [local] appears
|
|
override void bar5(int i) out { B9383.val = i; } do { dg = { ++i; }; } // -> closure [parameter] appears
|
|
override void bar6(int i) out { B9383.val = i; } do { } // -> closure [local] disappears
|
|
override void bar7(int i) out { B9383.val = i; } do { } // -> closure [parameter] disappears
|
|
}
|
|
|
|
void test9383()
|
|
{
|
|
auto a = new A9383();
|
|
auto b = new B9383();
|
|
|
|
// base class in-contract is used from derived class. // base derived
|
|
b.foo1(101); assert(A9383.val == 101 && B9383.val == 101); // no closure -> no closure
|
|
b.foo2(102); assert(A9383.val == 102 && B9383.val == 102); // closure [local] -> closure [local] appears
|
|
b.foo3(103); assert(A9383.val == 103 && B9383.val == 103); // closure [parameter] -> closure [parameter]
|
|
b.foo4(104); assert(A9383.val == 104 && B9383.val == 104); // no closure -> closure [local] appears
|
|
b.foo5(105); assert(A9383.val == 105 && B9383.val == 105); // no closure -> closure [parameter] appears
|
|
b.foo6(106); assert(A9383.val == 106 && B9383.val == 106); // closure [local] -> closure [local] disappears
|
|
b.foo7(107); assert(A9383.val == 107 && B9383.val == 107); // closure [parameter] -> closure [parameter] disappears
|
|
|
|
// base class out-contract is used from derived class. // base derived
|
|
b.bar1(101); assert(A9383.val == 101 && B9383.val == 101); // no closure -> no closure
|
|
b.bar2(102); assert(A9383.val == 102 && B9383.val == 102); // closure [local] -> closure [local] appears
|
|
b.bar3(103); assert(A9383.val == 103 && B9383.val == 103); // closure [parameter] -> closure [parameter]
|
|
b.bar4(104); assert(A9383.val == 104 && B9383.val == 104); // no closure -> closure [local] appears
|
|
b.bar5(105); assert(A9383.val == 105 && B9383.val == 105); // no closure -> closure [parameter] appears
|
|
b.bar6(106); assert(A9383.val == 106 && B9383.val == 106); // closure [local] -> closure [local] disappears
|
|
b.bar7(107); assert(A9383.val == 107 && B9383.val == 107); // closure [parameter] -> closure [parameter] disappears
|
|
|
|
// in-contract in base class.
|
|
a.foo1(101); assert(A9383.val == 101); // no closure
|
|
a.foo2(102); assert(A9383.val == 102); // closure [local]
|
|
a.foo3(103); assert(A9383.val == 103); // closure [parameter]
|
|
|
|
// out-contract in base class.
|
|
a.bar1(101); assert(A9383.val == 101); // no closure
|
|
a.bar2(102); assert(A9383.val == 102); // closure [local]
|
|
a.bar3(103); assert(A9383.val == 103); // closure [parameter]
|
|
}
|
|
|
|
/*******************************************/
|
|
// 15524 - Different from issue 9383 cases, closed variable size is bigger than REGSIZE.
|
|
|
|
class A15524
|
|
{
|
|
static void delegate() dg;
|
|
static string val;
|
|
|
|
void failInBase() { assert(typeid(this) is typeid(A15524)); }
|
|
|
|
// in-contract tests
|
|
void foo1(string s) in { A15524.val = s; failInBase; } do { } // no closure
|
|
void foo2(string s) in { A15524.val = s; failInBase; } do { string x; dg = { x = null; }; } // closure [local]
|
|
void foo3(string s) in { A15524.val = s; failInBase; } do { dg = { s = null; }; } // closure [parameter]
|
|
void foo4(string s) in { A15524.val = s; failInBase; } do { } // no closure
|
|
void foo5(string s) in { A15524.val = s; failInBase; } do { } // no closure
|
|
void foo6(string s) in { A15524.val = s; failInBase; } do { string x; dg = { x = null; }; } // closure [local]
|
|
void foo7(string s) in { A15524.val = s; failInBase; } do { dg = { s = null; }; } // closure [parameter]
|
|
|
|
// out-contract tests
|
|
void bar1(string s) out { A15524.val = s; } do { } // no closure
|
|
void bar2(string s) out { A15524.val = s; } do { string x; dg = { x = null; }; } // closure [local]
|
|
void bar3(string s) out { A15524.val = s; } do { dg = { s = null; }; } // closure [parameter]
|
|
void bar4(string s) out { A15524.val = s; } do { } // no closure
|
|
void bar5(string s) out { A15524.val = s; } do { } // no closure
|
|
void bar6(string s) out { A15524.val = s; } do { string x; dg = { x = null; }; } // closure [local]
|
|
void bar7(string s) out { A15524.val = s; } do { dg = { s = null; }; } // closure [parameter]
|
|
}
|
|
|
|
class B15524 : A15524
|
|
{
|
|
static string val;
|
|
|
|
// in-contract tests
|
|
override void foo1(string s) in { B15524.val = s; } do { } // -> no closure
|
|
override void foo2(string s) in { B15524.val = s; } do { string x; dg = { x = null; }; } // -> closure [local] appears
|
|
override void foo3(string s) in { B15524.val = s; } do { dg = { s = null; }; } // -> closure [parameter]
|
|
override void foo4(string s) in { B15524.val = s; } do { string x; dg = { x = null; }; } // -> closure [local] appears
|
|
override void foo5(string s) in { B15524.val = s; } do { dg = { s = null; }; } // -> closure [parameter] appears
|
|
override void foo6(string s) in { B15524.val = s; } do { } // -> closure [local] disappears
|
|
override void foo7(string s) in { B15524.val = s; } do { } // -> closure [parameter] disappears
|
|
|
|
// out-contract tests
|
|
override void bar1(string s) out { B15524.val = s; } do { } // -> no closure
|
|
override void bar2(string s) out { B15524.val = s; } do { string x; dg = { x = null; }; } // -> closure [local] appears
|
|
override void bar3(string s) out { B15524.val = s; } do { dg = { s = null; }; } // -> closure [parameter]
|
|
override void bar4(string s) out { B15524.val = s; } do { string x; dg = { x = null; }; } // -> closure [local] appears
|
|
override void bar5(string s) out { B15524.val = s; } do { dg = { s = null; }; } // -> closure [parameter] appears
|
|
override void bar6(string s) out { B15524.val = s; } do { } // -> closure [local] disappears
|
|
override void bar7(string s) out { B15524.val = s; } do { } // -> closure [parameter] disappears
|
|
}
|
|
|
|
void test15524()
|
|
{
|
|
auto a = new A15524();
|
|
auto b = new B15524();
|
|
|
|
// base class in-contract is used from derived class. // base derived
|
|
b.foo1("1"); assert(A15524.val == "1" && B15524.val == "1"); // no closure -> no closure
|
|
b.foo2("2"); assert(A15524.val == "2" && B15524.val == "2"); // closure [local] -> closure [local] appears
|
|
b.foo3("3"); assert(A15524.val == "3" && B15524.val == "3"); // closure [parameter] -> closure [parameter]
|
|
b.foo4("4"); assert(A15524.val == "4" && B15524.val == "4"); // no closure -> closure [local] appears
|
|
b.foo5("5"); assert(A15524.val == "5" && B15524.val == "5"); // no closure -> closure [parameter] appears
|
|
b.foo6("6"); assert(A15524.val == "6" && B15524.val == "6"); // closure [local] -> closure [local] disappears
|
|
b.foo7("7"); assert(A15524.val == "7" && B15524.val == "7"); // closure [parameter] -> closure [parameter] disappears
|
|
|
|
// base class out-contract is used from derived class. // base derived
|
|
b.bar1("1"); assert(A15524.val == "1" && B15524.val == "1"); // no closure -> no closure
|
|
b.bar2("2"); assert(A15524.val == "2" && B15524.val == "2"); // closure [local] -> closure [local] appears
|
|
b.bar3("3"); assert(A15524.val == "3" && B15524.val == "3"); // closure [parameter] -> closure [parameter]
|
|
b.bar4("4"); assert(A15524.val == "4" && B15524.val == "4"); // no closure -> closure [local] appears
|
|
b.bar5("5"); assert(A15524.val == "5" && B15524.val == "5"); // no closure -> closure [parameter] appears
|
|
b.bar6("6"); assert(A15524.val == "6" && B15524.val == "6"); // closure [local] -> closure [local] disappears
|
|
b.bar7("7"); assert(A15524.val == "7" && B15524.val == "7"); // closure [parameter] -> closure [parameter] disappears
|
|
|
|
// in-contract in base class.
|
|
a.foo1("1"); assert(A15524.val == "1"); // no closure
|
|
a.foo2("2"); assert(A15524.val == "2"); // closure [local]
|
|
a.foo3("3"); assert(A15524.val == "3"); // closure [parameter]
|
|
|
|
// out-contract in base class.
|
|
a.bar1("1"); assert(A15524.val == "1"); // no closure
|
|
a.bar2("2"); assert(A15524.val == "2"); // closure [local]
|
|
a.bar3("3"); assert(A15524.val == "3"); // closure [parameter]
|
|
}
|
|
|
|
void test15524a()
|
|
{
|
|
auto t1 = new Test15524a();
|
|
t1.infos["first"] = 0; //t1.add("first");
|
|
t1.add("second");
|
|
|
|
auto t2 = new Test15524b();
|
|
t2.add("second");
|
|
}
|
|
|
|
class Test15524a
|
|
{
|
|
int[string] infos;
|
|
|
|
void add(string key)
|
|
in
|
|
{
|
|
assert(key !in infos); // @@@ crash here at second
|
|
}
|
|
do
|
|
{
|
|
auto item = new class
|
|
{
|
|
void notCalled()
|
|
{
|
|
infos[key] = 0;
|
|
// affects, key parameter is made a closure variable.
|
|
}
|
|
};
|
|
}
|
|
}
|
|
|
|
class Test15524b
|
|
{
|
|
void add(string key)
|
|
in
|
|
{
|
|
assert(key == "second"); // @@@ fails
|
|
}
|
|
do
|
|
{
|
|
static void delegate() dg;
|
|
dg = { auto x = key; };
|
|
// affects, key parameter is made a closure variable.
|
|
}
|
|
}
|
|
|
|
/*******************************************/
|
|
// 10479
|
|
|
|
class B10479
|
|
{
|
|
B10479 foo()
|
|
out { } do { return null; }
|
|
}
|
|
|
|
class D10479 : B10479
|
|
{
|
|
override D10479 foo() { return null; }
|
|
}
|
|
|
|
/*******************************************/
|
|
// 10596
|
|
|
|
class Foo10596
|
|
{
|
|
auto bar()
|
|
out (result) { }
|
|
do { return 0; }
|
|
}
|
|
|
|
/*******************************************/
|
|
// 10721
|
|
|
|
class Foo10721
|
|
{
|
|
this()
|
|
out { }
|
|
do { }
|
|
|
|
~this()
|
|
out { }
|
|
do { }
|
|
}
|
|
|
|
struct Bar10721
|
|
{
|
|
this(this)
|
|
out { }
|
|
do { }
|
|
}
|
|
|
|
/*******************************************/
|
|
// 10981
|
|
|
|
class C10981
|
|
{
|
|
void foo(int i) pure
|
|
in { assert(i); }
|
|
out { assert(i); }
|
|
do {}
|
|
}
|
|
|
|
/*******************************************/
|
|
// 14779
|
|
|
|
class C14779
|
|
{
|
|
final void foo(int v)
|
|
in { assert(v == 0); }
|
|
out { assert(v == 0); }
|
|
do
|
|
{
|
|
}
|
|
}
|
|
|
|
void test14779()
|
|
{
|
|
auto c = new C14779();
|
|
c.foo(0);
|
|
}
|
|
|
|
/*******************************************/
|
|
|
|
//******************************************/
|
|
// DIP 1009
|
|
|
|
int dip1009_1(int x)
|
|
in (x > 0, "x must be positive!")
|
|
out (r; r < 0, "r must be negative!")
|
|
in (true, "cover trailing comma case",)
|
|
out (; true, "cover trailing comma case",)
|
|
{
|
|
return -x;
|
|
}
|
|
|
|
int dip1009_2(int x)
|
|
in (x > 0)
|
|
out (r; r < 0)
|
|
{
|
|
return -x;
|
|
}
|
|
|
|
int dip1009_3(int x)
|
|
in (x > 0,)
|
|
out (r; r < 0,)
|
|
do
|
|
{
|
|
return -x;
|
|
}
|
|
|
|
void dip1009_4(int x)
|
|
in (x > 0)
|
|
out (; x > 1)
|
|
{
|
|
x += 1;
|
|
}
|
|
|
|
interface DIP1009_5
|
|
{
|
|
void dip1009_5(int x)
|
|
in (x > 0)
|
|
out (; x > 1);
|
|
}
|
|
|
|
int dip1009_6(int x, int y)
|
|
in (x > 0)
|
|
out (r; r > 1)
|
|
out (; x > 0)
|
|
in (y > 0)
|
|
in (x + y > 1)
|
|
out (r; r > 1)
|
|
{
|
|
return x+y;
|
|
}
|
|
|
|
int dip1009_7(int x)
|
|
in (x > 0)
|
|
in { assert(x > 1); }
|
|
out { assert(x > 2); }
|
|
out (; x > 3)
|
|
out (r; r > 3)
|
|
{
|
|
x += 2;
|
|
return x;
|
|
}
|
|
|
|
class DIP1009_8
|
|
{
|
|
private int x = 4;
|
|
invariant (x > 0, "x must stay positive");
|
|
invariant (x > 1, "x must be greater than one",);
|
|
invariant (x > 2);
|
|
invariant (x > 3,);
|
|
void foo(){ x = 5; }
|
|
}
|
|
|
|
/*******************************************/
|
|
|
|
int main()
|
|
{
|
|
test1();
|
|
test2();
|
|
test3();
|
|
test4();
|
|
test5();
|
|
// test6();
|
|
test7();
|
|
test8();
|
|
test9();
|
|
test4785();
|
|
test6417();
|
|
test6549();
|
|
test7218();
|
|
test7517();
|
|
test8073();
|
|
test8093();
|
|
test9383();
|
|
test15524();
|
|
test15524a();
|
|
test14779();
|
|
dip1009_1(1);
|
|
dip1009_2(1);
|
|
dip1009_3(1);
|
|
dip1009_4(1);
|
|
dip1009_6(1, 1);
|
|
dip1009_7(3);
|
|
new DIP1009_8().foo();
|
|
|
|
printf("Success\n");
|
|
return 0;
|
|
}
|