AI Code Generation and the Tennis Kata

For an upcoming CSD workshop, I decided to expand the Tennis Refactoring Kata [1] to include scoring for sets. I thought it would be interesting to see how well GenAI could generating the code for the tests. (This was run through IntelliJ Junie which relies on Claude 3.7 Sonnet).

I gave Junie the following prompt:

It did a credible job of generating the test cases themselves. They’re simple, clear, and they test what I expected. There’s not enough test cases, but that wasn’t surprising, it covered only the winning and tiebreak cases. It also wrote the implementation code. That isn’t what I wanted, but I’ve yet to find a way to avoid that.

Test code for games like this is very repetitive. Since the similar setup is needed for each Set, Junie created a function to handle creating all of the sample TennisSets. This where it went off the rails. Junie wrote a function buildSetSequence() to generate a set’s worth of games.

function buildSetSequence(targetP1: number, targetP2: number): TennisGame[] {  
  // Builds a sequence that ends exactly at target score with player1 the winner (targetP1 > targetP2)  
  // and ensures the set is not prematurely won before the last game.  const seq: TennisGame[] = [];  
  if (targetP1 === 6 && targetP2 >= 0 && targetP2 <= 4) {  
    // Make it b-b, then to 5-b, then last to 6-b  
    for (let i = 0; i < targetP2; i++) { seq.push(P1, P2); }  
    for (let i = 0; i < 5 - targetP2; i++) { seq.push(P1); }  
    seq.push(P1);  
    return seq;  
  }  
  if (targetP2 === 6 && targetP1 >= 0 && targetP1 <= 4) {  
    for (let i = 0; i < targetP1; i++) { seq.push(P2, P1); }  
    for (let i = 0; i < 5 - targetP1; i++) { seq.push(P2); }  
    seq.push(P2);  
    return seq;  
  }  
  if (targetP1 === 7 && targetP2 === 5) {  
    for (let i = 0; i < 5; i++) { seq.push(P1, P2); } // 5-5  
    seq.push(P1, P1); // 7-5  
    return seq;  
  }  
  if (targetP2 === 7 && targetP1 === 5) {  
    for (let i = 0; i < 5; i++) { seq.push(P2, P1); } // 5-5  
    seq.push(P2, P2); // 7-5  
    return seq;  
  }  
  if (targetP1 === 7 && targetP2 === 6) {  
    for (let i = 0; i < 6; i++) { seq.push(P1, P2); } // 6-6  
    seq.push(P1); // 7-6  
    return seq;  
  }  
  if (targetP2 === 7 && targetP1 === 6) {  
    for (let i = 0; i < 6; i++) { seq.push(P2, P1); } // 6-6  
    seq.push(P2); // 7-6  
    return seq;  
  }  
  throw new Error(`Unsupported target score ${targetP1}-${targetP2}`);  
}

It’s silly the number of ways this code is strange:

• Exceptional conditions in test setup code - that’s wrong.
• P1 and P2 are constants in created, that copy the provided constants playerOneWin and playerTwoWin.
• Special cases handling for each of the possible outcomes.
• Nearly 40 lines for setup code.
• …it doesn’t even handle the cases like 1-0, 0-5 etc. Instead, it just throws an error.

(An aside to prove 6-5 isn’t a final score, it couldn’t use its own set generator and hand-rolled the code for that specific case.)

I don’t claim mine is perfect but it is smaller and more readable:

function buildSetSequence(targetP1: number, targetP2: number): TennisGame[] {  
  // Builds a sequence that ends exactly at target score with player1 the winner (targetP1 > targetP2)  
  // and ensures the set is not prematurely won before the last game.  
  const gamesPlayed: TennisGame[] = new Array<TennisGame>();  
  const mostGames = Math.max(targetP1, targetP2);  
  for (let gameCounter = 0; gameCounter < mostGames; gameCounter++) {  
      if (gameCounter < targetP1) {  
          gamesPlayed.push(playerOneWin);  
      }  
      if (gameCounter < targetP2) {  
          gamesPlayed.push(playerTwoWin);  
      }  
  }  
  return gamesPlayed;  
}

At least I didn’t rewrite Junie’s comments. FWIW, I also tried the same prompt with qwen/qwen3-coder-30b[2] on my local machine and I got test cases that were more idiomatically correct, but it made fatal tennis mistakes (e.g. playerOne gets 6 games, before playerTwo has any so the game is over at 6-0 even thought the test case promises 6-2).

It was very useful to outline the basics of the test cases, and it did provide an outline of the structure the problem requires. However, it continues to show that the current crop of GenAI tools can’t generate code that I would want to rely on.