Move conn to TypeScript

src/conn.ts

@@ -0,0 +1,75 @@
+export class Problem{
+    name?: string;
+    inputs?: string[];
+    outputs?: string[];
+
+    constructor(name?: string, inputs?: string[], outputs?: string[]){
+        this.name = name;
+        this.inputs = inputs;
+        this.outputs = outputs;
+    }
+}
+
+export class Contest{
+    problems?: Problem[];
+
+    constructor(problems?: Problem[]){
+        this.problems = problems;
+    }
+}
+
+export class SiteDescription{
+    name: string;
+    description: string;
+    contestParser: (contestId: string) => Contest;
+    problemParser: (problemId: string) => Problem;
+
+    constructor(name: string, description: string, contestParser: (contestId: string) => Contest, problemParser: (problemId: string) => Problem){
+        this.name = name;
+        this.description = description;
+        this.contestParser = contestParser;
+        this.problemParser = problemParser;
+    }
+}
+
+/**
+ * Register a new site creating an entry in this dictionary.
+ */
+export const SITES: SiteDescription[] = [
+    /**
+     * Not a real site.
+     *
+     * Util to create personal problems and debug this tool.
+     */
+    new SiteDescription(
+        "personal",
+        "Not a site. Custom problems and contest.",
+        function(contestId: string) {
+            return new Contest();
+        },
+        function(problemId: string) {
+            return new Problem();
+        },
+    ),
+
+    new SiteDescription(
+        "codeforces",
+        "codeforces.com",
+        function(contestId: string) {
+            return new Contest();
+        },
+        function(problemId: string){
+            return new Problem();
+        }
+    ),
+];
+
+export function getSite(site: string): SiteDescription  {
+    SITES.forEach(siteDescription => {
+        if (siteDescription.name === site){
+            return siteDescription;
+        }
+    });
+
+    throw new Error("Provided site is invalid");
+}

src/core.ts

@@ -0,0 +1,285 @@
+'use strict';
+import { mkdirSync, existsSync, copyFileSync, openSync, readSync, readdirSync, writeSync, closeSync } from "fs";
+import { dirname, join, extname, basename } from "path";
+import * as child_process from 'child_process';
+import * as gwen from './gwen';
+import * as conn from './conn';
+import { TestcaseResult, Veredict, SolutionResult } from "./types";
+
+export const TESTCASES = 'testcases';
+export const ATTIC = 'attic';
+const SRC = dirname(__filename);
+const TESTCASE_TIMEOUT = 1000;
+// TODO: Revisit this constant. Show specific error to know when this is an issue
+const MAX_SIZE_INPUT = 1024;
+
+function createFolder(path: string){
+    if (!existsSync(path)){
+        createFolder(dirname(path));
+        mkdirSync(path);
+    }
+}
+
+/**
+ * TODO: Comment full code
+ * Doc string
+ */
+export function newArena(path: string){
+    createFolder(path);
+
+    let testcases = join(path, TESTCASES);
+    createFolder(testcases);
+
+    let attic = join(path, ATTIC);
+    createFolder(attic);
+
+    copyFileSync(join(SRC, 'static', 'sol.cpp'), join(path, 'sol.cpp'));
+}
+
+export function testcasesName(path: string){
+    return readdirSync(join(path, TESTCASES)).
+            filter( function (tcpath) { return extname(tcpath) === '.in';}).
+            map( function(tcpath) { return tcpath.split('.')[0]; });
+}
+
+function testcases(path: string){
+    return testcasesName(path).map(function (name){
+        let inp_fd = openSync(join(path, TESTCASES, `${name}.in`), 'r');
+        let out_fd = openSync(join(path, TESTCASES, `${name}.out`), 'r');
+
+        let inp_buffer = new Buffer("");
+        let out_buffer = new Buffer("");
+
+        readSync(inp_fd, inp_buffer, 0, 1 << 30, 0);
+        readSync(out_fd, out_buffer, 0, 1 << 30, 0);
+
+        return [
+            inp_buffer.toString(),
+            out_buffer.toString()
+        ];
+    });
+}
+
+export function upgradeArena(path: string) {
+    let brute = join(path, 'brute.cpp');
+
+    if (!existsSync(brute)){
+        // Create brute.cpp file
+        copyFileSync(join(SRC, 'static', 'sol.cpp'), brute);
+    }
+
+    let generator = join(path, ATTIC, 'gen.py');
+
+    if (!existsSync(generator)){
+        // Create generator
+        let inputs: string[] = [];
+        let outputs: string[] = [];
+
+        testcases(path).forEach(function(testcases){
+            inputs.push(testcases[0]);
+            outputs.push(testcases[1]);
+        });
+
+        let generator_template = gwen.create(inputs, outputs);
+        let generator_fd = openSync(generator, 'w');
+        writeSync(generator_fd, generator_template);
+    }
+}
+
+// TODO: Test
+function newProblemFromId(path: string, site: string, problemId: string){
+    let siteDesc = conn.getSite(site);
+
+    let problem = siteDesc.problemParser(problemId);
+
+    newProblem(path, problem);
+}
+
+// TODO: Test
+function newProblem(path: string, problem: conn.Problem){
+    newArena(path);
+
+    problem.inputs!.forEach((value, index) => {
+        let fd = openSync(join(path, TESTCASES, `${index}.in`), 'w');
+        writeSync(fd, value);
+    });
+
+    problem.outputs!.forEach((value, index) => {
+        let fd = openSync(join(path, TESTCASES, `${index}.out`), 'w');
+        writeSync(fd, value);
+    });
+}
+
+// TODO: Test
+function newContestFromId(path: string, site: string, contestId: string){
+    createFolder(path);
+    let siteDesc = conn.getSite(site);
+    let contest = siteDesc.contestParser(contestId);
+    newContest(path, contest);
+}
+
+// TODO: Test
+function newContest(path: string, contest: conn.Contest){
+    contest.problems!.forEach(problem => {
+        newProblem(join(path, problem.name!), problem);
+    });
+}
+
+export function timedRun(path: string, tcName: string, timeout = TESTCASE_TIMEOUT){
+    let tcInput = join(path, TESTCASES, `${tcName}.in`);
+    let tcOutput = join(path, TESTCASES, `${tcName}.out`);
+    let tcCurrent = join(path, TESTCASES, `${tcName}.cur`);
+
+    let inputFd = openSync(tcInput, 'r');
+    let buffer = new Buffer(MAX_SIZE_INPUT);
+    readSync(inputFd, buffer, 0, MAX_SIZE_INPUT, 0);
+    let tcData = buffer.toString();
+    closeSync(inputFd);
+
+    let startTime = new Date().getTime();
+    let command = `${join(path, ATTIC, "sol")}`;
+
+    let xresult = child_process.spawnSync(command, {
+        input: tcData,
+        timeout,
+        killSignal: "SIGTERM"
+    });
+
+    // Check if an error happened
+    if (xresult.status !== 0){
+        if (xresult.error === undefined){
+            return new TestcaseResult(Veredict.RTE);
+        }
+        else{
+            return new TestcaseResult(Veredict.TLE);
+        }
+    }
+
+    let spanTime = new Date().getTime() - startTime;
+
+    // Check output is ok
+    let currentFd = openSync(tcCurrent, 'w');
+    writeSync(currentFd, xresult.stdout);
+    closeSync(currentFd);
+
+    // TODO: IMPORTANT: Use custom checker (This is probably only non crossplatform feature)
+    let checker_result = child_process.spawnSync("diff", [tcOutput, tcCurrent]);
+
+    if (checker_result.status !== 0){
+        return new TestcaseResult(Veredict.WA);
+    }
+    else{
+        return new TestcaseResult(Veredict.OK, spanTime);
+    }
+}
+
+function compileCode(pathCode: string, pathOutput: string){
+    // # TODO: Avoid this hardcoded line. Use personalized compile line.
+    return child_process.spawnSync("g++", ["-std=c++11", `${pathCode}`, "-o", `${pathOutput}`]);
+}
+
+export function testSolution(path: string){
+    let sol = join(path, 'sol.cpp');
+    let out = join(path, ATTIC, 'sol');
+
+    if (!existsSync(sol)){
+        throw new Error("Open a coding environment first.");
+    }
+
+    // Compile solution
+    let xresult = compileCode(sol, out);
+
+    if (xresult.status !== 0){
+        return new SolutionResult(Veredict.CE);
+    }
+
+    let testcasesId = testcasesName(path);
+    testcasesId.sort(); // Proccess all testcases in sorted order
+
+    let results = [];
+
+    testcasesId.forEach(tcId => {
+        let tcResult = timedRun(path, tcId);
+
+        if (tcResult.status !== Veredict.OK){
+            return new SolutionResult(tcResult.status, tcId);
+        }
+
+        results.push(tcResult);
+    });
+
+    // TODO: Report max time and maybe other stats. Same with stress
+    return new SolutionResult(Veredict.OK);
+}
+
+function generateTestcase(path: string){
+    // TODO: Revisit this call to python3. How to make it cross platform
+    let genResult = child_process.spawnSync("python3", [join(path, ATTIC, 'gen.py')]);
+
+    let currentFd = openSync(join(path, TESTCASES, 'gen.in'), 'w');
+    writeSync(currentFd, genResult.stdout);
+    closeSync(currentFd);
+}
+
+export function stressSolution(path: string, times: number = 10){
+    let sol = join(path, 'sol.cpp');
+    let out = join(path, ATTIC, 'sol');
+    let brute = join(path, 'brute.cpp');
+
+    if (!existsSync(sol)){
+        throw new Error("Open a coding environment first.");
+    }
+
+    if (!existsSync(brute)){
+        throw new Error("Upgrade environment first.");
+    }
+
+    let brout = join(path, ATTIC, 'brout');
+
+    let solCompileResult = compileCode(sol, out);
+    if (solCompileResult.status !== 0){
+        throw new Error("Compilation Error. sol.cpp");
+    }
+
+    let bruteCompileResult = compileCode(brute, brout);
+    if (bruteCompileResult.status !== 0){
+        throw new Error("Compilation Error. brute.cpp");
+    }
+
+    let history = [];
+
+    for (let index = 0; index < times; index++) {
+        // Generate input testcase
+        generateTestcase(path);
+
+        // Generate output testcase from brute.cpp
+        let inputFd = openSync(join(path, TESTCASES, 'gen.in'), 'r');
+        let buffer = new Buffer(MAX_SIZE_INPUT);
+        readSync(inputFd, buffer, 0, MAX_SIZE_INPUT, 0);
+        let tcData = buffer.toString();
+        closeSync(inputFd);
+
+        // Run without restrictions
+        // TODO: Restrict brute in time, and capture errors
+        let runResult = child_process.spawnSync(brout, {
+            input: tcData,
+        });
+
+        // Finally write .out
+        let currentFd = openSync(join(path, TESTCASES, 'gen.out'), 'w');
+        writeSync(currentFd, runResult.stdout);
+        closeSync(currentFd);
+
+        // Check sol.cpp report same result than brute.cpp
+        let result = timedRun(path, 'gen');
+
+        if (result.status !== Veredict.OK){
+            return new SolutionResult(result.status, 'gen');
+        }
+
+        history.push(result);
+    }
+
+    // TODO: Check testSolution comment on this point
+    return new SolutionResult(Veredict.OK);
+}

src/extension.ts

@@ -2,28 +2,36 @@
 // The module 'vscode' contains the VS Code extensibility API
 // Import the module and reference it with the alias vscode in your code below
 import * as vscode from 'vscode';
-import * as xpath from 'path';
 import { exec } from 'child_process';
 import { existsSync, writeFileSync } from 'fs';
-
-// TODO: Add several checkers and try to infer which is the correct! MACHINE LEARNING
-// TODO: Implement parser for codeforces to test on real cases
-// TODO: Smart ID detection while parsing ContestId & ProblemId (More Machine Learning :)
-// TODO: Move acmh to typescript. How to measure time in typescript???
-// TODO: Find great name/slogan!!! Competitive Programming made simple
-
-const SITES = [
-    { label: 'Codeforces', target: 'codeforces' },
-    // TODO: Disable this for real application
-    { label: 'Mock', description: 'Fake site for experimentation', target: 'mock' },
-];
+import { join, dirname } from 'path';
+import { SITES } from './conn';
+
+/**
+ * TODO: IMPORTANT: Move acmh to typescript.
+ * TODO: Add several checkers and try to infer which is the correct! [*]
+ * TODO: Smart ID detection while parsing ContestId & ProblemId [*]
+ * TODO: Find great name/slogan!!! Competitive Programming made simple
+ * TODO: Change mock for personal -> Allow user choose number of problems while creating personal contest
+ * TODO: Implement parser for codeforces to test on real cases
+ * TODO: Learn how to move static files from `src` to `out`.
+ * TODO: Allow programming in other languages than c++
+ *
+ * [*] Machine Learning?
+ */
+
+// TODO: Erase this. After testing, to avoid catastrophical forgetting.
+// const SITES = [
+//     { label: 'Codeforces', target: 'codeforces' },
+//     { label: 'Mock', description: 'Fake site for experimentation', target: 'mock' },
+// ];
 
 const TESTCASES = 'testcases';
 const ATTIC = 'attic';
 
 function is_problem_folder(path: string) {
-    return  existsSync(xpath.join(path, 'sol.cpp')) &&
-            existsSync(xpath.join(path, 'attic'));
+    return  existsSync(join(path, 'sol.cpp')) &&
+            existsSync(join(path, 'attic'));
 }
 
 function current_problem() {
@@ -33,7 +41,7 @@ function current_problem() {
         const MAX_DEPTH = 3;
 
         for (let i = 0; i < MAX_DEPTH && !is_problem_folder(path); i++) {
-            path = xpath.dirname(path);
+            path = dirname(path);
         }
 
         if (is_problem_folder(path)){
@@ -47,7 +55,7 @@ function current_problem() {
         const MAX_DEPTH = 1;
 
         for (let i = 0; i < MAX_DEPTH && !is_problem_folder(path); i++) {
-            path = xpath.dirname(path);
+            path = dirname(path);
         }
 
         if (is_problem_folder(path)){
@@ -58,6 +66,20 @@ function current_problem() {
     return undefined;
 }
 
+function quickPickSites() {
+    let sites: any[] = [];
+
+    SITES.forEach(value => {
+        sites.push({
+            "label" : value.name,
+            "target" : value.name,
+            "description" : value.description,
+        });
+    });
+
+    return sites;
+}
+
 // Create a new problem
 async function add_problem() {
     if (vscode.workspace.workspaceFolders === undefined) {
@@ -67,7 +89,7 @@ async function add_problem() {
 
     let path = vscode.workspace.workspaceFolders[0].uri.path;
 
-    let site_info = await vscode.window.showQuickPick(SITES, { placeHolder: 'Select contest site' });
+    let site_info = await vscode.window.showQuickPick(quickPickSites(), { placeHolder: 'Select contest site' });
 
     if (site_info === undefined){
         vscode.window.showErrorMessage("Site not provided.");
@@ -84,7 +106,7 @@ async function add_problem() {
         return;
     }
 
-    path = xpath.join(path, `${id}`);
+    path = join(path, `${id}`);
 
     let command = `acmh problem ${site} ${id} -p ${path}`;
 
@@ -105,7 +127,7 @@ async function add_contest() {
 
     let path = vscode.workspace.workspaceFolders[0].uri.path;
 
-    let site_info = await vscode.window.showQuickPick(SITES, { placeHolder: 'Select contest site' });
+    let site_info = await vscode.window.showQuickPick(quickPickSites(), { placeHolder: 'Select contest site' });
 
     if (site_info === undefined){
         vscode.window.showErrorMessage("Site not provided.");
@@ -122,7 +144,7 @@ async function add_contest() {
         return;
     }
 
-    path = xpath.join(path, `${id}`);
+    path = join(path, `${id}`);
 
     let command = `acmh contest ${site} ${id} -p ${path}`;
 
@@ -154,10 +176,10 @@ async function run_solution(){
             // This is always true
             if (path !== undefined){
                 let testid = lines[1];
-                let sol = xpath.join(path, `sol.cpp`);
-                let inp = xpath.join(path, TESTCASES, `${testid}.in`);
-                let out = xpath.join(path, TESTCASES, `${testid}.out`);
-                let cur = xpath.join(path, TESTCASES, `${testid}.cur`);
+                let sol = join(path, `sol.cpp`);
+                let inp = join(path, TESTCASES, `${testid}.in`);
+                let out = join(path, TESTCASES, `${testid}.out`);
+                let cur = join(path, TESTCASES, `${testid}.cur`);
 
                 // TODO: How to clear opened tabs?
                 await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(sol), vscode.ViewColumn.One);
@@ -185,7 +207,7 @@ async function open_testcase() {
 
     // TODO: How to listdir in typescript?
     let num = 0;
-    while (existsSync(xpath.join(path, TESTCASES, `${num}.in`))){
+    while (existsSync(join(path, TESTCASES, `${num}.in`))){
         tcs.push({
             'label' : `${num}`,
             'target' : `${num}`
@@ -197,8 +219,8 @@ async function open_testcase() {
     let tc = await vscode.window.showQuickPick(tcs, { placeHolder: 'Select testcase' });
 
     if (tc !== undefined){
-        let inp = xpath.join(path, TESTCASES, `${tc.target}.in`);
-        let out = xpath.join(path, TESTCASES, `${tc.target}.out`);
+        let inp = join(path, TESTCASES, `${tc.target}.in`);
+        let out = join(path, TESTCASES, `${tc.target}.out`);
 
         await vscode.commands.executeCommand("vscode.setEditorLayout", { orientation: 0, groups: [{}, {}]});
         await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(inp), vscode.ViewColumn.One);
@@ -215,12 +237,12 @@ async function add_testcase() {
     }
 
     let index = 0;
-    while (existsSync(xpath.join(path, TESTCASES, `${index}.hand.in`))){
+    while (existsSync(join(path, TESTCASES, `${index}.hand.in`))){
         index += 1;
     }
 
-    let inp = xpath.join(path, TESTCASES, `${index}.hand.in`);
-    let out = xpath.join(path, TESTCASES, `${index}.hand.out`);
+    let inp = join(path, TESTCASES, `${index}.hand.in`);
+    let out = join(path, TESTCASES, `${index}.hand.out`);
 
     writeFileSync(inp, "");
     writeFileSync(out, "");
@@ -240,7 +262,7 @@ async function coding() {
 
     await vscode.commands.executeCommand("vscode.setEditorLayout", { groups: [{}]});
 
-    let sol = xpath.join(path, `sol.cpp`);
+    let sol = join(path, `sol.cpp`);
 
     await vscode.commands.executeCommand("vscode.open", vscode.Uri.file(sol), vscode.ViewColumn.One);
 }
@@ -269,10 +291,10 @@ async function stress(){
             // This is always true
             if (path !== undefined){
                 let testid = lines[1];
-                let sol = xpath.join(path, `sol.cpp`);
-                let inp = xpath.join(path, TESTCASES, `${testid}.in`);
-                let out = xpath.join(path, TESTCASES, `${testid}.out`);
-                let cur = xpath.join(path, TESTCASES, `${testid}.cur`);
+                let sol = join(path, `sol.cpp`);
+                let inp = join(path, TESTCASES, `${testid}.in`);
+                let out = join(path, TESTCASES, `${testid}.out`);
+                let cur = join(path, TESTCASES, `${testid}.cur`);
 
                 // TODO: How to clear opened tabs?
 

src/gwen.ts

@@ -0,0 +1,3 @@
+export function create(inputs: string[], outputs: string[]) {
+    return 'print("Hello world!")';
+}

src/test/extension.test.ts

@@ -5,6 +5,13 @@
 
 // The module 'assert' provides assertion methods from node
 import * as assert from 'assert';
+import { dirname, join } from 'path';
+import { timedRun, testcasesName, testSolution, newArena, ATTIC, TESTCASES, upgradeArena, stressSolution } from '../core';
+import { TestcaseResult, Veredict } from '../types';
+import { exists, rmdir, rmdirSync, existsSync, fstat, readdirSync, Stats, unlink, unlinkSync, openSync, writeSync, closeSync, write } from 'fs';
+
+const SRC = join(dirname(dirname(dirname(__filename))), 'src', 'test');
+const ARENA = join(SRC, 'arena');
 
 // You can import and use all API from the 'vscode' module
 // as well as import your extension to test it
@@ -13,10 +20,240 @@ import * as assert from 'assert';
 
 // Defines a Mocha test suite to group tests of similar kind together
 suite("Extension Tests", function () {
+    /**
+     * Recursive remove
+     */
+    function recRmdir(path: string){
+        readdirSync(path).forEach(name => {
+            let cPath = join(path, name);
+
+            try{
+                unlinkSync(cPath);
+            }
+            catch(err){
+                recRmdir(cPath);
+            }
+        });
+
+        rmdirSync(path);
+    }
+
+    function writeFile(path: string, content: string){
+        let currentFd = openSync(path, 'w');
+        writeSync(currentFd, content);
+        closeSync(currentFd);
+    }
 
     // Defines a Mocha unit test
-    test("Something 1", function() {
-        assert.equal(-1, [1, 2, 3].indexOf(5));
-        assert.equal(-1, [1, 2, 3].indexOf(0));
+    test("learnjs", function() {
+    });
+
+    /**
+     * core::newArena
+     */
+    test("newArena", function(){
+        let path = join(ARENA, "testNew");
+
+        if (existsSync(path)){
+            recRmdir(path);
+        }
+
+        assert.equal(existsSync(path), false);
+
+        newArena(path);
+
+        assert.equal(existsSync(join(path, ATTIC)), true);
+        assert.equal(existsSync(join(path, TESTCASES)), true);
+        assert.equal(existsSync(join(path, 'sol.cpp')), true);
+    });
+
+    /**
+     * core::upgradeArena
+     */
+    test("upgradeArena", function(){
+        let path = join(ARENA, "testUpgrade");
+
+        if (existsSync(path)){
+            recRmdir(path);
+        }
+
+        assert.equal(existsSync(path), false);
+
+        newArena(path);
+        upgradeArena(path);
+
+        assert.equal(existsSync(join(path, ATTIC, 'gen.py')), true);
+        assert.equal(existsSync(join(path, 'brute.cpp')), true);
+    });
+
+    /**
+     * core::testcasesName
+     */
+    test("testcasesName", function(){
+        let path = join(ARENA, 'exampleContest', 'A');
+        let result = testcasesName(path);
+        let target = ["0", "1", "2"];
+
+        // TODO: How to check if two arrays are equal
+        // I want to compare `result` & `target`
+        target.forEach(name => {assert.notEqual(result.findIndex(tname => { return tname === name; }), -1);});
+        result.forEach(name => {assert.notEqual(target.findIndex(tname => { return tname === name; }), -1);});
+    });
+
+    /**
+     * core::timedRun
+     *
+     * Test running one single test cases, and receiving all different veredicts
+     */
+    test("timedRunOk", function() {
+        let exampleContest = join(ARENA, 'exampleContest');
+        let problem = join(exampleContest, 'A');
+        let testcaseId = '0';
+        let result: TestcaseResult = timedRun(problem, testcaseId);
+        assert.equal(result.status, Veredict.OK);
+    });
+
+    test("timedRunWA", function() {
+        let exampleContest = join(ARENA, 'exampleContest');
+        let problem = join(exampleContest, 'B');
+        let testcaseId = '0';
+        let result: TestcaseResult = timedRun(problem, testcaseId);
+        assert.equal(result.status, Veredict.WA);
+    });
+
+    test("timedRunRTE", function() {
+        let exampleContest = join(ARENA, 'exampleContest');
+        let problem = join(exampleContest, 'C');
+        let testcaseId = '0';
+        let result: TestcaseResult = timedRun(problem, testcaseId);
+        assert.equal(result.status, Veredict.RTE);
+    });
+
+    test("timedRunTLE", function() {
+        let exampleContest = join(ARENA, 'exampleContest');
+        let problem = join(exampleContest, 'D');
+        let testcaseId = '0';
+        let result: TestcaseResult = timedRun(problem, testcaseId, 100);
+        assert.equal(result.status, Veredict.TLE);
+    });
+
+    /**
+     * core::testSolution
+     *
+     * Test running one single test cases, and receiving all different veredicts
+     */
+    test("testSolutionOK", function() {
+        let exampleContest = join(ARENA, 'exampleContest');
+        let problem = join(exampleContest, 'A');
+        let result: TestcaseResult = testSolution(problem);
+        assert.equal(result.status, Veredict.OK);
+    });
+
+    test("testSolutionCE", function() {
+        let exampleContest = join(ARENA, 'exampleContest');
+        let problem = join(exampleContest, 'E');
+        let result: TestcaseResult = testSolution(problem);
+        assert.equal(result.status, Veredict.CE);
+    });
+
+    /**
+     * core::stressSolution
+     */
+    test("stressSolutionOK", function() {
+        let path = join(ARENA, 'testStressOK');
+
+        if (existsSync(path)){
+            recRmdir(path);
+        }
+
+        assert.equal(existsSync(path), false);
+
+        newArena(path);
+        upgradeArena(path);
+
+        // populate sol.cpp
+        writeFile(join(path, "sol.cpp"),
+        `#include <iostream>\n` +
+        `\n` +
+        `using namespace std;\n` +
+        `\n` +
+        `int main(){\n` +
+        `   int n; cin >> n;\n` +
+        `   cout << n + 2 << endl;\n` +
+        `   return 0;\n` +
+        `}\n`
+        );
+
+        // populate brute.cpp
+        writeFile(join(path, "brute.cpp"),
+        `#include <iostream>\n` +
+        `\n` +
+        `using namespace std;\n` +
+        `\n` +
+        `int main(){\n` +
+        `   int n; cin >> n;\n` +
+        `   cout << n + 2 << endl;\n` +
+        `   return 0;\n` +
+        `}\n`
+        );
+
+        // populate gen.py
+        writeFile(join(path, ATTIC, 'gen.py'),
+        `import random\n` +
+        `print(random.randint(0, 99))\n`
+        );
+
+        let result = stressSolution(path);
+
+        assert.equal(result.status, Veredict.OK);
+    });
+
+    test("stressSolutionWA", function() {
+        let path = join(ARENA, 'testStressWA');
+
+        if (existsSync(path)){
+            recRmdir(path);
+        }
+
+        assert.equal(existsSync(path), false);
+
+        newArena(path);
+        upgradeArena(path);
+
+        // populate sol.cpp
+        writeFile(join(path, "sol.cpp"),
+        `#include <iostream>\n` +
+        `\n` +
+        `using namespace std;\n` +
+        `\n` +
+        `int main(){\n` +
+        `   int n; cin >> n;\n` +
+        `   cout << n + 3 << endl;\n` +
+        `   return 0;\n` +
+        `}\n`
+        );
+
+        // populate brute.cpp
+        writeFile(join(path, "brute.cpp"),
+        `#include <iostream>\n` +
+        `\n` +
+        `using namespace std;\n` +
+        `\n` +
+        `int main(){\n` +
+        `   int n; cin >> n;\n` +
+        `   cout << n + 2 << endl;\n` +
+        `   return 0;\n` +
+        `}\n`
+        );
+
+        // populate gen.py
+        writeFile(join(path, ATTIC, 'gen.py'),
+        `import random\n` +
+        `print(random.randint(0, 99))\n`
+        );
+
+        let result = stressSolution(path);
+
+        assert.equal(result.status, Veredict.WA);
     });
 });

src/types.ts

@@ -0,0 +1,31 @@
+/**
+ * TODO: Move all custom types to this folder
+ */
+
+export enum Veredict{
+    OK,     // Accepted
+    WA,     // Wrong Answer
+    TLE,    // Time Limit Exceeded
+    RTE,    // Runtime Error
+    CE,     // Compilation Error
+}
+
+export class TestcaseResult{
+    status: Veredict;
+    spanTime?: number;
+
+    constructor(status: Veredict, spanTime?: number){
+        this.status = status;
+        this.spanTime = spanTime;
+    }
+}
+
+export class SolutionResult{
+    status: Veredict;
+    failTcId?: string;
+
+    constructor(status: Veredict, failTcId?: string){
+        this.status = status;
+        this.failTcId = failTcId;
+    }
+}