From 166dadd05187bb02daf66b3a2a215a44acaebeb8 Mon Sep 17 00:00:00 2001 From: Tomas Date: Sun, 30 May 2021 22:35:06 -0300 Subject: [PATCH] feat: added filesystem --- 04-lecture/filesystem/README.md | 131 +++++++ 04-lecture/filesystem/pom.xml | 136 ++++++++ 04-lecture/filesystem/spotbugs-exclude.xml | 8 + .../file/CanNotCloseFileException.java | 17 + .../file/CanNotOpenFileException.java | 17 + .../file/CanNotReadFileException.java | 17 + .../file/CanNotWriteFileException.java | 18 + .../src/main/java/fs/model/file/Buffer.java | 82 +++++ .../src/main/java/fs/model/file/File.java | 194 +++++++++++ .../model/filesystem/HighLevelFileSystem.java | 33 ++ .../model/filesystem/LowLevelFileSystem.java | 118 +++++++ .../filesystem/src/test/java/fs/.gitkeep | 0 .../src/test/java/fs/BufferTest.java | 36 ++ .../test/java/fs/HighLevelFileSystemTest.java | 196 +++++++++++ .../filesystem/target/checkstyle-cachefile | 10 + .../filesystem/target/checkstyle-checker.xml | 321 ++++++++++++++++++ .../filesystem/target/checkstyle-result.xml | 55 +++ 04-lecture/filesystem/target/jacoco.exec | Bin 0 -> 74256 bytes .../target/maven-archiver/pom.properties | 5 + .../compile/default-compile/createdFiles.lst | 8 + .../compile/default-compile/inputFiles.lst | 8 + .../default-testCompile/createdFiles.lst | 2 + .../default-testCompile/inputFiles.lst | 2 + .../filesystem/target/spotbugs-exclude.xml | 8 + 04-lecture/filesystem/target/spotbugs.xml | 2 + 04-lecture/filesystem/target/spotbugsXml.xml | 2 + .../surefire-reports/TEST-fs.BufferTest.xml | 64 ++++ .../TEST-fs.HighLevelFileSystemTest.xml | 74 ++++ .../target/surefire-reports/fs.BufferTest.txt | 4 + .../fs.HighLevelFileSystemTest.txt | 4 + .../target/test-classes/fs/.gitkeep | 0 31 files changed, 1572 insertions(+) create mode 100644 04-lecture/filesystem/README.md create mode 100644 04-lecture/filesystem/pom.xml create mode 100644 04-lecture/filesystem/spotbugs-exclude.xml create mode 100644 04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotCloseFileException.java create mode 100644 04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotOpenFileException.java create mode 100644 04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotReadFileException.java create mode 100644 04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotWriteFileException.java create mode 100644 04-lecture/filesystem/src/main/java/fs/model/file/Buffer.java create mode 100644 04-lecture/filesystem/src/main/java/fs/model/file/File.java create mode 100644 04-lecture/filesystem/src/main/java/fs/model/filesystem/HighLevelFileSystem.java create mode 100644 04-lecture/filesystem/src/main/java/fs/model/filesystem/LowLevelFileSystem.java create mode 100644 04-lecture/filesystem/src/test/java/fs/.gitkeep create mode 100644 04-lecture/filesystem/src/test/java/fs/BufferTest.java create mode 100644 04-lecture/filesystem/src/test/java/fs/HighLevelFileSystemTest.java create mode 100644 04-lecture/filesystem/target/checkstyle-cachefile create mode 100644 04-lecture/filesystem/target/checkstyle-checker.xml create mode 100644 04-lecture/filesystem/target/checkstyle-result.xml create mode 100644 04-lecture/filesystem/target/jacoco.exec create mode 100644 04-lecture/filesystem/target/maven-archiver/pom.properties create mode 100644 04-lecture/filesystem/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst create mode 100644 04-lecture/filesystem/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst create mode 100644 04-lecture/filesystem/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/createdFiles.lst create mode 100644 04-lecture/filesystem/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst create mode 100644 04-lecture/filesystem/target/spotbugs-exclude.xml create mode 100644 04-lecture/filesystem/target/spotbugs.xml create mode 100644 04-lecture/filesystem/target/spotbugsXml.xml create mode 100644 04-lecture/filesystem/target/surefire-reports/TEST-fs.BufferTest.xml create mode 100644 04-lecture/filesystem/target/surefire-reports/TEST-fs.HighLevelFileSystemTest.xml create mode 100644 04-lecture/filesystem/target/surefire-reports/fs.BufferTest.txt create mode 100644 04-lecture/filesystem/target/surefire-reports/fs.HighLevelFileSystemTest.txt create mode 100644 04-lecture/filesystem/target/test-classes/fs/.gitkeep diff --git a/04-lecture/filesystem/README.md b/04-lecture/filesystem/README.md new file mode 100644 index 0000000..e8dda21 --- /dev/null +++ b/04-lecture/filesystem/README.md @@ -0,0 +1,131 @@ +Sistema de Achivos +================== + +Esta es el código base para el ejercicio de File System (Sistema de Archivos). Está diseñado para: + +* Java 8. :warning: Si bien el proyecto no lo limita explícitamente, el comando `mvn verify` no funcionará con versiones mas modernas de Java. +* JUnit 5. :warning: La versión 5 de JUnit es la más nueva del framework y presenta algunas diferencias respecto a la versión "clásica" (JUnit 4). Para mayores detalles, ver: + * [Apunte de herramientas](https://docs.google.com/document/d/1VYBey56M0UU6C0689hAClAvF9ILE6E7nKIuOqrRJnWQ/edit#heading=h.dnwhvummp994) + * [Entrada de Blog (en inglés)](https://www.baeldung.com/junit-5-migration) + * [Entrada de Blog (en español)](https://www.paradigmadigital.com/dev/nos-espera-junit-5/) +* Maven 3.3 o superior + +# El enunciado + +Un equipo de desarrollo acaba de implementar un novedoso y revolucionario sistema de archivos: un conjunto de objetos +que nos permiten abrir y cerrar archivos (binarios), y leerlos o escribirlos secuencialmente. Sin embargo, no se esmeraron mucho en que la interfaz entrante al sistema sea fácil de usar: + +```java +public interface LowLevelFileSystem { + int openFile(String path); + + void closeFile(int fd); + int syncReadFile(int fd, byte[] bufferBytes, int bufferStart, int bufferEnd); + void syncWriteFile(int fd, byte[] bufferBytes, int bufferStart, int bufferEnd); + void asyncReadFile(int fd, byte[] bufferBytes, int bufferStart, int bufferEnd, + Consumer callback); + void asyncWriteFile(int fd, byte[] bufferBytes, int bufferStart, int bufferEnd, + Runnable callback); +} +``` +(ver archivo `fs/LowLevelFileSystem.java`) + +Como ven esta interfaz entrante (representada por una __interface__ Java) cumple lo solicitado, pero presenta un bajo nivel de abstraccion y no es por tanto fácil de usar. + + +Entonces nos solicitaron que diseñemos una mejor interfaz entrante a este sistema, que pueda usar un programador (una API, application programming interface) que sea de mayor nivel de abstracción y más simple de usar. Esta estará conformada por uno o más componentes (interfaces, objetos, clases, etc) que tendremos que diseñar. + +Ademas, nos pidieron que implementemos esta intefaz de forma que todas las operaciones que se hagan contra esta API terminen ejecutando las operaciones de la interfaz de bajo nivel del sistema de archivos. + +Sin embargo, los requerimientos son un poco abiertos. Nos han señalado las siguientes cosas: +* Este API debe ser "fácil" de usar para un programador: debería ser clara, aprovechar el paradigma de objetos, ocultar detalles que no nos aportan y presentar buenas abstracciones. +* No es necesario que exponga una única __interface__ tipo fachada. +* Debe usar a la interfaz entrante original que nos dieron, pero no modificarla. +* Debe ser robusta, presentando un buen manejo de errores +* Esta API debe permitr como mínimo: + * abrir un archivo para lecto escritura + * cerrar un archivo + * escribir sincrónicamente un bloque de n bytes de archivo + * leer sincrónicamente un bloque de n bytes de un archivo + * leer asincrónicamente un bloque de n bytes de un archivo + * escribir asincrónicamente un bloque de n bytes de un archivo +* ¡OJO! Es importante que el API tenga un buen manejo de errores +* Esta API que diseñaremos será básicamente un adaptador, es decir, no agregará funcionalidad al sistema de archivos original, + sino que tan solo expondrá una mejor interfaz entrante. Es decir, ahora aquella interfaz entrante original será para nosotres + la interfaz saliente del pequeño sistema adaptador que vamos a diseñar. + +``` + +---+ +-----------------+ +Componentes ---> |API|--> |File System Posta| +que usan +---+ +-----------------+ +al file system ^ + | + +--- nosotres diseñaremos esto + +``` +Entonces, tenemos como tarea "embellecer" al sistema de archivos. Y como segunda tarea, dar un ejemplo de uso del API para los siguiente casos: + * Tenemos que leer de un archivo 3 campos: el primero de 4 bytes (C0), el segundo de 1 byte (C1), el tercero de 5 bytes (C2). Y escribir en otro archivo C0, un bloque 0x0, 0x10, 0x0, y luego C1 y C2. + * Tenemos que leer un archivo completo, y escribirlo en otro archivo, en bloques de igual tamaño parametrizable. + +Los ejemplos tambien tenemos que plantearlos nosotres, en forma de tests. + +Finalmente, como nuestro cliente es bastante quisquilloso quiere ver formas alternativas de solucionar las lecturas sincrónicas y asincrónicas, para compararlas y ver cuales le gustan más. + +## Notas + + * no nos interesa lidiar con problemas de concurrencia. Asumimos que ya los resuelve el sistema de archivos. + * para poder testear vamos a necesitar usar mocks. [Mockito](https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html) ya se encuentra agregada como dependencia + * hay algunos tests implementados que les pueden servir de puntapié. Obviamente no andan, tienen que implementar el código faltante + * hay algunos tests que sólo están enunciados, pero no están implementados están implementados. Nuevamente, tienen que implementarlos + * [acá](https://docs.google.com/document/d/1l22DXR13J3XlcEkdwWsba5zg8gl_XwFA7cWf_LIOHHk/edit#) hay una solución propuesta que les puede guiar en la implementación. Tengan en cuenta que no contempla todos los requerimientos de forma detallada (en particular, las escrituras y validaciones no están desarroladas), pero creemos que servirá como orientación en gran medida. + * [acá](https://www.youtube.com/watch?v=-p7_NUDLRB0&list=PLTpxfh7PF3OpJSMNNPaYxLJii3Xm7PPA_&index=3) hay unos videos introductorios a Mockito + * [y acá](https://docs.google.com/document/d/1467Gc-adARJZZhVAdgazdCeHWRzCUJg6CfMD3nkhmG4/edit#) hay un breve apunte con un resúmen de las capacidades de Mockito + + +## Bonus + +Opcionalmente, esta interfaz debería permitir: + + * Saber si una ruta (path) denota un archivo regular + * Saber si una ruta (path) denota un directorio + * Saber si una ruta (path) existe (sin importar qué sea) + + +# Ejecutar tests + +``` +mvn test +``` + +# Validar el proyecto de forma exahustiva + +``` +mvn clean verify +``` + +Este comando hará lo siguiente: + + 1. Ejecutará los tests + 2. Validará las convenciones de formato mediante checkstyle + 3. Detectará la presencia de (ciertos) code smells + 4. Validará la cobertura del proyecto + +# Entrega del proyecto + +Para entregar el proyecto, crear un tag llamado `entrega-final`. Es importante que antes de realizarlo se corra la validación +explicada en el punto anterior. Se recomienda hacerlo de la siguiente forma: + +``` +mvn clean verify && git tag entrega-final && git push origin HEAD --tags +``` + +# Configuración del IDE (IntelliJ) + + 1. Tabular con dos espacios: ![Screenshot_2021-04-09_18-23-26](https://user-images.githubusercontent.com/677436/114242543-73e1fe00-9961-11eb-9a61-7e34be9fb8de.png) + 2. Instalar y configurar Checkstyle: + 1. Instalar el plugin https://plugins.jetbrains.com/plugin/1065-checkstyle-idea: + 2. Configurarlo activando los Checks de Google y la versión de Checkstyle `== 8.35`: ![Screenshot_2021-04-09_18-16-13](https://user-images.githubusercontent.com/677436/114242548-75132b00-9961-11eb-972e-28e6e1412979.png) + 3. Usar fin de linea unix + 1. En **Settings/Preferences**, ir a a **Editor | Code Style**. + 2. En la lista **Line separator**, seleccionar `Unix and OS X (\n)`. + ![Screenshot 2021-04-10 03-49-00](https://user-images.githubusercontent.com/11875266/114260872-c6490c00-99ad-11eb-838f-022acc1903f4.png) diff --git a/04-lecture/filesystem/pom.xml b/04-lecture/filesystem/pom.xml new file mode 100644 index 0000000..8eb69c5 --- /dev/null +++ b/04-lecture/filesystem/pom.xml @@ -0,0 +1,136 @@ + + + + 4.0.0 + + ar.edu.utn.frba.dds + FileSystem + 1.0-SNAPSHOT + + FileSystem + https://github.com/dds-utn + + + UTF-8 + 1.8 + 1.8 + + + + + org.junit.jupiter + junit-jupiter-engine + 5.7.0 + test + + + org.mockito + mockito-core + 3.10.0 + test + + + + + + + org.apache.maven.plugins + maven-surefire-plugin + 2.22.2 + + + org.apache.maven.plugins + maven-checkstyle-plugin + 3.1.2 + + google_checks.xml + warning + + MissingJavadocMethod, + MissingJavadocPackage, + MissingJavadocType, + NonEmptyAtclauseDescription, + JavadocParagraph, + JavadocTagContinuationIndentation, + SummaryJavadoc + + + + + Validar Formateo + verify + + check + + + + + + com.github.spotbugs + spotbugs-maven-plugin + 4.2.0 + + true + Low + default + spotbugs-exclude.xml + true + + + + Validar Code Smells + verify + + check + + + + + + org.jacoco + jacoco-maven-plugin + 0.8.2 + + + default-prepare-agent + + prepare-agent + + + + Validar Cobertura + verify + + check + + + + + PACKAGE + + + LINE + COVEREDRATIO + 0.75 + + + + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.8.1 + + 8 + 8 + + + + + diff --git a/04-lecture/filesystem/spotbugs-exclude.xml b/04-lecture/filesystem/spotbugs-exclude.xml new file mode 100644 index 0000000..72a0c18 --- /dev/null +++ b/04-lecture/filesystem/spotbugs-exclude.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotCloseFileException.java b/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotCloseFileException.java new file mode 100644 index 0000000..9f54d9f --- /dev/null +++ b/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotCloseFileException.java @@ -0,0 +1,17 @@ +package fs.exceptions.file; + +/** + * File exceptions. + */ +public class CanNotCloseFileException extends RuntimeException { + + /** + * Throws a new Can not close file. + * + * @param cause the cause of failure. + * @throws RuntimeException if file could not be closed. + */ + public CanNotCloseFileException(String cause) { + super("Couldn't close file: " + cause); + } +} diff --git a/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotOpenFileException.java b/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotOpenFileException.java new file mode 100644 index 0000000..facf08c --- /dev/null +++ b/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotOpenFileException.java @@ -0,0 +1,17 @@ +package fs.exceptions.file; + +/** + * File exceptions. + */ +public class CanNotOpenFileException extends RuntimeException { + + /** + * Throws a new Can not open file. + * + * @param cause the cause of failure. + * @throws RuntimeException if file could not be opened. + */ + public CanNotOpenFileException(String cause) { + super("Couldn't open file: " + cause); + } +} diff --git a/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotReadFileException.java b/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotReadFileException.java new file mode 100644 index 0000000..e7573b9 --- /dev/null +++ b/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotReadFileException.java @@ -0,0 +1,17 @@ +package fs.exceptions.file; + +/** + * File exceptions. + */ +public class CanNotReadFileException extends RuntimeException { + + /** + * Throws a new Can not read file. + * + * @param cause the cause of failure. + * @throws RuntimeException if file could not be read. + */ + public CanNotReadFileException(String cause) { + super("Couldn't read file: " + cause); + } +} diff --git a/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotWriteFileException.java b/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotWriteFileException.java new file mode 100644 index 0000000..eaa66d1 --- /dev/null +++ b/04-lecture/filesystem/src/main/java/fs/exceptions/file/CanNotWriteFileException.java @@ -0,0 +1,18 @@ +package fs.exceptions.file; + +/** + * File exception. + */ +public class CanNotWriteFileException extends RuntimeException { + + /** + * Throws a new Can not write file. + * + * @param cause the cause of failure. + * @throws RuntimeException if file could not be write. + */ + public CanNotWriteFileException(String cause) { + super("Couldn't write file: " + cause); + } + +} diff --git a/04-lecture/filesystem/src/main/java/fs/model/file/Buffer.java b/04-lecture/filesystem/src/main/java/fs/model/file/Buffer.java new file mode 100644 index 0000000..e6c5bed --- /dev/null +++ b/04-lecture/filesystem/src/main/java/fs/model/file/Buffer.java @@ -0,0 +1,82 @@ +package fs.model.file; + +/** + * Writting buffer. + */ +public class Buffer { + + /** + * Los bytes of the buffer. + */ + private byte[] bytes; + + /** + * Las index used on the buffer. + */ + private Integer start; + + /** + * The buffer current size. + */ + private Integer limit; + + /** + * The max size that the buffer can have. + */ + private Integer maxSize; + + /** + * The end of the buffer. + */ + private Integer end; + + /** + * Generates a buffer. + * + * @param size the size of the buffer. + */ + public Buffer(Integer size) { + this.limit = this.maxSize = size; + this.bytes = new byte[size]; + this.start = 0; + this.end = -1; + } + + /** + * Updates the limit of the buffer. + * + * @param amount the amount to increment + */ + public void limit(Integer amount) { + this.limit = this.start + amount; + } + + public void setEnd(Integer amount) { + this.end += amount; + } + + public byte[] getBytes() { + return bytes.clone(); + } + + public void setBytes(byte[] bytes) { + this.bytes = bytes.clone(); + } + + public Integer getCurrentSize() { + return this.limit; + } + + public Integer getStart() { + return this.start; + } + + public Integer getMaxSize() { + return this.maxSize; + } + + public Integer getEnd() { + return this.end; + } + +} diff --git a/04-lecture/filesystem/src/main/java/fs/model/file/File.java b/04-lecture/filesystem/src/main/java/fs/model/file/File.java new file mode 100644 index 0000000..ea42d5f --- /dev/null +++ b/04-lecture/filesystem/src/main/java/fs/model/file/File.java @@ -0,0 +1,194 @@ +package fs.model.file; + +import fs.exceptions.file.CanNotCloseFileException; +import fs.exceptions.file.CanNotOpenFileException; +import fs.exceptions.file.CanNotReadFileException; +import fs.exceptions.file.CanNotWriteFileException; +import fs.model.filesystem.LowLevelFileSystem; +import java.util.Objects; + +/** + * Open file. + */ +public class File { + + /** + * Invalid file descriptor. + */ + private static final Integer ERROR = -1; + + /** + * The file descriptor. + */ + private Integer fd = ERROR; + + /** + * The file system. + */ + LowLevelFileSystem fs; + + public File(LowLevelFileSystem fs, String path) { + + validatePath(fs, path); + + this.setFs(fs); + } + + public void setFd(Integer fd) { + this.fd = fd; + } + + public LowLevelFileSystem getFs() { + return fs; + } + + public void setFs(LowLevelFileSystem fs) { + this.fs = fs; + } + + + /** + * Verifies if path is valid. + * + * @param fs the filesystem interface + * @param path the path to verify + * @throws CanNotOpenFileException if file cannot be opened + */ + private void validatePath(LowLevelFileSystem fs, String path) { + + if (!fs.exists(path)) { + throw new CanNotOpenFileException("File " + path + " does not exist!"); + } + + if (fs.isDirectory(path)) { + throw new CanNotOpenFileException(path + " is a driectory not a file"); + } + + this.setFd(fs.openFile(path)); + if (this.fd.equals(ERROR)) { + throw new CanNotOpenFileException("Faield to open file: " + path); + } + + } + + /** + * Closes the file. + * + * @throws CanNotOpenFileException when file was never opened. + */ + public void close() { + + if (fd.equals(ERROR)) { + throw new CanNotCloseFileException("File was never opened"); + } + + this.fs.closeFile(this.getDescriptor()); + + this.fd = ERROR; + + } + + /** + * Gets the file descriptor. + * + * @return the file descriptor + */ + public Integer getDescriptor() { + return fd; + } + + /** + * Syncronic Reads the open file in a buffer. + * + * @param buffer the buffer to be read to. + */ + public void read(Buffer buffer) { + Integer bytes = + fs.syncReadFile(fd, buffer.getBytes(), buffer.getStart(), buffer.getCurrentSize()); + + updateBuffer(buffer, bytes); + } + + /** + * Async read of a file. + * + * @param buffer the buffer to be read to. + * @param callback the execution block + */ + public void read(Buffer buffer, Runnable callback) { + fs.asyncReadFile(fd, buffer.getBytes(), buffer.getStart(), buffer.getCurrentSize(), (bytes) -> { + updateBuffer(buffer, bytes); + callback.run(); + }); + } + + /** + * Syncronic write of a buffer. + * + * @param buffer the buffer tp write + */ + public void write(Buffer buffer) { + + verifyFdForWritting(); + + if (Objects.isNull(buffer)) { + return; + } + + fs.syncWriteFile(fd, buffer.getBytes(), buffer.getStart(), buffer.getCurrentSize()); + } + + /** + * Async write of a buffer. + * + * @param buffer the buffer to write + * @param callback a runnable + */ + public void write(Buffer buffer, Runnable callback) { + + verifyFdForWritting(); + + if (Objects.isNull(buffer)) { + return; + } + + fs.asyncWriteFile(fd, buffer.getBytes(), buffer.getStart(), buffer.getCurrentSize(), callback); + } + + + /** + * Verifies if the File-descriptor is OK. + * + * @throws CanNotWriteFileException when the file descriptor is not OK. + */ + private void verifyFdForWritting() { + if (fd.equals(ERROR)) { + throw new CanNotWriteFileException("No file to write in"); + } + } + + /** + * Validates bytes + * + * @param bytes the bytes to verify + * @throws CanNotReadFileException when an error occured while reading. + */ + private void verifyBytes(Integer bytes) { + if (bytes.equals(ERROR)) { + throw new CanNotReadFileException("Buffer could not be written"); + } + } + + /** + * Updates the buffer's offset with the bytes. + * + * @param buffer the buffer to modify + * @param bytes the bytes to update + */ + private void updateBuffer(Buffer buffer, Integer bytes) { + verifyBytes(bytes); + buffer.setEnd(bytes); + buffer.limit(bytes); + } + +} diff --git a/04-lecture/filesystem/src/main/java/fs/model/filesystem/HighLevelFileSystem.java b/04-lecture/filesystem/src/main/java/fs/model/filesystem/HighLevelFileSystem.java new file mode 100644 index 0000000..592da64 --- /dev/null +++ b/04-lecture/filesystem/src/main/java/fs/model/filesystem/HighLevelFileSystem.java @@ -0,0 +1,33 @@ +package fs.model.filesystem; + +import fs.model.file.File; + +public class HighLevelFileSystem { + + private LowLevelFileSystem fs; + + public HighLevelFileSystem(LowLevelFileSystem lowLevelFileSystem) { + this.setFs(lowLevelFileSystem); + } + + public void setFs(LowLevelFileSystem lowLevelFileSystem) { + this.fs = lowLevelFileSystem; + } + + public File open(String path) { + return new File(fs, path); + } + + public boolean isFile(String path) { + return this.fs.isRegularFile(path); + } + + public boolean isDirectory(String path) { + return this.fs.isDirectory(path); + } + + public boolean exists(String path) { + return this.fs.exists(path); + } + +} diff --git a/04-lecture/filesystem/src/main/java/fs/model/filesystem/LowLevelFileSystem.java b/04-lecture/filesystem/src/main/java/fs/model/filesystem/LowLevelFileSystem.java new file mode 100644 index 0000000..602ceb0 --- /dev/null +++ b/04-lecture/filesystem/src/main/java/fs/model/filesystem/LowLevelFileSystem.java @@ -0,0 +1,118 @@ +package fs.model.filesystem; + +import java.util.function.Consumer; + +/** + * Interfaz de bajo nivel de nuestro sistema de archivos, que nos permite abrir y cerrar archivos + * binarios, y leer y escribir en ellos en bloques. + *

+ * La escritura es siempre sincrónica. La lectura puede ser sincrónica o asincrónica, según que + * método se utilice + */ +public interface LowLevelFileSystem { + + /** + * Dice si un path es un directorio + * + * @param path + * @return si el path dado existe y es un directorio + */ + boolean isDirectory(String path); + + /** + * Dice si un path es un archivo regular, es decir, si no detona un directorio, un link ni un + * archivo especial + * + * @param path + * @return si el path dado existe y es un archivo regular + */ + boolean isRegularFile(String path); + + /** + * Dice si un path existe, independientemetne de aquello a lo que apunte + * + * @param path + * @return si el path existe + */ + boolean exists(String path); + + /** + * Abre un archivo, dejándolo listo para ser leido o escrito. + *

+ * Debe ser cerrado despues de usado + * + * @param path + * @return el descriptor (id) del archivo, o -1 si no se puedo abrir + */ + int openFile(String path); + + /** + * Cierra un archivo. + * + * @param fd el descriptor del archivo + */ + void closeFile(int fd); + + /** + * Lee tantos bytes como pueda, esto es, bufferEnd - bufferStart + 1 bytes devuelve la cantidad + * efectiva de bytes leidos y modifica al buffer de forma acorde + *

+ * Por ejemplo, si bufferStart = 0 y bufferEnd = 0 significa que hay que leer 1 byte, y colocarlo + * en la posicion 0 del buffer + *

+ * Advertencia: este método asume que el descriptor corresponde a un archivo abierto, que + * bufferEnd >= bufferStart, y que bufferStart >= 0 y + * bufferEnd <= bufferBytes.length + * + * @param fd el descriptor (id) del archivo + * @param bufferBytes + * @param bufferStart la posicion inicial a partir de la cual escribir los bytes leidos + * @param bufferEnd la posicion final hasta donde escribir los bytes leidos (inclusive). + * @return la cantidad de bytes leidos, que son siempre menores o iguales a bufferEnd - + * bufferStart + 1, o -1, si no se pudo leer + */ + int syncReadFile(int fd, byte[] bufferBytes, int bufferStart, int bufferEnd); + + /** + * Escribe bufferEnd - bufferStart bytes, a partir de bufferStart + * + * @param fd + * @param bufferBytes + * @param bufferStart + * @param bufferEnd + */ + void syncWriteFile(int fd, byte[] bufferBytes, int bufferStart, int bufferEnd); + + /** + * Similar a {@link #syncReadFile(int, byte[], int, int)}, pero asincrónico. + *

+ * En lugar de devolver la cantidad de bytes leidos, se lo pasa a un callback + * + * @param fd + * @param bufferBytes + * @param bufferStart + * @param bufferEnd + * @param callback un Callback (tipado como {@link Consumer}) que se ejecutará cuando la operación + * de lectura asincrónica se haya concretado. Le llega por parámetro la cantidad de bytes + * leidos efectivamente. Para cuando el {@link LowLevelFileSystem} ejecute este callabck, + * este {@link LowLevelFileSystem} ya habrá actualizado el buffer. Si el archivo no se pudo + * leer, los bytes leídos serán -1. + */ + void asyncReadFile(int fd, byte[] bufferBytes, int bufferStart, int bufferEnd, + Consumer callback); + + /** + * Similar a {@link #syncReadFile(int, byte[], int, int)}, pero asincrónico. + *

+ * Cuando la escritura terminó, el callback es ejecutado + * + * @param fd + * @param bufferBytes + * @param bufferStart + * @param bufferEnd + * @param callback un Callback (tipado como {@link Runnable}) que se ejecutará cuando la operación + * de escritura asincrónica se haya concretado. + */ + void asyncWriteFile(int fd, byte[] bufferBytes, int bufferStart, int bufferEnd, + Runnable callback); +} diff --git a/04-lecture/filesystem/src/test/java/fs/.gitkeep b/04-lecture/filesystem/src/test/java/fs/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/04-lecture/filesystem/src/test/java/fs/BufferTest.java b/04-lecture/filesystem/src/test/java/fs/BufferTest.java new file mode 100644 index 0000000..edab6c3 --- /dev/null +++ b/04-lecture/filesystem/src/test/java/fs/BufferTest.java @@ -0,0 +1,36 @@ +package fs; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import fs.model.file.Buffer; + +public class BufferTest { + + @Test + void inicialmenteCurrentSizeYMaxSizeCoinciden() { + Buffer buffer = new Buffer(27); + Assertions.assertEquals(buffer.getCurrentSize(), buffer.getMaxSize()); + } + + @Test + void currentSizeRetornaElTamanioSegunLosLimites() { + Buffer buffer = new Buffer(27); + buffer.limit(12); + Assertions.assertEquals(12, buffer.getCurrentSize()); + } + + @Test + void maxSizeRetornaElTamanioInicial() { + Buffer buffer = new Buffer(27); + Assertions.assertEquals(27, buffer.getMaxSize()); + } + + @Test + void maxSizeNoSeVeAfectadoPorLosLimite() { + Buffer buffer = new Buffer(27); + buffer.limit(8); + buffer.limit(14); + buffer.limit(1); + Assertions.assertEquals(27, buffer.getMaxSize()); + } +} diff --git a/04-lecture/filesystem/src/test/java/fs/HighLevelFileSystemTest.java b/04-lecture/filesystem/src/test/java/fs/HighLevelFileSystemTest.java new file mode 100644 index 0000000..e8e7ba0 --- /dev/null +++ b/04-lecture/filesystem/src/test/java/fs/HighLevelFileSystemTest.java @@ -0,0 +1,196 @@ +package fs; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import fs.exceptions.file.CanNotCloseFileException; +import fs.exceptions.file.CanNotOpenFileException; +import fs.exceptions.file.CanNotReadFileException; +import fs.model.file.Buffer; +import fs.model.file.File; +import fs.model.filesystem.HighLevelFileSystem; +import fs.model.filesystem.LowLevelFileSystem; +import java.util.Arrays; +import java.util.function.Consumer; +import static org.mockito.Mockito.*; + +class HighLevelFileSystemTest { + + private LowLevelFileSystem lowLevelFileSystem; + private HighLevelFileSystem fileSystem; + + @BeforeEach + void initFileSystem() { + lowLevelFileSystem = mock(LowLevelFileSystem.class); + fileSystem = new HighLevelFileSystem(lowLevelFileSystem); + } + + @Test + void sePuedeAbrirUnArchivo() { + when(lowLevelFileSystem.openFile("unArchivo.txt")).thenReturn(42); + // Agrego condicion de que existe el archivo + when(lowLevelFileSystem.exists("unArchivo.txt")).thenReturn(true); + File file = fileSystem.open("unArchivo.txt"); + Assertions.assertEquals(file.getDescriptor(), 42); + } + + @Test + void siLaAperturaFallaUnaExcepcionEsLanzada() { + when(lowLevelFileSystem.openFile("otroArchivo.txt")).thenReturn(-1); + Assertions.assertThrows(CanNotOpenFileException.class, + () -> fileSystem.open("otroArchivo.txt")); + } + + @Test + void sePuedeLeerSincronicamenteUnArchivoCuandoNoHayNadaParaLeer() { + Buffer buffer = new Buffer(100); + + when(lowLevelFileSystem.openFile("ejemplo.txt")).thenReturn(42); + // Agrego condicion de que existe el archivo + when(lowLevelFileSystem.exists("ejemplo.txt")).thenReturn(true); + when(lowLevelFileSystem.syncReadFile(42, buffer.getBytes(), 0, 100)).thenReturn(0); + + File file = fileSystem.open("ejemplo.txt"); + file.read(buffer); + + Assertions.assertEquals(0, buffer.getStart()); + Assertions.assertEquals(-1, buffer.getEnd()); + Assertions.assertEquals(0, buffer.getCurrentSize()); + } + + @Test + void sePuedeLeerSincronicamenteUnArchivoCuandoHayAlgoParaLeer() { + Buffer buffer = new Buffer(10); + + when(lowLevelFileSystem.openFile("ejemplo.txt")).thenReturn(42); + // Agrego condicion de que existe el archivo + when(lowLevelFileSystem.exists("ejemplo.txt")).thenReturn(true); + when(lowLevelFileSystem.syncReadFile(42, buffer.getBytes(), 0, 10)).thenAnswer(invocation -> { + byte[] bytes = buffer.getBytes(); + Arrays.fill(bytes, 0, 4, (byte) 3); + buffer.setBytes(bytes); + return 4; + }); + + File file = fileSystem.open("ejemplo.txt"); + file.read(buffer); + + Assertions.assertEquals(0, buffer.getStart()); + Assertions.assertEquals(3, buffer.getEnd()); + Assertions.assertEquals(4, buffer.getCurrentSize()); + Assertions.assertArrayEquals(buffer.getBytes(), new byte[] {3, 3, 3, 3, 0, 0, 0, 0, 0, 0}); + } + + @Test + void siLaLecturaSincronicaFallaUnaExcepciónEsLanzada() { + Buffer buffer = new Buffer(10); + + when(lowLevelFileSystem.openFile("archivoMalito.txt")).thenReturn(13); + // Agrego condicion de que existe el archivo + when(lowLevelFileSystem.exists("archivoMalito.txt")).thenReturn(true); + when(lowLevelFileSystem.syncReadFile(anyInt(), any(), anyInt(), anyInt())).thenReturn(-1); + + File file = fileSystem.open("archivoMalito.txt"); + + Assertions.assertThrows(CanNotReadFileException.class, () -> file.read(buffer)); + } + + @Test + void sePuedeEscribirSincronicamenteUnArchivoCuandoHayNoHayNadaParaEscribir() { + + when(lowLevelFileSystem.openFile("test.txt")).thenReturn(67); + // Agrego condicion de que existe el archivo + when(lowLevelFileSystem.exists("test.txt")).thenReturn(true); + + File file = fileSystem.open("test.txt"); + + Assertions.assertDoesNotThrow(() -> file.write(null)); + } + + @Test + void sePuedeEscribirSincronicamenteUnArchivoCuandoHayAlgoParaEscribir() { + + when(lowLevelFileSystem.openFile("test.txt")).thenReturn(67); + // Agrego condicion de que existe el archivo + when(lowLevelFileSystem.exists("test.txt")).thenReturn(true); + + File file = fileSystem.open("test.txt"); + + Assertions.assertDoesNotThrow(() -> file.write(new Buffer(200))); + } + + @Test + void sePuedeLeerAsincronicamenteUnArchivo() { + + Buffer buffer = new Buffer(10); + + when(lowLevelFileSystem.openFile("test.txt")).thenReturn(67); + // Agrego condicion de que existe el archivo + when(lowLevelFileSystem.exists("test.txt")).thenReturn(true); + + File file = fileSystem.open("test.txt"); + + file.read(buffer, () -> { + + }); + + verify(lowLevelFileSystem).asyncReadFile(anyInt(), any(byte[].class), anyInt(), anyInt(), + any(Consumer.class)); + + } + + @Test + void sePuedeEscribirAsincronicamenteUnArchivo() { + Buffer buffer = new Buffer(10); + + when(lowLevelFileSystem.openFile("test.txt")).thenReturn(67); + // Agrego condicion de que existe el archivo + when(lowLevelFileSystem.exists("test.txt")).thenReturn(true); + + File file = fileSystem.open("test.txt"); + + file.write(buffer); + } + + @Test + void sePuedeCerrarUnArchivo() { + + when(lowLevelFileSystem.openFile("test.txt")).thenReturn(67); + // Agrego condicion de que existe el archivo + when(lowLevelFileSystem.exists("test.txt")).thenReturn(true); + + File file = fileSystem.open("test.txt"); + + file.close(); + + verify(lowLevelFileSystem).closeFile(67); + } + + @Test + void sePuedeSaberSiUnPathEsUnArchivoRegular() { + when(lowLevelFileSystem.isRegularFile("test.txt")).thenReturn(true); + Assertions.assertTrue(fileSystem.isFile("test.txt")); + } + + @Test + void sePuedeSaberSiUnPathEsUnDirectorio() { + when(lowLevelFileSystem.isDirectory("test.txt")).thenReturn(false); + Assertions.assertFalse(fileSystem.isFile("test.txt")); + } + + @Test + void sePuedeSaberSiUnPathExiste() { + when(lowLevelFileSystem.exists("test.txt")).thenReturn(true); + Assertions.assertTrue(fileSystem.exists("test.txt")); + } + + @Test + void noSePuedeCerrarArchivoYaCerrado() { + when(lowLevelFileSystem.exists("test.txt")).thenReturn(true); + File file = fileSystem.open("test.txt"); + file.close(); + Assertions.assertThrows(CanNotCloseFileException.class, () -> { + file.close(); + }); + } +} diff --git a/04-lecture/filesystem/target/checkstyle-cachefile b/04-lecture/filesystem/target/checkstyle-cachefile new file mode 100644 index 0000000..d53033e --- /dev/null +++ b/04-lecture/filesystem/target/checkstyle-cachefile @@ -0,0 +1,10 @@ +#Sat May 29 11:37:18 ART 2021 +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/exceptions/file/CanNotWriteFileException.java=1622066405557 +configuration*?=3ACF83B2763AAD6B7690312D733728A5B8D5A7EA +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/exceptions/file/CanNotReadFileException.java=1622060916155 +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/exceptions/file/CanNotOpenFileException.java=1621998862553 +module-resource*?\:checkstyle-xpath-suppressions.xml=176E4345A6C3E6390E4DC5EA4A67460A25FBE9E0 +module-resource*?\:checkstyle-suppressions.xml=B026C5FA4BA0D86A10CE7F341ADCD947BD5BB112 +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/model/file/Buffer.java=1622298221977 +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/exceptions/file/CanNotCloseFileException.java=1621998784848 +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/model/filesystem/HighLevelFileSystem.java=1622297354157 diff --git a/04-lecture/filesystem/target/checkstyle-checker.xml b/04-lecture/filesystem/target/checkstyle-checker.xml new file mode 100644 index 0000000..3920eb3 --- /dev/null +++ b/04-lecture/filesystem/target/checkstyle-checker.xml @@ -0,0 +1,321 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/04-lecture/filesystem/target/checkstyle-result.xml b/04-lecture/filesystem/target/checkstyle-result.xml new file mode 100644 index 0000000..c2be523 --- /dev/null +++ b/04-lecture/filesystem/target/checkstyle-result.xml @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/04-lecture/filesystem/target/jacoco.exec b/04-lecture/filesystem/target/jacoco.exec new file mode 100644 index 0000000000000000000000000000000000000000..8e461be02817104ff2140c5487abf5ba7e13df0e GIT binary patch literal 74256 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

iI zQ`0G^V?}BI&ytV%@p4@D?r_OIjiZ9il0lNkR5C*9YN^vxXEe}j&=0!<7e@*s%*YSa znLNZzkh4on5Wpp~mF)oNUWFg1py>M32MPavi|PhUoSDSRG99BBFR|(d_6=i`@d^=o zCZOEx{*V7?GqAf2rHWiHkTX3}9_QNba5c9mZtoPYKQ?+(5fw)qsBc<4gK8F|X)cVN|f6GxW}bR(V#E0X3d1WU(0TI3dv>;2p3jl9mp^uGqj{nVI+ox_lXom zbjA*cK_q^)t$J$lD@ot2RJPigH6byN6`wB$FLmqBKy$bu4@GOP$ z2CR7nnh|(~9MUA9n$qftVQXzQ*^8ijMe~}B8daOR>!Gqd zD*+0%m6&c|A@84wT*z{C|K%I+|8=i6?*GB3W7T<~|9kf7QRnxX2muvTfb`PAI;R2M%UJy34%LDTJN_5el#r>)s__P+oGb~gA`Exdeh-7Ub@PIL7*B`LD zWDWyWsbE=n&!cUtgI`Wq$BWqcQ^SCfZEfgMoBZM*Vt0g9_zlDPNG_Py5F21%|)BPeTqV_8d3m6zQp;i3llxOEu+ zT=M5-CYaM4*T50hae4#p9?GVY1SiPcXH1;yerio@kTAR<9*h5Sil!u2uUvFob1Ssp z$|pWbv9)9jjGId}H}4dj9c_TpC(}8o-R&lYVl`Y^=RP0#-wWMHhl-h{He`ot{t1eS z5hXm>obdxT-hzS|Ad zS@eQT@apER6~pbuy}@_mTL4_ld$4Fh~q3{ze{`Ix|X*>rAtgQzXOzd zLoAYPmH%tt>h-NoHt=Tpz|DN(wl1^l%yCux<_*@069$$$9;giVOuK~S5szk3%Idq?b@j(XL%*nac=d~Q(NK|o1{0DwMKS72e*urFWt4A;cK4cM W6EDo0wnTjph;Ct)eBb6z?EVW%GTvwa literal 0 HcmV?d00001 diff --git a/04-lecture/filesystem/target/maven-archiver/pom.properties b/04-lecture/filesystem/target/maven-archiver/pom.properties new file mode 100644 index 0000000..130c427 --- /dev/null +++ b/04-lecture/filesystem/target/maven-archiver/pom.properties @@ -0,0 +1,5 @@ +#Generated by Maven +#Sat May 29 11:37:17 ART 2021 +groupId=ar.edu.utn.frba.dds +artifactId=FileSystem +version=1.0-SNAPSHOT diff --git a/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst b/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst new file mode 100644 index 0000000..dde9655 --- /dev/null +++ b/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst @@ -0,0 +1,8 @@ +fs/model/filesystem/LowLevelFileSystem.class +fs/model/filesystem/HighLevelFileSystem.class +fs/exceptions/file/CanNotCloseFileException.class +fs/model/file/Buffer.class +fs/model/file/File.class +fs/exceptions/file/CanNotWriteFileException.class +fs/exceptions/file/CanNotReadFileException.class +fs/exceptions/file/CanNotOpenFileException.class diff --git a/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst b/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst new file mode 100644 index 0000000..bf353f7 --- /dev/null +++ b/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst @@ -0,0 +1,8 @@ +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/exceptions/file/CanNotReadFileException.java +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/exceptions/file/CanNotWriteFileException.java +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/model/file/Buffer.java +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/exceptions/file/CanNotOpenFileException.java +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/exceptions/file/CanNotCloseFileException.java +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/model/file/File.java +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/model/filesystem/LowLevelFileSystem.java +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/fs/model/filesystem/HighLevelFileSystem.java diff --git a/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/createdFiles.lst b/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/createdFiles.lst new file mode 100644 index 0000000..901b9fc --- /dev/null +++ b/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/createdFiles.lst @@ -0,0 +1,2 @@ +fs/BufferTest.class +fs/HighLevelFileSystemTest.class diff --git a/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst b/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst new file mode 100644 index 0000000..86098c4 --- /dev/null +++ b/04-lecture/filesystem/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst @@ -0,0 +1,2 @@ +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/test/java/fs/HighLevelFileSystemTest.java +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/test/java/fs/BufferTest.java diff --git a/04-lecture/filesystem/target/spotbugs-exclude.xml b/04-lecture/filesystem/target/spotbugs-exclude.xml new file mode 100644 index 0000000..72a0c18 --- /dev/null +++ b/04-lecture/filesystem/target/spotbugs-exclude.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/04-lecture/filesystem/target/spotbugs.xml b/04-lecture/filesystem/target/spotbugs.xml new file mode 100644 index 0000000..7a1aa26 --- /dev/null +++ b/04-lecture/filesystem/target/spotbugs.xml @@ -0,0 +1,2 @@ + +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/target/generated-sources/annotations/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/test/java/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/target/generated-test-sources/test-annotations \ No newline at end of file diff --git a/04-lecture/filesystem/target/spotbugsXml.xml b/04-lecture/filesystem/target/spotbugsXml.xml new file mode 100644 index 0000000..266786f --- /dev/null +++ b/04-lecture/filesystem/target/spotbugsXml.xml @@ -0,0 +1,2 @@ + +/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/target/classes/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/src/main/java/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/target/generated-sources/annotations/home/tosanchez/Developer/tpi2-sistema-de-archivos-tomasanchez/target \ No newline at end of file diff --git a/04-lecture/filesystem/target/surefire-reports/TEST-fs.BufferTest.xml b/04-lecture/filesystem/target/surefire-reports/TEST-fs.BufferTest.xml new file mode 100644 index 0000000..95bf98d --- /dev/null +++ b/04-lecture/filesystem/target/surefire-reports/TEST-fs.BufferTest.xml @@ -0,0 +1,64 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/04-lecture/filesystem/target/surefire-reports/TEST-fs.HighLevelFileSystemTest.xml b/04-lecture/filesystem/target/surefire-reports/TEST-fs.HighLevelFileSystemTest.xml new file mode 100644 index 0000000..751d773 --- /dev/null +++ b/04-lecture/filesystem/target/surefire-reports/TEST-fs.HighLevelFileSystemTest.xml @@ -0,0 +1,74 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/04-lecture/filesystem/target/surefire-reports/fs.BufferTest.txt b/04-lecture/filesystem/target/surefire-reports/fs.BufferTest.txt new file mode 100644 index 0000000..bdbf7f0 --- /dev/null +++ b/04-lecture/filesystem/target/surefire-reports/fs.BufferTest.txt @@ -0,0 +1,4 @@ +------------------------------------------------------------------------------- +Test set: fs.BufferTest +------------------------------------------------------------------------------- +Tests run: 4, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.065 s - in fs.BufferTest diff --git a/04-lecture/filesystem/target/surefire-reports/fs.HighLevelFileSystemTest.txt b/04-lecture/filesystem/target/surefire-reports/fs.HighLevelFileSystemTest.txt new file mode 100644 index 0000000..f0351b7 --- /dev/null +++ b/04-lecture/filesystem/target/surefire-reports/fs.HighLevelFileSystemTest.txt @@ -0,0 +1,4 @@ +------------------------------------------------------------------------------- +Test set: fs.HighLevelFileSystemTest +------------------------------------------------------------------------------- +Tests run: 14, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.624 s - in fs.HighLevelFileSystemTest diff --git a/04-lecture/filesystem/target/test-classes/fs/.gitkeep b/04-lecture/filesystem/target/test-classes/fs/.gitkeep new file mode 100644 index 0000000..e69de29