fizz.java

/////// Ej.1

public class FizzBuzz {

    public static void main(String[] args) {
        if(args.length == 2) {
            FizzBuzz fizzBuzz = new FizzBuzz();
            System.out.println(fizzBuzz.fizzbuzz(Integer.parseInt(args[0]), Integer.parseInt(args[1])));
        }
    }

    public String fizzbuzz(int start, int end) {
        if(start < 1 || end < start) {
            throw new IllegalArgumentException();
        }
        StringBuilder sb = new StringBuilder();
        for(int i = start; i <= end; i++) {
            sb.append(convertSingleNumber(i)+" ");
        }
        return sb.toString().trim();
    }

    public String convertSingleNumber(int n) {
        if (n % 15 == 0) {
            return "fizzbuzz";
        }
        if (n % 3 == 0) {
            return "fizz";
        }
        if (n % 5 == 0) {
            return "buzz";
        }
        return String.valueOf(n);
    }
}

package io.quizzler;

import org.junit.Test;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;

public class FizzBuzzTest {

    private FizzBuzz fizzBuzz = new FizzBuzz();

    @Test
    public void print1() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(1, 1), equalTo("1"));
    }

    @Test
    public void print2() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(2, 2), equalTo("2"));
    }

    @Test
    public void print3IsFizz() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(3, 3), equalTo("fizz"));
    }

    @Test
    public void print5IsBuzz() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(5, 5), equalTo("buzz"));
    }

    @Test
    public void print6IsFizz() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(6, 6), equalTo("fizz"));
    }

    @Test
    public void print10IsBuzz() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(10, 10), equalTo("buzz"));
    }

    @Test
    public void print15IsFizzBuzz() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(15, 15), equalTo("fizzbuzz"));
    }

    @Test
    public void print30IsFizzBuzz() {
        assertThat(fizzBuzz.fizzbuzz(30, 30), equalTo("fizzbuzz"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void negativeRangeThrowsException() {
        fizzBuzz.fizzbuzz(2, 1);
    }

    @Test(expected = IllegalArgumentException.class)
    public void negativelRangeStartThrowsException() {
        fizzBuzz.fizzbuzz(-2, 4);
    }

    @Test
    public void rangePrintsSpacedNumbers() {
        assertThat(fizzBuzz.fizzbuzz(1, 15), equalTo("1 2 fizz 4 buzz fizz 7 8 fizz buzz 11 fizz 13 14 fizzbuzz"));
    }
}


/////// Ej.2

package io.quizzler;

public class FizzBuzz {

    public static void main(String[] args) {
        if(args.length == 2) {
            FizzBuzz fizzBuzz = new FizzBuzz();
            System.out.println(fizzBuzz.fizzbuzz(Integer.parseInt(args[0]), Integer.parseInt(args[1])));
        }
    }


    public String fizzbuzz(int start, int end) {
        if(start < 1 || end < start) {
            throw new IllegalArgumentException();
        }
        StringBuilder sb = new StringBuilder();
        for(int i = start; i <= end; i++) {
            sb.append(convertSingleNumber(i)+" ");
        }
        return sb.toString().trim();
    }

    private String convertSingleNumber(int n) {
        if(String.valueOf(n).contains("3")) {
            return "lucky";
        }
        if (n % 15 == 0) {
            return "fizzbuzz";
        }
        if (n % 3 == 0) {
            return "fizz";
        }
        if (n % 5 == 0) {
            return "buzz";
        }
        return String.valueOf(n);
    }
}


package io.quizzler;

import org.junit.Test;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;

public class FizzBuzzTest {

    private FizzBuzz fizzBuzz = new FizzBuzz();

    @Test
    public void print1() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(1, 1), equalTo("1"));
    }

    @Test
    public void print2() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(2, 2), equalTo("2"));
    }

    @Test
    public void print3IsLucky() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(3, 3), equalTo("lucky"));
    }

    @Test
    public void print5IsBuzz() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(5, 5), equalTo("buzz"));
    }

    @Test
    public void print6IsFizz() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(6, 6), equalTo("fizz"));
    }

    @Test
    public void print10IsBuzz() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(10, 10), equalTo("buzz"));
    }

    @Test
    public void print15IsFizzBuzz() throws Exception {
        assertThat(fizzBuzz.fizzbuzz(15, 15), equalTo("fizzbuzz"));
    }

    @Test
    public void print30IsLucky() {
        assertThat(fizzBuzz.fizzbuzz(30, 30), equalTo("lucky"));
    }

    @Test
    public void print13IsLucky() {
        assertThat(fizzBuzz.fizzbuzz(13, 13), equalTo("lucky"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void negativeRangeThrowsException() {
        fizzBuzz.fizzbuzz(2, 1);
    }

    @Test(expected = IllegalArgumentException.class)
    public void negativelRangeStartThrowsException() {
        fizzBuzz.fizzbuzz(-2, 4);
    }

    @Test
    public void rangePrintsSpacedNumbers() {
        assertThat(fizzBuzz.fizzbuzz(1, 15), equalTo("1 2 lucky 4 buzz fizz 7 8 fizz buzz 11 fizz lucky 14 fizzbuzz"));
    }
}

///////  Ej.3


package io.quizzler;

import java.util.HashMap;
import java.util.Map;

public class FizzBuzz {

    public static final String FIZZ = "fizz";
    public static final String BUZZ = "buzz";
    public static final String FIZZBUZZ = "fizzbuzz";
    public static final String LUCKY = "lucky";
    public static final String INTEGER = "integer";
    
    private int start;
    private int end;
    private String fizzBuzzString;
    private Map<String, Integer> fizzBuzzReport = new HashMap<String, Integer>(){{
        put(FIZZ, 0);
        put(BUZZ, 0);
        put(FIZZBUZZ, 0);
        put(LUCKY, 0);
        put(INTEGER, 0);
    }};

    public static void main(String[] args) {
        if(args.length == 2) {
            FizzBuzz fizzBuzz = new FizzBuzz(Integer.parseInt(args[0]), Integer.parseInt(args[1]));
            System.out.println(fizzBuzz.getFizzBuzzString());
            fizzBuzz.getFizzBuzzReport().entrySet().forEach(e -> {
                System.out.println(e.getKey() + ": " + e.getValue());
            });
        }
    }

    public FizzBuzz(int start, int end) {
        if(start < 1 || end < start) {
            throw new IllegalArgumentException();
        }
        this.start = start;
        this.end = end;
        calculateFizzBuzzString();
    }

    public void calculateFizzBuzzString() {
        StringBuilder sb = new StringBuilder();
        for(int i = start; i <= end; i++) {
            sb.append(convertSingleNumber(i)+" ");
        }
        fizzBuzzString = sb.toString().trim();
    }

    public String getFizzBuzzString() {
        return fizzBuzzString;
    }

    public Map<String, Integer> getFizzBuzzReport() {
        return fizzBuzzReport;
    }

    private String convertSingleNumber(int n) {
        if(String.valueOf(n).contains("3")) {
            incrementReport(LUCKY);
            return LUCKY;
        }
        if (n % 15 == 0) {
            incrementReport(FIZZBUZZ);
            return FIZZBUZZ;
        }
        if (n % 3 == 0) {
            incrementReport(FIZZ);
            return FIZZ;
        }
        if (n % 5 == 0) {
            incrementReport(BUZZ);
            return BUZZ;
        }
        incrementReport(INTEGER);
        return String.valueOf(n);
    }

    private void incrementReport(String key) {
        fizzBuzzReport.put(key, fizzBuzzReport.get(key)+1);
    }
}


package io.quizzler;

import org.junit.Test;

import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;

public class FizzBuzzTest {

    private FizzBuzz fizzBuzz;

    @Test
    public void print1() throws Exception {
        fizzBuzz = new FizzBuzz(1, 1);
        assertThat(fizzBuzz.getFizzBuzzString(), equalTo("1"));
    }

    @Test
    public void print2() throws Exception {
        fizzBuzz = new FizzBuzz(2, 2);
        assertThat(fizzBuzz.getFizzBuzzString(), equalTo("2"));
    }

    @Test
    public void print3IsLucky() throws Exception {
        fizzBuzz = new FizzBuzz(3, 3);
        assertThat(fizzBuzz.getFizzBuzzString(), equalTo("lucky"));
    }

    @Test
    public void print5IsBuzz() throws Exception {
        fizzBuzz = new FizzBuzz(5, 5);
        assertThat(fizzBuzz.getFizzBuzzString(), equalTo("buzz"));
    }

    @Test
    public void print6IsFizz() throws Exception {
        fizzBuzz = new FizzBuzz(6, 6);
        assertThat(fizzBuzz.getFizzBuzzString(), equalTo("fizz"));
    }

    @Test
    public void print10IsBuzz() throws Exception {
        fizzBuzz = new FizzBuzz(10, 10);
        assertThat(fizzBuzz.getFizzBuzzString(), equalTo("buzz"));
    }

    @Test
    public void print15IsFizzBuzz() throws Exception {
        fizzBuzz = new FizzBuzz(15, 15);
        assertThat(fizzBuzz.getFizzBuzzString(), equalTo("fizzbuzz"));
    }

    @Test
    public void print30IsLucky() {
        fizzBuzz = new FizzBuzz(30, 30);
        assertThat(fizzBuzz.getFizzBuzzString(), equalTo("lucky"));
    }

    @Test
    public void print13IsLucky() {
        fizzBuzz = new FizzBuzz(13, 13);
        assertThat(fizzBuzz.getFizzBuzzString(), equalTo("lucky"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void negativeRangeThrowsException() {
        fizzBuzz = new FizzBuzz(2, 1);
    }

    @Test(expected = IllegalArgumentException.class)
    public void negativelRangeStartThrowsException() {
        fizzBuzz = new FizzBuzz(-2, 4);
    }

    @Test
    public void rangePrintsSpacedNumbers() {
        fizzBuzz = new FizzBuzz(1, 15);
        assertThat(fizzBuzz.getFizzBuzzString(), equalTo("1 2 lucky 4 buzz fizz 7 8 fizz buzz 11 fizz lucky 14 fizzbuzz"));
    }

    @Test
    public void luckyAddedToReport() {
        fizzBuzz = new FizzBuzz(3, 3);
        assertThat(fizzBuzz.getFizzBuzzReport().get("lucky"), equalTo(1));
    }

    @Test
    public void fizzAddedToReport() {
        fizzBuzz = new FizzBuzz(6, 6);
        assertThat(fizzBuzz.getFizzBuzzReport().get("fizz"), equalTo(1));
    }

    @Test
    public void buzzAddedToReport() {
        fizzBuzz = new FizzBuzz(5, 5);
        assertThat(fizzBuzz.getFizzBuzzReport().get("buzz"), equalTo(1));
    }

    @Test
    public void fizzBuzzAddedToReport() {
        fizzBuzz = new FizzBuzz(15, 15);
        assertThat(fizzBuzz.getFizzBuzzReport().get("fizzbuzz"), equalTo(1));
    }

    @Test
    public void integerAddedToReport() {
        fizzBuzz = new FizzBuzz(1, 1);
        assertThat(fizzBuzz.getFizzBuzzReport().get("integer"), equalTo(1));
    }

    @Test
    public void rangeAddedToReport() {
        fizzBuzz = new FizzBuzz(1, 15);
        assertThat(fizzBuzz.getFizzBuzzReport().get("lucky"), equalTo(2));
        assertThat(fizzBuzz.getFizzBuzzReport().get("fizz"), equalTo(3));
        assertThat(fizzBuzz.getFizzBuzzReport().get("buzz"), equalTo(2));
        assertThat(fizzBuzz.getFizzBuzzReport().get("fizzbuzz"), equalTo(1));
        assertThat(fizzBuzz.getFizzBuzzReport().get("integer"), equalTo(7));
    }
}