2125 lines
30 KiB
D
2125 lines
30 KiB
D
// REQUIRED_ARGS:
|
|
|
|
module template1;
|
|
|
|
import core.stdc.stdio : printf;
|
|
import core.vararg;
|
|
|
|
/******************************************/
|
|
|
|
template TFoo1(T,U)
|
|
{
|
|
int foo(T t, U u)
|
|
{
|
|
return 3;
|
|
}
|
|
}
|
|
|
|
|
|
alias TFoo1!(int, char) Foo1;
|
|
|
|
|
|
void test1()
|
|
{
|
|
int i = Foo1.foo(1, 2);
|
|
assert(i == 3);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template TFoo2(T,U)
|
|
{
|
|
T x = 4;
|
|
U y;
|
|
}
|
|
|
|
|
|
alias TFoo2!(int, char) Foo2;
|
|
|
|
|
|
void test2()
|
|
{
|
|
assert(Foo2.x + Foo2.y == 0x103);
|
|
Foo2.x = 3;
|
|
Foo2.y = 7;
|
|
assert(Foo2.x + Foo2.y == 10);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template TFoo3(T,U)
|
|
{
|
|
class Bar
|
|
{
|
|
T x = 4;
|
|
U y;
|
|
}
|
|
}
|
|
|
|
|
|
alias TFoo3!(int, char) Foo3;
|
|
|
|
|
|
void test3()
|
|
{
|
|
Foo3.Bar b = new Foo3.Bar();
|
|
|
|
assert(b.x == 4);
|
|
assert(b.y == 0xFF);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template TFoo4(T,U)
|
|
{
|
|
T x;
|
|
U y;
|
|
}
|
|
|
|
template TFoo4(T:T,U:T)
|
|
{
|
|
T a;
|
|
U b;
|
|
}
|
|
|
|
template TFoo4(T:uint, U:uint)
|
|
{
|
|
T c;
|
|
U d;
|
|
}
|
|
|
|
alias TFoo4!(int, char) Foo4x;
|
|
|
|
void test4()
|
|
{
|
|
alias TFoo4!(int, char) Foo4;
|
|
int* x = &Foo4.c;
|
|
char* y = &Foo4.d;
|
|
|
|
alias TFoo4!(uint, char**) Foo4_2;
|
|
uint* x2 = &Foo4_2.x;
|
|
char*** y2 = &Foo4_2.y;
|
|
|
|
alias TFoo4!(int, int) Foo4_3;
|
|
int* x3 = &Foo4_3.a;
|
|
int* y3 = &Foo4_3.b;
|
|
|
|
alias TFoo4!(uint, uint) Foo4_4;
|
|
uint* x4 = &Foo4_4.c;
|
|
uint* y4 = &Foo4_4.d;
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template TtoUx(T, U)
|
|
{
|
|
T toUx(U[] s)
|
|
{
|
|
uint v = 0;
|
|
|
|
if (v != cast(T)v)
|
|
return 3;
|
|
|
|
return cast(T)v;
|
|
}
|
|
|
|
}
|
|
|
|
alias TtoUx!(ubyte, char).toUx toUbyte;
|
|
alias TtoUx!(ushort, char).toUx toUshort;
|
|
|
|
void test5()
|
|
{
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template TtoUx6(T, U)
|
|
{
|
|
T toUx(U[] s)
|
|
{
|
|
uint v = 0;
|
|
|
|
if (v != cast(T)v)
|
|
return 3;
|
|
|
|
return cast(T)v;
|
|
}
|
|
|
|
}
|
|
|
|
alias TtoUx6!(ubyte, char) t6;
|
|
|
|
void test6()
|
|
{
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template A7(T) {
|
|
T id(T t) {
|
|
return t;
|
|
}
|
|
}
|
|
|
|
alias A7!(int) a;
|
|
|
|
void test7()
|
|
{
|
|
printf("%d\r\n", a.id(3));
|
|
assert(a.id(3) == 3);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template Swapper(T)
|
|
{
|
|
void Swap(ref T a, ref T b)
|
|
{
|
|
T temp = a; a = b; b = temp;
|
|
}
|
|
}
|
|
|
|
void test8()
|
|
{
|
|
alias Swapper!(int) IntSwap;
|
|
int a=1,b=2;
|
|
IntSwap.Swap(a,b);
|
|
printf("a=%d,b=%d\n",a,b); // prints 2,1
|
|
assert(a == 2);
|
|
assert(b == 1);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template Foo9(T)
|
|
{
|
|
class B
|
|
{
|
|
T data;
|
|
}
|
|
}
|
|
|
|
void test9()
|
|
{
|
|
(new Foo9!(int).B).data += 4;
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template A10(T) {
|
|
}
|
|
|
|
template B10(T) {
|
|
alias A10!(int) a;
|
|
}
|
|
|
|
void test10()
|
|
{
|
|
alias B10!(int) b;
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template A11(T) {
|
|
T idf(T t) {
|
|
return t;
|
|
}
|
|
}
|
|
|
|
template B11(T) {
|
|
private alias A11!(T) a;
|
|
T same(T t) {
|
|
return a.idf(t);
|
|
}
|
|
}
|
|
|
|
void test11()
|
|
{
|
|
alias B11!(int) b;
|
|
//printf("%d\r\n", b.same(10));
|
|
assert(b.same(10) == 10);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template A12(T) {
|
|
class B {
|
|
invariant() {
|
|
assert(1);
|
|
}
|
|
T ide(T t) {
|
|
return t;
|
|
}
|
|
}
|
|
}
|
|
|
|
void test12()
|
|
{
|
|
alias A12!(int) a;
|
|
a.B b = new a.B();
|
|
printf("%d\r\n", b.ide(10));
|
|
assert(b.ide(10) == 10);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template A13(T) {
|
|
public interface I {
|
|
public T i();
|
|
}
|
|
}
|
|
|
|
class B13 : A13!(int).I {
|
|
public int i() {
|
|
return 42;
|
|
}
|
|
}
|
|
|
|
void test13()
|
|
{
|
|
B13 b = new B13();
|
|
A13!(int).I i = b;
|
|
assert(b.i() == 42);
|
|
assert(i.i() == 42);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
class B14
|
|
{
|
|
}
|
|
|
|
template A14(T, U) {
|
|
|
|
private U u;
|
|
|
|
static this()
|
|
{
|
|
u = new U();
|
|
}
|
|
}
|
|
|
|
alias A14!(int, B14) t14;
|
|
|
|
void test14()
|
|
{
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template A15(T) {
|
|
public interface Init {
|
|
public T init();
|
|
}
|
|
}
|
|
template A15(T : int) {
|
|
public class Init {
|
|
public T init() {
|
|
return 42;
|
|
};
|
|
}
|
|
}
|
|
template A15(T : float) {
|
|
public class Init {
|
|
public T init() {
|
|
return 3.25;
|
|
};
|
|
}
|
|
}
|
|
|
|
template TB15(T, U) {
|
|
private U initializer;
|
|
private void setInitializer(U init) {
|
|
initializer = init;
|
|
}
|
|
public class B {
|
|
private T _value;
|
|
public this() {
|
|
this._value = initializer.init();
|
|
}
|
|
public T value() {
|
|
return this._value;
|
|
}
|
|
}
|
|
}
|
|
template TB15(T) {
|
|
private alias TB15!(T, A15!(T).Init) tb;
|
|
private void setInitializer(A15!(T).Init init) {
|
|
tb.setInitializer(init);
|
|
}
|
|
public class B : tb.B {
|
|
}
|
|
}
|
|
|
|
void test15()
|
|
{
|
|
alias TB15!(int, A15!(int).Init) tb;
|
|
tb.setInitializer(new A15!(int).Init());
|
|
tb.B b = new tb.B();
|
|
int i;
|
|
i = b.value();
|
|
assert(i == 42);
|
|
|
|
alias TB15!(float) tb2;
|
|
tb2.setInitializer(new A15!(float).Init());
|
|
tb2.B b2 = new tb2.B();
|
|
assert(b2.value() == 3.25);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template foo16(U : int, int T : 9+1)
|
|
{
|
|
U x = T;
|
|
}
|
|
|
|
alias foo16!(int, 10) bar16;
|
|
|
|
void test16()
|
|
{
|
|
int i;
|
|
|
|
i = bar16.x;
|
|
assert(i == 10);
|
|
assert(foo16!(int, 10).x == 10);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template VecTemplate(tfloat)
|
|
{
|
|
struct Vector
|
|
{
|
|
tfloat d;
|
|
}
|
|
}
|
|
|
|
void test17()
|
|
{
|
|
with (VecTemplate!(int)) // crash DMD
|
|
{
|
|
}
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template Bomb (T)
|
|
{
|
|
void foo (T *parm)
|
|
{
|
|
}
|
|
}
|
|
|
|
template Name (T)
|
|
{
|
|
T y;
|
|
|
|
void test ()
|
|
{
|
|
Bomb!(T).foo (&y);
|
|
}
|
|
}
|
|
|
|
alias Name!(int) a18;
|
|
alias Name!(ubyte) b18;
|
|
|
|
void test18()
|
|
{
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template one20( T )
|
|
{
|
|
alias T function () safeptr;
|
|
}
|
|
|
|
template one20( T1, T2 )
|
|
{
|
|
alias int function(int) safeptr;
|
|
}
|
|
|
|
alias one20!( int ) A;
|
|
A.safeptr foo20;
|
|
|
|
alias one20!( int, int ) B;
|
|
B.safeptr bar20;
|
|
|
|
|
|
int func_bar(int i) { return 2; }
|
|
|
|
void test20()
|
|
{
|
|
bar20 = &func_bar;
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class A21 { int x; }
|
|
class B21 : A21 { int y; }
|
|
|
|
void abc21(B21* b) { }
|
|
|
|
template TFoo21(T : A21, U : T*)
|
|
{
|
|
void test()
|
|
{
|
|
assert(T.sizeof == B21.sizeof);
|
|
U u;
|
|
abc21(u);
|
|
}
|
|
}
|
|
|
|
alias TFoo21!(B21, B21*) bar21;
|
|
|
|
void test21()
|
|
{
|
|
bar21.test();
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template Bug22(T : Object) {
|
|
int print() {
|
|
printf("Bug22(T : Object).print()\r\n");
|
|
return 1;
|
|
}
|
|
}
|
|
template Bug22(T) {
|
|
int print() {
|
|
printf("Bug22(T).print()\r\n");
|
|
return 2;
|
|
}
|
|
}
|
|
template TTest22(T) {
|
|
private alias Bug22!(T) bug;
|
|
class Test {
|
|
int test() {
|
|
return bug.print();
|
|
}
|
|
}
|
|
}
|
|
|
|
void test22()
|
|
{
|
|
alias TTest22!(int).Test Test1;
|
|
alias TTest22!(Test1).Test Test2;
|
|
alias TTest22!(Object).Test Test3;
|
|
Test1 test1 = new Test1();
|
|
Test2 test2 = new Test2();
|
|
Test3 test3 = new Test3();
|
|
int i;
|
|
|
|
i = test1.test();
|
|
assert(i == 2);
|
|
i = test2.test();
|
|
assert(i == 1);
|
|
i = test3.test();
|
|
assert(i == 1);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template T23()
|
|
{
|
|
struct Rank
|
|
{
|
|
}
|
|
}
|
|
|
|
template A23()
|
|
{
|
|
struct Array
|
|
{
|
|
alias T23!().Rank Rank1;
|
|
|
|
Rank1 data;
|
|
}
|
|
}
|
|
|
|
alias A23!().Array Array_int23;
|
|
|
|
void test23()
|
|
{
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template TList24(T)
|
|
{
|
|
class Node
|
|
{
|
|
}
|
|
class List
|
|
{
|
|
Node m_first = null;
|
|
}
|
|
}
|
|
|
|
void test24()
|
|
{
|
|
alias TList24!(uint).List UIntList;
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template TList25(T)
|
|
{
|
|
class Node
|
|
{
|
|
Node prev;
|
|
Node next;
|
|
T Value;
|
|
}
|
|
class List
|
|
{
|
|
Node m_first = null;
|
|
Node m_last = null;
|
|
void AddFront(T _Value)
|
|
{
|
|
Node cur = new Node;
|
|
with (cur)
|
|
{
|
|
next = m_first;
|
|
prev = null;
|
|
Value = _Value;
|
|
if (next !is null)
|
|
next.prev = cur;
|
|
}
|
|
m_first = null;
|
|
if (m_last is null)
|
|
m_last = cur;
|
|
}
|
|
}
|
|
}
|
|
|
|
void test25()
|
|
{
|
|
alias TList25!(uint).List UIntList;
|
|
alias TList25!(uint).Node UIntNode;
|
|
UIntList list;
|
|
UIntNode node;
|
|
for (int i = 1; i <= 10; i++)
|
|
{} //list.AddFront(i);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template Foo26(T)
|
|
{
|
|
void doIt() {
|
|
printf("Foo26(T)\r\n");
|
|
}
|
|
}
|
|
|
|
template Foo26(T : T[])
|
|
{
|
|
private alias Foo26!(T) bug;
|
|
void doIt() {
|
|
printf("Foo26(T[])\r\n");
|
|
bug.doIt();
|
|
}
|
|
}
|
|
|
|
void test26()
|
|
{
|
|
alias Foo26!(int[]) foo;
|
|
foo.doIt();
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template Foo27(T)
|
|
{
|
|
public const T[] empty = [];
|
|
}
|
|
|
|
void test27()
|
|
{
|
|
alias Foo27!(int) bug;
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template A28(T) {
|
|
public bool all(in T[] array, bool function (T) predicate) {
|
|
for (int i = 0; i < array.length; i++) {
|
|
if (!predicate(array[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void test28()
|
|
{
|
|
static bool isVowel(char c) {
|
|
return (c == 'a') || (c == 'e') || (c == 'i') || (c == 'o') || (c == 'u');
|
|
}
|
|
|
|
alias A28!(char) arrays;
|
|
assert(arrays.all("aeiouoeieuiei", &isVowel));
|
|
assert(arrays.all("aeoiuaioeuioaeuiouoiaeu", &isVowel));
|
|
assert(!arrays.all("aaeiouioeujiurioue", &isVowel));
|
|
assert(!arrays.all("bjkqwkjbwqjbkwb", &isVowel));
|
|
assert(arrays.all("", &isVowel));
|
|
printf("A28(char).all tests passed!\r\n");
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
public template TRange29(T) {
|
|
debug private bool recursing = false;
|
|
public class Range {
|
|
private T _lower;
|
|
private T _upper;
|
|
public this(T lower, T upper) {
|
|
this._lower = lower;
|
|
this._upper = upper;
|
|
}
|
|
public T lower() {
|
|
return this._lower;
|
|
}
|
|
public T upper() {
|
|
return this._upper;
|
|
}
|
|
public bool contains(T item) {
|
|
return (lower() <= item) && (item <= upper());
|
|
}
|
|
public bool intersects(Range other)
|
|
in {
|
|
assert(other !is null);
|
|
} out (result) {
|
|
debug {
|
|
if (!recursing) {
|
|
recursing = true;
|
|
assert(result == other.intersects(this));
|
|
} else {
|
|
recursing = false;
|
|
}
|
|
}
|
|
} body {
|
|
return contains(other.lower()) || contains(other.upper()) || other.includes(this);
|
|
}
|
|
public bool includes(Range other)
|
|
in {
|
|
assert(other !is null);
|
|
} out (result) {
|
|
assert(result == (contains(other.lower()) && contains(other.upper())));
|
|
} body {
|
|
return contains(other.lower()) && contains(other.upper());
|
|
}
|
|
}
|
|
}
|
|
|
|
void test29()
|
|
{
|
|
alias TRange29!(int).Range Range;
|
|
Range r1 = new Range(1, 10);
|
|
Range r2 = new Range(5, 15);
|
|
assert(r1.intersects(r2) == 1);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template TCopy30(T)
|
|
{
|
|
void copy(out T to, T from)
|
|
{
|
|
to = from;
|
|
}
|
|
}
|
|
|
|
template TCopy30(T : string)
|
|
{
|
|
void copy(out string to, in string from)
|
|
{
|
|
printf("Specialization\n");
|
|
to = from;
|
|
}
|
|
}
|
|
|
|
void test30()
|
|
{
|
|
int i = 0;
|
|
float f = 0;
|
|
string s;
|
|
|
|
alias TCopy30!(int) copyint;
|
|
alias TCopy30!(string) copystr;
|
|
|
|
copyint.copy(i, 3);
|
|
printf("%d\n", i);
|
|
assert(i == 3);
|
|
|
|
copystr.copy(s, "Here it comes");
|
|
printf("%.*s\n", s.length, s.ptr);
|
|
assert(s == "Here it comes");
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
import std.string;
|
|
|
|
template Foo31(alias X)
|
|
{
|
|
alias X.toStringz y;
|
|
}
|
|
|
|
void test31()
|
|
{
|
|
alias Foo31!(std.string) bar;
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
shared int x32;
|
|
|
|
template Foo32(alias X)
|
|
{
|
|
static shared int* p = &X;
|
|
}
|
|
|
|
alias Foo32!(x32) abc32;
|
|
|
|
void test32()
|
|
{
|
|
alias Foo32!(x32) bar;
|
|
|
|
*bar.p = 3;
|
|
assert(x32 == 3);
|
|
|
|
*abc32.p = 4;
|
|
assert(x32 == 4);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
shared int x33;
|
|
|
|
template Foo33(alias X)
|
|
{
|
|
static shared int* p = &X;
|
|
}
|
|
|
|
template Bar33(alias T)
|
|
{
|
|
alias T!(x33) abc;
|
|
}
|
|
|
|
void test33()
|
|
{
|
|
alias Bar33!(Foo33) bar;
|
|
|
|
*bar.abc.p = 3;
|
|
assert(x33 == 3);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
shared int x34;
|
|
|
|
template Foo34(alias X)
|
|
{
|
|
static shared int* p = &X;
|
|
}
|
|
|
|
template Bar34(alias T)
|
|
{
|
|
alias T.p q;
|
|
}
|
|
|
|
void test34()
|
|
{
|
|
alias Foo34!(x34) foo;
|
|
alias Bar34!(foo) bar;
|
|
|
|
*bar.q = 3;
|
|
assert(x34 == 3);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class Foo35
|
|
{
|
|
static int p;
|
|
}
|
|
|
|
template Bar35(alias T)
|
|
{
|
|
alias T.p q;
|
|
}
|
|
|
|
void test35()
|
|
{
|
|
alias Bar35!(Foo35) bar;
|
|
|
|
bar.q = 3;
|
|
assert(Foo35.p == 3);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template Bar36(T)
|
|
{
|
|
class Bar36
|
|
{
|
|
static T x;
|
|
};
|
|
}
|
|
|
|
void test36()
|
|
{
|
|
Bar36!(int).x = 3;
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class Bar37(T)
|
|
{
|
|
static T x;
|
|
}
|
|
|
|
|
|
void test37()
|
|
{
|
|
Bar37!(int).x = 3;
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class Bar38(T)
|
|
{
|
|
static T x = 3;
|
|
}
|
|
|
|
|
|
void test38()
|
|
{
|
|
int i = template1.Bar38!(int).x;
|
|
assert(i == 3);
|
|
|
|
int j = Bar38!(int).x;
|
|
assert(j == 3);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class Bar39(T)
|
|
{
|
|
alias T x;
|
|
}
|
|
|
|
|
|
void test39()
|
|
{
|
|
Bar39!(int).x y = 3;
|
|
assert(y == 3);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template Bar40(T)
|
|
{
|
|
alias T Bar40;
|
|
}
|
|
|
|
|
|
void test40()
|
|
{
|
|
Bar40!(int) y = 3;
|
|
assert(y == 3);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template Bar41(T)
|
|
{
|
|
alias T Bar41;
|
|
}
|
|
|
|
|
|
void test41()
|
|
{
|
|
template1.Bar41!(int) y = 3;
|
|
assert(y == 3);
|
|
|
|
assert(template1.Bar41!(int).sizeof == int.sizeof);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template Bar42(T) { T t; }
|
|
|
|
typeof(Bar42!(int).t) bar42;
|
|
|
|
void test42()
|
|
{
|
|
bar42 = 5;
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template factor43(int n : 1)
|
|
{
|
|
enum { value = 1 }
|
|
}
|
|
|
|
template factor43(int n)
|
|
{
|
|
enum { value = n*factor43!(n-1).value }
|
|
}
|
|
|
|
void test43()
|
|
{
|
|
|
|
int i = factor43!(3).value;
|
|
|
|
printf("%d\n",i);
|
|
assert(i == 6);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template factorial1(int n : 1)
|
|
{
|
|
const int x = 1;
|
|
}
|
|
|
|
template factorial1(int n)
|
|
{
|
|
const int x = n*.factorial1!(n-1).x;
|
|
}
|
|
|
|
template factorial2(int n : 1)
|
|
{
|
|
const int factorial2 = 1;
|
|
}
|
|
|
|
template factorial2(int n)
|
|
{
|
|
const int factorial2 = n*.factorial2!(n-1);
|
|
}
|
|
|
|
template factorial3(int n : 1)
|
|
{
|
|
enum { x = 1 }
|
|
}
|
|
|
|
template factorial3(int n)
|
|
{
|
|
enum { x = n*.factorial3!(n-1).x }
|
|
}
|
|
|
|
template factorial4(int n : 1)
|
|
{
|
|
enum { factorial4 = 1 }
|
|
}
|
|
|
|
template factorial4(int n)
|
|
{
|
|
enum { factorial4 = n*.factorial4!(n-1) }
|
|
}
|
|
|
|
void test44()
|
|
{
|
|
|
|
int i = factorial1!(4).x;
|
|
printf("%d\n",i);
|
|
assert(i == 24);
|
|
|
|
i = factorial2!(4);
|
|
printf("%d\n",i);
|
|
assert(i == 24);
|
|
|
|
i = factorial3!(4).x;
|
|
printf("%d\n",i);
|
|
assert(i == 24);
|
|
|
|
i = factorial4!(4);
|
|
printf("%d\n",i);
|
|
assert(i == 24);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template factor45(int n)
|
|
{
|
|
int value()
|
|
{
|
|
if (n==0 || n==1)
|
|
return 1;
|
|
return n * factor45!(n-1).value();
|
|
}
|
|
}
|
|
|
|
template factor45(int n : 0)
|
|
{
|
|
int value()
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
template factor45(int n : 1)
|
|
{
|
|
int value()
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
void test45()
|
|
{
|
|
int i;
|
|
|
|
i = factor45!(4).value();
|
|
printf( "%d\n", i);
|
|
assert(i == 24);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template sqrt46(int n, int lo, int hi : lo)
|
|
{
|
|
enum { result = lo }
|
|
}
|
|
|
|
void test46()
|
|
{
|
|
int i;
|
|
|
|
i = sqrt46!(1, 24, 24).result;
|
|
printf("i = %d\n", i);
|
|
assert(i == 24);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template sqrt47(int n, int lo, int hi)
|
|
{
|
|
enum { mid = (lo + hi + 1) / 2 }
|
|
|
|
enum { result = (n < mid * mid) ? sqrt47!(n, lo, mid - 1).result
|
|
: sqrt47!(n, mid, hi).result }
|
|
}
|
|
|
|
template sqrt47(int n, int lo, int hi : lo)
|
|
{
|
|
enum { result = lo }
|
|
}
|
|
|
|
template sqrt47(int n)
|
|
{
|
|
enum { sqrt47 = .sqrt47!(n, 1, n).result }
|
|
}
|
|
|
|
void test47()
|
|
{
|
|
int i;
|
|
|
|
i = sqrt47!(24);
|
|
printf("i = %d\n", i);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class Foo48 (T)
|
|
{
|
|
alias T Type;
|
|
|
|
class Inner (U)
|
|
{
|
|
alias U Type;
|
|
};
|
|
};
|
|
|
|
struct Bar48 (alias TT)
|
|
{
|
|
alias TT!(int).Type A;
|
|
alias TT!(int).Inner!(A).Type B;
|
|
};
|
|
|
|
void test48()
|
|
{
|
|
Bar48!(Foo48).A x;
|
|
Bar48!(Foo48).B y;
|
|
|
|
int *p;
|
|
|
|
p = &x;
|
|
p = &y;
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
struct Foo49(T)
|
|
{
|
|
static Foo49 bar(T c1)
|
|
{
|
|
Foo49 rtn; // Error here
|
|
return rtn;
|
|
}
|
|
}
|
|
|
|
void test49()
|
|
{
|
|
alias Foo49!(double) vector;
|
|
|
|
vector.bar(1);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
struct Foo50(T)
|
|
{
|
|
T x = 0;
|
|
|
|
static Foo50 bar(T c1)
|
|
{
|
|
.Foo50!(typeof(c1)) rtn;
|
|
rtn.x = c1;
|
|
return rtn;
|
|
}
|
|
|
|
static .Foo50!(T) barx(T c1)
|
|
{
|
|
Foo50 rtn;
|
|
rtn.x = c1;
|
|
return rtn;
|
|
}
|
|
}
|
|
|
|
void test50()
|
|
{
|
|
alias Foo50!(double) vector;
|
|
|
|
vector xAxis = vector.bar(1);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
struct Foo51(T)
|
|
{
|
|
T x = 0;
|
|
.Foo51!(long)* p;
|
|
|
|
static Foo51 bar(T c1)
|
|
{
|
|
.Foo51!(typeof(c1)) rtn;
|
|
rtn.x = c1;
|
|
return rtn;
|
|
}
|
|
|
|
static .Foo51!(T) barx(T c1)
|
|
{
|
|
Foo51 rtn;
|
|
.Foo51!(int)* c;
|
|
rtn.x = c1;
|
|
return rtn;
|
|
}
|
|
}
|
|
|
|
void test51()
|
|
{
|
|
alias Foo51!(double) vector;
|
|
|
|
vector xAxis = vector.bar(1);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
interface Interface(T)
|
|
{
|
|
void foo52();
|
|
}
|
|
|
|
void bar52(Interface!(Object) i)
|
|
{
|
|
i.foo52();
|
|
}
|
|
|
|
class Abstract(T) : Interface!(T)
|
|
{
|
|
abstract void foo52();
|
|
}
|
|
|
|
class Concrete(T) : Abstract!(T)
|
|
{
|
|
override void foo52() { printf("Concrete.foo52(this = %p)\n", this); }
|
|
}
|
|
|
|
class Sub(T) : Concrete!(T)
|
|
{
|
|
}
|
|
|
|
void test52()
|
|
{
|
|
Sub!(Object) s = new Sub!(Object)();
|
|
s.foo52();
|
|
bar52(s);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
class Foo53
|
|
{
|
|
template tmethod (T)
|
|
{
|
|
public static void tmethod (T param)
|
|
{
|
|
printf("param = %d\n", param);
|
|
assert(param == 42);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void test53()
|
|
{
|
|
Foo53 foo = new Foo53;
|
|
|
|
Foo53.tmethod!(int)(42);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
class Foo54
|
|
{
|
|
template func(W) {
|
|
static void foo(W w) { printf("W_I %d\n", w); assert(w == 3); }
|
|
static int xx;
|
|
}
|
|
}
|
|
|
|
void test54() {
|
|
|
|
Foo54 c = new Foo54();
|
|
c.func!(int).foo(3);
|
|
c.func!(int).xx = 4;
|
|
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template T55(S)
|
|
{
|
|
struct Foo55
|
|
{
|
|
static Foo55 test(Foo55 f)
|
|
{
|
|
Foo55 a = f;
|
|
return f;
|
|
}
|
|
}
|
|
}
|
|
|
|
alias T55!(char).Foo55 Foo55;
|
|
alias T55!(char).Foo55 Bar55;
|
|
|
|
|
|
void test55()
|
|
{
|
|
Bar55 a;
|
|
Foo55 b;
|
|
b.test(a);
|
|
Bar55.test(a);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template CT56(T)
|
|
{
|
|
class C
|
|
{
|
|
const char[][1] arrArr=["foo" ];
|
|
}
|
|
}
|
|
|
|
void test56()
|
|
{
|
|
alias CT56!(int) Ct;
|
|
Ct.C c= new Ct.C();
|
|
printf("%.*s\n", c.arrArr[0].length, c.arrArr[0].ptr);
|
|
assert(c.arrArr[0] == "foo");
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template foo57(T : int = int)
|
|
{
|
|
T x = 3;
|
|
}
|
|
|
|
void test57()
|
|
{
|
|
printf("%d\n", foo57!().x);
|
|
assert(foo57!().x == 3);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template Foo58(T, U = T)
|
|
{
|
|
U x = 3;
|
|
}
|
|
|
|
void test58()
|
|
{
|
|
alias Foo58!(int) f;
|
|
assert(f.x == 3);
|
|
assert(f.x.sizeof == 4);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template Foo59(T, U = T*)
|
|
{
|
|
shared T x = 3;
|
|
shared U px = &x;
|
|
}
|
|
|
|
void test59()
|
|
{
|
|
alias Foo59!(uint) f;
|
|
assert(f.x == 3);
|
|
assert(f.x.sizeof == 4);
|
|
assert(*f.px == 3);
|
|
|
|
alias Foo59!(long) g;
|
|
assert(g.x == 3);
|
|
assert(g.x.sizeof == 8);
|
|
assert(*g.px == 3);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class A60
|
|
{}
|
|
|
|
template B60(T, U = short)
|
|
{
|
|
struct Thing
|
|
{
|
|
T t;
|
|
U u;
|
|
};
|
|
}
|
|
|
|
template C60(T, U = A60)
|
|
{
|
|
class C60
|
|
: U
|
|
{}
|
|
|
|
class C2
|
|
{};
|
|
}
|
|
|
|
void test60()
|
|
{
|
|
B60!(int, long).Thing thing1;
|
|
B60!(int).Thing thing2;
|
|
|
|
printf("thing1.sizeof: %u\n", thing1.sizeof);
|
|
printf("thing2.sizeof: %u\n", thing2.sizeof);
|
|
|
|
assert(thing1.sizeof == long.alignof + long.sizeof);
|
|
assert(thing2.sizeof == 8);
|
|
|
|
C60!(int /*,A60*/ ) container1;
|
|
|
|
printf("container1.sizeof: %u\n", container1.sizeof);
|
|
assert(container1.sizeof == (void*).sizeof);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
struct Foo61
|
|
{
|
|
int a;
|
|
|
|
template Bar(T)
|
|
{
|
|
T abc() { return a; }
|
|
}
|
|
|
|
int def() { return 4; }
|
|
}
|
|
|
|
void test61()
|
|
{
|
|
Foo61 *f = new Foo61();
|
|
int i;
|
|
|
|
f.a = 3;
|
|
i = f.def();
|
|
assert(i == 4);
|
|
i = f.Bar!(int).abc();
|
|
assert(i == 3);
|
|
|
|
Foo61 g;
|
|
g.a = 3;
|
|
i = g.def();
|
|
assert(i == 4);
|
|
i = g.Bar!(int).abc();
|
|
assert(i == 3);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class Foo62(T)
|
|
{
|
|
template Bar(T)
|
|
{
|
|
int func() { return 3; }
|
|
}
|
|
}
|
|
|
|
void test62()
|
|
{
|
|
Foo62!(int) x = new Foo62!(int);
|
|
|
|
assert(x.Bar!(int).func() == 3);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class Foo63(T)
|
|
{
|
|
template Bar(T)
|
|
{
|
|
int func() { this.def(); return 3; }
|
|
int func2() { return 4; }
|
|
}
|
|
|
|
void def()
|
|
{
|
|
assert(Bar!(T).func2() == 4);
|
|
}
|
|
}
|
|
|
|
void test63()
|
|
{
|
|
Foo63!(int) x = new Foo63!(int);
|
|
|
|
assert(x.Bar!(int).func() == 3);
|
|
x.def();
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
struct XVector(qfloat)
|
|
{
|
|
qfloat x;qfloat y;qfloat z;
|
|
|
|
static int opCall (qfloat x, qfloat y, qfloat z) { return 8; }
|
|
}
|
|
|
|
void test64()
|
|
{
|
|
int i;
|
|
i = XVector!(int)(1,2,3);
|
|
assert(i == 8);
|
|
i = XVector!(real).opCall(1,2,3);
|
|
assert(i == 8);
|
|
}
|
|
|
|
/******************************************/
|
|
// http://www.digitalmars.com/d/archives/28052.html
|
|
|
|
alias int value_type;
|
|
|
|
struct Foo65
|
|
{
|
|
uint length() { return 47; }
|
|
|
|
size_t test()
|
|
{
|
|
value_type[] e = new value_type[length];
|
|
return e.length;
|
|
}
|
|
}
|
|
|
|
void test65()
|
|
{
|
|
Foo65 f;
|
|
|
|
assert(f.test() == 47);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class Thing66
|
|
{
|
|
template print(T2)
|
|
{
|
|
void print(T2 t)
|
|
{
|
|
printf("t = %d\n", t);
|
|
assert(t == 10);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void test66()
|
|
{
|
|
Thing66 thing = new Thing66;
|
|
|
|
thing.print!(int)(10);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template Foo67(alias T)
|
|
{
|
|
void Foo67()
|
|
{
|
|
printf("T = '%.*s'\n", T.length, T.ptr);
|
|
assert(T == "hello");
|
|
}
|
|
}
|
|
|
|
void test67()
|
|
{
|
|
static string x = "hello";
|
|
|
|
Foo67!(x)();
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
template T68(int a) {
|
|
int vec[a];
|
|
}
|
|
|
|
void test68()
|
|
{
|
|
int i;
|
|
|
|
i = T68!(4>1?4:1).vec[0];
|
|
assert(i == 0);
|
|
i = T68!(4==1?1:(1==1?4:(4>1?1:4))).vec[0];
|
|
assert(i == 0);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
size_t printx(string s)
|
|
{
|
|
printf("s = '%.*s'\n", s.length, s.ptr);
|
|
return s.length;
|
|
}
|
|
|
|
size_t printx(int i)
|
|
{
|
|
printf("i = %d\n", i);
|
|
return 28;
|
|
}
|
|
|
|
template Foo69(alias T)
|
|
{
|
|
size_t Foo69()
|
|
{
|
|
return printx(T);
|
|
}
|
|
}
|
|
|
|
void test69()
|
|
{
|
|
static string x = "hello";
|
|
static string z = "abc";
|
|
static int y=100;
|
|
size_t i;
|
|
|
|
alias Foo69!(x) foox;
|
|
alias Foo69!(y) fooy;
|
|
|
|
i = Foo69!(x)();
|
|
assert(i == 5);
|
|
i = Foo69!(y)();
|
|
assert(i == 28);
|
|
i = Foo69!(z)();
|
|
assert(i == 3);
|
|
i = foox();
|
|
assert(i == 5);
|
|
i = fooy();
|
|
assert(i == 28);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template temptt70(alias func)
|
|
{
|
|
void temp()
|
|
{
|
|
func();
|
|
}
|
|
}
|
|
|
|
int x70;
|
|
|
|
void myfunc70()
|
|
{
|
|
printf("myfunc70()\n");
|
|
x70 = 6;
|
|
}
|
|
|
|
alias temptt70!(myfunc70).temp foo70;
|
|
|
|
void test70()
|
|
{
|
|
foo70();
|
|
assert(x70 == 6);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
struct A71(T)
|
|
{
|
|
alias .A71!(T) AT;
|
|
int x;
|
|
}
|
|
|
|
alias A71!(int) Aint71;
|
|
|
|
void test71()
|
|
{
|
|
Aint71.AT a;
|
|
a.x = 3;
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
template foo72(T)
|
|
{
|
|
char[] foo72(T d)
|
|
{
|
|
uint sz = typeof(d[0]).sizeof * 2;
|
|
return null;
|
|
}
|
|
}
|
|
|
|
void test72()
|
|
{
|
|
static ulong[5] a = [0,1,2,3,4];
|
|
static uint[5] b = [0,1,2,3,4];
|
|
char[] r;
|
|
r = foo72!(ulong[5])(a); printf("%.*s\n", r.length, r.ptr);
|
|
r = foo72!(uint[5])(b); printf("%.*s\n", r.length, r.ptr);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
alias int Int73;
|
|
class Test73(T = Int73);
|
|
alias Test73!() Foo73;
|
|
|
|
void test73()
|
|
{
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class A74
|
|
{
|
|
alias A74 atype;
|
|
int x;
|
|
}
|
|
|
|
|
|
class B74(R, int V = R.sizeof)
|
|
{
|
|
int v = V;
|
|
}
|
|
|
|
void test74()
|
|
{
|
|
B74!(A74,3) b = new B74!(A74,3)();
|
|
assert(b.v == 3);
|
|
|
|
B74!(A74) c = new B74!(A74)();
|
|
assert(c.v == A74.sizeof);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
interface NotionalRange75(V)
|
|
{
|
|
}
|
|
|
|
class MatchedNotionalRange75(R)
|
|
: NotionalRange75!(R.value_type)
|
|
{
|
|
}
|
|
|
|
class Range75
|
|
{
|
|
alias int value_type;
|
|
}
|
|
|
|
class List75
|
|
{
|
|
|
|
MatchedNotionalRange75!(Range75) x;
|
|
}
|
|
|
|
void test75()
|
|
{
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
interface Indian(T)
|
|
{
|
|
}
|
|
|
|
interface Iterable(T)
|
|
{
|
|
Indian!(T) foo();
|
|
}
|
|
|
|
class Lope(T) : Iterable!(T)
|
|
{
|
|
Indian!(T) foo()
|
|
{
|
|
return new Corn!(T);
|
|
}
|
|
}
|
|
|
|
class Corn(T) : Indian!(T)
|
|
{
|
|
}
|
|
|
|
void test76()
|
|
{
|
|
Lope!(int) x = new Lope!(int);
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
class RawFile
|
|
{
|
|
}
|
|
|
|
class Stream : RawFile
|
|
{
|
|
template readLineT(T) { bool readLineT()
|
|
{
|
|
if (super)
|
|
return false;
|
|
return true;
|
|
}}
|
|
|
|
bool readLine()
|
|
{
|
|
return readLineT!(int)();
|
|
}
|
|
}
|
|
|
|
void test77()
|
|
{
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
|
|
class Four(U, V, X, Y)
|
|
{
|
|
U i; V j; X k; Y l;
|
|
}
|
|
|
|
template WhatFour(U,V,X,Y)
|
|
{
|
|
int func(Four!(U,V,X,Y) four)
|
|
{
|
|
printf("general template\n");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
template WhatFour(U:int,V,X,Y)
|
|
{
|
|
int func(Four!(int,V,X,Y) four)
|
|
{
|
|
printf("specialization:: first int\n");
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
template WhatFour(U,V:U,X,Y:X)
|
|
{
|
|
int func(Four!(U,U,X,X) four)
|
|
{
|
|
printf("specialization:: first two equal, second two equal\n");
|
|
return 3;
|
|
}
|
|
}
|
|
|
|
alias WhatFour!(int,float,char,bool).func whatfour;
|
|
alias WhatFour!(float,float,char,bool).func whatfour;
|
|
alias WhatFour!(float,float,char,char).func whatfour;
|
|
alias WhatFour!(int,int,float,char).func whatfour; // ambiguous match
|
|
|
|
void test78()
|
|
{ int j;
|
|
|
|
Four!(int,float,char,bool) f;
|
|
Four!(float,float,char,bool) g;
|
|
Four!(float,float,char,char) h;
|
|
Four!(int,int,float,char) i;
|
|
|
|
j = whatfour(f);
|
|
assert(j == 2);
|
|
j = whatfour(g);
|
|
assert(j == 1);
|
|
j = whatfour(h);
|
|
assert(j == 3);
|
|
j = whatfour(i);
|
|
assert(j == 2);
|
|
|
|
/*
|
|
will print:
|
|
specialization:: first int
|
|
general template
|
|
specialization:: first two equal, second two equal
|
|
specialization:: first int
|
|
*/
|
|
}
|
|
|
|
|
|
/******************************************/
|
|
// http://www.digitalmars.com/pnews/read.php?server=news.digitalmars.com&group=digitalmars.D.bugs&artnum=2117
|
|
|
|
class Conversion(T,U){
|
|
alias char Small;
|
|
class Big{
|
|
char[2] dummy;
|
|
}
|
|
static Small Test(U u);
|
|
static Big Test(...);
|
|
static T MakeT();
|
|
enum {
|
|
exists = (Test(MakeT())).sizeof == (Small).sizeof
|
|
}
|
|
}
|
|
|
|
void variadicDummy(...){
|
|
}
|
|
|
|
void test79()
|
|
{
|
|
variadicDummy(Conversion!(double,int).exists);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
class A80(T)
|
|
{
|
|
T s;
|
|
|
|
int foo(int delegate (T) d) { return 3 + d(s); }
|
|
|
|
int bar()
|
|
{
|
|
return foo(delegate int (T t) { return 6 + t.x; });
|
|
}
|
|
}
|
|
|
|
class B80: A80!(B80)
|
|
{
|
|
int x = 20;
|
|
}
|
|
|
|
class C80: A80!(C80)
|
|
{
|
|
int y = 3;
|
|
int x = 10;
|
|
}
|
|
|
|
void test80()
|
|
{
|
|
B80 b = new B80();
|
|
C80 c = new C80();
|
|
|
|
b.s = b;
|
|
c.s = c;
|
|
|
|
assert(b.bar() == 9+20);
|
|
assert(c.bar() == 9+10);
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
struct T81(FOO)
|
|
{
|
|
S81 s;
|
|
}
|
|
|
|
struct S81
|
|
{
|
|
T81!(int)* pt;
|
|
}
|
|
|
|
void test81()
|
|
{
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
T foo82(T : const(U)*, U=char)(T t)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
void test82()
|
|
{ int i;
|
|
const int ci;
|
|
|
|
//writeln(typeid(typeof(foo82(&ci))));
|
|
//writeln(typeid(typeof(foo82(&i))));
|
|
assert(typeof(foo82(&ci)).stringof == "const(int)*");
|
|
assert(typeof(foo82(&i)).stringof == "int*");
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
struct A83
|
|
{
|
|
void foo(int) {}
|
|
void bar(T)(T) {}
|
|
}
|
|
|
|
void test83()
|
|
{
|
|
A83 a;
|
|
a.foo = 5;
|
|
a.bar = 6;
|
|
}
|
|
|
|
/******************************************/
|
|
|
|
int main()
|
|
{
|
|
test1();
|
|
test2();
|
|
test3();
|
|
test4();
|
|
test5();
|
|
test6();
|
|
test7();
|
|
test8();
|
|
test9();
|
|
test10();
|
|
test11();
|
|
test12();
|
|
test13();
|
|
test14();
|
|
test15();
|
|
test16();
|
|
test17();
|
|
test18();
|
|
// test19();
|
|
test20();
|
|
test21();
|
|
test22();
|
|
test23();
|
|
test24();
|
|
test25();
|
|
test26();
|
|
test27();
|
|
test28();
|
|
test29();
|
|
test30();
|
|
test31();
|
|
test32();
|
|
test33();
|
|
test34();
|
|
test35();
|
|
test36();
|
|
test37();
|
|
test38();
|
|
test39();
|
|
test40();
|
|
test41();
|
|
test42();
|
|
test43();
|
|
test44();
|
|
test45();
|
|
test46();
|
|
test47();
|
|
test48();
|
|
test49();
|
|
test50();
|
|
test51();
|
|
test52();
|
|
test53();
|
|
test54();
|
|
test55();
|
|
test56();
|
|
test57();
|
|
test58();
|
|
test59();
|
|
test60();
|
|
test61();
|
|
test62();
|
|
test63();
|
|
test64();
|
|
test65();
|
|
test66();
|
|
test67();
|
|
test68();
|
|
test69();
|
|
test70();
|
|
test71();
|
|
test72();
|
|
test73();
|
|
test74();
|
|
test75();
|
|
test76();
|
|
test77();
|
|
test78();
|
|
test79();
|
|
test80();
|
|
test81();
|
|
test82();
|
|
test83();
|
|
|
|
printf("Success\n");
|
|
return 0;
|
|
}
|