☰

AtCoder Easy Test

Make testing sample cases easy

2021-01-01 يوللانغان نەشرى. ئەڭ يېڭى نەشرىنى كۆرۈش.

  1. // ==UserScript==
  2. // @name         AtCoder Easy Test
  3. // @namespace    http://atcoder.jp/
  4. // @version      1.5.7
  5. // @description  Make testing sample cases easy
  6. // @author       magurofly
  7. // @match        https://atcoder.jp/contests/*/tasks/*
  8. // @grant        none
  9. // ==/UserScript==
  10.  
  11. // This script uses variables from page below:
  12. // * `$`
  13. // * `getSourceCode`
  14. // * `csrfToken`
  15.  
  16. // This scripts consists of three modules:
  17. // * bottom menu
  18. // * code runner
  19. // * view
  20.  
  21. (function script() {
  22.  
  23. const VERSION = "1.5.7";
  24.  
  25. if (typeof unsafeWindow !== "undefined") {
  26.     console.log(unsafeWindow);
  27.     unsafeWindow.eval(`(${script})();`);
  28.     console.log("Script run in unsafeWindow");
  29.     return;
  30. }
  31. const $ = window.$;
  32. const getSourceCode = window.getSourceCode;
  33. const csrfToken = window.csrfToken;
  34.  
  35. const $id = document.getElementById.bind(document);
  36. const $select = document.querySelector.bind(document);
  37. const $selectAll = document.querySelectorAll.bind(document);
  38. const $create = (tagName, attrs = {}, children = []) => {
  39.     const e = document.createElement(tagName);
  40.     for (const name in attrs) e.setAttribute(name, attrs[name]);
  41.     for (const child of children) e.appendChild(child);
  42.     return e;
  43. };
  44.  
  45. // -- code runner --
  46. const codeRunner = (function() {
  47.     'use strict';
  48.  
  49.     function buildParams(data) {
  50.         return Object.entries(data).map(([key, value]) => encodeURIComponent(key) + "=" + encodeURIComponent(value)).join("&");
  51.     }
  52.  
  53.     function sleep(ms) {
  54.         return new Promise(done => setTimeout(done, ms));
  55.     }
  56.  
  57.     class CodeRunner {
  58.         constructor(label, site) {
  59.             this.label = `${label} [${site}]`;
  60.         }
  61.  
  62.         async test(sourceCode, input, supposedOutput, options) {
  63.             const result = await this.run(sourceCode, input);
  64.             if (result.status != "OK" || typeof supposedOutput !== "string") return result;
  65.             let output = result.stdout || "";
  66.  
  67.             if (options.trim) {
  68.                 supposedOutput = supposedOutput.trim();
  69.                 output = output.trim();
  70.             }
  71.  
  72.             let equals = (x, y) => x === y;
  73.  
  74.             if ("allowableError" in options) {
  75.                 const floatPattern = /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$/;
  76.                 const superEquals = equals;
  77.                 equals = (x, y) => {
  78.                     if (floatPattern.test(x) && floatPattern.test(y)) return Math.abs(parseFloat(x) - parseFloat(y)) <= options.allowableError;
  79.                     return superEquals(x, y);
  80.                 }
  81.             }
  82.  
  83.             if (options.split) {
  84.                 const superEquals = equals;
  85.                 equals = (x, y) => {
  86.                     x = x.split(/\s+/);
  87.                     y = y.split(/\s+/);
  88.                     if (x.length != y.length) return false;
  89.                     const len = x.length;
  90.                     for (let i = 0; i < len; i++) {
  91.                         if (!superEquals(x[i], y[i])) return false;
  92.                     }
  93.                     return true;
  94.                 }
  95.             }
  96.  
  97.             result.status = equals(output, supposedOutput) ? "AC" : "WA";
  98.  
  99.             return result;
  100.         }
  101.     }
  102.  
  103.     class CustomRunner extends CodeRunner {
  104.         constructor(label, run) {
  105.             super(label, "Browser");
  106.             this.run = run;
  107.         }
  108.     }
  109.  
  110.     class WandboxRunner extends CodeRunner {
  111.         constructor(name, label, options = {}) {
  112.             super(label, "Wandbox");
  113.             this.name = name;
  114.             this.options = options;
  115.         }
  116.  
  117.         run(sourceCode, input) {
  118.             let options = this.options;
  119.             if (typeof options == "function") options = options(sourceCode, input);
  120.             return this.request(Object.assign(JSON.stringify({
  121.                 compiler: this.name,
  122.                 code: sourceCode,
  123.                 stdin: input,
  124.             }), this.options));
  125.         }
  126.  
  127.         async request(body) {
  128.             const startTime = Date.now();
  129.             let res;
  130.             try {
  131.                 res = await fetch("https://wandbox.org/api/compile.json", {
  132.                     method: "POST",
  133.                     mode: "cors",
  134.                     headers: {
  135.                         "Content-Type": "application/json",
  136.                     },
  137.                     body,
  138.                 }).then(r => r.json());
  139.             } catch (error) {
  140.                 console.error(error);
  141.                 return {
  142.                     status: "IE",
  143.                     stderr: error,
  144.                 };
  145.             }
  146.             const endTime = Date.now();
  147.  
  148.             const result = {
  149.                 status: "OK",
  150.                 exitCode: res.status,
  151.                 execTime: endTime - startTime,
  152.                 stdout: res.program_output,
  153.                 stderr: res.program_error,
  154.             };
  155.             if (res.status != 0) {
  156.                 if (res.signal) {
  157.                     result.exitCode += " (" + res.signal + ")";
  158.                 }
  159.                 result.stdout = (res.compiler_output || "") + (result.stdout || "");
  160.                 result.stderr = (res.compiler_error || "") + (result.stderr || "");
  161.                 if (res.compiler_output || res.compiler_error) {
  162.                     result.status = "CE";
  163.                 } else {
  164.                     result.status = "RE";
  165.                 }
  166.             }
  167.  
  168.             return result;
  169.         }
  170.     }
  171.  
  172.     class PaizaIORunner extends CodeRunner {
  173.         constructor(name, label) {
  174.             super(label, "PaizaIO");
  175.             this.name = name;
  176.         }
  177.  
  178.         async run(sourceCode, input) {
  179.             let id, status, error;
  180.             try {
  181.                 const res = await fetch("https://api.paiza.io/runners/create?" + buildParams({
  182.                     source_code: sourceCode,
  183.                     language: this.name,
  184.                     input,
  185.                     longpoll: true,
  186.                     longpoll_timeout: 10,
  187.                     api_key: "guest",
  188.                 }), {
  189.                     method: "POST",
  190.                     mode: "cors",
  191.                 }).then(r => r.json());
  192.                 id = res.id;
  193.                 status = res.status;
  194.                 error = res.error;
  195.             } catch (error) {
  196.                 return {
  197.                     status: "IE",
  198.                     stderr: error,
  199.                 };
  200.             }
  201.  
  202.             while (status == "running") {
  203.                 const res = await (await fetch("https://api.paiza.io/runners/get_status?" + buildParams({
  204.                     id,
  205.                     api_key: "guest",
  206.                 }), {
  207.                     mode: "cors",
  208.                 })).json();
  209.                 status = res.status;
  210.                 error = res.error;
  211.             }
  212.  
  213.             const res = await fetch("https://api.paiza.io/runners/get_details?" + buildParams({
  214.                 id,
  215.                 api_key: "guest",
  216.             }), {
  217.                 mode: "cors",
  218.             }).then(r => r.json());
  219.  
  220.             const result = {
  221.                 exitCode: res.exit_code,
  222.                 execTime: +res.time * 1e3,
  223.                 memory: +res.memory * 1e-3,
  224.             };
  225.  
  226.             if (res.build_result == "failure") {
  227.                 result.status = "CE";
  228.                 result.exitCode = res.build_exit_code;
  229.                 result.stdout = res.build_stdout;
  230.                 result.stderr = res.build_stderr;
  231.             } else {
  232.                 result.status = (res.result == "timeout") ? "TLE" : (res.result == "failure") ? "RE" : "OK";
  233.                 result.exitCode = res.exit_code;
  234.                 result.stdout = res.stdout;
  235.                 result.stderr = res.stderr;
  236.             }
  237.  
  238.             return result;
  239.         }
  240.     }
  241.  
  242.     class WandboxCppRunner extends WandboxRunner {
  243.         async run(sourceCode, input) {
  244.           const ACLBase = "https://cdn.jsdelivr.net/gh/atcoder/ac-library/atcoder/";
  245.           const files = new Map();
  246.           const includeHeader = async source => {
  247.             const pattern = /^#\s*include\s*[<"]atcoder\/([^>"]+)[>"]/gm;
  248.             const loaded = [];
  249.             let match;
  250.             while (match = pattern.exec(source)) {
  251.               const file = match[1];
  252.               if (files.has(file)) continue;
  253.               files.set(file, null);
  254.               loaded.push([file, fetch(ACLBase + file, { mode: "cors", cache: "force-cache", }).then(r => r.text())]);
  255.             }
  256.             const included = await Promise.all(loaded.map(async ([file, r]) => {
  257.               const source = await r;
  258.               files.set(file, source);
  259.               return source;
  260.             }));
  261.             for (const source of included) {
  262.               await includeHeader(source);
  263.             }
  264.           };
  265.           await includeHeader(sourceCode);
  266.           const codes = [];
  267.           for (const [file, code] of files) {
  268.             codes.push({ file, code, });
  269.           }
  270.           let options = this.options;
  271.           if (typeof options == "function") options = options(sourceCode, input);
  272.           return await this.request(JSON.stringify(Object.assign({
  273.               compiler: this.name,
  274.               code: sourceCode,
  275.               stdin: input,
  276.               codes,
  277.               "compiler-option-raw": "-I.",
  278.           }, options)));
  279.         }
  280.     }
  281.  
  282.     let waitAtCoderCustomTest = Promise.resolve();
  283.     const AtCoderCustomTestBase = location.href.replace(/\/tasks\/.+$/, "/custom_test");
  284.     const AtCoderCustomTestResultAPI = AtCoderCustomTestBase + "/json?reload=true";
  285.     const AtCoderCustomTestSubmitAPI = AtCoderCustomTestBase + "/submit/json";
  286.     class AtCoderRunner extends CodeRunner {
  287.         constructor(languageId, label) {
  288.             super(label, "AtCoder");
  289.             this.languageId = languageId;
  290.         }
  291.  
  292.         async run(sourceCode, input) {
  293.             const promise = this.submit(sourceCode, input);
  294.             waitAtCoderCustomTest = promise;
  295.             return await promise;
  296.         }
  297.  
  298.         async submit(sourceCode, input) {
  299.             try {
  300.                 await waitAtCoderCustomTest;
  301.             } catch (error) {
  302.                 console.error(error);
  303.             }
  304.  
  305.             const error = await fetch(AtCoderCustomTestSubmitAPI, {
  306.                 method: "POST",
  307.                 credentials: "include",
  308.                 headers: {
  309.                     "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
  310.                 },
  311.                 body: buildParams({
  312.                     "data.LanguageId": this.languageId,
  313.                     sourceCode,
  314.                     input,
  315.                     csrf_token: csrfToken,
  316.                 }),
  317.             }).then(r => r.text());
  318.  
  319.             if (error) {
  320.                 throw new Error(error)
  321.             }
  322.  
  323.             await sleep(100);
  324.  
  325.             for (;;) {
  326.                 const data = await fetch(AtCoderCustomTestResultAPI, {
  327.                     method: "GET",
  328.                     credentials: "include",
  329.                 }).then(r => r.json());
  330.  
  331.                 if (!("Result" in data)) continue;
  332.                 const result = data.Result;
  333.  
  334.                 if ("Interval" in data) {
  335.                     await sleep(data.Interval);
  336.                     continue;
  337.                 }
  338.  
  339.                 return {
  340.                     status: (result.ExitCode == 0) ? "OK" : (result.TimeConsumption == -1) ? "CE" : "RE",
  341.                     exitCode: result.ExitCode,
  342.                     execTime: result.TimeConsumption,
  343.                     memory: result.MemoryConsumption,
  344.                     stdout: data.Stdout,
  345.                     stderr: data.Stderr,
  346.                 };
  347.             }
  348.         }
  349.     }
  350.  
  351.     const runners = {
  352.         4001: [new WandboxRunner("gcc-10.1.0-c", "C (GCC 9.2.0)")],
  353.         4002: [new PaizaIORunner("c", "C (C17 / Clang 10.0.0)", )],
  354.         4003: [new WandboxCppRunner("gcc-10.1.0", "C++ (GCC 9.2.0)", {options: "warning,boost-1.73.0-gcc-9.2.0,gnu++17"})],
  355.         4004: [new WandboxCppRunner("clang-10.0.0", "C++ (Clang 10.0.0)", {options: "warning,boost-nothing-clang-10.0.0,c++17"})],
  356.         4006: [new PaizaIORunner("python3", "Python (3.8.2)")],
  357.         4007: [new PaizaIORunner("bash", "Bash (5.0.17)")],
  358.         4010: [new WandboxRunner("csharp", "C# (.NET Core 6.0.100-alpha.1.20562.2)")],
  359.         4011: [new WandboxRunner("mono-head", "C# (Mono-mcs 5.19.0.0)")],
  360.         4013: [new PaizaIORunner("clojure", "Clojure (1.10.1-1)")],
  361.         4017: [new PaizaIORunner("d", "D (LDC 1.23.0)")],
  362.         4020: [new PaizaIORunner("erlang", "Erlang (10.6.4)")],
  363.         4021: [new PaizaIORunner("elixir", "Elixir (1.10.4)")],
  364.         4022: [new PaizaIORunner("fsharp", "F# (Interactive 4.0)")],
  365.         4023: [new PaizaIORunner("fsharp", "F# (Interactive 4.0)")],
  366.         4026: [new WandboxRunner("go-1.14.1", "Go (1.14.1)")],
  367.         4027: [new WandboxRunner("ghc-head", "Haskell (GHC 8.7.20181121)")],
  368.         4030: [new PaizaIORunner("javascript", "JavaScript (Node.js 12.18.3)")],
  369.         4032: [new PaizaIORunner("kotlin", "Kotlin (1.4.0)")],
  370.         4033: [new WandboxRunner("lua-5.3.4", "Lua (Lua 5.3.4)")],
  371.         4034: [new WandboxRunner("luajit-head", "Lua (LuaJIT 2.1.0-beta3)")],
  372.         4036: [new WandboxRunner("nim-1.0.6", "Nim (1.0.6)")],
  373.         4037: [new PaizaIORunner("objective-c", "Objective-C (Clang 10.0.0)")],
  374.         4039: [new WandboxRunner("ocaml-head", "OCaml (4.13.0+dev0-2020-10-19)")],
  375.         4041: [new WandboxRunner("fpc-3.0.2", "Pascal (FPC 3.0.2)")],
  376.         4042: [new PaizaIORunner("perl", "Perl (5.30.0)")],
  377.         4044: [
  378.             new PaizaIORunner("php", "PHP (7.4.10)"),
  379.             new WandboxRunner("php-7.3.3", "PHP (7.3.3)"),
  380.         ],
  381.         4046: [new WandboxRunner("pypy-head", "PyPy2 (7.3.4-alpha0)")],
  382.         4047: [new WandboxRunner("pypy-7.2.0-3", "PyPy3 (7.2.0)")],
  383.         4049: [
  384.             new WandboxRunner("ruby-head", "Ruby (HEAD 3.0.0dev)"),
  385.             new PaizaIORunner("ruby", "Ruby (2.7.1)"),
  386.             new WandboxRunner("ruby-2.7.0-preview1", "Ruby (2.7.0-preview1)"),
  387.         ],
  388.         4050: [
  389.             new AtCoderRunner(4050, "Rust (1.42.0)"),
  390.             new WandboxRunner("rust-head", "Rust (1.37.0-dev)"),
  391.             new PaizaIORunner("rust", "Rust (1.43.0)"),
  392.         ],
  393.         4051: [new PaizaIORunner("scala", "Scala (2.13.3)")],
  394.         4053: [new PaizaIORunner("scheme", "Scheme (Gauche 0.9.6)")],
  395.         4055: [new PaizaIORunner("swift", "Swift (5.2.5)")],
  396.         4056: [new CustomRunner("Text",
  397.             async (sourceCode, input) => {
  398.                 return {
  399.                     status: "OK",
  400.                     exitCode: 0,
  401.                     stdout: sourceCode,
  402.                 };
  403.             }
  404.         )],
  405.         4058: [new PaizaIORunner("vb", "Visual Basic (.NET Core 4.0.1)")],
  406.         4061: [new PaizaIORunner("cobol", "COBOL - Free (OpenCOBOL 2.2.0)")],
  407.         4101: [new WandboxCppRunner("gcc-9.2.0", "C++ (GCC 9.2.0)")],
  408.         4102: [new WandboxCppRunner("clang-10.0.0", "C++ (Clang 10.0.0)")],
  409.     };
  410.  
  411.     for (const e of $selectAll("#select-lang option[value]")) {
  412.         const languageId = e.value;
  413.         if (!(languageId in runners)) runners[languageId] = [];
  414.         if (runners[languageId].some(runner => runner instanceof AtCoderRunner)) continue;
  415.         runners[languageId].push(new AtCoderRunner(languageId, e.textContent));
  416.     }
  417.  
  418.     console.info("codeRunner OK");
  419.  
  420.     return {
  421.         run(languageId, index, sourceCode, input, supposedOutput = null, options = { trim: true, split: true, }) {
  422.             if (!(languageId in runners)) return Promise.reject("language not supported");
  423.             return runners[languageId][index].test(sourceCode, input, supposedOutput, options);
  424.         },
  425.  
  426.         getEnvironment(languageId) {
  427.             if (!(languageId in runners)) return Promise.reject("language not supported");
  428.             return Promise.resolve(runners[languageId].map(runner => runner.label));
  429.         },
  430.     };
  431. })();
  432.  
  433.  
  434. // -- bottom menu --
  435. const bottomMenu = (function () {
  436.     'use strict';
  437.  
  438.     const tabs = new Set();
  439.  
  440.     const bottomMenuKey = $(`<button id="bottom-menu-key" type="button" class="navbar-toggle collapsed glyphicon glyphicon-menu-down" data-toggle="collapse" data-target="#bottom-menu">`);
  441.     const bottomMenuTabs = $(`<ul id="bottom-menu-tabs" class="nav nav-tabs">`);
  442.     const bottomMenuContents = $(`<div id="bottom-menu-contents" class="tab-content">`);
  443.  
  444.     $(() => {
  445.         const style = $create("style");
  446.         style.textContent = `
  447.  
  448. #bottom-menu-wrapper {
  449.     background: transparent;
  450.     border: none;
  451.     pointer-events: none;
  452.     padding: 0;
  453. }
  454.  
  455. #bottom-menu-wrapper>.container {
  456.     position: absolute;
  457.     bottom: 0;
  458.     width: 100%;
  459.     padding: 0;
  460. }
  461.  
  462. #bottom-menu-wrapper>.container>.navbar-header {
  463.     float: none;
  464. }
  465.  
  466. #bottom-menu-key {
  467.     display: block;
  468.     float: none;
  469.     margin: 0 auto;
  470.     padding: 10px 3em;
  471.     border-radius: 5px 5px 0 0;
  472.     background: #000;
  473.     opacity: 0.5;
  474.     color: #FFF;
  475.     cursor: pointer;
  476.     pointer-events: auto;
  477.     text-align: center;
  478. }
  479.  
  480. @media screen and (max-width: 767px) {
  481.     #bottom-menu-key {
  482.         opacity: 0.25;
  483.     }
  484. }
  485.  
  486. #bottom-menu-key.collapsed:before {
  487.     content: "\\e260";
  488. }
  489.  
  490. #bottom-menu-tabs {
  491.     padding: 3px 0 0 10px;
  492.     cursor: n-resize;
  493. }
  494.  
  495. #bottom-menu-tabs a {
  496.     pointer-events: auto;
  497. }
  498.  
  499. #bottom-menu {
  500.     pointer-events: auto;
  501.     background: rgba(0, 0, 0, 0.8);
  502.     color: #fff;
  503.     max-height: unset;
  504. }
  505.  
  506. #bottom-menu.collapse:not(.in) {
  507.     display: none !important;
  508. }
  509.  
  510. #bottom-menu-tabs>li>a {
  511.     background: rgba(150, 150, 150, 0.5);
  512.     color: #000;
  513.     border: solid 1px #ccc;
  514.     filter: brightness(0.75);
  515. }
  516.  
  517. #bottom-menu-tabs>li>a:hover {
  518.     background: rgba(150, 150, 150, 0.5);
  519.     border: solid 1px #ccc;
  520.     color: #111;
  521.     filter: brightness(0.9);
  522. }
  523.  
  524. #bottom-menu-tabs>li.active>a {
  525.     background: #eee;
  526.     border: solid 1px #ccc;
  527.     color: #333;
  528.     filter: none;
  529. }
  530.  
  531. .bottom-menu-btn-close {
  532.     font-size: 8pt;
  533.     vertical-align: baseline;
  534.     padding: 0 0 0 6px;
  535.     margin-right: -6px;
  536. }
  537.  
  538. #bottom-menu-contents {
  539.     padding: 5px 15px;
  540.     max-height: 50vh;
  541.     overflow-y: auto;
  542. }
  543.  
  544. #bottom-menu-contents .panel {
  545.     color: #333;
  546. }
  547.  
  548. `;
  549.         document.head.appendChild(style);
  550.         const bottomMenu = $(`<div id="bottom-menu" class="collapse navbar-collapse">`).append(bottomMenuTabs, bottomMenuContents);
  551.         $(`<div id="bottom-menu-wrapper" class="navbar navbar-default navbar-fixed-bottom">`)
  552.         .append($(`<div class="container">`)
  553.             .append(
  554.                 $(`<div class="navbar-header">`).append(bottomMenuKey),
  555.                 bottomMenu))
  556.         .appendTo("#main-div");
  557.  
  558.         let resizeStart = null;
  559.         bottomMenuTabs.on({
  560.             mousedown({target, pageY}) {
  561.                 if (target.id != "bottom-menu-tabs") return;
  562.                 resizeStart = {y: pageY, height: bottomMenuContents.height()};
  563.             },
  564.             mousemove(e) {
  565.                 if (!resizeStart) return;
  566.                 e.preventDefault();
  567.                 bottomMenuContents.height(resizeStart.height - (e.pageY - resizeStart.y));
  568.             },
  569.         });
  570.         document.addEventListener("mouseup", () => { resizeStart = null; });
  571.         document.addEventListener("mouseleave", () => { resizeStart = null; });
  572.     });
  573.  
  574.     const menuController = {
  575.         addTab(tabId, tabLabel, paneContent, options = {}) {
  576.             console.log("addTab: %s (%s)", tabLabel, tabId, paneContent);
  577.             const tab = $(`<a id="bottom-menu-tab-${tabId}" href="#" data-target="#bottom-menu-pane-${tabId}" data-toggle="tab">`)
  578.             .click(e => {
  579.                 e.preventDefault();
  580.                 tab.tab("show");
  581.             })
  582.             .append(tabLabel);
  583.             const tabLi = $(`<li>`).append(tab).appendTo(bottomMenuTabs);
  584.             const pane = $(`<div class="tab-pane" id="bottom-menu-pane-${tabId}">`).append(paneContent).appendTo(bottomMenuContents);
  585.             console.dirxml(bottomMenuContents);
  586.             const controller = {
  587.                 close() {
  588.                     tabLi.remove();
  589.                     pane.remove();
  590.                     tabs.delete(tab);
  591.                     if (tabLi.hasClass("active") && tabs.size > 0) {
  592.                         tabs.values().next().value.tab("show");
  593.                     }
  594.                 },
  595.  
  596.                 show() {
  597.                     menuController.show();
  598.                     tab.tab("show");
  599.                 },
  600.  
  601.                 set color(color) {
  602.                     tab.css("background-color", color);
  603.                 },
  604.             };
  605.             tabs.add(tab);
  606.             if (options.closeButton) tab.append($(`<a class="bottom-menu-btn-close btn btn-link glyphicon glyphicon-remove">`).click(() => controller.close()));
  607.             if (options.active || tabs.size == 1) pane.ready(() => tab.tab("show"));
  608.             return controller;
  609.         },
  610.  
  611.         show() {
  612.             if (bottomMenuKey.hasClass("collapsed")) bottomMenuKey.click();
  613.         },
  614.  
  615.         toggle() {
  616.             bottomMenuKey.click();
  617.         },
  618.     };
  619.  
  620.     console.info("bottomMenu OK");
  621.  
  622.     return menuController;
  623. })();
  624.  
  625. $(() => {
  626.     // returns [{input, output, anchor}]
  627.     function getTestCases() {
  628.         const selectors = [
  629.             ["#task-statement p+pre.literal-block", ".section"], // utpc2011_1
  630.             ["#task-statement pre.source-code-for-copy", ".part"],
  631.             ["#task-statement .lang>*:nth-child(1) .div-btn-copy+pre", ".part"],
  632.             ["#task-statement .div-btn-copy+pre", ".part"],
  633.             ["#task-statement>.part pre.linenums", ".part"], // abc003_4
  634.             ["#task-statement>.part:not(.io-style)>h3+section>pre", ".part"],
  635.             ["#task-statement pre", ".part"],
  636.         ];
  637.  
  638.         for (const [selector, closestSelector] of selectors) {
  639.             const e = $selectAll(selector);
  640.             if (e.length == 0) continue;
  641.             const testcases = [];
  642.             for (let i = 0; i < e.length; i += 2) {
  643.                 const container = e[i].closest(closestSelector);
  644.                 testcases.push({
  645.                     input: (e[i]||{}).textContent,
  646.                     output: (e[i+1]||{}).textContent,
  647.                     anchor: container.querySelector("h3"),
  648.                 });
  649.             }
  650.             return testcases;
  651.         }
  652.  
  653.         return [];
  654.     }
  655.  
  656.     async function runTest(title, input, output = null) {
  657.         const uid = Date.now().toString();
  658.         title = title ? "Result " + title : "Result";
  659.         const content = $create("div", { class: "container" });
  660.         content.innerHTML = `
  661. <div class="row">
  662.     <div class="col-xs-12 ${(output == null) ? "" : "col-sm-6"}"><div class="form-group">
  663.         <label class="control-label col-xs-12" for="atcoder-easy-test-${uid}-stdin">Standard Input</label>
  664.         <div class="col-xs-12">
  665.             <textarea id="atcoder-easy-test-${uid}-stdin" class="form-control" rows="3" readonly></textarea>
  666.         </div>
  667.     </div></div>${(output == null) ? "" : `
  668.     <div class="col-xs-12 col-sm-6"><div class="form-group">
  669.         <label class="control-label col-xs-12" for="atcoder-easy-test-${uid}-expected">Expected Output</label>
  670.         <div class="col-xs-12">
  671.             <textarea id="atcoder-easy-test-${uid}-expected" class="form-control" rows="3" readonly></textarea>
  672.         </div>
  673.     </div></div>
  674. `}
  675. </div>
  676. <div class="row"><div class="col-sm-6 col-sm-offset-3">
  677.         <div class="panel panel-default"><table class="table table-condensed">
  678.             <tr>
  679.                 <th class="text-center">Exit Code</th>
  680.                 <th class="text-center">Exec Time</th>
  681.                 <th class="text-center">Memory</th>
  682.             </tr>
  683.             <tr>
  684.                 <td id="atcoder-easy-test-${uid}-exit-code" class="text-center"></td>
  685.                 <td id="atcoder-easy-test-${uid}-exec-time" class="text-center"></td>
  686.                 <td id="atcoder-easy-test-${uid}-memory" class="text-center"></td>
  687.             </tr>
  688.         </table></div>
  689. </div></div>
  690. <div class="row">
  691.     <div class="col-xs-12 col-md-6"><div class="form-group">
  692.         <label class="control-label col-xs-12" for="atcoder-easy-test-${uid}-stdout">Standard Output</label>
  693.         <div class="col-xs-12">
  694.             <textarea id="atcoder-easy-test-${uid}-stdout" class="form-control" rows="5" readonly></textarea>
  695.         </div>
  696.     </div></div>
  697.     <div class="col-xs-12 col-md-6"><div class="form-group">
  698.         <label class="control-label col-xs-12" for="atcoder-easy-test-${uid}-stderr">Standard Error</label>
  699.         <div class="col-xs-12">
  700.             <textarea id="atcoder-easy-test-${uid}-stderr" class="form-control" rows="5" readonly></textarea>
  701.         </div>
  702.     </div></div>
  703. </div>
  704. `;
  705.         const tab = bottomMenu.addTab("easy-test-result-" + uid, title, content, { active: true, closeButton: true });
  706.         $id(`atcoder-easy-test-${uid}-stdin`).value = input;
  707.         if (output != null) $id(`atcoder-easy-test-${uid}-expected`).value = output;
  708.  
  709.         const options = { trim: true, split: true, };
  710.         if ($id("atcoder-easy-test-allowable-error-check").checked) {
  711.             options.allowableError = parseFloat($id("atcoder-easy-test-allowable-error").value);
  712.         }
  713.  
  714.         const result = await codeRunner.run($select("#select-lang>select").value, +$id("atcoder-easy-test-language").value, window.getSourceCode(), input, output, options);
  715.  
  716.         if (result.status == "AC") {
  717.             tab.color = "#dff0d8";
  718.             $id(`atcoder-easy-test-${uid}-stdout`).style.backgroundColor = "#dff0d8";
  719.         } else if (result.status != "OK") {
  720.             tab.color = "#fcf8e3";
  721.             if (result.status == "WA") $id(`atcoder-easy-test-${uid}-stdout`).style.backgroundColor = "#fcf8e3";
  722.         }
  723.  
  724.         const eExitCode = $id(`atcoder-easy-test-${uid}-exit-code`);
  725.         eExitCode.textContent = result.exitCode;
  726.         eExitCode.classList.toggle("bg-success", result.exitCode == 0);
  727.         eExitCode.classList.toggle("bg-danger", result.exitCode != 0);
  728.         if ("execTime" in result) $id(`atcoder-easy-test-${uid}-exec-time`).textContent = result.execTime + " ms";
  729.         if ("memory" in result) $id(`atcoder-easy-test-${uid}-memory`).textContent = result.memory + " KB";
  730.         $id(`atcoder-easy-test-${uid}-stdout`).value = result.stdout || "";
  731.         $id(`atcoder-easy-test-${uid}-stderr`).value = result.stderr || "";
  732.  
  733.         result.uid = uid;
  734.         result.tab = tab;
  735.         return result;
  736.     }
  737.  
  738.     console.log("bottomMenu", bottomMenu);
  739.  
  740.     bottomMenu.addTab("easy-test", "Easy Test", $(`<form id="atcoder-easy-test-container" class="form-horizontal">`)
  741.                       .html(`
  742. <small style="position: absolute; display: block; bottom: 0; right: 0; padding: 1% 4%; width: 95%; text-align: right;">AtCoder Easy Test v${VERSION}</small>
  743. <div class="row">
  744.     <div class="col-xs-12 col-lg-8">
  745.         <div class="form-group">
  746.             <label class="control-label col-sm-2">Test Environment</label>
  747.             <div class="col-sm-10">
  748.                 <select class="form-control" id="atcoder-easy-test-language"></select>
  749.             </div>
  750.         </div>
  751.         <div class="form-group">
  752.             <label class="control-label col-sm-2" for="atcoder-easy-test-input">Standard Input</label>
  753.             <div class="col-sm-10">
  754.                 <textarea id="atcoder-easy-test-input" name="input" class="form-control" rows="3"></textarea>
  755.             </div>
  756.         </div>
  757.     </div>
  758.     <div class="col-xs-12 col-lg-4">
  759.         <details close>
  760.             <summary>Expected Output</summary>
  761.             <div class="form-group">
  762.                 <label class="control-label col-sm-2" for="atcoder-easy-test-allowable-error-check">Allowable Error</label>
  763.                 <div class="col-sm-10">
  764.                     <div class="input-group">
  765.                         <span class="input-group-addon">
  766.                             <input id="atcoder-easy-test-allowable-error-check" type="checkbox" checked>
  767.                         </span>
  768.                         <input id="atcoder-easy-test-allowable-error" type="text" class="form-control" value="1e-6">
  769.                     </div>
  770.                 </div>
  771.             </div>
  772.             <div class="form-group">
  773.                 <label class="control-label col-sm-2" for="atcoder-easy-test-output">Expected Output</label>
  774.                 <div class="col-sm-10">
  775.                     <textarea id="atcoder-easy-test-output" name="output" class="form-control" rows="3"></textarea>
  776.                 </div>
  777.             </div>
  778.         </details>
  779.     </div>
  780.     <div class="col-xs-12">
  781.         <div class="col-xs-11 col-xs-offset=1">
  782.             <div class="form-group">
  783.                  <a id="atcoder-easy-test-run" class="btn btn-primary">Run</a>
  784.             </div>
  785.         </div>
  786.     </div>
  787. </div>
  788. <style>
  789. #atcoder-easy-test-language {
  790.     border: none;
  791.     background: transparent;
  792.     font: inherit;
  793.     color: #fff;
  794. }
  795. #atcoder-easy-test-language option {
  796.     border: none;
  797.     color: #333;
  798.     font: inherit;
  799. }
  800. </style>
  801. `).ready(() => {
  802.     $id("atcoder-easy-test-run").addEventListener("click", () => {
  803.         const title = "";
  804.         const input = $id("atcoder-easy-test-input").value;
  805.         const output = $id("atcoder-easy-test-output").value;
  806.         runTest(title, input, output || null);
  807.     });
  808.     $("#select-lang>select").change(() => setLanguage()); //NOTE: This event is only for jQuery; do not replce with Vanilla
  809.     $id("atcoder-easy-test-allowable-error").disabled = this.checked;
  810.     $id("atcoder-easy-test-allowable-error-check").addEventListener("change", e => { $id("atcoder-easy-test-allowable-error").disabled = !e.target.checked; });
  811.  
  812.     async function setLanguage() {
  813.         const languageId = $select("#select-lang>select").value;
  814.         const eTestLanguage = $id("atcoder-easy-test-language");
  815.         while (eTestLanguage.firstChild) eTestLanguage.removeChild(eTestLanguage.firstChild);
  816.         try {
  817.             const labels = await codeRunner.getEnvironment(languageId);
  818.             console.log(`language: ${labels[0]} (${languageId})`);
  819.             labels.forEach((label, index) => {
  820.                 const option = $create("option", {value: index});
  821.                 option.textContent = label;
  822.                 eTestLanguage.appendChild(option);
  823.             });
  824.             $id("atcoder-easy-test-run").classList.remove("disabled");
  825.             $id("atcoder-easy-test-btn-test-all").disabled = false;
  826.         } catch (error) {
  827.             console.log(`language: ? (${languageId})`);
  828.             const option = $create("option", { "class": "fg-danger" });
  829.             option.textContent = error;
  830.             eTestLanguage.appendChild(option);
  831.             $id("atcoder-easy-test-run").classList.add("disabled");
  832.             $id("atcoder-easy-test-btn-test-all").disabled = true;
  833.         }
  834.     }
  835.  
  836.     setLanguage();
  837. }), { active: true });
  838.  
  839.     const testfuncs = [];
  840.     const runButtons = [];
  841.  
  842.     const testcases = getTestCases();
  843.     for (const {input, output, anchor} of testcases) {
  844.         const testfunc = async () => {
  845.             const title = anchor.childNodes[0].data;
  846.             const result = await runTest(title, input, output);
  847.             if (result.status == "OK" || result.status == "AC") {
  848.                 $id(`atcoder-easy-test-${result.uid}-stdout`).classList.add("bg-success");
  849.             }
  850.             return result;
  851.         };
  852.         testfuncs.push(testfunc);
  853.  
  854.         const runButton = $(`<a class="btn btn-primary btn-sm" style="vertical-align: top; margin-left: 0.5em">`)
  855.         .text("Run")
  856.         .click(async () => {
  857.             await testfunc();
  858.             if ($id("bottom-menu-key").classList.contains("collapsed")) $id("bottom-menu-key").click();
  859.         });
  860.         anchor.appendChild(runButton[0]);
  861.         runButtons.push(runButton);
  862.     }
  863.  
  864.     const testAllResultRow = $(`<div class="row">`);
  865.     const testAllButton = $(`<a id="atcoder-easy-test-btn-test-all" class="btn btn-default btn-sm" style="margin-left: 5px" title="Alt+Enter" data-toggle="tooltip">`)
  866.     .text("Test All Samples")
  867.     .click(async () => {
  868.         if (testAllButton.attr("disabled")) throw new Error("Button is disabled");
  869.         const statuses = testfuncs.map(_ => $(`<div class="label label-default" style="margin: 3px">`).text("WJ..."));
  870.         const progress = $(`<div class="progress-bar">`).text(`0 / ${testfuncs.length}`);
  871.         let finished = 0;
  872.         const closeButton = $(`<button type="button" class="close" data-dismiss="alert" aria-label="close">`)
  873.         .append($(`<span aria-hidden="true">`).text("\xd7"));
  874.         const resultAlert = $(`<div class="alert alert-dismissible">`)
  875.         .append(closeButton)
  876.         .append($(`<div class="progress">`).append(progress))
  877.         .append(...statuses)
  878.         .prependTo(testAllResultRow);
  879.         const results = await Promise.all(testfuncs.map(async (testfunc, i) => {
  880.             const result = await testfunc();
  881.             finished++;
  882.             progress.text(`${finished} / ${statuses.length}`).css("width", `${finished/statuses.length*100}%`);
  883.             statuses[i].toggleClass("label-success", result.status == "AC").toggleClass("label-warning", result.status != "AC").text(result.status).click(() => result.tab.show()).css("cursor", "pointer");
  884.             return result;
  885.         }));
  886.         if (results.every(({status}) => status == "AC")) {
  887.             resultAlert.addClass("alert-success");
  888.         } else {
  889.             resultAlert.addClass("alert-warning");
  890.         }
  891.         closeButton.click(() => {
  892.             for (const {tab} of results) {
  893.                 tab.close();
  894.             }
  895.         });
  896.     });
  897.     $("#submit").after(testAllButton).closest("form").append(testAllResultRow);
  898.     document.addEventListener("keydown", e => {
  899.         if (e.altKey) {
  900.             switch (e.key) {
  901.                 case "Enter":
  902.                     testAllButton.click();
  903.                     break;
  904.                 case "Escape":
  905.                     bottomMenu.toggle();
  906.                     break;
  907.             }
  908.         }
  909.     });
  910.  
  911.     console.info("view OK");
  912. });
  913.  
  914. })();