Chapter 8 Test-Driven Development
It’s Time to Clean Up Again
At this point we should take a critical look at our code once again. If we continue like this, the code will contain many code duplications, because the three while statements look very similar. We can, however, take advantage of these similarities by abstracting the code parts that are equal in all three while loops.
It’s refactoring time! The only code parts that are different in all three while loops are the Arabic number and its corresponding Roman numeral. The idea is to separate these variable parts from the stable rest of the loop.
In a first step, we introduce a struct that maps Arabic numbers to their Roman equivalents. In addition, we need an array (we will use std::array from the C++ Standard Library here) of that struct. Initially, we will only add one element to the array that allocates letter “C” to the number 100. See Listing 8-21.
Listing 8-21. Introducing an Array that Holds Mappings Between Arabic Numbers and Their Roman Equivalents
struct ArabicToRomanMapping { unsigned int arabicNumber; std::string romanNumeral;
};
const std::array arabicToRomanMappings { ArabicToRomanMapping { 100, "C" }
};
After these preparations, we modify the first while loop in the conversion function to verify if the basic idea will work. See Listing 8-22.
Listing 8-22. Replacing the Literals with Entries from the New Array
std::string convertArabicNumberToRomanNumeral(unsigned int arabicNumber) { std::string romanNumeral;
while (arabicNumber >= arabicToRomanMappings[0].arabicNumber) { romanNumeral += arabicToRomanMappings[0].romanNumeral; arabicNumber -= arabicToRomanMappings[0].arabicNumber;
}
359
Chapter 8 Test-Driven Development
while (arabicNumber >= 10) { romanNumeral += "X"; arabicNumber -= 10;
}
while (arabicNumber >= 1) { romanNumeral += "I"; arabicNumber--;
}
return romanNumeral;
}
All tests pass. So, we can continue to fill the array with the mappings “10-is-X” and “1-is-I”. See Listing 8-23.
Listing 8-23. Again a Pattern Emerges: The Obvious Code Redundancy Can Be Eliminated by a Loop
const std::array arabicToRomanMappings {
ArabicToRomanMapping { 100, |
"C" }, |
|||
ArabicToRomanMapping |
{ |
10, |
"X" |
}, |
ArabicToRomanMapping |
{ |
1, |
"I" |
} |
};
std::string convertArabicNumberToRomanNumeral(unsigned int arabicNumber) { std::string romanNumeral;
while (arabicNumber >= arabicToRomanMappings[0].arabicNumber) { romanNumeral += arabicToRomanMappings[0].romanNumeral; arabicNumber -= arabicToRomanMappings[0].arabicNumber;
}
while (arabicNumber >= arabicToRomanMappings[1].arabicNumber) { romanNumeral += arabicToRomanMappings[1].romanNumeral; arabicNumber -= arabicToRomanMappings[1].arabicNumber;
}
while (arabicNumber >= arabicToRomanMappings[2].arabicNumber) { romanNumeral += arabicToRomanMappings[2].romanNumeral; arabicNumber -= arabicToRomanMappings[2].arabicNumber;
}
return romanNumeral;
}
360
Chapter 8 Test-Driven Development
And again, all tests are passed. Excellent! But there is still a lot of duplicated code, so we have to continue our refactoring. The good news is that we can now see that the
only difference in all three while loops is just the array index. This means that we can get along with just one while loop if we iterate through the array. See Listing 8-24.
Listing 8-24. Through the Range Based for Loop, the DRY Principle Is No Longer Violated
std::string convertArabicNumberToRomanNumeral(unsigned int arabicNumber) { std::string romanNumeral;
for (const auto& mapping : arabicToRomanMappings) { while (arabicNumber >= mapping.arabicNumber) {
romanNumeral += mapping.romanNumeral; arabicNumber -= mapping.arabicNumber;
}
}
return romanNumeral;
}
All tests pass. Wow, that’s great! Just take a look at this compact and well-readable piece of code. More mappings of Arabic numbers to their Roman equivalents can now be supported by adding them to the array. We will try this for 1,000, which must be converted into an M. Here is our next test:
checkIf(1000).isConvertedToRomanNumeral("M");
The test failed as expected. By adding another element for “1000-is-M” to the array, the new test, and of course all previously tests, should pass.
const std::array arabicToRomanMappings {
ArabicToRomanMapping { 1000, |
"M" }, |
|||
ArabicToRomanMapping { |
100, |
"C" }, |
||
ArabicToRomanMapping |
{ |
10, |
"X" |
}, |
ArabicToRomanMapping |
{ |
1, |
"I" |
} |
};
A successful test run after this small change confirms our assumption: it works! That was quite easy. We can add more tests now, for example, for 2,000 and 3,000. And even 3,333 should work immediately:
361
