Finally some better naming but still with fragile tests

After sleeping on it I've found better names for the examples I've recently posted about (see preious post).

The obstacle was seeing it as an action on a form. Thinking instead on information that needs to be introduced and sent made the names flow much better.

This is the resulting class:

	<?php
	class IntroducedInformation
	{
	private $emailSender;
	private $redirection;
	private $formEmailComposer;
	private $form;
	function __construct(
	Form $form,
	EmailSender $emailSender,
	Redirection $redirection,
	FormEmailComposer $formEmailComposer
	) {
	$this->emailSender = $emailSender;
	$this->redirection = $redirection;
	$this->formEmailComposer = $formEmailComposer;
	$this->form = $form;
	}
	public function sendByEmailAndRedirect()
	{
	if ($this->form->isNotFilled()) {
	$this->redirection->backToInitialPage();
	return;
	}
	$email = $this->createEmail();
	$sendingSucceeded = $this->send($email);
	$this->redirect($sendingSucceeded);
	}
	private function redirect($sendingSucceeded)
	{
	if ($sendingSucceeded) {
	$this->redirection->toSuccessPage();
	} else {
	$this->redirection->toFailPage();
	}
	}
	private function createEmail()
	{
	return
	$this->formEmailComposer
	->composeEmailFrom($this->form);
	}
	private function send(Email $email)
	{
	return $this->emailSender->send($email);
	}
	}

view raw IntroducedInformation.php hosted with ❤ by GitHub

and these are its tests:

	<?php
	class IntroducedInformationTest extends PHPUnit_Framework_TestCase
	{
	private $form;
	private $redirection;
	private $emailSender;
	private $introducedInformation;
	private $formEmailComposer;
	private $email;
	function setUp()
	{
	$this->redirection = Phake::mock('Redirection');
	$this->email = new Email("from", "to", "subject", "message");
	$this->form = Phake::mock('Form');
	$this->emailSender = Phake::mock('EmailSender');
	$this->formEmailComposer = Phake::mock('FormEmailComposer');
	$this->introducedInformation =
	new IntroducedInformation(
	$this->form,
	$this->emailSender,
	$this->redirection,
	$this->formEmailComposer
	);
	}
	function testRedirectionBackToFormPage()
	{
	$this->whenFormNotFilled();
	$this->introducedInformation->sendByEmailAndRedirect();
	Phake::verify($this->redirection)
	->backToInitialPage();
	}
	function testEmailComposition()
	{
	$this->whenFormFilledWithWhateverFields();
	$this->andEmailGetsComposed();
	$this->introducedInformation->sendByEmailAndRedirect();
	Phake::verify($this->formEmailComposer)
	->composeEmailFrom($this->form);
	}
	function testEmailSending()
	{
	$this->whenFormFilledWithWhateverFields();
	$this->andEmailGetsComposed();
	$this->introducedInformation->sendByEmailAndRedirect();
	Phake::verify($this->emailSender)
	->send($this->email);
	}
	function testRedirectionToSuccesPage()
	{
	$this->whenFormFilledWithWhateverFields();
	$this->andEmailGetsComposed();
	$this->andIsSentSuccessfully();
	$this->introducedInformation->sendByEmailAndRedirect();
	Phake::verify($this->redirection)->toSuccessPage();
	}
	function testRedirectionToFailPage()
	{
	$this->whenFormFilledWithWhateverFields();
	$this->andEmailGetsComposed();
	$this->butIsNotSentSuccessfully();
	$this->introducedInformation->sendByEmailAndRedirect();
	Phake::verify($this->redirection)->toFailPage();
	}
	private function whenFormFilledWithWhateverFields()
	{
	Phake::when($this->form)
	->isNotFilled()
	->thenReturn(false);
	}
	private function whenFormNotFilled()
	{
	Phake::when($this->form)
	->isNotFilled()
	->thenReturn(true);
	}
	private function andIsSentSuccessfully()
	{
	Phake::when($this->emailSender)
	->send($this->email)
	->thenReturn(true);
	}
	private function butIsNotSentSuccessfully()
	{
	Phake::when($this->emailSender)
	->send($this->email)
	->thenReturn(false);
	}
	private function andEmailGetsComposed()
	{
	Phake::when($this->formEmailComposer)
	->composeEmailFrom($this->form)
	->thenReturn($this->email);
	}
	}

view raw IntroducedInformationTest.php hosted with ❤ by GitHub

Finally, this is how it's used now:

	<?php
	$info =
	IntroducedInfoBuilder::aNewIntroducedInformation()
	->onPage("empresas")
	->toBeSentTo("xxx@ppp.es")
	->build();
	$info->sendByEmailAndRedirect();

view raw use3.php hosted with ❤ by GitHub

I'm much happier with the naming now.

The tests are still fragile, but by using helpers in the tests the amount of places where the mocks are used gets reduced.

Refactored my clumsy tests

I've reworked the class and the tests I showed in my previous post.

This is the refactored class:

	<?php
	class SendingAndRedirectionAction
	{
	private $emailSender;
	private $redirection;
	private $formEmailComposer;
	function __construct(
	EmailSender $emailSender,
	Redirection $redirection,
	FormEmailComposer $formEmailComposer
	) {
	$this->emailSender = $emailSender;
	$this->redirection = $redirection;
	$this->formEmailComposer = $formEmailComposer;
	}
	public function applyOn(Form $form)
	{
	if ($form->isNotFilled()) {
	$this->redirection->backToInitialPage();
	return;
	}
	$email = $this->createEmailFrom($form);
	$sendingSucceeded = $this->send($email);
	$this->redirect($sendingSucceeded);
	}
	private function redirect($sendingSucceeded)
	{
	if ($sendingSucceeded) {
	$this->redirection->toSuccessPage();
	} else {
	$this->redirection->toFailPage();
	}
	}
	private function createEmailFrom(Form $form)
	{
	return $this->formEmailComposer->composeEmailFrom($form);
	}
	private function send(Email $email)
	{
	return $this->emailSender->send($email);
	}
	}

view raw SendingAndRedirectionAction.php hosted with ❤ by GitHub

The responsibility to compose an email from the form fields was delegated to the FormEmailComposer collaborator whereas the responsibility of sending the email was delegated to the EmailSender collaborator.

The Redirection collaborator is still in charge of the redirecting responsibility.

Now the Form and the Email class are just value objects.

These are the new tests:

	<?php
	class SendingAndRedirectionActionTest extends PHPUnit_Framework_TestCase
	{
	private $form;
	private $redirection;
	private $emailSender;
	private $sendingAndRedirectionAction;
	private $WHATEVER_FIELDS;
	private $formEmailComposer;
	private $email;
	function setUp()
	{
	$this->WHATEVER_FIELDS =
	array("fieldName" => "fieldContent");
	$this->redirection = Phake::mock('Redirection');
	$this->email = new Email(
	"from", "to", "subject", "message"
	);
	$this->form = Phake::mock('Form');
	$this->emailSender = Phake::mock('EmailSender');
	$this->formEmailComposer = Phake::mock('FormEmailComposer');
	$this->sendingAndRedirectionAction =
	new SendingAndRedirectionAction(
	$this->emailSender,
	$this->redirection,
	$this->formEmailComposer
	);
	}
	function testRedirectionBackToFormPage()
	{
	$this->whenFormNotFilled();
	$this->sendingAndRedirectionAction->applyOn($this->form);
	Phake::verify($this->redirection)
	->backToInitialPage();
	}
	function testEmailComposition()
	{
	$this->whenFormFilledWithWhateverFields();
	$this->andEmailGetsComposed();
	$this->sendingAndRedirectionAction->applyOn($this->form);
	Phake::verify($this->formEmailComposer)
	->composeEmailFrom($this->form);
	}
	function testEmailSending()
	{
	$this->whenFormFilledWithWhateverFields();
	$this->andEmailGetsComposed();
	$this->sendingAndRedirectionAction->applyOn($this->form);
	Phake::verify($this->emailSender)
	->send($this->email);
	}
	function testRedirectionToSuccesPage()
	{
	$this->whenFormFilledWithWhateverFields();
	$this->andEmailGetsComposed();
	$this->andIsSentSuccessfully();
	$this->sendingAndRedirectionAction->applyOn($this->form);
	Phake::verify($this->redirection)->toSuccessPage();
	}
	function testRedirectionToFailPage()
	{
	$this->whenFormFilledWithWhateverFields();
	$this->andEmailGetsComposed();
	$this->butIsNotSentSuccessfully();
	$this->sendingAndRedirectionAction->applyOn($this->form);
	Phake::verify($this->redirection)->toFailPage();
	}
	private function whenFormFilledWithWhateverFields()
	{
	$this->form = new Form($this->WHATEVER_FIELDS);
	}
	private function whenFormNotFilled()
	{
	$this->form = new Form(array());
	}
	private function andIsSentSuccessfully()
	{
	Phake::when($this->emailSender)
	->send($this->email)
	->thenReturn(true);
	}
	private function butIsNotSentSuccessfully()
	{
	Phake::when($this->emailSender)
	->send($this->email)
	->thenReturn(false);
	}
	private function andEmailGetsComposed()
	{
	Phake::when($this->formEmailComposer)
	->composeEmailFrom($this->form)
	->thenReturn($this->email);
	}
	}

view raw SendingAndRedirectionActionTest.php hosted with ❤ by GitHub

And this is how I'm using the SendingAndRedirectionAction class:

	<?php
	$action =
	Action::aSendByEmailAndRedirection()
	->ofFormIn("academias")
	->to("xxx@ppp.es")
	->build();
	$action->applyOn(new Form($_POST));

view raw use2.php hosted with ❤ by GitHub

I'm a bit happier with the naming and I also reduced the number of classes.
However I'm still concerned about the tests fragility.

Five years ago in Garajeando...

This is a post from five years ago that I read today:

Primeros pasos en Java
Hice mi primer programa orientado a objetos!
Es un programa muy tonto para probar, modificando uno que sale en el libro Head first Java.
Tengo tres clases: la que inicia el juego, el juego en sí y el jugador.
En la clase que inicia el juego se crea un objeto Juego y se le pide que inicie la partida. Durante la partida el objeto Juego piensa un número, crea un número de jugadores y les pide que adivinen el número. El diálogo entre los jugadores sale por pantalla.
Es una chorrada pero me lo pasé muy bien. Lo guapo es que si modificas algo en el programa. Sólo tienes que volver a compilar el código de la clase modificada. Todo lo demás sigue funcionando igual.

I have tender feelings reading this again.
I'm also happy that I'm still as passionate about programming as I was then.

First clumsy tests using Phake test doubles framework

Two weeks ago I started learning PHP for my new job at Runroom.

It's my first job as a web developer so I'm still a bit "lost".

Today I tried to write unit test for this class in order to learn how to use Phake test doubles framework:

	<?php
	class SendingFormByEmailAndRedirecting
	{
	private $form;
	private $email;
	private $formRedirection;
	function __construct(
	FormEmail $email,
	Form $form,
	FormRedirection $formRedirection
	) {
	$this->email = $email;
	$this->form = $form;
	$this->formRedirection = $formRedirection;
	}
	public function execute()
	{
	if ($this->form->isNotFilled()) {
	$this->formRedirection->backToFormPage();
	return;
	}
	$sendingSucceeded = $this->email->send(
	$this->form->fields()
	);
	$this->redirect($sendingSucceeded);
	}
	private function redirect($sendingSucceeded)
	{
	if ($sendingSucceeded) {
	$this->formRedirection->toSuccessPage();
	} else {
	$this->formRedirection->toFailPage();
	}
	}
	}

view raw SendingFormByEmailAndRedirecting.php hosted with ❤ by GitHub

These were the resulting tests:

	<?php
	class SendingFormByEmailAndRedirectingTest extends PHPUnit_Framework_TestCase
	{
	private $form;
	private $formRedirection;
	private $email;
	private $sendAndRedirectAction;
	private $WHATEVER_FIELDS;
	function setUp()
	{
	$this->WHATEVER_FIELDS =
	array("fieldName" => "fieldContent");
	$this->form = Phake::mock('Form');
	$this->formRedirection = Phake::mock('FormRedirection');
	$this->email = Phake::mock('FormEmail');
	$this->sendAndRedirectAction =
	new SendingFormByEmailAndRedirecting(
	$this->email,
	$this->form,
	$this->formRedirection
	);
	}
	function testRedirectionBackToFormPage()
	{
	$this->whenFormNotFilled();
	$this->sendAndRedirectAction->execute();
	Phake::verify($this->formRedirection)
	->backToFormPage();
	}
	function testEmailSending()
	{
	$this->whenFormFilledWithWhateverFields();
	$this->sendAndRedirectAction->execute();
	Phake::verify($this->email)
	->send($this->WHATEVER_FIELDS);
	}
	function testRedirectionToSuccesPage()
	{
	$this->whenFormFilledWithWhateverFields();
	$this->andEmailSentSuccessfully();
	$this->sendAndRedirectAction->execute();
	Phake::verify($this->formRedirection)->toSuccessPage();
	}
	function testRedirectionToFailPage()
	{
	$this->whenFormFilledWithWhateverFields();
	$this->andEmailNotSentSuccessfully();
	$this->sendAndRedirectAction->execute();
	Phake::verify($this->formRedirection)->toFailPage();
	}
	private function whenFormFilledWithWhateverFields() {
	Phake::when($this->form)
	->isNotFilled()
	->thenReturn(false);
	Phake::when($this->form)
	->fields()
	->thenReturn($this->WHATEVER_FIELDS);
	}
	private function whenFormNotFilled()
	{
	Phake::when($this->form)
	->isNotFilled()
	->thenReturn(true);
	}
	private function andEmailSentSuccessfully()
	{
	Phake::when($this->email)
	->send($this->WHATEVER_FIELDS)
	->thenReturn(true);
	}
	private function andEmailNotSentSuccessfully()
	{
	Phake::when($this->email)
	->send($this->WHATEVER_FIELDS)
	->thenReturn(false);
	}
	}

view raw SendingFormByEmailAndRedirectingTest.php hosted with ❤ by GitHub

Although I like the readability of the tests, I'm not very happy with them because I think they will be too fragile. At the same time I'm not sure how else I could test the behavior of SendingFormByEmailAndRedirecting class...

To give you a bit more of context this is how I'm using it from my code:

	<?php
	$action =
	Action::sendingByEmail()
	->formIn("empresas")
	->to("xxx@ppp.es")
	->build();
	$action->execute();

view raw use.php hosted with ❤ by GitHub

Interesting Talk: "The Care and Feeding of C++'s Dragons"

I've just watched this interesting talk by Chandler Carruth about the amazing LLVM clang tools for C++:

• The Care and Feeding of C++'s Dragons

Interesting Talk: "Testing and Refactoring Legacy Code"

I've just watched this great live-coding talk by Sandro Mancuso:

• Testing and Refactoring Legacy Code

Using C++11 to split strings without using the boost library

Recently I did the StringCalculator kata in C++.

In order to be able to split a string using several alternative delimiters of one or more characters I used the following function:

	#include <boost/algorithm/string.hpp>
	#include <boost/algorithm/string/join.hpp>
	#include <boost/algorithm/string/regex.hpp>
	#include <boost/regex.hpp>
	std::vector<std::string> StringUtils::split(
	const std::string & str,
	const std::vector<std::string> & delimiters) {
	std::vector<std::string> tokens;
	boost::algorithm::split_regex(
	tokens,
	str,
	boost::regex(
	boost::join(escapeDelimiters(delimiters), "|"))
	);
	return tokens;
	}

view raw splitWithBoost.cpp hosted with ❤ by GitHub

which is using several functions from the boost library: boost::algorithm::split_regex, boost::regex and boost::join.

Yesterday I managed to use some C++11 features to get the same functionality without using the boost library. This is the resulting code which uses C++11 regex and lambdas:

	#include <regex>
	#include <sstream>
	std::vector<std::string> StringUtils::split(
	const std::string & str,
	const std::vector<std::string> & delimiters) {
	std::regex rgx(join(escapeStrings(delimiters), "|"));
	std::sregex_token_iterator
	first{begin(str), end(str), rgx, -1},
	last;
	return{first, last};
	}
	std::vector<std::string> StringUtils::split(const std::string & str,
	const std::string & delimiter) {
	std::vector<std::string> delimiters = {delimiter};
	return split(str, delimiters);
	}
	std::string StringUtils::join(
	const std::vector<std::string> & tokens,
	const std::string & delimiter) {
	std::stringstream stream;
	stream << tokens.front();
	std::for_each(
	begin(tokens) + 1,
	end(tokens),
	[&](const std::string &elem) {
	stream << delimiter << elem;}
	);
	return stream.str();
	}

view raw splitWithoutBoost.cpp hosted with ❤ by GitHub

These are the StringUtils tests where you can see how the split and join functions work:

	#include <gmock/gmock.h>
	#include <vector>
	#include "../code/StringUtils.h"
	using namespace ::testing;
	TEST(StringUtils, CanEscapeOneString) {
	EXPECT_THAT(StringUtils::escapeString("*"), Eq("\\*"));
	EXPECT_THAT(StringUtils::escapeString("\\"), Eq("\\\\"));
	EXPECT_THAT(StringUtils::escapeString("||"), Eq("\\|\\|"));
	EXPECT_THAT(StringUtils::escapeString(","), Eq(","));
	}
	TEST(StringUtils, CanEscapeSeveralStringsEvenThoseUsedInRegularExpressions) {
	EXPECT_THAT(StringUtils::escapeStrings({",", "*", "||", ";", "\\"}),
	ElementsAre(",", "\\*", "\\|\\|", ";", "\\\\"));
	}
	TEST(StringUtils, CanSplitUsingMultipleTokens) {
	std::vector<std::string> delimiters = {",", "*", "??"};
	EXPECT_THAT(StringUtils::split("1*2??3,4", delimiters),
	ElementsAre("1", "2", "3", "4"));
	}
	TEST(StringUtils, CanTellIfAGivenStringRepresentsAnInteger) {
	EXPECT_TRUE(StringUtils::isAnInteger("1"));
	EXPECT_FALSE(StringUtils::isAnInteger("15 7 8"));
	EXPECT_FALSE(StringUtils::isAnInteger("1.5"));
	EXPECT_FALSE(StringUtils::isAnInteger("!15"));
	}
	TEST(StringUtils, CanJoinAVectorOfStrings) {
	EXPECT_THAT(StringUtils::join({"1", "2", "3"}, "|"), Eq("1|2|3"));
	EXPECT_THAT(StringUtils::join({"1", "2", "3"}, " "), Eq("1 2 3"));
	EXPECT_THAT(StringUtils::join({"1", "2", "3"}, ", "), Eq("1, 2, 3"));
	EXPECT_THAT(StringUtils::join({"1", "2", "3"}, ""), Eq("123"));
	}
	TEST(StringUtils, CanSplitStringsAndJoinThemAgain) {
	std::string str = "1|2|3";
	std::string delimiter = "|";
	EXPECT_THAT(StringUtils::join(StringUtils::split(str, delimiter), delimiter),
	Eq(str));
	}

view raw StringUtilsTests.cpp hosted with ❤ by GitHub

You can find all the code in this repository.

Interesting KataCast: "StringCalculator TDD Kata 2 - Interactions"

I've just watched a great KataCast where Rickard Nilsson test-drives the second part of the String Calculator Kata introducing interaction based testing with mocks:

• String Calculator TDD Kata 2 - Interactions

Rickard Nilsson comments his solution to the kata in this blog post.

Some resources about scientific software quality

Some time ago I collected these links about scientific software quality and testing for a Barcelona Supercomputing Center winter retreat.

I hope they could be useful for people interested in introducing better practices in scientific software.

• Software exoskeletons
• Computational science: ...Error …why scientific programming does not compute.
• The Challenge of Testing Scientific Software
• How Do Scientists Develop and Use Scientific Software?
• Understanding the High-Performance-Computing Community: A Software Engineer’s Perspective
• Assessing the Quality of Scientific Software
• Where’s the Real Bottleneck in Scientific Computing?
• Software Carpentry

Beware, it might be very hard or even useless to directly apply some of industry's good practices in this field.

I think it would be necessary to adapt and refine many of them to cater for the special needs of the scientific software community.

Some resources about Object-Oriented Design, Testability and Legacy Code

These are some resources about Object Oriented Design, testability and legacy code that I collected for the developers at Tecnatom.

I hope that you'll find them useful.

OOP

• Embedded Object Oriented Design
• DIP in the wild
• Google The Clean Code talks

Testing and Testability

• Writing testable code
• Design for Testability Talk by Miško Hevery
• The Magic Tricks of Testing Talk by Sandi Metz
• Integration tests are scams Talk by J. B. Rainsberger (blog)

Ports and Adapters

• Ports and Adapters (hexagonal architecture)

Legacy Code

• An Agile Approach to a Legacy System
• Strangler Application Pattern
• Seventeen Secrets of the Great Legacy Makeover Masters Talk by Brian Foote

Some resources about the physical structure of C++ projects

These are several links about the physical structure of C++ projects that I collected for the C++ developers at Tecnatom.

I hope that you'll find them useful.

• Physical Structure and C++ – Part 1: A First Look
• Physical Structure and C++ – Part 2: Build Times
• C++ Header File Include Patterns
• When to use forward declaration?

Some resources about continuous integration for C++ projects on Windows

These are several links about continuous integration for C++ projects on Windows that I collected for the C++ developers at Tecnatom.

I hope that you'll find them useful.

C++ Continuous Integration (CI)

• Jenkins for C++
• BuildBot
• C++ Jenkins QA Stack/Tools
• Buildbot vs Jenkins for C++ CI

C++ Tools that might be interesting to use from Jenkins or on their own

• Cppcheck (static code analysis)
• DrMemory (memory leak detector)
• Is there a good Valgrind substitute for Windows?
• C++ open source plugin for Sonar
• Visual Leak Detector for VS 2008/2010/2012
• Google’s cppclean

Kata: Small step by step TDD kata using C++ and GoogleMock

I've just made a small TDD kata in C++ using GoogleMock.

I committed the existing code after each green and after each refactoring step.
Check the step by step process in GitHub.

Extracting reusable C++ templated functions from StringCalculator code

I've recently coded a solution to the StringCalculator kata in C++ using GoogleMock, (you can check its code in GitHub).

In one of the refactoring steps, I extracted the code that filters out not numeric tokens to a separated helper method: filterOutNotNumericTokens:

	std::vector<std::string> NumbersExtractor::filterOutNotNumericTokens(const std::vector<std::string> & tokens) const {
	std::vector<std::string> numericTokens;
	for (unsigned int i = 0; i < tokens.size(); ++i) {
	std::string token = tokens[i];
	if (isNotAnInteger(token)) {
	continue;
	}
	numericTokens.push_back(tokens[i]);
	return numericTokens;
	}
	bool NumbersExtractor::isNotAnInteger(const std::string & str) const {
	return ! StringUtils::isAnInteger(str);
	}

view raw filterOutNotNumericExample.cpp hosted with ❤ by GitHub

Once all the kata requirements were satisfied, I refactored this method a little bit more using C++11 copy_if algorithm:

	std::vector<std::string> NumbersExtractor::filterOutNotNumericTokens(const std::vector<std::string> & tokens) const {
	std::vector<std::string> numericTokens;
	std::copy_if(tokens.begin(), tokens.end(),
	std::back_inserter(numericTokens),
	StringUtils::isAnInteger);
	return numericTokens;
	}

view raw filterOutNotNumericRefactored.cpp hosted with ❤ by GitHub

We can use the same technique to refactor the method that ignores numbers greater than 1000, ignoreTooBig, from this:

	std::vector<int> NumbersFilter::ignoreTooBig(const std::vector<int> & numbers) const {
	std::vector<int> filteredNumbers;
	for (unsigned int i = 0; i < numbers.size(); ++i) {
	if (notTooBig(numbers[i])) {
	filteredNumbers.push_back(numbers[i]);
	}
	}
	return filteredNumbers;
	}
	bool NumbersFilter::notTooBig(int number) const {
	return !(number > 1000);
	}

view raw ignoreTooBig.cpp hosted with ❤ by GitHub

to this:
 

	bool notTooBig(int number);
	std::vector<int> NumbersFilter::ignoreTooBig(const std::vector<int> & numbers) const {
	std::vector<int> filteredNumbers;
	std::copy_if(numbers.begin(), numbers.end(),
	std::back_inserter(filteredNumbers),
	notTooBig);
	return filteredNumbers;
	}
	bool notTooBig(int number) {
	return !(number > 1000);
	}

view raw ignoreTooBigRefactoredWithoutLambd.cpp hosted with ❤ by GitHub

Notice that we had to make notTooBig a free function in order to pass it to copy_if.

To keep it as a member function we'd need to write this less readable version:

	std::vector<int> NumbersFilter::ignoreTooBig(const std::vector<int> & numbers) const {
	std::vector<int> filteredNumbers;
	std::copy_if(numbers.begin(), numbers.end(),
	std::back_inserter(filteredNumbers),
	std::bind1st(std::mem_fun(&NumbersFilter::notTooBig), this));
	return filteredNumbers;
	}
	bool NumbersFilter::notTooBig(int number) const {
	return !(number > 1000);
	}

view raw ignoreTooBigRefactoredKeepingMemberFunction.cpp hosted with ❤ by GitHub

which uses the bind1st and mem_fun functions from functional.

In this case, I think it's probably better to use a lambda:

	std::vector<int> NumbersFilter::ignoreTooBig(const std::vector<int> & numbers) const {
	std::vector<int> filteredNumbers;
	std::copy_if(numbers.begin(), numbers.end(),
	std::back_inserter(filteredNumbers),
	[](const int number) { return !(number > 1000); });
	return filteredNumbers;
	}

view raw ignoreTooBigRefactoredWithLambda.cpp hosted with ❤ by GitHub

In the two previous examples we eliminated duplication using the copy_if algorithm.

We can improve the readability of this code introducing a helper templated functions, filter:

	namespace VectorUtils {
	template<typename T, typename Function>
	std::vector<T> filter(const std::vector<T> & original, Function pred) {
	std::vector<T> filtered;
	std::copy_if(original.begin(), original.end(),
	std::back_inserter(filtered),
	pred);
	return filtered;
	}
	template<typename T2, typename T1, typename Function>
	std::vector<T2> map(const std::vector<T1> & original, Function f) {
	std::vector<T2> mapped;
	std::transform(original.begin(), original.end(),
	std::back_inserter(mapped),
	f);
	return mapped;
	}
	}

view raw VectorUtils.hpp hosted with ❤ by GitHub

Notice that filter works only for vector, copy_if is more general. But this leads to a bit more readable code for filterOutNotNumericTokens and ignoreTooBig:
 

	std::vector<std::string> NumbersExtractor::filterOutNotNumericTokens(
	const std::vector<std::string> & tokens) const {
	return VectorUtils::filter(tokens, StringUtils::isAnInteger);
	}

view raw filterOutNotNumericTokensUsingFilter.cpp hosted with ❤ by GitHub

	std::vector<int> NumbersFilter::ignoreTooBig(const std::vector<int> & numbers) const {
	return VectorUtils::filter(numbers,
	[](int number) { return !(number > 1000); });
	}

view raw ignoreTooBigUsingFilter.cpp hosted with ❤ by GitHub

We can also use filter to refactor the getNegatives method:
 

	std::vector<int> NumbersValidator::getNegatives(const std::vector<int> & numbers) const {
	return VectorUtils::filter(numbers, [](int number) { return number < 0; });
	}

view raw getNegativesInNumbersValidator.cpp hosted with ❤ by GitHub

The same procedure can be applied to have a map templated function that uses the transform algorithm which can then be used to refactor the convertToInts method:

	std::vector<int> NumbersExtractor::convertToInts(
	const std::vector<std::string> & numbersStrings) const {
	return VectorUtils::map<int, std::string>(numbersStrings, StringUtils::convertToInt);
	}

view raw convertToIntsUsingMap.cpp hosted with ❤ by GitHub

This map and filter functions that we'd refactored out from the StringCalculator code are pure functions that are highly reusable and will help us to avoid duplication in another projects.

Kata: Small step by step refactoring kata in C++

I've just made a small refactoring kata in C++.

Some of the tests in the initial code* were very slow because their code had to sleep some time in order for them to pass. Some other tests relied on having certain environment variable set to a given value.

The behavior that checked the environment variable and the one related to time were embedded in the Course class.

Through refactoring this behavior was isolated and extracted so that it could be injected into Course and then two fake classes were created to isolate Course in tests

Check the step by step refactoring in GitHub*.

Thanks to Leo Antoli for passing me the initial code in C#.

---------------------------

* This C++ code example works only for Windows.

Kata: StringCalculator in C++ step by step using GoogleMock and Boost.Regex

I've just coded the StringCalculator kata in C++ using GoogleMock and Boost.Regex.

I commited it step by step. Check the resulting code in Github.

--------------------------

Update:
I did some refactorings to my solution in order to a) reduce some duplication and b) avoid having to use Boost.Regex.
They're explained, respectively, in the two following posts:

• Extracting reusable C++ templated functions from StringCalculator code
• Using C++11 to split strings without using the boost library