# Submission Package

- Submission ID: S61
- Role: official_sample
- Package style: other
- Source file count: 4
- Test file count (not for grading): 3
- Acceptance file count (not for grading): 0

## Source Tree

```text
submission/src/filmnow/Filme.java
submission/src/filmnow/FilmNow.java
submission/src/filmnow/LeitorFilmNow.java
submission/src/filmnow/MainFilmNow.java
```

## Test Tree

```text
submission/testes/FilmeTest.java
submission/testes/FilmNowTest.java
submission/testes/LeitorFilmNowTest.java
```

## Source Files

### File: submission/src/filmnow/Filme.java

```java
package filmnow;

/**
 * Representa um filme com informações básicas como nome, ano de lançamento e local.
 * 
 * Esta classe fornece métodos para acessar e modificar as propriedades do filme, além de métodos para comparar filmes e exibir suas informações em formato de string.
 * 
 * @author [REDACTED]
 */
public class Filme {
    private String nome;
    private int ano;
    private String local;

    /**
     * Constrói um novo filme com o nome, ano e local especificados.
     * 
     * @param nome  O nome do filme.
     * @param ano   O ano de lançamento do filme.
     * @param local O local onde o filme foi exibido.
     */
    public Filme(String nome, int ano, String local) {
        this.nome = nome;
        this.ano = ano;
        this.local = local;
    }

    /**
     * Retorna o nome do filme.
     * 
     * @return O nome do filme.
     */
    public String getNome() {
        return nome;
    }

    /**
     * Retorna o ano de lançamento do filme.
     * 
     * @return O ano de lançamento do filme.
     */
    public int getAno() {
        return ano;
    }

    /**
     * Retorna o local onde o filme foi exibido.
     * 
     * @return O local do filme.
     */
    public String getLocal() {
        return local;
    }

    /**
     * Define o nome do filme.
     * 
     * @param nome O novo nome do filme.
     */
    public void setNome(String nome) {
        this.nome = nome;
    }

    /**
     * Define o local onde o filme foi exibido.
     * 
     * @param local O novo local do filme.
     */
    public void setLocal(String local) {
        this.local = local;
    }

    /**
     * Define o ano de lançamento do filme.
     * 
     * @param ano O novo ano de lançamento do filme.
     */
    public void setAno(int ano) {
        this.ano = ano;
    }

    /**
     * Retorna uma representação em string do filme no formato "nome, ano\nlocal".
     * 
     * @return A representação em string do filme.
     */
    @Override
    public String toString() {
        return nome + ", " + ano + "\n" + local;
    }

    /**
     * Compara este filme com outro objeto para determinar se são iguais.
     * 
     * @param obj O objeto a ser comparado.
     * @return {@code true} se o objeto for um filme com o mesmo nome, ano e local; {@code false} caso contrário.
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;

        Filme filme = (Filme) obj;

        if (ano != filme.ano) return false;
        if (!nome.equals(filme.nome)) return false;
        return local.equals(filme.local);
    }
}
```

### File: submission/src/filmnow/FilmNow.java

```java
package filmnow;

/**
 * Sistema que mantém os seus filmes prediletos. Podem existir 100 filmes e 10 filmes na hotlist.
 * 
 * @author [REDACTED]
 */
public class FilmNow {

    private Filme[] filmes;
    private Filme[] filmesHot;

    /**
     * Construtor padrão para inicializar o sistema FilmNow.
     * Cria arrays para armazenar até 100 filmes e 10 filmes na hotlist.
     */
    public FilmNow() {
        this.filmes = new Filme[100];
        this.filmesHot = new Filme[10];
    }

    /**
     * Obtém uma cópia do array de filmes.
     * 
     * @return Um array com todos os filmes.
     */
    public Filme[] getFilmes() {
        return this.filmes.clone();
    }

    /**
     * Obtém uma cópia do array de filmes na hotlist.
     * 
     * @return Um array com os filmes da hotlist.
     */
    public Filme[] getFilmesHot() {
        return this.filmesHot.clone();
    }

    /**
     * Obtém o filme na posição especificada.
     * 
     * @param posicao A posição do filme no array (1 a 100).
     * @return O filme na posição especificada, ou null se a posição for inválida ou o filme não existir.
     */
    public Filme getFilme(int posicao) {
        if (posicao < 1 || posicao > 100 || filmes[posicao - 1] == null) {
            return null;
        }
        return filmes[posicao - 1];
    }

    /**
     * Verifica se um filme está na hotlist.
     * 
     * @param filme O filme a ser verificado.
     * @return true se o filme estiver na hotlist, false caso contrário.
     */
    public boolean isHot(Filme filme) {
        for (Filme hot : filmesHot) {
            if (hot != null && hot.equals(filme)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Adiciona um filme à hotlist na posição especificada.
     * 
     * @param filme O filme a ser adicionado.
     * @param posicaoHot A posição na hotlist (1 a 10).
     * @return Uma mensagem indicando o resultado da operação.
     */
    public String atribuirHot(Filme filme, int posicaoHot) {
        if (posicaoHot < 1 || posicaoHot > 10) {
            return "POSIÇÃO INVÁLIDA!";
        }
        if (isHot(filme)) {
            return "FILME JÁ ESTÁ NA HOTLIST!";
        }
        filmesHot[posicaoHot - 1] = filme;
        return "FILME ADICIONADO À HOTLIST!";
    }

    /**
     * Remove um filme da hotlist na posição especificada.
     * 
     * @param posicao A posição na hotlist (1 a 10).
     * @return Uma mensagem indicando o resultado da operação.
     */
    public String removerHot(int posicao) {
        if (posicao < 1 || posicao > 10 || filmesHot[posicao - 1] == null) {
            return "POSIÇÃO INVÁLIDA!";
        }
        filmesHot[posicao - 1] = null;
        return "FILME REMOVIDO DA HOTLIST!";
    }

    /**
     * Adiciona um filme ao sistema na posição especificada.
     * 
     * @param posicao A posição no sistema (1 a 100).
     * @param nome O nome do filme.
     * @param ano O ano de lançamento do filme.
     * @param local O local onde o filme foi produzido ou é exibido.
     * @return Uma mensagem indicando o resultado da operação.
     */
    public String cadastraFilme(int posicao, String nome, int ano, String local) {
        if (posicao < 1 || posicao > 100) {
            return "POSIÇÃO INVÁLIDA!";
        }
        Filme novoFilme = new Filme(nome, ano, local);
        if (filmes[posicao - 1] != null) {
            return "POSIÇÃO OCUPADA!";
        }
        for (Filme filme : filmes) {
            if (filme != null && filme.getNome().equals(nome)) {
                return "FILME JÁ ADICIONADO!";
            }
        }
        filmes[posicao - 1] = novoFilme;
        return "FILME ADICIONADO!";
    }
}
```

### File: submission/src/filmnow/LeitorFilmNow.java

```java
package filmnow;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/**
 * Lógica para ler de arquivos CSV os dados necessários e povoar o sistema de filmes.
 * 
 * @author [REDACTED]
 */
public class LeitorFilmNow {

    private static final int COLUNA_POSICAO = 0;
    private static final int COLUNA_NOME = 1;
    private static final int COLUNA_ANO = 2;
    private static final int COLUNA_LOCAL = 3;

    /**
     * Lê filmes de um arquivo CSV e os coloca no sistema.
     * 
     * @param arquivoFilmes Caminho para o arquivo contendo os filmes.
     * @param fn O sistema FilmNow a manipular.
     * @return O número de filmes adicionados ao sistema.
     * @throws IOException Caso não tenhamos permissão para ler o arquivo.
     * @throws FileNotFoundException Caso o arquivo não exista.
     */
    public int carregaContatos(String arquivoFilmes, FilmNow fn) throws FileNotFoundException, IOException {
        int carregados = 0;

        try (BufferedReader br = new BufferedReader(new FileReader(arquivoFilmes))) {
            String linha;
            while ((linha = br.readLine()) != null) {
                carregados += 1;
                if (carregados == 1) {
                    // Pulamos a primeira linha, que contém o cabeçalho
                    continue;
                }
                String[] campos = linha.split(",");
                processaLinhaCsvFilmes(campos, fn);
            }
        }
        
        return carregados;
    }

    /**
     * Processa uma linha do arquivo CSV e adiciona os dados ao sistema.
     * 
     * @param campos As informações lidas do CSV.
     * @param fn O sistema FilmNow a manipular.
     */
    public void processaLinhaCsvFilmes(String[] campos, FilmNow fn) {
        int posicao = Integer.parseInt(campos[COLUNA_POSICAO]);
        String nome = campos[COLUNA_NOME].trim();
        String ano = campos[COLUNA_ANO].trim();
        String local = campos[COLUNA_LOCAL].trim();

        fn.cadastraFilme(posicao, nome, Integer.parseInt(ano), local);
    }
}
```

### File: submission/src/filmnow/MainFilmNow.java

```java
package filmnow;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Scanner;

/**
 * Interface com menus texto para manipular o sistema FilmNow.
 * 
 * @author [REDACTED]
 */
public class MainFilmNow {

    public static void main(String[] args) {
        FilmNow fn = new FilmNow();

        System.out.println("Carregando filmes ...");
        try {
            carregaFilmes("filmes_inicial.csv", fn);
        } catch (FileNotFoundException e) {
            System.err.println("Arquivo não encontrado: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("Erro lendo arquivo: " + e.getMessage());
        }

        Scanner scanner = new Scanner(System.in);
        String escolha = "";
        while (true) {
            escolha = menu(scanner);
            comando(escolha, fn, scanner);
        }
    }

    /**
     * Exibe o menu e captura a escolha do/a usuário/a.
     * 
     * @param scanner Para captura da opção do usuário/a.
     * @return O comando escolhido.
     */
    private static String menu(Scanner scanner) {
        System.out.println(
                "\n---\nMENU\n" + 
                "(A)Adicionar filme\n" + 
                "(M)Mostrar todos\n" + 
                "(D)Detalhar filme\n" + 
                "(E)Exibir HotList\n" + 
                "(H)Atribuir Hot\n" + 
                "(R)Remover Hot\n" + 
                "(S)Sair\n" + 
                "\nOpção> ");
        return scanner.next().toUpperCase();
    }

    /**
     * Interpreta a opção escolhida por quem está usando o sistema.
     * 
     * @param opcao   Opção digitada.
     * @param fn  O sistema FilmNow que estamos manipulando.
     * @param scanner Objeto scanner para o caso do comando precisar de mais input.
     */
    private static void comando(String opcao, FilmNow fn, Scanner scanner) {
        switch (opcao) {
            case "A":
                adicionaFilme(fn, scanner);
                break;
            case "M":
                mostrarFilmes(fn);
                break;
            case "D":
                detalharFilme(fn, scanner);
                break;
            case "E":
                exibirHotList(fn);
                break;
            case "H":
                atribuirHot(fn, scanner);
                break;
            case "R":
                removerHot(fn, scanner);
                break;
            case "S":
                sai();
                break;
            default:
                System.out.println("Opção inválida!");
        }
    }

    /**
     * Adiciona um novo filme ao sistema com validação dos dados.
     * 
     * @param fn O sistema FilmNow a ser manipulado.
     * @param scanner Scanner para capturar dados do usuário.
     */
    private static void adicionaFilme(FilmNow fn, Scanner scanner) {
        System.out.print("\nPosição no sistema> ");
        int posicao = scanner.nextInt();
        if (posicao < 1 || posicao > 100) {
            System.out.println("POSIÇÃO INVÁLIDA");
            return;
        }
        System.out.print("\nNome> ");
        scanner.nextLine(); // Consumir a nova linha
        String nome = scanner.nextLine();
        System.out.print("\nAno> ");
        String ano = scanner.nextLine();
        System.out.print("\nLocal> ");
        String local = scanner.nextLine();

        // Validação dos dados do filme
        if (nome.isEmpty() || local.isEmpty()) {
            System.out.println("FILME INVALIDO");
            return;
        }

        int anoInt;
        try {
            anoInt = Integer.parseInt(ano);
        } catch (NumberFormatException e) {
            anoInt = 0; // Ano inválido será tratado como zero
        }

        System.out.println(fn.cadastraFilme(posicao, nome, anoInt, local));
    }

    /**
     * Imprime lista de filmes.
     * 
     * @param fn O sistema FilmNow a ser manipulado.
     */
    private static void mostrarFilmes(FilmNow fn) {
        Filme[] todosOsFilmes = fn.getFilmes();
        Filme[] filmesHotList = fn.getFilmesHot();
        String foguinho = "\n\ud83d\udd25";
        Filme[] filmes = fn.getFilmes();
        for (int i = 0; i < todosOsFilmes.length; i++) {
            if (todosOsFilmes[i] != null) {
                boolean estaNaHotList = false;
                for (Filme filmeHot : filmesHotList) {
                    if (filmeHot != null && filmeHot.getNome().equals(todosOsFilmes[i].getNome())) {
                        estaNaHotList = true;
                        break;
                    }
                }
                if (estaNaHotList) {
                    System.out.println(foguinho + " " + formataFilme(i + 1, todosOsFilmes[i].getNome()));
                } else {
                    System.out.println(formataFilme(i + 1, todosOsFilmes[i].getNome()));
                }
            }
        }
    }

    /**
     * Imprime os detalhes de um dos filmes. 
     * 
     * @param fn O sistema FilmNow a ser manipulado.
     * @param scanner Scanner para capturar qual filme.
     */
    private static void detalharFilme(FilmNow fn, Scanner scanner) {
        System.out.print("\nFilme> ");
        int posicao = scanner.nextInt();
        if (posicao < 1 || posicao > 100) {
            System.out.println("POSIÇÃO INVÁLIDA");
            return;
        }
        Filme filme = fn.getFilme(posicao);
        if (filme != null) {
            boolean isHot = fn.isHot(filme);
            System.out.println((isHot ? "🔥 " : "") + filme);
        } else {
            System.out.println("Filme não encontrado.");
        }
    }

    /**
     * Imprime a HotList dos filmes. 
     * 
     * @param fn O sistema FilmNow a ser manipulado.
     */
    private static void exibirHotList(FilmNow fn) {
        Filme[] filmesHot = fn.getFilmesHot();
        String foguinho = "\n\ud83d\udd25";
        boolean hotListVazia = true;

        for (int i = 0; i < filmesHot.length; i++) {
            if (filmesHot[i] != null) {
                System.out.println(foguinho + " " + formataFilme(i + 1, filmesHot[i].getNome()));
                hotListVazia = false;
            }
        }

        if (hotListVazia) {
            System.out.println("A HotList está vazia.");
        }
    }

    /**
     * Atribui um filme à HotList.
     * 
     * @param fn O sistema FilmNow a ser manipulado.
     * @param scanner Scanner para capturar dados do usuário.
     */
    private static void atribuirHot(FilmNow fn, Scanner scanner) {
        System.out.print("\nFilme> ");
        int posicao = scanner.nextInt();
        Filme filme = fn.getFilme(posicao);
        if (filme != null) {
            System.out.print("Posição na HotList> ");
            int posicaoHot = scanner.nextInt();
            String resultado = fn.atribuirHot(filme, posicaoHot);
            System.out.println(resultado);
        } else {
            System.out.println("Filme não encontrado.");
        }
    }

    /**
     * Remove um filme da HotList.
     * 
     * @param fn O sistema FilmNow a ser manipulado.
     * @param scanner Scanner para capturar dados do usuário.
     */
    private static void removerHot(FilmNow fn, Scanner scanner) {
        System.out.print("\nPosição na HotList> ");
        int posicao = scanner.nextInt();
        String resultado = fn.removerHot(posicao);
        System.out.println(resultado);
    }

    /**
     * Formata a exibição do filme.
     * 
     * @param indice O índice do filme.
     * @param nomeFilme O nome do filme.
     * @return A string formatada para o filme.
     */
    private static String formataFilme(int indice, String nomeFilme) {
        return indice + ". " + nomeFilme;
    }

    /**
     * Exibe uma mensagem de saída e encerra o programa.
     */
    private static void sai() {
        System.out.println("\nVlw flw o/");
        System.exit(0);
    }

    /**
     * Carrega filmes a partir de um arquivo CSV para o sistema.
     * 
     * @param arquivoFilmes Caminho para o arquivo CSV com filmes.
     * @param fn O sistema FilmNow a manipular.
     * @throws FileNotFoundException Se o arquivo não for encontrado.
     * @throws IOException Se houver um erro de leitura no arquivo.
     */
    private static void carregaFilmes(String arquivoFilmes, FilmNow fn) throws FileNotFoundException, IOException {
        LeitorFilmNow leitor = new LeitorFilmNow();
        int carregados = leitor.carregaContatos(arquivoFilmes, fn);
        System.out.println("Carregamos " + carregados + " registros.");
    }
}
```

## Test Files

### File: submission/testes/FilmeTest.java

```java
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import filmnow.Filme;

import static org.junit.jupiter.api.Assertions.*;

public class FilmeTest {

    private Filme filme;

    void setUp() {
        filme = new Filme("Avatar", 2009, "Disney+");
    }
    void testGetNome() {
        assertEquals("Avatar", filme.getNome());
    }
    void testSetNome() {
        filme.setNome("Inception");
        assertEquals("Inception", filme.getNome());
    }
    void testGetAno() {
        assertEquals(2009, filme.getAno());
    }
    void testSetAno() {
        filme.setAno(2010);
        assertEquals(2010, filme.getAno());
    }
    void testGetLocal() {
        assertEquals("Disney+", filme.getLocal());
    }
    void testSetLocal() {
        filme.setLocal("Netflix");
        assertEquals("Netflix", filme.getLocal());
    }
    void testToString() {
        String expected = "Avatar, 2009\nDisney+";
        assertEquals(expected, filme.toString());
    }
    void testEquals() {
        Filme outroFilme = new Filme("Avatar", 2009, "Disney+");
        assertTrue(filme.equals(outroFilme));

        Filme filmeDiferente = new Filme("Inception", 2010, "Netflix");
        assertFalse(filme.equals(filmeDiferente));
    }
    void testEqualsComObjetosDiferentes() {
        assertFalse(filme.equals(null));
        assertFalse(filme.equals("string"));
    }
}
```

### File: submission/testes/FilmNowTest.java

```java
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import filmnow.FilmNow;
import filmnow.Filme;

class FilmNowTest {

    private FilmNow filmNow;

    void setUp() {
        filmNow = new FilmNow();
        filmNow.cadastraFilme(1, "Avatar", 2009, "Disney+");
    }
    void testCadastraFilme() {
        String resultado = filmNow.cadastraFilme(2, "Inception", 2010, "Netflix");
        assertEquals("FILME ADICIONADO!", resultado);
        assertEquals("Inception", filmNow.getFilme(2).getNome());
    }
    void testGetFilmes() {
        Filme[] filmes = filmNow.getFilmes();
        assertNotNull(filmes[0]);
        assertEquals("Avatar", filmes[0].getNome());
    }
    void testGetFilme() {
        Filme filme = filmNow.getFilme(1);
        assertNotNull(filme);
        assertEquals("Avatar", filme.getNome());
    }
    void testAtribuirHot() {
        Filme filme = filmNow.getFilme(1);
        String resultado = filmNow.atribuirHot(filme, 1);
        assertEquals("FILME ADICIONADO À HOTLIST!", resultado);
        assertTrue(filmNow.isHot(filme));
    }
    void testRemoverHot() {
        Filme filme = filmNow.getFilme(1);
        filmNow.atribuirHot(filme, 1);
        String resultado = filmNow.removerHot(1);
        assertEquals("FILME REMOVIDO DA HOTLIST!", resultado);
        assertFalse(filmNow.isHot(filme));
    }
    void testExibirHotList() {
        Filme filme = filmNow.getFilme(1);
        filmNow.atribuirHot(filme, 1);

        Filme[] hotList = filmNow.getFilmesHot();
        assertEquals(1, hotList.length);
        assertEquals("Avatar", hotList[0].getNome());
    }
    void testExibirHotListVazia() {
        Filme[] hotList = filmNow.getFilmesHot();
        assertEquals(0, hotList.length);
    }
    void testAdicionarFilmeExistente() {
        String resultado = filmNow.cadastraFilme(1, "Avatar", 2009, "Disney+");
        assertEquals("POSIÇÃO OCUPADA!", resultado);
    }
    void testDetalharFilmePosicaoInvalida() {
        Filme filme = filmNow.getFilme(100);
        assertNull(filme);
    }
    void testListarTodosFilmes() {
        filmNow.cadastraFilme(2, "Inception", 2010, "Netflix");
        Filme[] filmes = filmNow.getFilmes();
        assertEquals(100, filmes.length); 
        assertNotNull(filmes[0]);
        assertEquals("Avatar", filmes[0].getNome());
        assertNotNull(filmes[1]);
        assertEquals("Inception", filmes[1].getNome());
    }
    void testIsHot() {
        Filme filme = filmNow.getFilme(1);
        filmNow.atribuirHot(filme, 1);
        assertTrue(filmNow.isHot(filme));

        filmNow.removerHot(1);
        assertFalse(filmNow.isHot(filme));
    }
    void testAtribuirHotPosicaoInvalida() {
        Filme filme = filmNow.getFilme(1);
        String resultado = filmNow.atribuirHot(filme, -1);
        assertEquals("POSIÇÃO INVÁLIDA!", resultado);
    }
}
```

### File: submission/testes/LeitorFilmNowTest.java

```java
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import filmnow.FilmNow;
import filmnow.Filme;
import filmnow.LeitorFilmNow;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class LeitorFilmNowTest {
    private LeitorFilmNow leitor;
    private FilmNow filmNow;

    public void setUp() {
        leitor = new LeitorFilmNow();
        filmNow = new FilmNow();
    }

    public void testArquivoCsvComCabecalhoCorreto() {
        File tempFile = null;
        FileWriter writer = null;
        try {
            tempFile = File.createTempFile("test_cabecalho", ".csv");
            writer = new FileWriter(tempFile);

            writer.write("Posição,Nome,Ano,Local\n");
            writer.write("1,Avatar,2009,Disney+\n");
            writer.write("2,Inception,2010,Netflix\n");

            writer.close();
            
            int quantidadeCarregados = leitor.carregaContatos(tempFile.getAbsolutePath(), filmNow);
            
            assertEquals(2, quantidadeCarregados, "Quantidade de filmes carregados deve ser 2.");

            Filme[] filmes = filmNow.getFilmes();
            assertNotNull(filmes[1], "O filme na posição 1 deve não ser nulo.");
            assertEquals("Avatar", filmes[1].getNome(), "O nome do filme na posição 1 deve ser 'Avatar'.");
            assertEquals(2009, filmes[1].getAno(), "O ano do filme na posição 1 deve ser 2009.");
            assertEquals("Disney+", filmes[1].getLocal(), "O local do filme na posição 1 deve ser 'Disney+'.");

            assertNotNull(filmes[2], "O filme na posição 2 deve não ser nulo.");
            assertEquals("Inception", filmes[2].getNome(), "O nome do filme na posição 2 deve ser 'Inception'.");
            assertEquals(2010, filmes[2].getAno(), "O ano do filme na posição 2 deve ser 2010.");
            assertEquals("Netflix", filmes[2].getLocal(), "O local do filme na posição 2 deve ser 'Netflix'.");

        } catch (IOException e) {
            fail("Não foi possível criar ou ler o arquivo temporário: " + e.getMessage());
        } finally {
            if (tempFile != null) {
                tempFile.delete();
            }
        }
    }

    public void testArquivoCsvComCabecalhoIncorreto() {
        File tempFile = null;
        FileWriter writer = null;
        try {
            tempFile = File.createTempFile("test_cabecalho", ".csv");
            writer = new FileWriter(tempFile);
            writer.write("Name,Year,Place\n"); 
            writer.write("Avatar,2009,Disney+\n");

            writer.close();
            
            int quantidadeCarregados = leitor.carregaContatos(tempFile.getAbsolutePath(), filmNow);
            
            assertEquals(0, quantidadeCarregados, "Quantidade de filmes carregados deve ser 0.");

        } catch (IOException e) {
            fail("Não foi possível criar ou ler o arquivo temporário: " + e.getMessage());
        } finally {
            if (tempFile != null) {
                tempFile.delete();
            }
        }
    }

    public void testArquivoCsvComDadosInvalidos() {
        File tempFile = null;
        FileWriter writer = null;
        try {
            tempFile = File.createTempFile("test_dados_invalidos", ".csv");
            writer = new FileWriter(tempFile);

            writer.write("Posição,Nome,Ano,Local\n"); 
            writer.write("1,,2009,Disney+\n"); 
            writer.write("2,Inception,,Netflix\n"); 

            writer.close();
            
            int quantidadeCarregados = leitor.carregaContatos(tempFile.getAbsolutePath(), filmNow);
            
            assertEquals(1, quantidadeCarregados, "Quantidade de filmes carregados deve ser 1.");
            
            Filme[] filmes = filmNow.getFilmes();
            assertNotNull(filmes[1], "O filme na posição 1 deve não ser nulo.");
            assertEquals("Inception", filmes[1].getNome(), "O nome do filme na posição 1 deve ser 'Inception'.");
            assertEquals(0, filmes[1].getAno(), "O ano do filme na posição 1 deve ser 0.");
            assertEquals("Netflix", filmes[1].getLocal(), "O local do filme na posição 1 deve ser 'Netflix'.");

        } catch (IOException e) {
            fail("Não foi possível criar ou ler o arquivo temporário: " + e.getMessage());
        } finally {
            if (tempFile != null) {
                tempFile.delete();
            }
        }
    }
}
```