From 9c0c82d9790526c5b8c4cb886a2cdc98d595a45a Mon Sep 17 00:00:00 2001 From: lspigariol Date: Thu, 10 Oct 2024 10:38:27 -0300 Subject: [PATCH] solucion --- .github/workflows/ci.yml | 14 ++++ .gitignore | 6 ++ README.md | 6 ++ autos-Clases.wlk | 141 +++++++++++++++++++++++++++++++++++++++ autos.wlk | 135 +++++++++++++++++++++++++++++++++++++ colores.wlk | 10 +++ package.json | 7 ++ testAutos-Clases.wtest | 36 ++++++++++ testAutos.wtest | 31 +++++++++ 9 files changed, 386 insertions(+) create mode 100644 .github/workflows/ci.yml create mode 100644 .gitignore create mode 100644 README.md create mode 100644 autos-Clases.wlk create mode 100644 autos.wlk create mode 100644 colores.wlk create mode 100644 package.json create mode 100644 testAutos-Clases.wtest create mode 100644 testAutos.wtest diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..8e84736 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,14 @@ +name: build + +on: [push, pull_request] +jobs: + wollok-ts: + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + - run: | + wget -O wollok-ts-cli https://github.com/uqbar-project/wollok-ts-cli/releases/latest/download/wollok-ts-cli-linux-x64 + chmod a+x ./wollok-ts-cli + ./wollok-ts-cli test --skipValidations -p ./ + shell: bash diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9e95028 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ + +# Local history +.history + +# Wollok Log +*.log diff --git a/README.md b/README.md new file mode 100644 index 0000000..76b305e --- /dev/null +++ b/README.md @@ -0,0 +1,6 @@ + + +## example + +TODO + diff --git a/autos-Clases.wlk b/autos-Clases.wlk new file mode 100644 index 0000000..e7749ff --- /dev/null +++ b/autos-Clases.wlk @@ -0,0 +1,141 @@ +import colores.* + +object dominic{ + + const autos = [] + + method comprar(auto){ + autos.add(auto) + } + method finDeTemporada(){ + autos.clear() + } + method promedioVelocidades() = + autos.sum({auto=> auto.velocidadMaxima()}) / autos.size() + + method masRapido() = + self.autosEnCondiciones().max{auto=> auto.velocidadMaxima()} + + method autosEnCondiciones() = + autos.filter{auto=>auto.enCondiciones()} + + method autosNoEnCondiciones() = + autos.filter{auto=>not auto.enCondiciones()} + + method hayUnAutoMuyRapido() = + self.masRapido().velocidadMaxima() > 2 * self.promedioVelocidades() + + method hacerPrueba(){ + autos.forEach({auto=>auto.hacerPrueba()}) + } + + method mandarAlTaller(){ + taller.recibirAutos(self.autosNoEnCondiciones()) + } +} + +object taller { + const autos = [] + + method recibirAutos(nuevos){ + autos.addAll(nuevos) + } + + method trabajar(){ + autos.forEach{auto=>auto.reparar()} + } + +} + +class Ferrari { +// Tiene un motor que está inicialmente está funcionando en un 87% (puede oscilar entre 0 y 100%). + var motor = 87 + +//El problema es que al hacer una prueba de velocidad su motor se daña +//disminuyendo en 30 unidades su nivel funcionamiento actual. + method pruebaVelocidad(){ + motor = (motor - 30).max(0) + } +//Está en condiciones para correr si el motor esta funcionando en al menos un 65%. + method enCondiciones() = motor >= 65 + +//Al reparar el motor, queda funcionando al 100%. + method reparar() { + motor = 100 + } + +//Su velocidad máxima es 110 km/s, +//más 15 km/s adicionales si el motor está funcionando por encima del 75%. + method velocidadMaxima() = 110 + if (motor > 75) 15 else 0 + + +} + +object gasolina{ + method nivelMinimo() = 85 + method modificarVelocidad(litros)= litros + 10 +} + +object nafta{ + method nivelMinimo() = 50 + method modificarVelocidad(litros)= litros * 0.9 +} + +object nitro{ + method nivelMinimo() = 0 + method modificarVelocidad(litros)= litros * 10 +} + +class AutoCombustible { +//Tiene un nivel de combustible inicial de 100 litros. +//Inicialmente se trata de gasolina, pero puede cambiar su combustible por nafta o nitrógeno líquido. +//El color inicial es azul. + var color = azul + var nivel = 100 + var property combustible = gasolina + +// En la prueba de velocidad el auto consume 5 litros del combustible que sea. + method pruebaVelocidad(){ + nivel = nivel - 5 + } + //Está en condiciones si tiene más de 85 litros de gasolina o 50 litros de nafta. + //En caso de que esté cargado con nitrógeno líquido, con que no esté totalmente vacío es suficiente. + //Además, para poder correr debe estar pintado de rojo. + + method enCondiciones() = nivel > combustible.nivelMinimo() and color == rojo + +//En el taller la reparación consiste en duplicar la cantidad de combustible que tenga y en cambiarle su color. +//Cuando su color es rojo cambia a azul, cuando es azul cambia a verde y cuando es verde cambia a rojo. + + method reparar() { + nivel = nivel * 2 + color = color.aCualCambia() + } + +//Su velocidad máxima en principio es el doble de los litros de combustible que tenga, +//pero tambíen depende de que combustible sea. +//Si es gasolina se le agregan 10 km/s, +//si es nafta se pierde un 10% y +//si es nitrógeno líquido se multiplica por 10. + method velocidadMaxima() = combustible.modificarVelocidad(nivel * 2) + +} + +object intocable{ + var enCondiciones = true + + method pruebaVelocidad(){ + enCondiciones = false + } + method enCondiciones() = enCondiciones + + method reparar() { + enCondiciones = true + } + + method velocidadMaxima() = 45 + +} + + + diff --git a/autos.wlk b/autos.wlk new file mode 100644 index 0000000..0f99499 --- /dev/null +++ b/autos.wlk @@ -0,0 +1,135 @@ +import colores.* +object dominic{ + + const autos = [] + + method comprar(auto){ + autos.add(auto) + } + method finDeTemporada(){ + autos.clear() + } + method promedioVelocidades() = + autos.sum({auto=> auto.velocidadMaxima()}) / autos.size() + + method masRapido() = + self.autosEnCondiciones().max{auto=> auto.velocidadMaxima()} + + method autosEnCondiciones() = + autos.filter{auto=>auto.enCondiciones()} + + method autosNoEnCondiciones() = + autos.filter{auto=>not auto.enCondiciones()} + + method hayUnAutoMuyRapido() = + self.masRapido().velocidadMaxima() > 2 * self.promedioVelocidades() + + method hacerPrueba(){ + autos.forEach({auto=>auto.hacerPrueba()}) + } + + method mandarAlTaller(){ + taller.recibirAutos(self.autosNoEnCondiciones()) + } +} + +object taller { + const autos = [] + + method recibirAutos(nuevos){ + autos.addAll(nuevos) + } + + method trabajar(){ + autos.forEach{auto=>auto.reparar()} + } +} + +object ferrari { +// Tiene un motor que está inicialmente está funcionando en un 87% (puede oscilar entre 0 y 100%). + var motor = 87 + +//El problema es que al hacer una prueba de velocidad su motor se daña +//disminuyendo en 30 unidades su nivel funcionamiento actual. + method pruebaVelocidad(){ + motor = (motor - 30).max(0) + } +//Está en condiciones para correr si el motor esta funcionando en al menos un 65%. + method enCondiciones() = motor >= 65 + +//Al reparar el motor, queda funcionando al 100%. + method reparar() { + motor = 100 + } + +//Su velocidad máxima es 110 km/s, +//más 15 km/s adicionales si el motor está funcionando por encima del 75%. + method velocidadMaxima() = 110 + if (motor > 75) 15 else 0 +} + +object gasolina{ + method nivelMinimo() = 85 + method modificarVelocidad(litros)= litros + 10 +} + +object nafta{ + method nivelMinimo() = 50 + method modificarVelocidad(litros)= litros * 0.9 +} + +object nitro{ + method nivelMinimo() = 0 + method modificarVelocidad(litros)= litros * 10 +} + +object flecha { +//Tiene un nivel de combustible inicial de 100 litros. +//Inicialmente se trata de gasolina, pero puede cambiar su combustible por nafta o nitrógeno líquido. +//El color inicial es azul. + var color = azul + var nivel = 100 + var property combustible = gasolina + +// En la prueba de velocidad el auto consume 5 litros del combustible que sea. + method pruebaVelocidad(){ + nivel = nivel - 5 + } + //Está en condiciones si tiene más de 85 litros de gasolina o 50 litros de nafta. + //En caso de que esté cargado con nitrógeno líquido, con que no esté totalmente vacío es suficiente. + //Además, para poder correr debe estar pintado de rojo. + + method enCondiciones() = nivel > combustible.nivelMinimo() and color == rojo + +//En el taller la reparación consiste en duplicar la cantidad de combustible que tenga y en cambiarle su color. +//Cuando su color es rojo cambia a azul, cuando es azul cambia a verde y cuando es verde cambia a rojo. + + method reparar() { + nivel = nivel * 2 + color = color.aCualCambia() + } + +//Su velocidad máxima en principio es el doble de los litros de combustible que tenga, +//pero tambíen depende de que combustible sea. +//Si es gasolina se le agregan 10 km/s, +//si es nafta se pierde un 10% y +//si es nitrógeno líquido se multiplica por 10. + method velocidadMaxima() = combustible.modificarVelocidad(nivel * 2) + +} + +object intocable{ + var enCondiciones = true + + method pruebaVelocidad(){ + enCondiciones = false + } + method enCondiciones() = enCondiciones + + method reparar() { + enCondiciones = true + } + + method velocidadMaxima() = 45 + +} +*/ \ No newline at end of file diff --git a/colores.wlk b/colores.wlk new file mode 100644 index 0000000..f105af9 --- /dev/null +++ b/colores.wlk @@ -0,0 +1,10 @@ + +object azul{ + method aCualCambia() = verde +} +object rojo{ + method aCualCambia() = azul +} +object verde{ + method aCualCambia() = rojo +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..765a6b9 --- /dev/null +++ b/package.json @@ -0,0 +1,7 @@ +{ + "name": "primerparcial", + "version": "1.0.0", + "wollokVersion": "4.0.0", + "author": "lucas", + "license": "ISC" +} diff --git a/testAutos-Clases.wtest b/testAutos-Clases.wtest new file mode 100644 index 0000000..ff6443c --- /dev/null +++ b/testAutos-Clases.wtest @@ -0,0 +1,36 @@ +import autos-Clases.* +import colores.* + +describe "group of tests for dominic" { + + test "dominic velocidad promedio con un auto" { + dominic.comprar(intocable) + assert.equals(45, dominic.promedioVelocidades()) + } + + test "auto en condiciones mas rapido de dominic es ferrari cuando la flecha no esta en condiciones" { + const unaFerrari = new Ferrari() + dominic.comprar(intocable) + dominic.comprar(unaFerrari) + dominic.comprar(new Ferrari(motor = 10)) + dominic.comprar(new AutoCombustible()) + assert.equals(unaFerrari, dominic.masRapido()) + } + test "auto en condiciones mas rapido de dominic es flecha cuando la flecha esta en condiciones" { + const flecha = new AutoCombustible(color=rojo, combustible = nitro) + + dominic.comprar(intocable) + dominic.comprar(new Ferrari()) + dominic.comprar(flecha) + dominic.comprar( new AutoCombustible(color=rojo, combustible = nafta)) + dominic.comprar( new AutoCombustible(color=rojo, combustible = gasolina)) + + assert.equals(flecha, dominic.masRapido()) + } + test "no hay un auto muy rapido " { + dominic.comprar(intocable) + assert.notThat(dominic.hayUnAutoMuyRapido()) + } + + +} \ No newline at end of file diff --git a/testAutos.wtest b/testAutos.wtest new file mode 100644 index 0000000..796132d --- /dev/null +++ b/testAutos.wtest @@ -0,0 +1,31 @@ + +import autos.* + +describe "group of tests for dominic" { + + test "dominic velocidad promedio con un auto" { + dominic.comprar(intocable) + assert.equals(45, dominic.promedioVelocidades()) + } + + test "auto en condiciones mas rapido de dominic es ferrari cuando la flecha no esta en condiciones" { + dominic.comprar(intocable) + dominic.comprar(ferrari) + dominic.comprar(flecha) + assert.equals(ferrari, dominic.masRapido()) + } + test "auto en condiciones mas rapido de dominic es flecha cuando esta en condiciones" { + dominic.comprar(intocable) + dominic.comprar(ferrari) + dominic.comprar(flecha) + flecha.reparar() + flecha.reparar() + assert.equals(flecha, dominic.masRapido()) + } + test "no hay un auto muy rapido " { + dominic.comprar(intocable) + assert.notThat(dominic.hayUnAutoMuyRapido()) + } + + +}