bearophile 
| I like to test all my functions, are there ways to unit test nested functions?
void foo() {
int add(int x, int y) {
return x + y;
}
unittest { // found 'unittest' instead of statement
assert(add(10, 20) == 30);
}
}
unittest {
assert(foo.add(10, 20) == 30); // Error: no property 'add' for type 'void'
}
void main() {}
If currently there's no way, I think it can be good to add to the language some way to test them.
----------------------
This is a question regarding templates. Let's say I have a simple struct template that is specified by an integer:
struct S(int N) {
int[N] a;
}
Now I'd like to write a function that takes a S, and for example prints the integers of S.a separated by a space (I don't care of the extra space at the end).
This is easy to to in Haskell because it has type classes, but it's less easy to do in D (I don't know if type classes can be introduced into the D type system):
http://en.wikipedia.org/wiki/Type_class
This is a simple solution, but it compiles only if N == 2, so I'd like something more general:
void printS1(S!(2) s) {
foreach (el; s.a)
put(el, " ");
putr();
}
This is general, a function template, but it requires you to specify N:
void printS2(int N)(S!(N) s) {
foreach (el; s.a)
put(el, " ");
putr();
}
You have to call it for example like this:
printS2!(s.a.length)(s);
The following way ignores S, and just looks if the given type T has the requires qualities:
void printS3(T)(T s) {
static assert(is(T == struct) && (T.tupleof.length == 1) &&
is(typeof(T.a)) && is(ArrayType1!(typeof(T.a)) == int)
);
foreach (el; s.a)
put(el, " ");
putr();
}
(Where ArrayType1 gives the type of the items of T.a). printS3 isn't strict enough, because it accepts all typedef-ined types as long as they have that qualities. And if you change S a little, you have to change lot of code.
The following doesn't work, I don't know why:
void printSX(T)(T s) {
static assert ( is(T == S) );
...
So this is more strict, but requires more RAM during compilation, and it doesn't accept N > 13:
void printS4(T)(T s) {
//static assert (is(T == S), "printS4: err"); // doesn't work
static assert (IsType!(T, S!(0), S!(1), S!(2), S!(3), S!(4), S!(5), S!(6),
S!(7), S!(8), S!(9), S!(10), S!(11), S!(12), S!(13)
), "printS4: err");
foreach (el; s.a)
put(el, " ");
putr();
}
Of course that can be generalized, up to N =~ 2930 but it requires lot of RAM and some compilation time, so this can't be the way to go:
template IsTN(alias TN, T, int N=0) {
static if (N >= 2900 || N < 0) // 2900 is an arbitrary high value
const bool IsTN = false;
else static if ( is(T == TN!(N)) )
const bool IsTN = true;
else
const bool IsTN = IsTN!(TN, T, N+1);
}
void printS5(T)(T s) {
static assert (IsTN!(S, T), "printS5: err");
foreach (el; s.a)
put(el, " ");
putr();
}
To reduce the RAM used I have tried to use a CT function, but it doesn't work:
bool isTN(alias TN, T)() { // doesn't work
int i = 0;
while ( is(T == TN!(i)) ) {}
return true;
}
void printS6(T)(T s) {
static assert (isTN!(S, T)(), "printS6: err");
foreach (el; s.a)
put(el, " ");
putr();
}
I have tried with a recursive CT function, but it doesn't work still (maybe there are ways to make it run):
bool isTN2(alias TN, T)(int n=0) {
if (n >= 2900 || n < 0)
return false;
else if ( is(T == TN!(n)) )
return true;
else
return IsTN2!(TN, T)(n+1);
}
void printS8(T)(T s) {
static assert (isTN2!(S, T)(), "printS6: err");
foreach (el; s.a)
put(el, " ");
putr();
}
In the end changing totally approch it works and uses little RAM, but is this a good solution?
void printS7(T)(T s) {
static assert (S.stringof == "S(int N)", "printS7: err");
foreach (el; s.a)
put(el, " ");
putr();
}
Bye,
bearophile
|
Permalink
Reply
