root/test.d

import std.stdio;
import std.utf;
import std.file;
import std.path;
import std.algorithm;
import std.string;
import std.process;
import core.stdc.ctype;
import std.c.windows.windows;

string compiler = "dmd";

class Test
{
    enum EXTRA_SOURCES = "EXTRA_SOURCES";
    enum COMPILE_SEPARATELY = "COMPILE_SEPARATELY";
    enum PERMUTE_ARGS = "PERMUTE_ARGS";
    enum REQUIRED_ARGS = "REQUIRED_ARGS";
    enum POST_SCRIPT = "POST_SCRIPT";
    enum EXECUTE_ARGS = "EXECUTE_ARGS";
    
    this(string path, string outputDir)
    {
        this.outputDir = outputDir;
        this.baseDir = dirname(path);
        
        this.baseName = getBaseName(path);
        this.name = getName(baseName);
        
        this.fileNames ~= baseName;
        
        auto file = File(path);
        while (true) {
            auto line = file.readln();
            if (!line.startsWith("// ")) {
                break;
            }
            
            line = trim(line[3..$]);
            if (line.startsWith(EXTRA_SOURCES)) {
                fileNames ~= split(line[EXTRA_SOURCES.length + 2..$], " ");
            } else if (line.startsWith(COMPILE_SEPARATELY)) {
                compileSeparately = true;
            } else if (line.startsWith(EXECUTE_ARGS)) {
                executeArgs = line[EXECUTE_ARGS.length + 2..$];
            } else if (line.startsWith(PERMUTE_ARGS)) {
                // ignore for now
            } else if (line.startsWith(REQUIRED_ARGS)) {
                requiredArgs = line[REQUIRED_ARGS.length + 2..$];
            } else if (line.startsWith(POST_SCRIPT)) {
                // ignore for now
            } else {
                continue;
            }
        }
    }
    
    private string prefix()
    {
        return std.string.format(compiler ~ " -od%s -I%s %s", outputDir, baseDir, requiredArgs);
    }
    
    private string csuffix(string fileName)
    {
        // output to console
        return ""; //std.string.format(" > %s\\%s.clog", outputDir, getBaseName(fileName));
    }
    
    private string lsuffix(string fileName)
    {
        return std.string.format(" > %s\\%s.llog", outputDir, getBaseName(fileName));
    }
    
    private string output()
    {
        return std.string.format(" -of%s\\%s.exe", outputDir, name);
    }
    
    private void execute(string command)
    {
        system(command);
    }
    
    void compile()
    {
        if (compileSeparately) {
            string link_command = compiler ~ output();
            foreach (fileName; fileNames) {
                string compile_command = prefix();
                
                compile_command ~= std.string.format(" %s\\%s -c", baseDir, fileName);
                compile_command ~= csuffix(fileName);
                
                execute(compile_command);
                link_command ~= std.string.format(" %s\\%s.obj", outputDir, getName(getBaseName(fileName)));
            }
            
            link_command ~= lsuffix(baseName);
            
            execute(link_command);          
        } else {
            string compile_command = prefix();
            foreach (fileName; fileNames) {
                compile_command ~= std.string.format(" %s\\%s", baseDir, fileName);
            }
            
            compile_command ~= output();
            compile_command ~= csuffix(baseName);
            
            execute(compile_command);
        }
    }
    
    private string[] fileNames;
    
    private string name;
    private string baseName;
    private string outputDir;
    private string baseDir;
    private string requiredArgs;
    private string executeArgs;
    
    private bool compileSeparately = false;
}

class RunnableTest : Test
{
    this(string path, string outputDir)
    {
        super(path, outputDir);
    }
    
    void run()
    {
        string run_command = std.string.format("%s\\%s.exe %s > %s\\%s.exe.rlog", outputDir, name, executeArgs, outputDir, name);
        execute(run_command);
    }
}

int main(string[] args)
{
    auto runnable_tests = wildcard("runnable/*.d"/*, "runnable/*.html", "runnable/*.sh"*/);
    auto runnable_test_results = map!q{"result/" ~ a ~ ".out"}(runnable_tests);

    auto outputDir = "result";
    
    if (args.length >= 2) {
        compiler = args[1];
    } else {
        // compiler = "dmd"; // value by default
    }

    foreach (fileName; runnable_tests) {
        //fileName = "runnable\\a18.d";
        writeln("testing ", fileName);
        auto test = new RunnableTest(fileName, outputDir);
        test.compile();
//      test.run();
//      break;
    }
    
    return 0;
}

string[] wildcard(string[] paths...)
{
    string[] fileNames;
    
    foreach (path; paths) {
        filter(path, (string fileName) { fileNames ~= fileName; return true; });
    }
    
    return fileNames;
}

string trimLeft(string s)
{
    for (int i = 0; i < s.length; ++i) {
        if (!isspace(s[i])) {
            return s[i..$];
        }
    }
    
    return null;
}

string trimRight(string s)
{
    for (int i = s.length - 1; i >= 0; --i) {
        if (!isspace(s[i])) {
            return s[0..i + 1];
        }
    }
    
    return null;
}

string trim(string s)
{
    return trimLeft(trimRight(s));
}

version(Windows) void filter(string pattern, bool delegate(string fileName) callback)
{
    WIN32_FIND_DATAW fileinfo;

    auto h = FindFirstFileW(std.utf.toUTF16z(pattern), &fileinfo);
    if (h == INVALID_HANDLE_VALUE)
        return;

    auto path = dirname(pattern);

    do
    {
        // Skip "." and ".."
        auto name = fileinfo.cFileName.ptr;
        if (name[0] == '.' && (name[1] == 0 || name[1] == '.'))
            continue;

        size_t clength = std.string.wcslen(fileinfo.cFileName.ptr);
        auto fileName = std.path.join(path, std.utf.toUTF8(fileinfo.cFileName[0 .. clength]));
        
        if (!callback(fileName)) {
            break;
        }
    } while (FindNextFileW(h, &fileinfo) != FALSE);
    
    FindClose(h);
}

string getBaseName(string fullname, string extension = null)
{
    auto i = fullname.length;
    for (; i > 0; i--)
    {
        version(Windows)
        {
            if (fullname[i - 1] == ':' || fullname[i - 1] == '\\' || fullname[i - 1] == '/')
                break;
        }
        else version(Posix)
        {
            if (fullname[i - 1] == '/')
                break;
        }
        else
        {
            static assert(0);
        }
    }
    return chomp(fullname[i .. fullname.length],
            extension.length ? extension : "");
}