@jpetit/toolkit 3.0.22 → 3.1.1

package/lib/maker.ts

@@ -1,700 +0,0 @@
-import tui from '../lib/tui'
-import { filesAreEqual, fileSize, nothing, projectDir, readText, readYaml, writeText } from '../lib/utils'
-import chalk from 'chalk'
-import { execa } from 'execa'
-import { cp, exists, glob, mkdir, mkdtemp, rename } from 'fs/promises'
-import { imageSizeFromFile } from 'image-size/fromFile'
-import { tmpdir } from 'os'
-import { basename, dirname, join, normalize, resolve, sep } from 'path'
-import prettyBytes from 'pretty-bytes'
-import prettyMs from 'pretty-ms'
-import { getCompilerByExtension, getCompilerById } from './compilers'
-import type { Compiler } from './compilers/base'
-import { languageNames, proglangExtensions, proglangNames } from './data'
-import { type Handler, ZHandler, ZScores } from './types'
-import { th } from 'zod/locales'
-
-export interface MakerOptions {
-    verbose?: boolean
-    directory: string
-}
-
-export async function newMaker(options: MakerOptions): Promise<Maker> {
-    const maker = new Maker(options)
-    await maker.makeInspection()
-    return maker
-}
-
-type ExecutionResult = {
-    testcase: string
-    time: number
-    inputSize: number
-    outputSize: number
-    error: boolean
-}
-
-export class Maker {
-    verbose: boolean
-    directory: string
-    structure: 'multi' | 'single' = 'multi'
-    // multi: many languages in the same directory
-    // single: one language in a subdirectory of a .pbm directory
-    language: string | null = null // only for single structure, tells which language it is
-
-    // @ts-expect-error: will be initialized later
-    handler: Handler
-    languages: string[] = []
-    originalLanguage: string | null = null
-    problemYmls: Record<string, any> = {} // language -> content
-    solutions: string[] = []
-    goldenSolution: string | null = null
-    testcases: string[] = [] // testcase names without extensions
-
-    public constructor(options: MakerOptions) {
-        this.verbose = options.verbose || false
-        this.directory = normalize(join(options.directory, '.')) // normalize path and ensure no trailing slash
-    }
-
-    public async makeInspection() {
-        await tui.section('Inspecting problem', async () => {
-            await this.loadStructure()
-            await this.loadLanguages()
-            await this.loadHandler()
-            await this.loadOriginalLanguage()
-            await this.loadSolutions()
-            await this.loadGoldenSolution()
-            await this.loadTestcases()
-            await this.loadScores()
-            await this.loadAwards()
-        })
-    }
-
-    private async loadStructure() {
-        await tui.section('Determining structure', async () => {
-            await nothing()
-            if (this.directory.endsWith('.pbm')) {
-                this.structure = 'multi'
-            } else {
-                this.structure = 'single'
-            }
-            console.log(this.structure)
-        })
-    }
-
-    private async loadLanguages() {
-        await tui.section('Loading languages', async () => {
-            if (this.structure === 'multi') {
-                await this.loadLanguagesMulti()
-            } else {
-                await this.loadLanguagesSingle()
-            }
-        })
-    }
-
-    private async loadLanguagesMulti() {
-        const files = await Array.fromAsync(glob('problem.*.yml', { cwd: this.directory }))
-        const languages = files
-            .map((file) => {
-                const match = file.match(/problem\.(.+)\.yml/)
-                return match ? match[1] : null
-            })
-            .filter((language) => language && language in languageNames)
-        this.languages = languages as string[]
-        tui.yaml(this.languages)
-
-        for (const language of this.languages) {
-            await tui.section(`Loading problem.${language}.yml`, async () => {
-                this.problemYmls[language] = await readYaml(`${this.directory}/problem.${language}.yml`)
-                tui.yaml(this.problemYmls[language])
-            })
-        }
-    }
-
-    private async loadLanguagesSingle() {
-        for (const language of Object.keys(languageNames)) {
-            const name = join(this.directory, '..', language, `problem.${language}.yml`)
-            if (await exists(name)) {
-                this.languages.push(language)
-            }
-        }
-        tui.yaml(this.languages)
-
-        for (const language of this.languages) {
-            const name = join(this.directory, '..', language, `problem.${language}.yml`)
-            await tui.section(`Loading ..${sep}${language}${sep}problem.${language}.yml`, async () => {
-                this.problemYmls[language] = await readYaml(name)
-                tui.yaml(this.problemYmls[language])
-            })
-        }
-
-        this.language = basename(this.directory)
-    }
-
-    private async loadHandler() {
-        await tui.section('Loading handler.yml', async () => {
-            const data = await readYaml(`${this.directory}/handler.yml`)
-            this.handler = ZHandler.parse(data)
-            tui.yaml(this.handler)
-        })
-    }
-
-    private async loadScores() {
-        await tui.section('Loading scores.yml', async () => {
-            if (await exists(`${this.directory}/scores.yml`)) {
-                const data = await readYaml(`${this.directory}/scores.yml`)
-                const scores = ZScores.parse(data)
-                tui.yaml(scores)
-            } else {
-                tui.print('scores.yml not defined')
-            }
-        })
-    }
-    private async loadOriginalLanguage() {
-        await tui.section('Determining original language', async () => {
-            await nothing()
-            for (const language of this.languages) {
-                if ('author' in this.problemYmls[language]) {
-                    this.originalLanguage = language
-                    break
-                }
-            }
-            if (!this.originalLanguage) {
-                throw new Error('No original language found (a language with an author field)')
-            }
-            tui.print(this.originalLanguage)
-        })
-    }
-
-    private async loadSolutions() {
-        await tui.section('Loading solutions', async () => {
-            const comaSeparatedExtensions = Object.keys(proglangNames).join(',')
-            const files = await Array.fromAsync(glob(`solution.{${comaSeparatedExtensions}}`, { cwd: this.directory }))
-            this.solutions = files
-            tui.yaml(this.solutions)
-            if (this.solutions.length === 0) throw new Error('No solutions found')
-        })
-    }
-
-    private async loadGoldenSolution() {
-        await tui.section('Determining golden solution', async () => {
-            if (this.handler.compilers === 'RunPython') {
-                this.goldenSolution = 'solution.py'
-            } else if (this.handler.compilers === 'RunHaskell' || this.handler.compilers === 'GHC') {
-                this.goldenSolution = 'solution.hs'
-            } else if (this.handler.compilers === 'RunClojure' || this.handler.compilers === 'Clojure') {
-                this.goldenSolution = 'solution.clj'
-            } else {
-                // any compilers
-                const solutionProglang = this.handler.solution
-                const extension = proglangExtensions[solutionProglang]
-                if (!extension) {
-                    throw new Error(`Unknown programming language ${solutionProglang} for solution`)
-                }
-                const goldenSolutionPath = join(this.directory, `solution.${extension}`)
-                const fileExists = await exists(goldenSolutionPath)
-                if (!fileExists) {
-                    throw new Error(`Golden solution file ${goldenSolutionPath} not found`)
-                }
-                this.goldenSolution = `solution.${extension}`
-            }
-            tui.print(this.goldenSolution)
-        })
-    }
-
-    private async loadTestcases() {
-        await tui.section('Loading testcases', async () => {
-            const files = await Array.fromAsync(glob('*.inp', { cwd: this.directory }))
-            this.testcases = files.map((file) => file.replace('.inp', '')).sort()
-            tui.yaml(this.testcases)
-        })
-    }
-
-    private async loadAwards() {
-        await tui.section('Loading awards', async () => {
-            if (await exists(join(this.directory, 'award.html'))) {
-                tui.success(tui.hyperlink(this.directory, 'award.html') + ' found')
-            } else {
-                tui.warning('award.html not found')
-            }
-
-            if (await exists(join(this.directory, 'award.png'))) {
-                tui.success(tui.hyperlink(this.directory, 'award.png') + ' found')
-                const dimensions = await imageSizeFromFile(join(this.directory, 'award.png'))
-                await tui.image(join(this.directory, 'award.png'), 6, 3)
-                tui.print(`${dimensions.width}x${dimensions.height}`)
-            } else {
-                tui.warning('award.png not found')
-            }
-        })
-    }
-
-    async showDirectory() {
-        await tui.section('Directory', async () => {
-            await nothing()
-            tui.directory(resolve(this.directory))
-            const fullPath = normalize(resolve(this.directory))
-            if (!fullPath.endsWith('.pbm')) {
-                const lastPath = basename(fullPath)
-                const butLastPath = dirname(fullPath)
-                /*
-                 */
-                if (!Object.keys(languageNames).includes(lastPath) || !butLastPath.endsWith('.pbm')) {
-                    throw new Error(
-                        'The problem directory should end with .pbm or be a language id inside a .pbm directory',
-                    )
-                }
-            }
-        })
-    }
-    public async makeProblem() {
-        await this.makeGoldenExecutable()
-        await this.makeCorrects()
-        await this.verifySolutions()
-        await this.makePdfs()
-        await this.makeTexts()
-    }
-
-    public async makeExecutable(program: string) {
-        const compiler = this.selectCompiler()
-        await tui.section(`Compiling ${tui.hyperlink(this.directory, program)} with ${compiler.name()}`, async () => {
-            try {
-                await compiler.compile(this.handler, this.directory, program)
-            } catch (error) {
-                throw new Error(`Compilation failed`)
-            }
-        })
-    }
-
-    public async makeExecutables() {
-        await tui.section('Compiling solutions', async () => {
-            for (const solution of this.solutions) {
-                await this.makeExecutable(solution)
-            }
-        })
-    }
-
-    public async makeGoldenExecutable() {
-        await tui.section(
-            `Compiling golden solution ${tui.hyperlink(this.directory, this.goldenSolution!)}`,
-            async () => {
-                if (!this.goldenSolution) {
-                    throw new Error('Golden solution not set')
-                }
-                await this.makeExecutable(this.goldenSolution)
-            },
-        )
-    }
-
-    public async verifySolutions() {
-        for (const solution of this.solutions) {
-            if (solution !== this.goldenSolution) {
-                await this.verifyCandidate(solution)
-            }
-        }
-    }
-
-    async makeCorrect(testcase: string, compiler: Compiler, sourcePath: string): Promise<ExecutionResult> {
-        return await this.runTestcase(testcase, `${testcase}.inp`, `${testcase}.cor`, compiler, sourcePath)
-    }
-
-    async runTestcase(
-        testcase: string,
-        input: string,
-        output: string,
-        compiler: Compiler,
-        sourcePath: string,
-    ): Promise<ExecutionResult> {
-        let error = false
-        const start = Date.now()
-        try {
-            await compiler.execute(this.handler, this.directory, sourcePath, input, output)
-        } catch (e) {
-            tui.error(`Execution failed for testcase '${testcase}'`)
-            error = true
-        }
-        const end = Date.now()
-        const time = end - start
-
-        if (this.handler.handler === 'graphic') {
-            await rename(join(this.directory, 'output.png'), join(this.directory, output))
-        }
-
-        const inputSize = await fileSize(`${this.directory}/${input}`)
-        const outputSize = await fileSize(`${this.directory}/${output}`)
-
-        return { testcase, error, time, inputSize, outputSize }
-    }
-
-    selectCompiler(): Compiler {
-        if (this.handler.compilers === 'RunPython') {
-            return getCompilerById('RunPython')
-        } else if (this.handler.compilers === 'RunHaskell') {
-            return getCompilerById('RunHaskell')
-        } else if (this.handler.compilers === 'RunClojure') {
-            return getCompilerById('RunClojure')
-        } else {
-            const extension = this.goldenSolution!.split('.').pop()!
-            return getCompilerByExtension(extension)
-        }
-    }
-
-    public async makeCorrects() {
-        const compiler = this.selectCompiler()
-        await tui.section(`Making corrects with golden solution`, async () => {
-            await tui.section(`Executing testcases using ${compiler.name()}`, async () => {
-                const results: ExecutionResult[] = []
-
-                for (const testcase of this.testcases) {
-                    results.push(await this.makeCorrect(testcase, compiler, this.goldenSolution!))
-                }
-
-                console.log()
-                console.log(`testcase           time      input     output`)
-                for (const result of results) {
-                    const time = prettyMs(result.time)
-                    const inputSize = prettyBytes(result.inputSize).replace(' ', '')
-                    const outputSize = prettyBytes(result.outputSize).replace(' ', '')
-                    console.log(
-                        (result.error ? chalk.red : chalk.green)(
-                            `${result.testcase.padEnd(12)} ${time.padStart(10)} ${inputSize.padStart(10)} ${outputSize.padStart(
-                                10,
-                            )}`,
-                        ),
-                    )
-                }
-
-                const errors = results.filter((result) => result.error).length
-                if (errors > 0) {
-                    console.log()
-                    throw new Error(`${errors} errors occurred while making correct answers`)
-                }
-            })
-        })
-    }
-
-    public async makePdfs() {
-        await tui.section('Making PDF statements', async () => {
-            const tmpDirBase = await mkdtemp(join(tmpdir(), `jutge-toolkit-pdf-`))
-            await tui.section('Creating working directory', async () => {
-                await nothing()
-                tui.directory(tmpDirBase)
-            })
-            try {
-                for (const language of this.languages) {
-                    if (this.structure === 'multi' || (this.structure === 'single' && language === this.language)) {
-                        await tui.section(`Making PDF statement for ${languageNames[language]}`, async () => {
-                            await this.makePdf(tmpDirBase, language)
-                        })
-                    }
-                }
-            } finally {
-                // do not clean up because of hyperlinks
-            }
-        })
-    }
-
-    async makeSamples(tmpDir: string, language: string): Promise<[string, string]> {
-        const graphic = this.handler.handler === 'graphic'
-        const samples1c: string[] = []
-        const samples2c: string[] = []
-        let index = 1
-        for (const testcase of this.testcases) {
-            if (testcase.startsWith('sample')) {
-                let size = ''
-                if (graphic) {
-                    await cp(join(this.directory, `${testcase}.cor`), join(tmpDir, `${testcase}.cor.png`))
-                    const dimensions = await imageSizeFromFile(join(tmpDir, `${testcase}.cor.png`))
-                    size = `(${dimensions.width}$\\times$${dimensions.height})`
-                }
-                samples1c.push(`\n\\SampleOneColInputOutput[${size}]{${testcase}}{${index}}\n`)
-                samples2c.push(`\n\\SampleTwoColInputOutput[${size}]{${testcase}}{${index}}\n`)
-                index++
-            }
-        }
-        return [samples1c.join('\n'), samples2c.join('\n')]
-    }
-
-    async makePdf(tmpDirBase: string, language: string) {
-        const tmpDir = join(tmpDirBase, language)
-        await mkdir(tmpDir)
-
-        const date = new Date().toISOString().substring(0, 10)
-        const year = new Date().getFullYear()
-        const author = this.problemYmls[language].author || 'Unknown'
-        const authorEmail = this.problemYmls[language].author_email || 'unknown email'
-        const translator = this.problemYmls[language].translator || ''
-
-        const [samples1c, samples2c] = await this.makeSamples(tmpDir, language)
-
-        const root = `
-    
-\\documentclass[11pt]{article}
-
-\\usepackage{judgeit}
-\\usepackage{judgeit.${language}}
-
-% TODO?
-\\lstMakeShortInline@
-
-\\begin{document}
-
-\\providecommand{\\SampleOneCol}{${samples1c}} 
-\\providecommand{\\SampleTwoCol}{${samples2c}} 
-\\ProblemId{{DRAFT ${language}}}
-\\DoProblem{${language}}
-
-\\ProblemInformation
-\\Author: ${author}\\\\ ${translator ? `(${language}: ${translator})` : ''}
-\\Generation: ${date}
-
-\\subsection*{Draft}
-Draft generated with \\textbf{new-jutge-toolkit}.
-
-\\end{document}
-
-        `
-
-        // copy files to tmpDir
-        await cp(this.directory, tmpDir, { recursive: true })
-
-        // write root.tex
-        await writeText(join(tmpDir, 'root.tex'), root)
-
-        // tweak the tex file
-        const tex1 = await readText(join(tmpDir, `problem.${language}.tex`))
-        const tex2 = tex1
-            .replace(/\\begin{htmlonly}[\s\S]*?\\end{htmlonly}/g, '')
-            .replace(/\\begin{latexonly}/g, '')
-            .replace(/\\end{latexonly}/g, '')
-            .replace(/\.eps}/g, '}')
-        await writeText(join(tmpDir, `problem.${language}.tex`), tex2)
-
-        // copy style files
-        await this.copyStyleFiles(tmpDir, language)
-
-        // latex
-        try {
-            tui.command('xelatex -interaction=nonstopmode -file-line-error root.tex')
-            await execa({
-                stderr: 'inherit',
-                // stdout: 'inherit',
-                cwd: tmpDir,
-            })`xelatex -interaction=nonstopmode -file-line-error root.tex`
-            await cp(join(tmpDir, 'root.pdf'), join(this.directory, `problem.${language}.pdf`))
-            tui.success(
-                `Generated ${tui.hyperlink(this.directory, `problem.${language}.pdf`)} see ${tui.hyperlink(tmpDir, `root.log`)}`,
-            )
-        } catch (e) {
-            tui.error(`Error in LaTeX: ${tui.hyperlink(tmpDir, `root.log`)}`)
-        }
-    }
-
-    async copyStyleFiles(tmpDir: string, language: string) {
-        const cpSty = async (path: string) => {
-            const source = join(projectDir(), 'assets', 'sty', path)
-            await cp(source, join(tmpDir, path))
-        }
-        await cpSty('picins.sty')
-        await cpSty('judgeit.sty')
-        if (language === 'ca') await cpSty('judgeit.ca.sty')
-        if (language === 'es') await cpSty('judgeit.es.sty')
-        if (language === 'en') await cpSty('judgeit.en.sty')
-        if (language === 'fr') await cpSty('judgeit.fr.sty')
-        if (language === 'de') await cpSty('judgeit.de.sty')
-    }
-
-    public async makeTexts() {
-        await tui.section('Making text statements', async () => {
-            const tmpDirBase = await mkdtemp(join(tmpdir(), `jutge-toolkit-text-`))
-            await tui.section('Creating working directory', async () => {
-                await nothing()
-                tui.directory(tmpDirBase)
-            })
-            try {
-                for (const language of this.languages) {
-                    if (this.structure === 'multi' || (this.structure === 'single' && language === this.language)) {
-                        await tui.section(`Making text statements for ${languageNames[language]}`, async () => {
-                            await this.makeText(tmpDirBase, language)
-                        })
-                    }
-                }
-            } finally {
-                // do not clean up because of hyperlinks
-            }
-        })
-    }
-
-    async makeText(tmpDirBase: string, language: string) {
-        const tmpDir = join(tmpDirBase, language)
-        await mkdir(tmpDir)
-
-        const date = new Date().toISOString().substring(0, 10)
-        const year = new Date().getFullYear()
-        const author = this.problemYmls[language].author || 'Unknown'
-        const authorEmail = this.problemYmls[language].author_email || 'unknown email'
-        const translator = this.problemYmls[language].translator || ''
-
-        const root = `
-    
-\\documentclass[11pt]{article}
-
-\\usepackage{judgeit}
-\\usepackage{judgeit.${language}}
-
-% TODO?
-\\lstMakeShortInline@
-
-% redefine commands to simplify text output
-\\renewcommand{\\Sample}{}
-\\renewcommand{\\Statement}{}
-\\renewcommand{\\Problem}[1]{\\section{#1}}
-\\renewcommand{\\ProblemId}[1]{DRAFT ${language}}
-
-% redefine figure commands to avoid troubles with \\parpic
-\\renewcommand{\\FigureL}[2]{\\includegraphics[#1]{#2}}
-\\renewcommand{\\FigureC}[2]{\\includegraphics[#1]{#2}}
-\\renewcommand{\\FigureR}[2]{\\includegraphics[#1]{#2}}
-
-\\begin{document}
-
-\\DoProblem{${language}}
-
-\\subsection*{\\TxtAuthor}
-${author} ${translator ? `(${language}: ${translator})` : ''}
-
-\\subsection*{Draft}
-Draft generated with \\textbf{new-jutge-toolkit}.
-
-\\end{document}
-
-        `
-
-        // copy files to tmpDir
-        await cp(this.directory, tmpDir, { recursive: true })
-
-        // write root.tex
-        await writeText(join(tmpDir, 'root.tex'), root)
-
-        // tweak the tex file
-        const tex1 = await readText(join(tmpDir, `problem.${language}.tex`))
-        const tex2 = tex1
-            .replace(/\\begin{latexonly}[\s\S]*?\\end{latexonly}/g, '')
-            .replace(/\\begin{htmlonly}/g, '')
-            .replace(/\\end{htmlonly}/g, '')
-            .replace(/\\begin{minipage}/g, '')
-            .replace(/\\end{minipage}/g, '')
-            .replace(/\.eps}/g, '}')
-        await writeText(join(tmpDir, `problem.${language}.tex`), tex2)
-
-        // copy style files
-        await this.copyStyleFiles(tmpDir, language)
-
-        // convert .eps files to png
-        const files = (await Array.fromAsync(glob('*.eps', { cwd: tmpDir }))).sort()
-        for (const file of files) {
-            tui.command(`convert ${file} ${file.replace(/\.eps$/, '.png')}`)
-            await execa({ cwd: tmpDir })`convert ${file} ${file.replace(/\.eps$/, '.png')}`
-        }
-
-        // create lua files
-        const luaSource = join(projectDir(), 'assets', 'lua', 'fixCodeBlocks.lua')
-        await cp(luaSource, join(tmpDir, 'fixCodeBlocks.lua'))
-
-        // txt
-        try {
-            tui.command('pandoc --quiet root.tex --to plain --output root.txt')
-            await execa({ cwd: tmpDir })`pandoc --quiet root.tex --to plain --output root.txt`
-            await cp(join(tmpDir, 'root.txt'), join(this.directory, `problem.${language}.txt`))
-            tui.success('Generated ' + tui.hyperlink(this.directory, `problem.${language}.txt`))
-        } catch (e) {
-            console.error('pandoc error', e)
-        }
-
-        // md
-        try {
-            tui.command(
-                'pandoc --quiet root.tex --to markdown --to markdown-header_attributes --lua-filter=fixCodeBlocks.lua --output root.md',
-            )
-            await execa({
-                cwd: tmpDir,
-            })`pandoc --quiet root.tex --to markdown --to markdown-header_attributes --lua-filter=fixCodeBlocks.lua --output root.md`
-            await cp(join(tmpDir, 'root.md'), join(this.directory, `problem.${language}.md`))
-            tui.success('Generated ' + tui.hyperlink(this.directory, `problem.${language}.md`))
-        } catch (e) {
-            console.error('pandoc error', e)
-        }
-
-        // md
-        try {
-            tui.command('pandoc --quiet root.tex --to html --mathml --embed-resources --output root.html')
-            await execa({
-                cwd: tmpDir,
-            })`pandoc --quiet root.tex --to html --mathml --embed-resources --output root.html`
-            await cp(join(tmpDir, 'root.html'), join(this.directory, `problem.${language}.html`))
-            tui.success('Generated ' + tui.hyperlink(this.directory, `problem.${language}.html`))
-        } catch (e) {
-            console.error('pandoc error', e)
-        }
-    }
-
-    public async verifyCandidate(program: string) {
-        await tui.section(`Verifying ${program}`, async () => {
-            const extension = program.split('.').pop()!
-            const compiler = getCompilerByExtension(extension)
-
-            await tui.section(
-                `Using compiler ${compiler.name()} to compile ${tui.hyperlink(this.directory, program)}`,
-                async () => {
-                    try {
-                        await compiler.compile(this.handler, this.directory, program)
-                    } catch (error) {
-                        throw new Error(`Compilation failed`)
-                    }
-                },
-            )
-
-            const results: ExecutionResult[] = []
-            await tui.section('Executing testcases', async () => {
-                for (const testcase of this.testcases) {
-                    results.push(
-                        await this.runTestcase(
-                            testcase,
-                            `${testcase}.inp`,
-                            `${testcase}.${extension}.out`,
-                            compiler,
-                            program,
-                        ),
-                    )
-                }
-
-                console.log()
-                console.log(`testcase           time     status`)
-                let errors = 0
-                for (const result of results) {
-                    const status = result.error
-                        ? 'EE'
-                        : (await filesAreEqual(
-                                `${this.directory}/${result.testcase}.cor`,
-                                `${this.directory}/${result.testcase}.${extension}.out`,
-                            ))
-                          ? 'OK'
-                          : 'WA'
-                    const time = prettyMs(result.time)
-                    console.log(
-                        (status !== 'OK' ? chalk.red : chalk.green)(
-                            `${result.testcase.padEnd(12)} ${time.padStart(10)} ${status.padStart(10)}`,
-                        ),
-                    )
-                    if (status !== 'OK') errors++
-                }
-                console.log()
-
-                if (errors) {
-                    tui.error(`${errors} errors found for ${program}`)
-                } else {
-                    tui.success(`All testcases passed successfully for ${program}`)
-                }
-            })
-        })
-    }
-}