Tag: dictionary

I don’t think you need to test everything around opening the input file, closing it, handling exceptions, etc. For the purpose of this task, I believe you want to test your logic, and trust that FileReader or FileInputStream etc just work.

I would have a class that that can read the format of the dictionary (not provided, presumably this is FileBasedDictionary), and create a test of that class that it produces the expected Map<String, String>.

Then have a class that does business logic (i.e. the word replacement) that can operate independant of the source of the data (by taking in a flexible type like a BufferedReader). You can add a test case that demonstrates how to create a valid data source, while also demonstrating the business logic – tests are as much about documentation/demonstration as they are about checking.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.util.Map;

public class DictionaryReplacementService {
    
    private Map<String, String> dictionary;
    
    public DictionaryReplacementService(Map<String, String> dictionary) {
        this.dictionary = dictionary;
    }

    public void replaceWords(BufferedReader input, BufferedWriter output)
            throws IOException {
        String line;
        while ((line = input.readLine()) != null) {
            for (Map.Entry<String, String> entry : dictionary.entrySet()) {
                line = line.replaceAll(entry.getKey(), entry.getValue());
            }
            output.write(line);
        }
    }
}

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

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.LinkedHashMap;
import java.util.Map;

import org.junit.jupiter.api.Test;

class DictionaryReplacementServiceTest {

    @Test
    void test() throws IOException {
        String source = "It was the best of times, it was the blurst of times.";

        Map<String, String> dictionary = new LinkedHashMap<String, String>();
        dictionary.put("blurst", "worst");

        StringWriter outString = new StringWriter();
        try (BufferedReader in = new BufferedReader(new StringReader(source));
                BufferedWriter out = new BufferedWriter(outString)) {
            new DictionaryReplacementService(dictionary).replaceWords(in, out);
        }

        assertEquals("It was the best of times, it was the worst of times.",
                outString.toString());
    }

}

In this case, the user of your class would just need to replace StringReader with FileReader if that’s what they wanted – the DictionaryReplacementService is not interested in that.

A last note is about exceptions and return values. Instead of returning true for success and false for failure, I prefer to return void for success and just throw any exceptions that mean the success case is not possible (in my case, the try is just to ensure the resources are closed – it doesn’t catch any exceptions, and throwing an exception from a JUnit test means a test failure, which is what we want).

You said you don’t want to trivialize file i/o and you want to test what happens when problems happen, but that’s not a concern of DictionaryReplacementService – it only needs to signal that something went wrong. In a full program, you would have logic in the UI layer to try and recover (let the user know there was a problem, prompt them to try again or use a different file etc). You’re not writing that UI layer now, so I wouldn’t expect to see tests about it now.