blob: e38ab1c858de4653f95577cc062d965eaf024e98 [file] [log] [blame]
// RUNNABLE_PHOBOS_TEST
/*
TEST_OUTPUT:
---
Object
---
*/
module test34;
import std.stdio;
import std.string;
import std.format;
import core.exception;
/************************************************/
class Foo {}
class Bar {}
void test1()
{
TypeInfo ti_foo = typeid(Foo);
TypeInfo ti_bar = typeid(Bar);
auto hfoo = ti_foo.toHash();
auto hbar = ti_bar.toHash();
writefln("typeid(Foo).toHash: ", hfoo);
writefln("typeid(Bar).toHash: ", hbar);
assert(hfoo != hbar);
auto e = (ti_foo == ti_bar);
writefln("opEquals: ", e ? "equal" : "not equal");
assert(!e);
auto c = (ti_foo.opCmp(ti_bar) == 0);
writefln("opCmp: ", c ? "equal" : "not equal");
assert(!c);
}
/************************************************/
void test2()
{
assert( [2,3]!=[2,4] );
assert( [3,2]!=[4,2] );
assert( !([2,3]==[2,4]) );
assert( ([2,3]==[2,3]) );
}
/************************************************/
struct Struct
{
int langID;
long _force_nrvo;
}
Struct[1] table;
Struct getfirst()
{
foreach(v; table) {
writeln(v.langID);
assert(v.langID == 1);
return v;
}
assert(0);
}
Struct getsecond()
{
foreach(ref v; table) {
writeln(v.langID);
assert(v.langID == 1);
return v;
}
assert(0);
}
void test3()
{
table[0].langID = 1;
auto v = getfirst();
writeln(v.langID);
assert(v.langID == 1);
v = getsecond();
writeln(v.langID);
assert(v.langID == 1);
}
/************************************************/
class ExOuter
{
class ExInner
{
this()
{
typeof(this.outer) X;
static assert(is(typeof(X) == ExOuter));
}
}
}
void test4()
{
}
/************************************************/
int status5;
struct MyStruct5
{
}
void rec5(int i, MyStruct5 s)
{
if( i > 0 )
{
status5++;
rec5(i-1, s);
}
}
void test5()
{
assert(status5==0);
MyStruct5 st;
rec5(1030, st);
assert(status5==1030);
}
/************************************************/
class C6
{
const int a;
this()
{
a = 3;
}
this(int x)
{
this();
}
}
void test6()
{
}
/************************************************/
template parseUinteger(string s)
{
static if (s.length == 0)
{ const char[] value = "";
const char[] rest = "";
}
else static if (s[0] >= '0' && s[0] <= '9')
{ const char[] value = s[0] ~ parseUinteger!(s[1..$]).value;
const char[] rest = parseUinteger!(s[1..$]).rest;
}
else
{ const char[] value = "";
const char[] rest = s;
}
}
template parseInteger(string s)
{
static if (s.length == 0)
{ const char[] value = "";
const char[] rest = "";
}
else static if (s[0] >= '0' && s[0] <= '9')
{ const char[] value = s[0] ~ parseUinteger!(s[1..$]).value;
const char[] rest = parseUinteger!(s[1..$]).rest;
}
else static if (s.length >= 2 &&
s[0] == '-' && s[1] >= '0' && s[1] <= '9')
{ const char[] value = s[0..2] ~ parseUinteger!(s[2..$]).value;
const char[] rest = parseUinteger!(s[2..$]).rest;
}
else
{ const char[] value = "";
const char[] rest = s;
}
}
void test7()
{
writeln(parseUinteger!("1234abc").value);
writeln(parseUinteger!("1234abc").rest);
writeln(parseInteger!("-1234abc").value);
writeln(parseInteger!("-1234abc").rest);
assert(parseUinteger!("1234abc").value == "1234");
assert(parseUinteger!("1234abc").rest == "abc");
assert(parseInteger!("-1234abc").value == "-1234");
assert(parseInteger!("-1234abc").rest == "abc");
}
/************************************************/
struct Foo8 { }
enum Enum { RED }
//typedef int myint;
alias int myalias;
void test8()
{
/+
assert((1+2).stringof == "1 + 2");
assert(Foo8.stringof == "Foo8");
assert(test.Foo8.stringof == "test.Foo8");
assert(int.stringof == "int");
assert((int*[5][]).stringof == "int*[5][]");
assert(Enum.RED.stringof == "Enum.RED");
assert(test.myint.stringof == "test.myint");
assert(myalias.stringof == "myalias");
assert((5).stringof == "5");
assert(typeof(5).stringof == "typeof(5)");
+/
}
/************************************************/
/+
class Base9 {
public void fnc(){
}
}
class Foo9 : Base9 {
alias Base9.fnc fnc;
public void fnc(){
}
static this(){
alias void function() T;
T ptr = & fnc;
}
}
+/
void test9()
{
}
/************************************************/
bool isalnum(dchar c) { return c>='0' && c >= '9'; }
char[] toHtmlFilename(char[] fname)
{
foreach (ref c; fname)
{
if (!isalnum(c) && c != '.' && c != '-')
c = '_';
}
return fname;
}
void test10()
{
}
/************************************************/
class A34 { }
class B34 : A34 { }
void test11()
{
A34 test=new B34;
writefln("Test is ", test.toString);
assert(test.toString == "test34.B34");
A34 test_2=cast(A34)(new B34);
writefln("Test 2 is ", test_2.toString);
assert(test_2.toString == "test34.B34");
}
/************************************************/
template Foo12(T: T[U], U)
{
alias int Foo12;
}
void test12()
{
Foo12!(int[long]) x;
assert(is(typeof(x) == int));
}
/************************************************/
class C13
{
int a = 4;
this()
{
printf("C13.this()\n");
assert(a == 4);
a = 5;
}
}
void test13()
{
C13 c = cast(C13)Object.factory("test34.C13");
assert(c.a == 5);
Object o = Object.factory("test35.C13");
assert(o is null);
}
/************************************************/
class Base15 {
int func(int a) { return 1; }
}
class Foo15 : Base15 {
alias Base15.func func;
}
class Bar15 : Foo15 {
alias Foo15.func func;
int func(string a) { return 2; }
}
void test15()
{
Bar15 b = new Bar15();
assert(b.func("hello") == 2);
assert(b.func(5) == 1);
}
/************************************************/
struct Basic16(T, U) {}
struct Iterator16(T : Basic16!(T, U), U)
{
static void Foo()
{
writeln(typeid(T), typeid(U));
assert(is(T == int));
assert(is(U == float));
}
}
void test16()
{
Iterator16!(Basic16!(int, float)).Foo();
}
/************************************************/
struct S17(T)
{
struct iterator {}
}
int insert17(T) (S17!(T) lst, S17!(T).iterator i)
{
return 3;
}
void test17()
{
S17!(int) a;
S17!(int).iterator i;
auto x = insert17(a, i);
assert(x == 3);
}
/************************************************/
void test18()
{
real t = 0.;
for(int i=0; i<10; i++)
{
t += 1.;
real r = (2*t);
printf("%Lg %Lg %Lg\n", t, r, 2*t);
assert(2*t == (i+1)*2);
}
}
/************************************************/
void test19()
{
char c = '3';
void[] ca = cast(void[])[c];
char[] x = cast(char[])ca;
assert(x[0] == '3');
}
/************************************************/
enum type20
{
a,
b,
}
class myclass20
{
template XX(uint a, uint c)
{
static uint XX(){ return (a*256+c);}
}
void testcase()
{
switch (cast(uint)type20.a)
{
case XX!(cast(uint)type20.a,cast(uint)type20.b)():
break;
default: assert(0);
}
}
}
void test20()
{
}
/************************************************/
struct S21
{
alias int Foo;
int x;
}
void test21()
{
S21 s;
typeof(s).Foo j;
assert(is(typeof(j) == int));
}
/************************************************/
void test22()
{
auto i = 3, j = 4;
assert(is(typeof(i) == int));
assert(is(typeof(j) == int));
}
/************************************************/
static m23 = 5, n23 = 6;
void test23()
{
auto i = 3, j = 4;
assert(is(typeof(i) == int));
assert(is(typeof(j) == int));
assert(is(typeof(m23) == int));
assert(is(typeof(n23) == int));
}
/************************************************/
const int a24 = 0;
const int foo24 = 4;
const int[1] bar24 = [foo24 * 2];
const int zap24 = (1 << bar24[a24]);
void test24()
{
assert(zap24 == 256);
}
/************************************************/
struct List25(T) { }
struct CircularQueue25(T) { }
void front25(T)(ref List25!(T) list) { }
void front25(T)(ref CircularQueue25!(T) queue) { }
void test25()
{
List25!(int) x;
front25(x);
}
/************************************************/
struct Foo26
{
const string x;
}
static Foo26 foo26 = {"something"};
void test26()
{
assert(foo26.x == "something");
}
/************************************************/
template Mang(alias F)
{
class G { }
alias void function (G ) H;
const string mangledname = H.mangleof;
}
template moo(alias A)
{
pragma(msg," ");
const string a = Mang!(A).mangledname;
pragma(msg," ");
static assert(Mang!(A).mangledname == a); // FAILS !!!
pragma(msg," ");
}
void test27()
{
int q;
string b = moo!(q).a;
}
/************************************************/
struct Color
{
static void fromRgb(uint rgb)
{
}
static void fromRgb(ubyte alpha, uint rgb)
{
}
}
void test28()
{
Color.fromRgb(0);
Color.fromRgb(cast(uint)0);
}
/************************************************/
void test29()
{
const char[] t="abcd";
const ubyte[] t2=cast(ubyte[])t;
const char[] t3=['a','b','c','d'];
const ubyte[] t4=cast(ubyte[])t3;
assert(t4[1] == 'b');
}
/************************************************/
void test30()
{
const char[] test = "" ~ 'a' ~ 'b' ~ 'c';
char[] test2 = (cast(char[])null)~'a'~'b'~'c';
const char[] test3 = (cast(char[])null)~'a'~'b'~'c';
char[] test4 = (cast(char[])[])~'a'~'b'~'c';
const char[] test5 = (cast(char[])[])~'a'~'b'~'c';
const char[] test6 = null;
const char[] test7 = test6~'a'~'b'~'c';
}
/************************************************/
class C31
{
synchronized invariant() { int x; }
}
void test31()
{
}
/************************************************/
ulong foo32()
{
return cast(ulong) (cast(ulong) 1176576512 + cast(float) -2);
}
void test32()
{
assert(foo32()==1176576510);
}
/************************************************/
class RangeCoder
{
uint[258] cumCount; // 256 + end + total
uint lower;
uint upper;
ulong range;
this() {
for (int i=0; i<cumCount.length; i++)
cumCount[i] = i;
lower = 0;
upper = 0xffffffff;
range = 0x100000000;
}
void encode(uint symbol) {
uint total = cumCount[$ - 1];
// "Error: Access Violation" in following line
upper = lower + cast(uint)((cumCount[symbol+1] * range) / total) - 1;
lower = lower + cast(uint)((cumCount[symbol] * range) / total);
}
}
void test33()
{
RangeCoder rc = new RangeCoder();
rc.encode(77);
}
/************************************************/
struct Vector34
{
float x, y, z;
public static Vector34 opCall(float x = 0, float y = 0, float z = 0)
{
Vector34 v;
v.x = x;
v.y = y;
v.z = z;
return v;
}
public string toString()
{
return std.string.format("<%f, %f, %f>", x, y, z);
}
}
class Foo34
{
private Vector34 v;
public this()
{
v = Vector34(1, 0, 0);
}
public void foo()
{
bar();
}
private void bar()
{
auto s = foobar();
writef("Returned: %s\n", s);
assert(std.string.format("%s", s) == "<1.000000, 0.000000, 0.000000>");
}
public Vector34 foobar()
{
writef("Returning %s\n", v);
return v;
Vector34 b = Vector34();
return b;
}
}
void test34()
{
Foo34 f = new Foo34();
f.foo();
}
/************************************************/
void foo35()
{
uint a;
uint b;
uint c;
extern (Windows) int function(int i, int j, int k) xxx;
a = 1;
b = 2;
c = 3;
xxx = cast(typeof(xxx))(a + b);
throw new Exception("xxx");
xxx( 4, 5, 6 );
}
void test35()
{
}
/************************************************/
void test36()
{
int* p = void, c = void;
}
/************************************************/
void test37()
{
synchronized
{
synchronized
{
writefln("Hello world!");
}
}
}
/************************************************/
struct Rect {
int left, top, right, bottom;
}
void test38()
{
print38(sizeTest(false));
print38(sizeTest(true));
print38(defaultRect);
}
static Rect sizeTest(bool empty) {
if (empty) {
Rect result;
return result;
//return Rect.init;
} else {
return defaultRect;
/+Rect result = defaultRect;
return result;+/
}
}
void print38(Rect r) {
writefln("(%d, %d)-(%d, %d)", r.left, r.top, r.right, r.bottom);
assert(r.left == 0);
assert(r.right == 0);
assert(r.top == 0);
assert(r.bottom == 0);
}
Rect defaultRect() {
return Rect.init;
}
/************************************************/
void test39()
{
double[][] foo = [[1.0],[2.0]];
writeln(foo[0]); // --> [1] , ok
writeln(foo[1]); // --> [2] , ok
writeln(foo); // --> [[1],4.63919e-306] ack!
writefln("%s", foo); // --> ditto
auto f = std.string.format("%s", foo);
assert(f == "[[1], [2]]");
double[1][2] bar;
bar[0][0] = 1.0;
bar[1][0] = 2.0;
writeln(bar); // Error: Access violation
auto r = std.string.format("%s", bar);
assert(r == "[[1], [2]]");
}
/************************************************/
void test40()
{
int[char] x;
x['b'] = 123;
writeln(x);
auto r = std.string.format("%s", x);
assert(r == "['b':123]");
writeln(x['b']);
}
/************************************************/
void test41()
{
}
/************************************************/
enum Enum42 {
A = 1
}
void test42() {
Enum42[] enums = new Enum42[1];
assert(enums[0] == Enum42.A);
}
/************************************************/
struct A43 {}
struct B43(L) {
A43 l;
}
void test43()
{
A43 a;
auto b = B43!(A43)(a);
}
/************************************************/
void test44()
{
int[ const char[] ] a = ["abc":3, "def":4];
}
/************************************************/
void test45()
{
//char[3][] a = ["abc", "def"];
//writefln(a);
//char[][2] b = ["abc", "def"];
//writefln(b);
}
/************************************************/
struct bignum
{
bool smaller()
{
if (true) return false;
else return false;
assert(0);
}
void equal()
{
if (!smaller)
return;
}
}
void test46()
{
}
/************************************************/
static size_t myfind(string haystack, char needle) {
foreach (i, c ; haystack) {
if (c == needle) return i;
}
return size_t.max;
}
static size_t skip_digits(string s) {
foreach (i, c ; s) {
if (c < '0' || c > '9') return i;
}
return s.length;
}
static uint matoi(string s) {
uint result = 0;
foreach (c ; s) {
if (c < '0' || c > '9') break;
result = result * 10 + (c - '0');
}
return result;
}
enum { leading, skip, width, modifier, format, fmt_length, extra };
static string GetFormat(string s) {
uint pos = 0;
string result;
// find the percent sign
while (pos < s.length && s[pos] != '%') {
++pos;
}
const leading_chars = pos;
result ~= cast(char) pos;
if (pos < s.length) ++pos; // go right after the '%'
// skip?
if (pos < s.length && s[pos] == '*') {
result ~= 1;
++pos;
} else {
result ~= 0;
}
// width?
result ~= cast(char) matoi(s);
pos += skip_digits(s[pos .. $]);
// modifier?
if (pos < s.length && myfind("hjlLqtz", s[pos]) != size_t.max) {
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@
static if (true) {
result ~= s[pos++];
} else {
result ~= s[pos];
++pos;
}
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@
} else {
result ~= '\0';
}
return result;
}
void test47()
{
static string test = GetFormat(" %*Lf");
assert(test[modifier] == 'L', "`" ~ test[modifier] ~ "'");
}
/************************************************/
class B48() {}
class C48 {}
int foo48()(B48!()) { return 1; }
int foo48()(C48 c) { return 2; }
void test48()
{
auto i = foo48(new B48!());
assert(i == 1);
i = foo48(new C48);
assert(i == 2);
}
/************************************************/
void test49()
{
struct A { int v; }
A a = A(10);
version (all)
{
writefln("Before test 1: ", a.v);
if (a == a.init) { writeln(a.v,"(a==a.init)"); assert(0); }
else { writeln(a.v,"(a!=a.init)"); assert(a.v == 10); }
}
else
{
writefln("Before test 1: ", a.v);
if (a == a.init) { writeln(a.v,"(a==a.init)"); assert(a.v == 10); }
else { writeln(a.v,"(a!=a.init)"); assert(0); }
}
a.v = 100;
writefln("Before test 2: ", a.v);
if (a == a.init) { writeln(a.v,"(a==a.init)"); assert(0); }
else { writeln(a.v,"(a!=a.init)"); assert(a.v == 100); }
a = A(1000);
writefln("Before test 3: ", a.v);
if (a == a.init) { writeln(a.v,"(a==a.init)"); assert(0); }
else { writeln(a.v,"(a!=a.init)"); assert(a.v == 1000); }
version (all)
assert(a.init.v == 0);
else
assert(a.init.v == 10);
}
/************************************************/
struct S51
{
int i = 3;
void div() { assert(i == 3); }
}
void test51()
{
S51().div();
}
/************************************************/
void test52()
{
struct Foo {
alias int Y;
}
with (Foo) {
Y y;
}
}
/************************************************/
struct TestStruct
{
int dummy0 = 0;
int dummy1 = 1;
int dummy2 = 2;
}
void func53(TestStruct[2] testarg)
{
writeln(testarg[0].dummy0);
writeln(testarg[0].dummy1);
writeln(testarg[0].dummy2);
writeln(testarg[1].dummy0);
writeln(testarg[1].dummy1);
writeln(testarg[1].dummy2);
assert(testarg[0].dummy0 == 0);
assert(testarg[0].dummy1 == 1);
assert(testarg[0].dummy2 == 2);
assert(testarg[1].dummy0 == 0);
assert(testarg[1].dummy1 == 1);
assert(testarg[1].dummy2 == 2);
}
TestStruct m53[2];
void test53()
{
writeln(&m53);
func53(m53);
}
/************************************************/
void test54()
{
double a = 0;
double b = 1;
// Internal error: ..\ztc\cg87.c 3233
// a += (1? b: 1+1i)*1i;
writeln(a);
// assert(a == 0);
// Internal error: ..\ztc\cod2.c 1680
// a += (b?1:b-1i)*1i;
writeln(a);
// assert(a == 0);
}
/************************************************/
class B55 {}
class D55 : B55 {}
template foo55(S, T : S) { } // doesn't work
alias foo55!(B55, D55) bar55;
void test55()
{
}
/************************************************/
template t56() { alias Object t56; }
pragma(msg, t56!().stringof);
void test56()
{
}
/************************************************/
void test57()
{
alias long[char[]] AA;
static if (is(AA T : T[U], U : const char[]))
{
writeln(typeid(T));
writeln(typeid(U));
assert(is(T == long));
assert(is(U == const(char)[]));
}
static if (is(AA A : A[B], B : int))
{
assert(0);
}
static if (is(int[10] W : W[V], int V))
{
writeln(typeid(W));
assert(is(W == int));
writeln(V);
assert(V == 10);
}
static if (is(int[10] X : X[Y], int Y : 5))
{
assert(0);
}
}
/************************************************/
static this()
{
printf("one\n");
}
static this()
{
printf("two\n");
}
static ~this()
{
printf("~two\n");
}
static ~this()
{
printf("~one\n");
}
void test59()
{
}
/************************************************/
class C60
{
extern (C++) int bar60(int i, int j, int k)
{
printf("this = %p\n", this);
printf("i = %d\n", i);
printf("j = %d\n", j);
printf("k = %d\n", k);
assert(i == 4);
assert(j == 5);
assert(k == 6);
return 1;
}
}
extern (C++)
int foo60(int i, int j, int k)
{
printf("i = %d\n", i);
printf("j = %d\n", j);
printf("k = %d\n", k);
assert(i == 1);
assert(j == 2);
assert(k == 3);
return 1;
}
void test60()
{
foo60(1, 2, 3);
C60 c = new C60();
c.bar60(4, 5, 6);
}
/***************************************************/
template Foo61(alias a) {}
struct Bar61 {}
const Bar61 bar61 = {};
alias Foo61!(bar61) baz61;
void test61()
{
}
/************************************************/
T foo62(T)(lazy T value)
{
return value;
}
void test62()
{
foo62(new float[1]);
}
/************************************************/
void main()
{
test1();
test2();
test3();
test4();
test5();
test6();
test7();
test8();
test9();
test10();
test11();
test12();
test13();
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();
test51();
test52();
test53();
test54();
test55();
test56();
test57();
test59();
test60();
test61();
test62();
writefln("Success");
}