blob: f99a10afff24e5d2df42c1aa29b407e7cd54b270 [file] [log] [blame]
// 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;
}