Jesse Duncan

One way to test the effectiveness of a test suit is to use mutation testing. Personally I have never used it.

Here is an article on how it can be done with PI Test: https://www.baeldung.com/java-mutation-testing-with-pitest

Welcome to the Ranch

I can't make it this time around, although I'd love to be there.

Are there any updates? So far it seems the leading days on the cow poll are tomorrow and Friday afternoon.

Question: Do you decouple your test classes from your code classes, and if so, what does the structure of your tests look like?

Context: I watched this Uncle Bob video on TDD and I found this particular Q&A interesting: https://youtu.be/58jGpV2Cg50?t=4984.

To paraphrase (badly): Q: Should every class have a matching unit test class? Uncle Bob's response: It is a bad idea to couple the tests to the structure of the classes, because this will make the tests fragile. He also gives a recommendation on how to avoid this.

You should believe it already then

I would absolutely love to watch!

It looks like I'm doing the same as Tim:
public class Part1 {    private static final int simulationDays = 256;    public static void main(String[] args) throws IOException {        String[] numbers = Files.readString(Path.of("data.txt"))                .split(",");        Map<Integer, Long> internalTimes = Arrays.stream(numbers)                .map(Integer::valueOf)                .collect(Collectors.groupingBy(x -> x, Collectors.counting()));        long[] fishInternalCount = new long[9];        Arrays.setAll(fishInternalCount, i -> internalTimes.get(i) != null ? internalTimes.get(i) : 0);        for (int i = 0; i < simulationDays; i++) {            simulateCycle(fishInternalCount);        }        long sum = Arrays.stream(fishInternalCount).sum();        System.out.println(sum);    }    private static void simulateCycle(long[] arr) {        long spawningFish = arr[0];        System.arraycopy(arr, 1, arr, 0, 8);        arr[6] += spawningFish;        arr[8] = spawningFish;    } }

I used the same BingoBoard class for both parts:public class BingoBoard {    private String[][] board;    private boolean hasWon = false;    public BingoBoard(String[][] boardValues) {        this.board = boardValues;    }    public boolean playValue(String s) {        for (int i = 0; i < board.length; ++i) {            for (int j = 0; j < board[0].length; ++j) {                if (board[i][j].equals(s)) {                    board[i][j] = "X";                    return checkForWin(j, i);                }            }        }        return false;    }    public long calculateScore() {        return Arrays.stream(board)                .flatMap(Arrays::stream)                .filter(x -> x != "X")                .mapToInt(Integer::parseInt)                .sum();    }    public boolean hasWon() {        return hasWon;    }    private boolean checkForWin(int lastPlayedX, int lastPlayedY) {        if(!hasWon) {            hasWon = checkRowForWin(lastPlayedY) || checkColForWin(lastPlayedX);        }        return hasWon;    }    private boolean checkRowForWin(int lastPlayedY) {        for (int i = 0; i < board.length; i++) {            if (board[lastPlayedY][i] != "X") return false;        }        return true;    }    private boolean checkColForWin(int lastPlayedX) {        for (int i = 0; i < board[0].length; i++) {            if (board[i][lastPlayedX] != "X") return false;        }        return true;    } }

The rest is basically the same for part 1 and 2, only the logic is switched to select the board with the least moves instead of the most:
public class Part1 {    private static final int boardSize = 5;    public static void main(String[] args) throws IOException {        BufferedReader buff = new BufferedReader(new FileReader("data.txt"));        String[] randomValues = readValues(buff);        int lowestTurnsToWin = randomValues.length;        BingoBoard lowestTurnsBoard = null;        int winningNumber = 0;        String[][] board;        while ((board = readNextBoard(buff)) != null) {            BingoBoard bingoBoard = new BingoBoard(board);            int turnsCount = 0;            for (var value : randomValues) {                bingoBoard.playValue(value);                ++turnsCount;                if (bingoBoard.hasWon() || turnsCount == lowestTurnsToWin) {                    if (turnsCount < lowestTurnsToWin) {                        lowestTurnsBoard = bingoBoard;                        lowestTurnsToWin = turnsCount;                        winningNumber = Integer.parseInt(value);                    }                    break;                }            }        }        System.out.println(lowestTurnsBoard.calculateScore() * winningNumber);    }    private static String[] readValues(BufferedReader buff) throws IOException {        String input = buff.readLine();        buff.readLine();        return input.split(",");    }    private static String[][] readNextBoard(BufferedReader buff) throws IOException {        String[][] boardValues = new String[boardSize][boardSize];        for (int i = 0; i < boardSize; i++) {            String line = buff.readLine();            if (line == null) return null;            boardValues[i] = line.trim().split("[ ]+");        }        buff.readLine();        return boardValues;    } }

Part 2:
public class Part2 {    public static void main(String[] args) throws IOException {        List<String> diagnosticReport = Files.lines(Path.of("data.txt"))                .collect(toList());        int oxygen = getValueByBitCriteria(diagnosticReport, true);        int co2 = getValueByBitCriteria(diagnosticReport, false);        System.out.println(oxygen * co2);    }    private static int getValueByBitCriteria(List<String> l, boolean selectMostCommon)   {        List<String> valuesList = new ArrayList<>(l);        for (int i = 0; i < valuesList.get(0).length(); ++i) {            int mostCommonValue = mostCommonValueAtPosition(valuesList, i);            int finalI = i;            valuesList.removeIf(x -> (x.charAt(finalI) == mostCommonValue) == selectMostCommon);            if (valuesList.size() == 1) {                break;            }        }        return Integer.parseInt(valuesList.get(0), 2);    }    private static int mostCommonValueAtPosition(List<String> l, int position) {        long zerosCount = l.stream()                .filter(x -> x.charAt(position) == '0')                .count();        return (zerosCount > (l.size() / 2)) ? '0' : '1';    } }

My solution to part one; not great but it worked.
public class Part1 {    public static void main(String[] args) throws IOException {        BufferedReader buff = new BufferedReader(new FileReader("data.txt"));        int[][] valuesCount = new int[12][2];        String line;        for(line = buff.readLine(); line != null; line = buff.readLine()) {            char[] digits = line.toCharArray();            for(int i = 0; i < digits.length; ++i) {                int value = Character.getNumericValue(digits[i]);                ++valuesCount[i][value];            }        }        String gammaBinaryString = Arrays.stream(valuesCount)                .map(x -> compare(x[1], x[0]))                .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)                .toString();        String epsilonBinaryString = Arrays.stream(valuesCount)                .map(x -> compare(x[0], x[1]))                .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)                .toString();        int gamma = Integer.parseInt(gammaBinaryString, 2);        int epsilon = Integer.parseInt(epsilonBinaryString, 2);        System.out.println(gamma * epsilon);    }    private static int compare(int a, int b) {        return a < b ? 0 : 1;    } }

My solution to part two (my original didn't use the new switch syntax, though. It is so much neater!):

public class Part2 {    public static void main(String[] args) throws IOException {        Submarine2 submarine = new Submarine2(0,0, 0);        BufferedReader buff = new BufferedReader(new FileReader("data.txt"));        String line;        while ((line = buff.readLine()) != null) {            executeInstruction(submarine, line);        }        System.out.println(submarine.getDistance() * submarine.getDepth());    }    private static void executeInstruction(Submarine2 submarine, String s) {        String[] split = s.split(" ");        String command = split[0];        int amount = Integer.parseInt(split[1]);        switch (command) {            case "forward" -> submarine.moveForward(amount);            case "down" -> submarine.lowerAim(amount);            case "up" -> submarine.raiseAim(amount);        }    } } class Submarine2 {    private int depth, distance, aim;    public Submarine2(int depth, int distance, int aim) {        this.depth = depth;        this.distance = distance;        this.aim = aim;    }    public void moveForward(int units) {        this.distance += units;        this.depth += (aim * units);    }    public void raiseAim(int units) {        this.aim -= units;    }    public void lowerAim(int units) {        this.aim += units;    }    public int getDepth() {        return depth;    }    public int getDistance() {        return distance;    } }

I don't know how to do fancy stuff, so I just did a simple Submarine class with methods to update its values in the specified way. I hardly had to change it for the second part. I work in Ruby for my day job, so I'm taking this as a opportunity to remember my Java.

I'm looking forward to it, though I don't expect to get far

Congrats to all of you