tko


Nametko JSON
Version 0.6.3 PyPI version JSON
download
home_pagehttps://github.com/senapk/tko
Summarytko: Test Kit Operations
upload_time2024-06-15 19:33:36
maintainerNone
docs_urlNone
authorDavid Sena Oliveira
requires_python<4,>=3.8
licenseNone
keywords programming learning
VCS
bugtrack_url
requirements appdirs build twine
Travis-CI No Travis.
coveralls test coverage No coveralls.
            <!-- markdownlint-configure-file {
  "MD033": false,
  "MD041": false
} -->

<!-- toc -->
- [Instalação](#instalação)
- [Dependências](#dependências)
- [Download atividades](#download-atividades)
- [Rodando](#rodando)
  - [Rodando sem testar](#rodando-sem-testar)
  - [Rodando os testes](#rodando-os-testes)
  - [Rodando múltiplos arquivos](#rodando-múltiplos-arquivos)
- [Utilizando outras linguagens de programação](#utilizando-outras-linguagens-de-programação)
  - [Opção 1: chamando o interpretador da linguagem](#opção-1-chamando-o-interpretador-da-linguagem)
  - [Compilando antecipadamente](#compilando-antecipadamente)
- [Verificando o resultado](#verificando-o-resultado)
  - [Opções extras](#opções-extras)
- [O que é um teste?](#o-que-é-um-teste)
  - [Formatos de teste](#formatos-de-teste)
  - [Sintaxe TIO](#sintaxe-tio)
  - [Escrevendo alguns testes](#escrevendo-alguns-testes)
- [Convertendo entre formatos](#convertendo-entre-formatos)
<!-- toc -->

# tko

O TKO é um sistema de testes para programação competitiva. Ele é capaz de rodar testes em várias linguagens de programação e em vários formatos de testes. Ele está integrado com os repositórios de atividades das disciplinas de programação da UFC de Quixadá permitindo baixar as atividades e rodar os testes.

- [FUP - Fundamentos de Programação](https://github.com/qxcodefup/arcade)
- [ED - Estrutura de Dados](https://github.com/qxcodeed/arcade)
- [POO - Programação Orientada a Objetos](https://github.com/qxcodepoo/arcade)

![intro](install/intro.webp)

## Instalação

| [Windows](install/windows.md) | [Linux](install/linux.md) | [Replit](replit/Readme.md) | [Codespace](install/codespace.md) |
| ------- | ----- | ------ | --------- |
| [![_](install/windows.jpg)](install/windows.md) | [![_](install/linux.jpg)](install/linux.md)       | [![_](install/replit.jpg)](replit/Readme.md) | [![_](install/codespace.jpg)](install/codespace.md) |

```bash
# instalar utilizando o gerenciador de pacotes do python
pip install tko
```

## Dependências

Você precisará do compilador próprio da linguagem que for programar, instale manualmente no seu sistema. Se estiver no replit, o template da linguagem já vem com o compilador instalado.

- c/c++: `gcc` ou `g++`
- java: `javac`
- python: `python3`
- javascript: `node`
- typescript: `esbuild` e `node`

## Download atividades

- Para baixar, por exemplo, a atividade do carro do repositório de POO(Programação Orientada a Objetos): [contrua seu primeiro @carro](https://github.com/qxcodepoo/arcade/blob/master/base/carro/Readme.md) para `java`:

```bash
# Você informa o repositório `poo` o problema `carro` e vai ser perguntado a linguagem interativamente
# tko down _course _activity
tko down poo carro

# você pode também especificar a linguagem para pular o prompt
tko down poo carro -l java

# ou pode definir a linguagem padrão de download dos rascunhos para não precisar informar toda vez
tko config -l java
```

Ao baixar a questão, você terá uma pasta com o nome `carro` contendo:

- Readme.md: com a descrição da atividade em markdown.
- cases.tio: com os casos de teste.
- draft.ext: com o rascunho da solução.

## Rodando

### Rodando sem testar

Após baixar, entre na pasta.

Você pode aproveitar o arquivo de rascunho e renomeá-lo, ou criar seus próprios arquivos de resposta ao problema.

Para executar seu arquivo sem testar, basta rodar o comando `tko run` passando o arquivo de código como parâmetro.

Por exemplo, para a linguagem Java, você pode rodar o seguinte comando:

```bash
# tko run _arquivo_de_codigo
tko run Solver.java
```

A ferramenta vai compilar e executar seu código, mostrando se houve algum erro.

### Rodando os testes

Para rodar os testes, passe também o arquivo de testes `cases.tio` em qualquer ordem, antes ou depois do seu arquivo de código para o comando.

```bash
# tko run _arquivos_de_codigo _arquivo_de_casos_de_teste
tko run Solver.java cases.tio
```

### Descompactando os testes

Se preferir trabalhar com o modelo de testes em arquivos separados, você pode descompactar o arquivo `cases.tio` para uma pasta com os arquivos de entrada e saída. Será gerado um arquivo `.in` e um `.sol` para cada teste.

```bash
$ mkdir pasta
$ tko build pasta cases.tio
$ ls pasta
00.in 00.sol 01.in 01.sol 02.in 02.sol 03.in 03.sol 04.in 04.sol
```

Para rodar a partir da pasta com os testes descompactados, basta passar o nome da pasta como parâmetro.

```bash
$ tko run Solver.java pasta
```

Se quiser utilizar um nome padrão diferente para leitura ou escrita das pastas, veja a seção de [Convertendo entre formatos](#convertendo-entre-formatos).

### Rodando múltiplos arquivos

Se você tiver mais de um arquivo de código, o comportamento depende da linguagem.

<details>
<summary> Java </summary>

Se estiver executando `tko` de dentro da pasta. Basta executar o arquivo que contém a `main`. No exemplo abaixo, tanto a classe `Shell` quanto a classe `Motorcycle` contém a `main`. A classe `Shell` é usada para rodar junto com o `cases.tio`, para interpretar os testes. A classe `Motorcycle` é usada para rodar sem testes.

```bash
[lion@jungle java]$ ls
Adapter.java  cases.tio  Motorcycle.java  Person.java  Shell.java
[lion@jungle java]$ tko run Shell.java cases.tio 
═══════════════════════════ Running solver against test cases ═══════════════════════════
=> base:[cases.tio(15)] prog:[Shell.java] [✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓]

[lion@jungle java]$ tko run Motorcycle.java 
─────────── No test cases found. Running: java -cp /tmp/tmph43lgfhb Motorcycle ──────────
Rodando a main do arquivo da motoca
[lion@jungle java]$ 
```

</details>

<details> <summary> C e C++ </summary>

- Você precisa passar todos os arquivo `c` ou `cpp` que deseja compilar e rodar.
- A ordem dos arquivos não importa, mas apenas um deles pode ter a função `main`.
- No exemplo abaixo, o arquivo `main.cpp` é o arquivo que contém a `main` e o arquivo `point.cpp` contém as implementação das funções que serão usadas no arquivo `main.cpp`.

```bash
[lion@jungle cpp]$ ls
cases.tio  fn.hpp  main.cpp  point.cpp  point.hpp
[lion@jungle cpp]$ tko run *.cpp cases.tio
═══════════════════════════ Running solver against test cases ═══════════════════════════
=> base:[cases.tio(02)] prog:[main.cpp, point.cpp] [✓ ✓]
```

</details>

<details> <summary> Typescript e Javascript </summary>

- Você precisa passar todos os arquivo `ts` ou `js` que deseja compilar e rodar. Exemplo
- O primeiro arquivo `.ts` passado por parâmetro é o arquivo que vai ser executado.
- Opção 1: Você pode escolher o arquivo principal, antes de passar os outros arquivos.
  - `tko run cases.tio shell.ts adapter.ts motoca.ts pessoa.ts`
- Opção 2: Você pode passar o arquivo principal primeiro e depois utilizar o `*.ts` para os outros.
  - `tko run cases.tio shell.ts *.ts`
- Opção 3: Você pode renomear o arquivo principal para um nome que esteja "antes" dos outros.
  - `mv shell.ts aashell.ts`
  - `tko run cases.tio *.ts`

</details>

<details> <summary> Exemplos: Typescript e Javascript </summary>

```bash
[lion@jungle ts]$ ls
adapter.ts  cases.tio  motoca.ts  pessoa.ts  shell.ts

##########################################
# PASSANDO OS ARQUIVOS SEM USAR WILDCARD *

[lion@jungle ts]$ tko run cases.tio shell.ts adapter.ts motoca.ts pessoa.ts 
═══════════════════════════ Running solver against test cases ═══════════════════════════
=> base:[cases.tio(15)] prog:[shell.ts, adapter.ts, motoca.ts, pessoa.ts] [✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓]

##########################################
# PASSANDO O ARQUIVO PRINCIPAL PRIMEIRO E DEPOIS OS OUTROS

[lion@jungle ts]$ tko run cases.tio shell.ts *.ts
═══════════════════════════ Running solver against test cases ═══════════════════════════
=> base:[cases.tio(15)] prog:[shell.ts, adapter.ts, motoca.ts, pessoa.ts] [✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓]

##########################################
# MUDANDO O NOME DO SHELL PARA AASHELL

[lion@jungle ts]$ mv shell.ts aashell.ts
[lion@jungle ts]$ tko run cases.tio *.ts
═══════════════════════════ Running solver against test cases ═══════════════════════════
=> base:[cases.tio(15)] prog:[aashell.ts, adapter.ts, motoca.ts, pessoa.ts] [✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓]
```

Se algum módulo quiser ser executado individualmente, ele pode ter o seguinte bloco de código:

```ts
export { Motoca };
// esse if garante que o módulo só vai ser executado se for chamado diretamente
if (module === require.main) {
    let moto = new Motoca(2);
    console.log(moto.toString());
    moto.inserir(new Pessoa("jose", 9));
    console.log(moto.toString());
}

```

E pode ser executado passando o arquivo diretamente:

```bash
[lion@jungle ts]$ tko run motoca.ts pessoa.ts 

────────── No test cases found. Running: node /tmp/tmp2yhb8xem/motoca.js ──────────
power:2, time:0, person:(empty)
power:2, time:0, person:(jose:9)
```

</details>

## Utilizando outras linguagens de programação

### Opção 1: chamando o interpretador da linguagem

Códigos em `lua` podem ser executados por um interpretador, tal qual `python` e `javascript`.

Seja o seguinte código

```lua
// teste.lua
print("Hello World")
```

- Podemos mostrar ao `tko` qual comando executar com a flag `--cmd`:
  - `tko run --cmd "lua teste.lua" cases.tio`

![lua](install/lua.png)

### Compilando antecipadamente

Se sua linguagem gera código executável, tal qual `c`, `c++` ou `rust` você pode compilar e passar o executável para o `tko`. Vamos ver um exemplo em `c++`, compilado manualmente.

- compilação: `g++ -std=c++20 -Wall teste.cpp -o teste.out`
- teste: `tko run teste.out cases.tio`

![alt text](install/cpp.png)

## Verificando o resultado

Após fazer uma parte do código, executamos os testes novamente. Agora ele compila e mostra:

- Quantos testes passaram.
- O nome e o índice dos testes que falharam.
- O diff do primeiro teste que falhou
  - resultado esperado (lado esquerdo), resultado obtido (lado direito).
- O diff da primeira linha diferente renderizando os whitespaces.

![image](https://user-images.githubusercontent.com/4747652/262019524-eef3035a-6132-4151-9f5f-6945294e173d.png)

### Opções extras

- É muito útil na hora de debugar, isolar o teste que você está trabalhando. Caso queira rodar apenas um índice de teste, utilize a opção `-i`:

```bash
# rodando apenas o teste 5 depois de encher o código de print para debugar
tko run Solver.java cases.tio -i 5
```

- Você pode mudar o modo padrão de ver o `diff` no `tko run` com:
  - Um em cima do outro (`-u` ou `--updown`)
  - Um ao lado do outro (`-s` ou `--sideby`)

```bash
tko run Solver.java cases.tio -u
```

- Através do `tko config`, você pode trocar configurações default para:
  - o padrão do `diff`.
  - esquema de cores: monocromático e colorido.
  - tipo de caracteres: entre ascii e unicode.
  - a linguagem padrão de download dos rascunhos.

```bash
$ tko config --help
options:
  -h, --help          show this help message and exit
  --show, -s          show current settings.
  --ascii             set ascii mode.
  --unicode           set unicode mode.
  --color             set colored mode.
  --mono              set mono mode.
  --side              set side_by_side diff mode.
  --updown            set up_to_down diff mode.
  --lang ext, -l ext  set default language extension.
  --ask               ask language extension every time.
```

Vou definir a cor para monocromático, `diff updown` e a linguagem padrão para `js`.

```bash
$ tko config --mono
Color mode now is: MONOCHROMATIC
$ tko config --updown
Diff mode now is: UP_DOWN
$ tko config -l js
Default language extension now is: js
```

## O que é um teste?

- Um teste define qual o comportamento esperado de um programa determinístico. Para uma determinada entrada, o programa deve gerar **sempre** a mesma saída.
- A entrada e saída e o comportamento esperado devem ser bem definidos, por exemplo:
  - Dados dois números inteiros de entrada, um por linha, mostre o resultado da divisão. Se o resultado for inteiro, mostre o valor inteiro, se for flutuante, mostre com duas casas decimais.

### Formatos de teste

- Um arquivo de texto com vários testes:
  - modelo TIO(test input output).
  - modelo VPL que é utilizado no plugin do moodle.
- Uma pasta com um dois arquivos para cada teste, um arquivo com a entrada e outro com a saída.
  - modelo maratona:
    - Arquivos .in e .out
    - Arquivos .in e .sol

---

### Sintaxe TIO

```txt
>>>>>>>>
entrada
...
========
saída
...
<<<<<<<<

>>>>>>>>
entrada
...
========
saída
...
<<<<<<<<
```

---

### Escrevendo alguns testes

Vamos escrever alguns testes para o problema proposto. Crie um arquivo chamado `testes.tio` e vamos inserir algumas entradas para o problema proposto.

```txt
>>>>>>>>
4
2
========
2
<<<<<<<<

>>>>>>>>
3
2
========
1.50
<<<<<<<<

>>>>>>>>
5
4
========
1.25
<<<<<<<<

>>>>>>>>
1
3
========
0.33
<<<<<<<<
```

## Convertendo entre formatos

- Gerando um `t.vpl`
  - `tko build t.vpl testes.tio`
- Gerando um `t.tio` a partir do `Readme.md`e de um `extra.tio`.
  - `tko build t.tio Readme.md extra.tio`
- Para extrair os testes para uma pasta com um arquivo para entrada e outro para saída, crie uma pasta vazia e passe para o primeiro parâmetro do `tko build`.

```bash
$ ls
cases.tio  draft.c  Readme.md
$ mkdir pasta
$ tko build pasta cases.tio 
$ ls pasta/
00.in   02.sol  05.in   07.sol  10.in   12.sol  15.in   17.sol  20.in   22.sol
00.sol  03.in   05.sol  08.in   10.sol  13.in   15.sol  18.in   20.sol  23.in
01.in   03.sol  06.in   08.sol  11.in   13.sol  16.in   18.sol  21.in   23.sol
01.sol  04.in   06.sol  09.in   11.sol  14.in   16.sol  19.in   21.sol
02.in   04.sol  07.in   09.sol  12.in   14.sol  17.in   19.sol  22.in
```

- Você pode definir o padrão de nome dos arquivos gerados com `-p "@ @"`, sendo @ o wildcard que representa a numeração dos arquivo.
  - Vamos refazer o comando acima, mas colocando "-p in.@ out.@"

```bash
$ tko build pasta/ cases.tio -p "in.@ out.@"
$ ls pasta/
in.00  in.05  in.10  in.15  in.20   out.01  out.06  out.11  out.16  out.21
in.01  in.06  in.11  in.16  in.21   out.02  out.07  out.12  out.17  out.22
in.02  in.07  in.12  in.17  in.22   out.03  out.08  out.13  out.18  out.23
in.03  in.08  in.13  in.18  in.23   out.04  out.09  out.14  out.19
in.04  in.09  in.14  in.19  out.00  out.05  out.10  out.15  out.20
```

- O `pattern` é útil para converter os formatos de Maratona, que vem em múltiplos arquivos para o `.tio`. Basta fazer o `match` do modelo que eles utilizarem. 
  - `-p "@.in @.out"`
  - `-p "in@ out@"`
  - entre outros.

            

Raw data

            {
    "_id": null,
    "home_page": "https://github.com/senapk/tko",
    "name": "tko",
    "maintainer": null,
    "docs_url": null,
    "requires_python": "<4,>=3.8",
    "maintainer_email": null,
    "keywords": "programming, learning",
    "author": "David Sena Oliveira",
    "author_email": "sena@ufc.br",
    "download_url": "https://files.pythonhosted.org/packages/38/68/2e04126e30adc9219f2ae49d6ca6ed8d369a450a0f2992fabc799fb7b86f/tko-0.6.3.tar.gz",
    "platform": null,
    "description": "<!-- markdownlint-configure-file {\n  \"MD033\": false,\n  \"MD041\": false\n} -->\n\n<!-- toc -->\n- [Instala\u00e7\u00e3o](#instala\u00e7\u00e3o)\n- [Depend\u00eancias](#depend\u00eancias)\n- [Download atividades](#download-atividades)\n- [Rodando](#rodando)\n  - [Rodando sem testar](#rodando-sem-testar)\n  - [Rodando os testes](#rodando-os-testes)\n  - [Rodando m\u00faltiplos arquivos](#rodando-m\u00faltiplos-arquivos)\n- [Utilizando outras linguagens de programa\u00e7\u00e3o](#utilizando-outras-linguagens-de-programa\u00e7\u00e3o)\n  - [Op\u00e7\u00e3o 1: chamando o interpretador da linguagem](#op\u00e7\u00e3o-1-chamando-o-interpretador-da-linguagem)\n  - [Compilando antecipadamente](#compilando-antecipadamente)\n- [Verificando o resultado](#verificando-o-resultado)\n  - [Op\u00e7\u00f5es extras](#op\u00e7\u00f5es-extras)\n- [O que \u00e9 um teste?](#o-que-\u00e9-um-teste)\n  - [Formatos de teste](#formatos-de-teste)\n  - [Sintaxe TIO](#sintaxe-tio)\n  - [Escrevendo alguns testes](#escrevendo-alguns-testes)\n- [Convertendo entre formatos](#convertendo-entre-formatos)\n<!-- toc -->\n\n# tko\n\nO TKO \u00e9 um sistema de testes para programa\u00e7\u00e3o competitiva. Ele \u00e9 capaz de rodar testes em v\u00e1rias linguagens de programa\u00e7\u00e3o e em v\u00e1rios formatos de testes. Ele est\u00e1 integrado com os reposit\u00f3rios de atividades das disciplinas de programa\u00e7\u00e3o da UFC de Quixad\u00e1 permitindo baixar as atividades e rodar os testes.\n\n- [FUP - Fundamentos de Programa\u00e7\u00e3o](https://github.com/qxcodefup/arcade)\n- [ED - Estrutura de Dados](https://github.com/qxcodeed/arcade)\n- [POO - Programa\u00e7\u00e3o Orientada a Objetos](https://github.com/qxcodepoo/arcade)\n\n![intro](install/intro.webp)\n\n## Instala\u00e7\u00e3o\n\n| [Windows](install/windows.md) | [Linux](install/linux.md) | [Replit](replit/Readme.md) | [Codespace](install/codespace.md) |\n| ------- | ----- | ------ | --------- |\n| [![_](install/windows.jpg)](install/windows.md) | [![_](install/linux.jpg)](install/linux.md)       | [![_](install/replit.jpg)](replit/Readme.md) | [![_](install/codespace.jpg)](install/codespace.md) |\n\n```bash\n# instalar utilizando o gerenciador de pacotes do python\npip install tko\n```\n\n## Depend\u00eancias\n\nVoc\u00ea precisar\u00e1 do compilador pr\u00f3prio da linguagem que for programar, instale manualmente no seu sistema. Se estiver no replit, o template da linguagem j\u00e1 vem com o compilador instalado.\n\n- c/c++: `gcc` ou `g++`\n- java: `javac`\n- python: `python3`\n- javascript: `node`\n- typescript: `esbuild` e `node`\n\n## Download atividades\n\n- Para baixar, por exemplo, a atividade do carro do reposit\u00f3rio de POO(Programa\u00e7\u00e3o Orientada a Objetos): [contrua seu primeiro @carro](https://github.com/qxcodepoo/arcade/blob/master/base/carro/Readme.md) para `java`:\n\n```bash\n# Voc\u00ea informa o reposit\u00f3rio `poo` o problema `carro` e vai ser perguntado a linguagem interativamente\n# tko down _course _activity\ntko down poo carro\n\n# voc\u00ea pode tamb\u00e9m especificar a linguagem para pular o prompt\ntko down poo carro -l java\n\n# ou pode definir a linguagem padr\u00e3o de download dos rascunhos para n\u00e3o precisar informar toda vez\ntko config -l java\n```\n\nAo baixar a quest\u00e3o, voc\u00ea ter\u00e1 uma pasta com o nome `carro` contendo:\n\n- Readme.md: com a descri\u00e7\u00e3o da atividade em markdown.\n- cases.tio: com os casos de teste.\n- draft.ext: com o rascunho da solu\u00e7\u00e3o.\n\n## Rodando\n\n### Rodando sem testar\n\nAp\u00f3s baixar, entre na pasta.\n\nVoc\u00ea pode aproveitar o arquivo de rascunho e renome\u00e1-lo, ou criar seus pr\u00f3prios arquivos de resposta ao problema.\n\nPara executar seu arquivo sem testar, basta rodar o comando `tko run` passando o arquivo de c\u00f3digo como par\u00e2metro.\n\nPor exemplo, para a linguagem Java, voc\u00ea pode rodar o seguinte comando:\n\n```bash\n# tko run _arquivo_de_codigo\ntko run Solver.java\n```\n\nA ferramenta vai compilar e executar seu c\u00f3digo, mostrando se houve algum erro.\n\n### Rodando os testes\n\nPara rodar os testes, passe tamb\u00e9m o arquivo de testes `cases.tio` em qualquer ordem, antes ou depois do seu arquivo de c\u00f3digo para o comando.\n\n```bash\n# tko run _arquivos_de_codigo _arquivo_de_casos_de_teste\ntko run Solver.java cases.tio\n```\n\n### Descompactando os testes\n\nSe preferir trabalhar com o modelo de testes em arquivos separados, voc\u00ea pode descompactar o arquivo `cases.tio` para uma pasta com os arquivos de entrada e sa\u00edda. Ser\u00e1 gerado um arquivo `.in` e um `.sol` para cada teste.\n\n```bash\n$ mkdir pasta\n$ tko build pasta cases.tio\n$ ls pasta\n00.in 00.sol 01.in 01.sol 02.in 02.sol 03.in 03.sol 04.in 04.sol\n```\n\nPara rodar a partir da pasta com os testes descompactados, basta passar o nome da pasta como par\u00e2metro.\n\n```bash\n$ tko run Solver.java pasta\n```\n\nSe quiser utilizar um nome padr\u00e3o diferente para leitura ou escrita das pastas, veja a se\u00e7\u00e3o de [Convertendo entre formatos](#convertendo-entre-formatos).\n\n### Rodando m\u00faltiplos arquivos\n\nSe voc\u00ea tiver mais de um arquivo de c\u00f3digo, o comportamento depende da linguagem.\n\n<details>\n<summary> Java </summary>\n\nSe estiver executando `tko` de dentro da pasta. Basta executar o arquivo que cont\u00e9m a `main`. No exemplo abaixo, tanto a classe `Shell` quanto a classe `Motorcycle` cont\u00e9m a `main`. A classe `Shell` \u00e9 usada para rodar junto com o `cases.tio`, para interpretar os testes. A classe `Motorcycle` \u00e9 usada para rodar sem testes.\n\n```bash\n[lion@jungle java]$ ls\nAdapter.java  cases.tio  Motorcycle.java  Person.java  Shell.java\n[lion@jungle java]$ tko run Shell.java cases.tio \n\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 Running solver against test cases \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n=> base:[cases.tio(15)] prog:[Shell.java] [\u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713]\n\n[lion@jungle java]$ tko run Motorcycle.java \n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 No test cases found. Running: java -cp /tmp/tmph43lgfhb Motorcycle \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nRodando a main do arquivo da motoca\n[lion@jungle java]$ \n```\n\n</details>\n\n<details> <summary> C e C++ </summary>\n\n- Voc\u00ea precisa passar todos os arquivo `c` ou `cpp` que deseja compilar e rodar.\n- A ordem dos arquivos n\u00e3o importa, mas apenas um deles pode ter a fun\u00e7\u00e3o `main`.\n- No exemplo abaixo, o arquivo `main.cpp` \u00e9 o arquivo que cont\u00e9m a `main` e o arquivo `point.cpp` cont\u00e9m as implementa\u00e7\u00e3o das fun\u00e7\u00f5es que ser\u00e3o usadas no arquivo `main.cpp`.\n\n```bash\n[lion@jungle cpp]$ ls\ncases.tio  fn.hpp  main.cpp  point.cpp  point.hpp\n[lion@jungle cpp]$ tko run *.cpp cases.tio\n\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 Running solver against test cases \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n=> base:[cases.tio(02)] prog:[main.cpp, point.cpp] [\u2713 \u2713]\n```\n\n</details>\n\n<details> <summary> Typescript e Javascript </summary>\n\n- Voc\u00ea precisa passar todos os arquivo `ts` ou `js` que deseja compilar e rodar. Exemplo\n- O primeiro arquivo `.ts` passado por par\u00e2metro \u00e9 o arquivo que vai ser executado.\n- Op\u00e7\u00e3o 1: Voc\u00ea pode escolher o arquivo principal, antes de passar os outros arquivos.\n  - `tko run cases.tio shell.ts adapter.ts motoca.ts pessoa.ts`\n- Op\u00e7\u00e3o 2: Voc\u00ea pode passar o arquivo principal primeiro e depois utilizar o `*.ts` para os outros.\n  - `tko run cases.tio shell.ts *.ts`\n- Op\u00e7\u00e3o 3: Voc\u00ea pode renomear o arquivo principal para um nome que esteja \"antes\" dos outros.\n  - `mv shell.ts aashell.ts`\n  - `tko run cases.tio *.ts`\n\n</details>\n\n<details> <summary> Exemplos: Typescript e Javascript </summary>\n\n```bash\n[lion@jungle ts]$ ls\nadapter.ts  cases.tio  motoca.ts  pessoa.ts  shell.ts\n\n##########################################\n# PASSANDO OS ARQUIVOS SEM USAR WILDCARD *\n\n[lion@jungle ts]$ tko run cases.tio shell.ts adapter.ts motoca.ts pessoa.ts \n\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 Running solver against test cases \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n=> base:[cases.tio(15)] prog:[shell.ts, adapter.ts, motoca.ts, pessoa.ts] [\u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713]\n\n##########################################\n# PASSANDO O ARQUIVO PRINCIPAL PRIMEIRO E DEPOIS OS OUTROS\n\n[lion@jungle ts]$ tko run cases.tio shell.ts *.ts\n\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 Running solver against test cases \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n=> base:[cases.tio(15)] prog:[shell.ts, adapter.ts, motoca.ts, pessoa.ts] [\u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713]\n\n##########################################\n# MUDANDO O NOME DO SHELL PARA AASHELL\n\n[lion@jungle ts]$ mv shell.ts aashell.ts\n[lion@jungle ts]$ tko run cases.tio *.ts\n\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550 Running solver against test cases \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n=> base:[cases.tio(15)] prog:[aashell.ts, adapter.ts, motoca.ts, pessoa.ts] [\u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713 \u2713]\n```\n\nSe algum m\u00f3dulo quiser ser executado individualmente, ele pode ter o seguinte bloco de c\u00f3digo:\n\n```ts\nexport { Motoca };\n// esse if garante que o m\u00f3dulo s\u00f3 vai ser executado se for chamado diretamente\nif (module === require.main) {\n    let moto = new Motoca(2);\n    console.log(moto.toString());\n    moto.inserir(new Pessoa(\"jose\", 9));\n    console.log(moto.toString());\n}\n\n```\n\nE pode ser executado passando o arquivo diretamente:\n\n```bash\n[lion@jungle ts]$ tko run motoca.ts pessoa.ts \n\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 No test cases found. Running: node /tmp/tmp2yhb8xem/motoca.js \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\npower:2, time:0, person:(empty)\npower:2, time:0, person:(jose:9)\n```\n\n</details>\n\n## Utilizando outras linguagens de programa\u00e7\u00e3o\n\n### Op\u00e7\u00e3o 1: chamando o interpretador da linguagem\n\nC\u00f3digos em `lua` podem ser executados por um interpretador, tal qual `python` e `javascript`.\n\nSeja o seguinte c\u00f3digo\n\n```lua\n// teste.lua\nprint(\"Hello World\")\n```\n\n- Podemos mostrar ao `tko` qual comando executar com a flag `--cmd`:\n  - `tko run --cmd \"lua teste.lua\" cases.tio`\n\n![lua](install/lua.png)\n\n### Compilando antecipadamente\n\nSe sua linguagem gera c\u00f3digo execut\u00e1vel, tal qual `c`, `c++` ou `rust` voc\u00ea pode compilar e passar o execut\u00e1vel para o `tko`. Vamos ver um exemplo em `c++`, compilado manualmente.\n\n- compila\u00e7\u00e3o: `g++ -std=c++20 -Wall teste.cpp -o teste.out`\n- teste: `tko run teste.out cases.tio`\n\n![alt text](install/cpp.png)\n\n## Verificando o resultado\n\nAp\u00f3s fazer uma parte do c\u00f3digo, executamos os testes novamente. Agora ele compila e mostra:\n\n- Quantos testes passaram.\n- O nome e o \u00edndice dos testes que falharam.\n- O diff do primeiro teste que falhou\n  - resultado esperado (lado esquerdo), resultado obtido (lado direito).\n- O diff da primeira linha diferente renderizando os whitespaces.\n\n![image](https://user-images.githubusercontent.com/4747652/262019524-eef3035a-6132-4151-9f5f-6945294e173d.png)\n\n### Op\u00e7\u00f5es extras\n\n- \u00c9 muito \u00fatil na hora de debugar, isolar o teste que voc\u00ea est\u00e1 trabalhando. Caso queira rodar apenas um \u00edndice de teste, utilize a op\u00e7\u00e3o `-i`:\n\n```bash\n# rodando apenas o teste 5 depois de encher o c\u00f3digo de print para debugar\ntko run Solver.java cases.tio -i 5\n```\n\n- Voc\u00ea pode mudar o modo padr\u00e3o de ver o `diff` no `tko run` com:\n  - Um em cima do outro (`-u` ou `--updown`)\n  - Um ao lado do outro (`-s` ou `--sideby`)\n\n```bash\ntko run Solver.java cases.tio -u\n```\n\n- Atrav\u00e9s do `tko config`, voc\u00ea pode trocar configura\u00e7\u00f5es default para:\n  - o padr\u00e3o do `diff`.\n  - esquema de cores: monocrom\u00e1tico e colorido.\n  - tipo de caracteres: entre ascii e unicode.\n  - a linguagem padr\u00e3o de download dos rascunhos.\n\n```bash\n$ tko config --help\noptions:\n  -h, --help          show this help message and exit\n  --show, -s          show current settings.\n  --ascii             set ascii mode.\n  --unicode           set unicode mode.\n  --color             set colored mode.\n  --mono              set mono mode.\n  --side              set side_by_side diff mode.\n  --updown            set up_to_down diff mode.\n  --lang ext, -l ext  set default language extension.\n  --ask               ask language extension every time.\n```\n\nVou definir a cor para monocrom\u00e1tico, `diff updown` e a linguagem padr\u00e3o para `js`.\n\n```bash\n$ tko config --mono\nColor mode now is: MONOCHROMATIC\n$ tko config --updown\nDiff mode now is: UP_DOWN\n$ tko config -l js\nDefault language extension now is: js\n```\n\n## O que \u00e9 um teste?\n\n- Um teste define qual o comportamento esperado de um programa determin\u00edstico. Para uma determinada entrada, o programa deve gerar **sempre** a mesma sa\u00edda.\n- A entrada e sa\u00edda e o comportamento esperado devem ser bem definidos, por exemplo:\n  - Dados dois n\u00fameros inteiros de entrada, um por linha, mostre o resultado da divis\u00e3o. Se o resultado for inteiro, mostre o valor inteiro, se for flutuante, mostre com duas casas decimais.\n\n### Formatos de teste\n\n- Um arquivo de texto com v\u00e1rios testes:\n  - modelo TIO(test input output).\n  - modelo VPL que \u00e9 utilizado no plugin do moodle.\n- Uma pasta com um dois arquivos para cada teste, um arquivo com a entrada e outro com a sa\u00edda.\n  - modelo maratona:\n    - Arquivos .in e .out\n    - Arquivos .in e .sol\n\n---\n\n### Sintaxe TIO\n\n```txt\n>>>>>>>>\nentrada\n...\n========\nsa\u00edda\n...\n<<<<<<<<\n\n>>>>>>>>\nentrada\n...\n========\nsa\u00edda\n...\n<<<<<<<<\n```\n\n---\n\n### Escrevendo alguns testes\n\nVamos escrever alguns testes para o problema proposto. Crie um arquivo chamado `testes.tio` e vamos inserir algumas entradas para o problema proposto.\n\n```txt\n>>>>>>>>\n4\n2\n========\n2\n<<<<<<<<\n\n>>>>>>>>\n3\n2\n========\n1.50\n<<<<<<<<\n\n>>>>>>>>\n5\n4\n========\n1.25\n<<<<<<<<\n\n>>>>>>>>\n1\n3\n========\n0.33\n<<<<<<<<\n```\n\n## Convertendo entre formatos\n\n- Gerando um `t.vpl`\n  - `tko build t.vpl testes.tio`\n- Gerando um `t.tio` a partir do `Readme.md`e de um `extra.tio`.\n  - `tko build t.tio Readme.md extra.tio`\n- Para extrair os testes para uma pasta com um arquivo para entrada e outro para sa\u00edda, crie uma pasta vazia e passe para o primeiro par\u00e2metro do `tko build`.\n\n```bash\n$ ls\ncases.tio  draft.c  Readme.md\n$ mkdir pasta\n$ tko build pasta cases.tio \n$ ls pasta/\n00.in   02.sol  05.in   07.sol  10.in   12.sol  15.in   17.sol  20.in   22.sol\n00.sol  03.in   05.sol  08.in   10.sol  13.in   15.sol  18.in   20.sol  23.in\n01.in   03.sol  06.in   08.sol  11.in   13.sol  16.in   18.sol  21.in   23.sol\n01.sol  04.in   06.sol  09.in   11.sol  14.in   16.sol  19.in   21.sol\n02.in   04.sol  07.in   09.sol  12.in   14.sol  17.in   19.sol  22.in\n```\n\n- Voc\u00ea pode definir o padr\u00e3o de nome dos arquivos gerados com `-p \"@ @\"`, sendo @ o wildcard que representa a numera\u00e7\u00e3o dos arquivo.\n  - Vamos refazer o comando acima, mas colocando \"-p in.@ out.@\"\n\n```bash\n$ tko build pasta/ cases.tio -p \"in.@ out.@\"\n$ ls pasta/\nin.00  in.05  in.10  in.15  in.20   out.01  out.06  out.11  out.16  out.21\nin.01  in.06  in.11  in.16  in.21   out.02  out.07  out.12  out.17  out.22\nin.02  in.07  in.12  in.17  in.22   out.03  out.08  out.13  out.18  out.23\nin.03  in.08  in.13  in.18  in.23   out.04  out.09  out.14  out.19\nin.04  in.09  in.14  in.19  out.00  out.05  out.10  out.15  out.20\n```\n\n- O `pattern` \u00e9 \u00fatil para converter os formatos de Maratona, que vem em m\u00faltiplos arquivos para o `.tio`. Basta fazer o `match` do modelo que eles utilizarem. \n  - `-p \"@.in @.out\"`\n  - `-p \"in@ out@\"`\n  - entre outros.\n",
    "bugtrack_url": null,
    "license": null,
    "summary": "tko: Test Kit Operations",
    "version": "0.6.3",
    "project_urls": {
        "Bug Reports": "https://github.com/senapk/tko/issues",
        "Homepage": "https://github.com/senapk/tko",
        "Source": "https://github.com/senapk/tko/"
    },
    "split_keywords": [
        "programming",
        " learning"
    ],
    "urls": [
        {
            "comment_text": "",
            "digests": {
                "blake2b_256": "da0b6d207a1fe40c5ded711fd73b4d4deac2dec0a9dc99bb13932b7c9cb46abf",
                "md5": "9e8b977e6927193f0d04cc11688d9139",
                "sha256": "c7d5065d66fa02c75baaf0d9e486615f1f98462fab3cd144c28840f68007078a"
            },
            "downloads": -1,
            "filename": "tko-0.6.3-py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "9e8b977e6927193f0d04cc11688d9139",
            "packagetype": "bdist_wheel",
            "python_version": "py3",
            "requires_python": "<4,>=3.8",
            "size": 47307,
            "upload_time": "2024-06-15T19:33:33",
            "upload_time_iso_8601": "2024-06-15T19:33:33.692050Z",
            "url": "https://files.pythonhosted.org/packages/da/0b/6d207a1fe40c5ded711fd73b4d4deac2dec0a9dc99bb13932b7c9cb46abf/tko-0.6.3-py3-none-any.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": "",
            "digests": {
                "blake2b_256": "38682e04126e30adc9219f2ae49d6ca6ed8d369a450a0f2992fabc799fb7b86f",
                "md5": "f14285b3c272fc11fa4b021fd688aeb2",
                "sha256": "1fd25403fdf95fcf0e21c862cb7d8ae49af2db58c7521f8e5ef93e4f20edc6b1"
            },
            "downloads": -1,
            "filename": "tko-0.6.3.tar.gz",
            "has_sig": false,
            "md5_digest": "f14285b3c272fc11fa4b021fd688aeb2",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": "<4,>=3.8",
            "size": 51779,
            "upload_time": "2024-06-15T19:33:36",
            "upload_time_iso_8601": "2024-06-15T19:33:36.040567Z",
            "url": "https://files.pythonhosted.org/packages/38/68/2e04126e30adc9219f2ae49d6ca6ed8d369a450a0f2992fabc799fb7b86f/tko-0.6.3.tar.gz",
            "yanked": false,
            "yanked_reason": null
        }
    ],
    "upload_time": "2024-06-15 19:33:36",
    "github": true,
    "gitlab": false,
    "bitbucket": false,
    "codeberg": false,
    "github_user": "senapk",
    "github_project": "tko",
    "travis_ci": false,
    "coveralls": false,
    "github_actions": false,
    "requirements": [
        {
            "name": "appdirs",
            "specs": []
        },
        {
            "name": "build",
            "specs": []
        },
        {
            "name": "twine",
            "specs": []
        }
    ],
    "lcname": "tko"
}
        
Elapsed time: 0.27989s