From 2934468febeae3bcf606648a18b9c0984a4ddc0f Mon Sep 17 00:00:00 2001 From: Fredy Date: Fri, 4 Nov 2016 16:25:37 -0200 Subject: [PATCH 01/10] Add TEST_INCLUDES var in compilation OBJ_DIR recipe. This allows to run call target "make test" --- Makefile | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/Makefile b/Makefile index 7360639..354f754 100644 --- a/Makefile +++ b/Makefile @@ -29,7 +29,7 @@ $(APP): setup $(OBJS) $(CXX) -o $(APP) $(OBJS) $(LDFLAGS) $(OBJ_DIR)/%.o: $(SRC_DIR)/%.cpp - $(CXX) -c $< $(CXX_FLAGS) $(TEST_CXX_FLAGS) $(INCLUDES) -o $@ + $(CXX) -c $< $(CXX_FLAGS) $(TEST_CXX_FLAGS) $(INCLUDES) $(TEST_INCLUDES) -o $@ $(TEST_OBJ_DIR)/%.o: $(TEST_DIR)/%.cpp $(CXX) -c $< $(CXX_FLAGS) $(TEST_CXX_FLAGS) $(INCLUDES) $(TEST_INCLUDES) -o $@ @@ -61,5 +61,3 @@ clean: rm -Rf $(OBJ_DIR) rm -Rf $(DIST_DIR) rm -Rf $(COVERAGE_DIR) - - From ec3882b2dc350ac0911f91ca1c90a5b6e645b404 Mon Sep 17 00:00:00 2001 From: Fredy Date: Mon, 7 Nov 2016 07:41:09 -0200 Subject: [PATCH 02/10] Add body to Primos::toString function --- src/Primos.cpp | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/Primos.cpp b/src/Primos.cpp index d784f73..d62c7fe 100644 --- a/src/Primos.cpp +++ b/src/Primos.cpp @@ -39,7 +39,16 @@ int Primos::resultado(unsigned int indice) { string Primos::toString(char sep){ // TODO: Implementar - return ""; + stringstream ss; + unsigned int i = 0; + for(vector::iterator it = this->resultados.begin(); it != this->resultados.end(); it++){ + ss << *it; + if(i < (this->resultados.size() - 1)){ + ss << sep; + } + i++; + } + return ss.str(); } void Primos::limpaCalculo() { From f4c39e18848e809f65f5b321c5a4467fdf8ad8a0 Mon Sep 17 00:00:00 2001 From: Fredy Date: Mon, 7 Nov 2016 08:06:09 -0200 Subject: [PATCH 03/10] Merge with upstream --- README.md | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/README.md b/README.md index 647ee60..fede518 100644 --- a/README.md +++ b/README.md @@ -45,13 +45,3 @@ Nosso caso de uso é: O usuário entra no diretório do nosso aplicativo e execu - ExpectCallFunc: O mesmo que ExpectCall mas para funções estáticas. - OnCall: Falsifica uma chamada independente dela ser utilizada durante o ciclo de vida do teste. - OnCallFunc: O mesmo que OnCall mas para funções estáticas. - - - - - - - - - - From 85238d52b7ab7f5d7c3ead862bbb68eb533a0d53 Mon Sep 17 00:00:00 2001 From: Fredy Date: Mon, 7 Nov 2016 15:01:36 -0200 Subject: [PATCH 04/10] Add Golomb classes and test --- src/Golomb.cpp | 80 ++++++++++++++++++++++++++++++++++ src/Golomb.h | 80 ++++++++++++++++++++++++++++++++++ test/TestGolomb.cpp | 102 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 262 insertions(+) create mode 100644 src/Golomb.cpp create mode 100644 src/Golomb.h create mode 100644 test/TestGolomb.cpp diff --git a/src/Golomb.cpp b/src/Golomb.cpp new file mode 100644 index 0000000..ecefe97 --- /dev/null +++ b/src/Golomb.cpp @@ -0,0 +1,80 @@ +#include +#include +#include +#include + +Golomb::Golomb(int inicio, unsigned int tamanho, Interceptador *interceptador) : + Calculo(inicio, tamanho, interceptador) +{ + this->resultados.reserve(tamanho); +} + +void Golomb::calcula() +{ + std::stringstream ss; + for (int i = inicio; i < (int)(inicio + tamanho); ++i) { + for (int j = 0; j < i; ++j) { + ss << i; + } + this->resultados.push_back(ss.str()); + //std::cout << ss.str() << std::endl; + ss.str(""); + } +} + +void Golomb::limpaCalculo() +{ + this->resultados.clear(); +} + +unsigned int Golomb::numeroResultados() +{ + return this->resultados.size(); +} + +int Golomb::resultado(unsigned int indice) +{ + if (indice >= this->resultados.size()) { + return 0; //? + } + + return this->interceptador->intercepta(indice); +} + +bool Golomb::resultado(unsigned int id, std::string& value) +{ + if (id >= this->resultados.size()) { + return false; + } + value = this->resultados[id]; + this->interceptador->intercepta(id); + return true; +} + + +string Golomb::toString(char sep) +{ + std::stringstream ss; + unsigned int i = 0; + for(vector::iterator it = this->resultados.begin(); it != this->resultados.end(); it++){ + ss << *it; + if(i < (this->resultados.size() - 1)){ + ss << sep; + } + i++; + } + return ss.str(); +} + +string Golomb::nome() const +{ + return "Golomb"; +} + +Golomb::~Golomb() { + this->inicio = 0; + if (interceptador != 0){ + delete interceptador; + interceptador = 0; + } +} diff --git a/src/Golomb.h b/src/Golomb.h new file mode 100644 index 0000000..af012c4 --- /dev/null +++ b/src/Golomb.h @@ -0,0 +1,80 @@ +#ifndef GOLOMB_H +#define GOLOMB_H + +#include +#include + +using namespace std; + +/** + * Implementa o calculo da serie de Golomb + */ +class Golomb: public Calculo { + +public: + /** + * Constructor + * @param inicio Inicio do calculo + * @params tamanho Numero de resultados para calcular + */ + Golomb(int inicio = 0, unsigned int tamanho = 10, Interceptador *interceptador = 0); + + /** + * Calcula + */ + void calcula(); + + /** + * Resultados + * @return + */ + virtual unsigned int numeroResultados(); + + /** + * Limpa o calculo + */ + virtual void limpaCalculo(); + + /** + * Retorna o resultado em uma determinada posição + * @param indice + * @param valor + * @return + */ + virtual bool resultado(unsigned int id, std::string& value); + + /** + * Retorna o resultado em uma determinada posição + * @param indice + * @return + */ + virtual int resultado(unsigned int indice); + + /** + * Retorna o nome do calculo + * @return + */ + virtual std::string nome() const; + + /** + * Transforma o resultado em string. + * @param sep Separador + * @return + */ + virtual std::string toString(char sep); + + /** + * Destructor + */ + virtual ~Golomb(); +private: + + /** + * Lista de resultados + */ + std::vector resultados; + +}; + +#endif /* GOLOMB_H */ + diff --git a/test/TestGolomb.cpp b/test/TestGolomb.cpp new file mode 100644 index 0000000..ec77313 --- /dev/null +++ b/test/TestGolomb.cpp @@ -0,0 +1,102 @@ +#include +#include + +#include "Golomb.h" + +class TestGolomb: public ::testing::Test { + +protected: + Calculo* golomb; + + virtual void SetUp() + { + golomb = new Golomb(0, 10); + //mocks.ExpectCall(golomb, Golomb::calcula) + golomb->calcula(); + } + + virtual void TearDown() + { + //mocks->ExpectCall(golomb, Golomb::calcula); + golomb->limpaCalculo(); + delete golomb; + } +}; + +class +TestGolombInterceptator: public ::testing::Test { +protected: + Calculo* golomb; + MockRepository* mocks; + Interceptador* interceptador; + + virtual void SetUp() + { + mocks = new MockRepository(); + interceptador = mocks->Mock(); + golomb = new Golomb(0, 10, interceptador); + golomb->calcula(); + } + + virtual void TearDown() + { + mocks->OnCallDestructor(interceptador); + delete golomb; + } +}; + +TEST_F(TestGolomb, TesteDeTamanho) +{ + EXPECT_TRUE(golomb->numeroResultados() == 10); +} + +TEST_F(TestGolomb, TesteDeResultado) +{ + std::string value; + golomb->resultado(0, value); + EXPECT_TRUE(value == ""); + golomb->resultado(1, value); + EXPECT_TRUE(value == "1"); + golomb->resultado(2, value); + EXPECT_TRUE(value == "22"); + golomb->resultado(3, value); + EXPECT_TRUE(value == "333"); + golomb->resultado(4, value); + EXPECT_TRUE(value == "4444"); + golomb->resultado(5, value); + EXPECT_TRUE(value == "55555"); + golomb->resultado(6, value); + EXPECT_TRUE(value == "666666"); + golomb->resultado(7, value); + EXPECT_TRUE(value == "7777777"); + golomb->resultado(8, value); + EXPECT_TRUE(value == "88888888"); + golomb->resultado(9, value); + EXPECT_TRUE(value == "999999999"); + golomb->resultado(1, value); + EXPECT_FALSE(value == "7777777"); + + EXPECT_TRUE(golomb->resultado(golomb->numeroResultados()) == 0); + EXPECT_TRUE(golomb->resultado(golomb->numeroResultados(), value) == 0); +} + +TEST_F(TestGolomb, TestDeNome) +{ + EXPECT_STREQ(golomb->nome().c_str(), "Golomb"); +} + +TEST_F(TestGolomb, TesteToString) +{ + EXPECT_STREQ(golomb->toString(',').c_str(), ",1,22,333,4444,55555,666666,7777777,88888888,999999999"); + EXPECT_STREQ(golomb->toString(';').c_str(), ";1;22;333;4444;55555;666666;7777777;88888888;999999999"); +} + +TEST_F(TestGolombInterceptator, TesteDeResultadoZero) +{ + mocks->ExpectCall(interceptador, Interceptador::intercepta).With(3).Return(15); + //mocks->ExpectCall(interceptador, Interceptador::intercepta).With(4).Return(66); + //mocks->ExpectCall(interceptador, Interceptador::intercepta).With(6).Return(44); + EXPECT_TRUE(golomb->resultado(3) == 15); + //EXPECT_FALSE(golomb->resultado(4) == 99); + //EXPECT_TRUE(golomb->resultado(6) == 44); +} From f346492183b92e74200389b488ba98f71e82fdbf Mon Sep 17 00:00:00 2001 From: Fredy Date: Mon, 7 Nov 2016 15:06:18 -0200 Subject: [PATCH 05/10] Overload "resultado" function, to return string value by reference. Golomb number might be really high (ex. Golomb 10 > long long). Remove whitespaces --- src/Calculo.cpp | 5 +++ src/Calculo.h | 34 +++++++++++-------- src/Fibonacci.h | 20 +++++------ src/Main.cpp | 4 ++- src/Primos.cpp | 2 +- src/Primos.h | 48 +++++++++++++-------------- test/TestCalculo.cpp | 79 +++++++++++++++++++++++--------------------- test/TestPrimos.cpp | 7 +++- 8 files changed, 111 insertions(+), 88 deletions(-) diff --git a/src/Calculo.cpp b/src/Calculo.cpp index 72f2a54..df914c9 100644 --- a/src/Calculo.cpp +++ b/src/Calculo.cpp @@ -36,6 +36,11 @@ int Calculo::resultado(unsigned int indice){ return 0; } +bool Calculo::resultado(unsigned int id, std::string& value){ + return false; + // TODO: Implementar +} + string Calculo::toString(char sep){ // TODO: Implementar return ""; diff --git a/src/Calculo.h b/src/Calculo.h index 9fb2b5b..4922dd7 100644 --- a/src/Calculo.h +++ b/src/Calculo.h @@ -18,71 +18,79 @@ using namespace std; */ class Calculo { public: - + /** * Construtor * @param inicio Início do cálculo */ Calculo(int inicio = 0, unsigned int tamanho = 0, Interceptador *interceptador = 0); - + /** * Calcula Fibonacci */ virtual void calcula(); - + /** * Limpa calculo */ virtual void limpaCalculo(); - + /** * Resultados * @return */ virtual unsigned int numeroResultados(); - + /** * Retorna o resultado em uma determinada posição * @param indice * @return */ virtual int resultado(unsigned int indice); - + + /** + * Retorna o resultado em uma determinada posição + * @param id + * @param value + * @return + */ + virtual bool resultado(unsigned int id, std::string& value); + /** * Nome do cálculo * @return */ virtual string nome() const; - + /** * Transforma o resultado em string. * @param sep Separador * @return */ virtual string toString(char sep); - + /** * Destrutor */ virtual ~Calculo(); - + protected: - + /** * Início */ int inicio; - + /** * Tamanho do cálculo que será realizado */ unsigned int tamanho; - + /** * Interceptador */ Interceptador *interceptador; - + }; #endif /* CALCULO_H */ diff --git a/src/Fibonacci.h b/src/Fibonacci.h index 3ed59c2..c0a9523 100644 --- a/src/Fibonacci.h +++ b/src/Fibonacci.h @@ -17,7 +17,7 @@ using namespace std; * Implementa o calculo de Fibonacci. */ class Fibonacci: public Calculo { - + public: /** * Constructor @@ -25,54 +25,54 @@ class Fibonacci: public Calculo { * @params tamanho Numero de resultados para calcular */ Fibonacci(int inicio = 0, unsigned int tamanho = 10, Interceptador *interceptador = 0); - + /** * Calcula */ void calcula(); - + /** * Resultados * @return */ virtual unsigned int numeroResultados(); - + /** * Limpa o calculo */ virtual void limpaCalculo(); - + /** * Retorna o resultado em uma determinada posição * @param indice * @return */ virtual int resultado(unsigned int indice); - + /** * Retorna o nome do calculo * @return */ virtual string nome() const; - + /** * Transforma o resultado em string. * @param sep Separador * @return */ virtual string toString(char sep); - + /** * Destructor */ virtual ~Fibonacci(); private: - + /** * Lista de resultados */ vector resultados; - + }; #endif /* FIBONACCI_H */ diff --git a/src/Main.cpp b/src/Main.cpp index f916175..cc301b4 100644 --- a/src/Main.cpp +++ b/src/Main.cpp @@ -11,6 +11,7 @@ #include "Fibonacci.h" #include "Primos.h" #include "SalvaCalculo.h" +#include #include #ifdef WITH_UNIT_TEST @@ -55,7 +56,8 @@ int main(int argc, char** argv) { map calculos; calculos.insert(pair("fibonacci", new Fibonacci(inicio, tamanho))); calculos.insert(pair("primos", new Primos(inicio, tamanho))); - + calculos.insert(pair("golomb", new Golomb(inicio, tamanho))); + // Retorna sucesso if (argc > 3) { if (calculos.count(argv[3]) > 0) { diff --git a/src/Primos.cpp b/src/Primos.cpp index d62c7fe..8298a8b 100644 --- a/src/Primos.cpp +++ b/src/Primos.cpp @@ -1,6 +1,7 @@ #include "Primos.h" #include #include +#include Primos::Primos(int inicio, unsigned int tamanho, Interceptador *interceptador) : Calculo(inicio, tamanho, interceptador) { this->resultados.reserve(tamanho); @@ -38,7 +39,6 @@ int Primos::resultado(unsigned int indice) { } string Primos::toString(char sep){ - // TODO: Implementar stringstream ss; unsigned int i = 0; for(vector::iterator it = this->resultados.begin(); it != this->resultados.end(); it++){ diff --git a/src/Primos.h b/src/Primos.h index 40d5f4c..eb30802 100644 --- a/src/Primos.h +++ b/src/Primos.h @@ -12,30 +12,30 @@ #include "Calculo.h" class Primos : public Calculo { - - public: - - Primos(int inicio = 0, unsigned int tamanho = 0, Interceptador *interceptador = 0); - - virtual unsigned int numeroResultados(); - - virtual int resultado(unsigned int indice); - - virtual void limpaCalculo(); - - virtual string nome() const; - - void calcula(); - - virtual string toString(char sep); - - virtual ~Primos(); - - private: - - vector resultados; - - + +public: + + Primos(int inicio = 0, unsigned int tamanho = 0, Interceptador *interceptador = 0); + + virtual unsigned int numeroResultados(); + + virtual int resultado(unsigned int indice); + + virtual void limpaCalculo(); + + virtual string nome() const; + + void calcula(); + + virtual string toString(char sep); + + virtual ~Primos(); + +private: + + vector resultados; + + }; #endif /* PRIMOS_H */ diff --git a/test/TestCalculo.cpp b/test/TestCalculo.cpp index b58cc38..4a7f1a6 100644 --- a/test/TestCalculo.cpp +++ b/test/TestCalculo.cpp @@ -3,62 +3,65 @@ #include "Calculo.h" -MockRepository mocks; class TestCalculoMock : public ::testing::Test { - - protected: - - MockRepository *mocks; - Calculo* calculo; - - virtual void SetUp() { - mocks = new MockRepository(); - calculo = mocks->Mock(); - mocks->ExpectCall(calculo, Calculo::calcula); - calculo->calcula(); - } - - virtual void TearDown() { - mocks->ExpectCall(calculo, Calculo::limpaCalculo); - calculo->limpaCalculo(); - } - + +protected: + + MockRepository *mocks; + Calculo* calculo; + + virtual void SetUp() { + mocks = new MockRepository(); + calculo = mocks->Mock(); + mocks->ExpectCall(calculo, Calculo::calcula); + calculo->calcula(); + } + + virtual void TearDown() { + mocks->ExpectCall(calculo, Calculo::limpaCalculo); + calculo->limpaCalculo(); + } + }; class TestCalculo : public ::testing::Test { - - protected: - - Calculo* calculo; - - virtual void SetUp() { - calculo = new Calculo(); - calculo->calcula(); - } - - virtual void TearDown() { - calculo->limpaCalculo(); - delete calculo; - } - + +protected: + + Calculo* calculo; + + virtual void SetUp() { + calculo = new Calculo(); + calculo->calcula(); + } + + virtual void TearDown() { + calculo->limpaCalculo(); + delete calculo; + } + }; + TEST_F(TestCalculoMock, Test) { - mocks->ExpectCall(calculo, Calculo::resultado).With(1).Return(7); + std::string value; + mocks->ExpectCallOverload(calculo, static_cast(&Calculo::resultado)).With(1, _).Return(true); mocks->ExpectCall(calculo, Calculo::numeroResultados).Return(0); mocks->ExpectCall(calculo, Calculo::nome).Return("Calcula nada"); - + mocks->OnCall(calculo, Calculo::toString).With(',').Return("1,2,3"); - - EXPECT_TRUE(calculo->resultado(1) == 7); + + EXPECT_TRUE(calculo->resultado(1, value)); EXPECT_TRUE(calculo->numeroResultados() == 0); EXPECT_STREQ(calculo->nome().c_str(), "Calcula nada"); EXPECT_STREQ(calculo->toString(',').c_str(), "1,2,3"); } TEST_F(TestCalculo, Test) { + std::string value; EXPECT_TRUE(calculo->resultado(0) == 0); + EXPECT_FALSE(calculo->resultado(0, value)); EXPECT_TRUE(calculo->numeroResultados() == 0); EXPECT_STREQ(calculo->nome().c_str(), "Calculo vazio"); EXPECT_STREQ(calculo->toString(',').c_str(), ""); diff --git a/test/TestPrimos.cpp b/test/TestPrimos.cpp index 3dcfb8d..3de6142 100644 --- a/test/TestPrimos.cpp +++ b/test/TestPrimos.cpp @@ -68,4 +68,9 @@ TEST_F(TestPrimosInitialize, TesteDeResultado){ TEST_F(TestPrimosInitialize, TesteDeNome) { EXPECT_STREQ(primos->nome().c_str(), "Primos"); -} \ No newline at end of file +} + +TEST_F(TestPrimosInitialize, TesteToString) { + EXPECT_STREQ(primos->toString(',').c_str(), "2,3,5,7,11,13,17,19,23,29"); + EXPECT_STREQ(primos->toString(';').c_str(), "2;3;5;7;11;13;17;19;23;29"); +} From 7aaf0514093f58cd8ef5945ef5a7a7757f187451 Mon Sep 17 00:00:00 2001 From: Fredy Date: Mon, 7 Nov 2016 15:18:57 -0200 Subject: [PATCH 06/10] Switch between "resultado" function depending on computation method. For Golomb, use ad-hoc "resultado" with string parameter --- src/Main.cpp | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/Main.cpp b/src/Main.cpp index cc301b4..6412606 100644 --- a/src/Main.cpp +++ b/src/Main.cpp @@ -34,7 +34,14 @@ void imprimeCalculo(Calculo *calculo) { printf("%s\n", calculo->nome().c_str()); printf("%s\t\t%s\n", "Indice", "Valor"); for (unsigned int i = 0; i < calculo->numeroResultados(); i++) { - printf("%d\t\t%d\n", i, calculo->resultado(i)); + std::string value; + if (calculo->nome() == "Golomb") { + calculo->resultado(i, value); + printf("%d\t\t%s\n", i, value.c_str()); + } + else { + printf("%d\t\t%d\n", i, calculo->resultado(i)); + } } } From 8bd7295607bfba803ddeac2a4b3ab08c8c8b340f Mon Sep 17 00:00:00 2001 From: Fredy Date: Mon, 7 Nov 2016 16:48:52 -0200 Subject: [PATCH 07/10] Cast from str to number without exceptions --- src/Golomb.cpp | 19 ++++++++++++++----- test/TestCalculo.cpp | 2 +- test/TestGolomb.cpp | 10 +++++----- 3 files changed, 20 insertions(+), 11 deletions(-) diff --git a/src/Golomb.cpp b/src/Golomb.cpp index ecefe97..b9baa1f 100644 --- a/src/Golomb.cpp +++ b/src/Golomb.cpp @@ -1,7 +1,6 @@ #include #include #include -#include Golomb::Golomb(int inicio, unsigned int tamanho, Interceptador *interceptador) : Calculo(inicio, tamanho, interceptador) @@ -17,7 +16,6 @@ void Golomb::calcula() ss << i; } this->resultados.push_back(ss.str()); - //std::cout << ss.str() << std::endl; ss.str(""); } } @@ -31,23 +29,34 @@ unsigned int Golomb::numeroResultados() { return this->resultados.size(); } - +#include int Golomb::resultado(unsigned int indice) { + int rtn; + std::stringstream ss; + if (indice >= this->resultados.size()) { return 0; //? } + ss << this->resultados[indice]; + ss >> rtn; - return this->interceptador->intercepta(indice); + return this->interceptador->intercepta(rtn); } bool Golomb::resultado(unsigned int id, std::string& value) { + int rtn; + std::stringstream ss; + if (id >= this->resultados.size()) { return false; } value = this->resultados[id]; - this->interceptador->intercepta(id); + ss << value; + ss >> rtn; + + this->interceptador->intercepta(rtn); return true; } diff --git a/test/TestCalculo.cpp b/test/TestCalculo.cpp index 4a7f1a6..d68c75c 100644 --- a/test/TestCalculo.cpp +++ b/test/TestCalculo.cpp @@ -61,7 +61,7 @@ TEST_F(TestCalculoMock, Test) { TEST_F(TestCalculo, Test) { std::string value; EXPECT_TRUE(calculo->resultado(0) == 0); - EXPECT_FALSE(calculo->resultado(0, value)); + EXPECT_TRUE(calculo->resultado(0, value) == 0); EXPECT_TRUE(calculo->numeroResultados() == 0); EXPECT_STREQ(calculo->nome().c_str(), "Calculo vazio"); EXPECT_STREQ(calculo->toString(',').c_str(), ""); diff --git a/test/TestGolomb.cpp b/test/TestGolomb.cpp index ec77313..fbca4a2 100644 --- a/test/TestGolomb.cpp +++ b/test/TestGolomb.cpp @@ -93,10 +93,10 @@ TEST_F(TestGolomb, TesteToString) TEST_F(TestGolombInterceptator, TesteDeResultadoZero) { - mocks->ExpectCall(interceptador, Interceptador::intercepta).With(3).Return(15); - //mocks->ExpectCall(interceptador, Interceptador::intercepta).With(4).Return(66); - //mocks->ExpectCall(interceptador, Interceptador::intercepta).With(6).Return(44); + mocks->ExpectCall(this->interceptador, Interceptador::intercepta).With(333).Return(15); + mocks->ExpectCall(this->interceptador, Interceptador::intercepta).With(4444).Return(66); + mocks->ExpectCall(this->interceptador, Interceptador::intercepta).With(666666).Return(44); EXPECT_TRUE(golomb->resultado(3) == 15); - //EXPECT_FALSE(golomb->resultado(4) == 99); - //EXPECT_TRUE(golomb->resultado(6) == 44); + EXPECT_FALSE(golomb->resultado(4) == 99); + EXPECT_TRUE(golomb->resultado(6) == 44); } From f5c23a9206ea6871b1465f866ea2e34aad0bb735 Mon Sep 17 00:00:00 2001 From: Fredy Date: Tue, 8 Nov 2016 08:28:42 -0200 Subject: [PATCH 08/10] Fix Golomb computation value. New computation is based in recurrence relation given in https://en.wikipedia.org/wiki/Golomb_sequence. Update expected values in tests --- src/Golomb.cpp | 22 +++++++++++++++++++++- src/Golomb.h | 8 ++++++++ test/TestGolomb.cpp | 26 ++++++++++++-------------- 3 files changed, 41 insertions(+), 15 deletions(-) diff --git a/src/Golomb.cpp b/src/Golomb.cpp index b9baa1f..9495b98 100644 --- a/src/Golomb.cpp +++ b/src/Golomb.cpp @@ -8,11 +8,15 @@ Golomb::Golomb(int inicio, unsigned int tamanho, Interceptador *interceptador) : this->resultados.reserve(tamanho); } +#include void Golomb::calcula() { std::stringstream ss; + unsigned int gV; for (int i = inicio; i < (int)(inicio + tamanho); ++i) { - for (int j = 0; j < i; ++j) { + gV = this->golombValue(i); + + for (unsigned int j = 0; j < gV; ++j) { ss << i; } this->resultados.push_back(ss.str()); @@ -20,6 +24,22 @@ void Golomb::calcula() } } +unsigned int Golomb::golombValue(const unsigned int n) +{ + if (n < 1) return 0; + + std::vector g; + g.push_back(0); + for (unsigned int i = 1; i <= n; ++i) { + if (i == 1) { + g.push_back(1); + continue; + } + g.push_back(1 + g[(i - 1) + 1 - g[g[i-1]]]); + } + return g[n]; +} + void Golomb::limpaCalculo() { this->resultados.clear(); diff --git a/src/Golomb.h b/src/Golomb.h index af012c4..cbcabb8 100644 --- a/src/Golomb.h +++ b/src/Golomb.h @@ -67,6 +67,14 @@ class Golomb: public Calculo { * Destructor */ virtual ~Golomb(); + + /** + * @brief Dummy implementation of Golomb sequence. For each input + * all precedessor values are computed again. + * @param [in] n Input for Golomb sequence + * @return Golomb value + */ + unsigned int golombValue(const unsigned int n); private: /** diff --git a/test/TestGolomb.cpp b/test/TestGolomb.cpp index fbca4a2..cad5309 100644 --- a/test/TestGolomb.cpp +++ b/test/TestGolomb.cpp @@ -11,13 +11,11 @@ class TestGolomb: public ::testing::Test { virtual void SetUp() { golomb = new Golomb(0, 10); - //mocks.ExpectCall(golomb, Golomb::calcula) golomb->calcula(); } virtual void TearDown() { - //mocks->ExpectCall(golomb, Golomb::calcula); golomb->limpaCalculo(); delete golomb; } @@ -60,19 +58,19 @@ TEST_F(TestGolomb, TesteDeResultado) golomb->resultado(2, value); EXPECT_TRUE(value == "22"); golomb->resultado(3, value); - EXPECT_TRUE(value == "333"); + EXPECT_TRUE(value == "33"); golomb->resultado(4, value); - EXPECT_TRUE(value == "4444"); + EXPECT_TRUE(value == "444"); golomb->resultado(5, value); - EXPECT_TRUE(value == "55555"); + EXPECT_TRUE(value == "555"); golomb->resultado(6, value); - EXPECT_TRUE(value == "666666"); + EXPECT_TRUE(value == "6666"); golomb->resultado(7, value); - EXPECT_TRUE(value == "7777777"); + EXPECT_TRUE(value == "7777"); golomb->resultado(8, value); - EXPECT_TRUE(value == "88888888"); + EXPECT_TRUE(value == "8888"); golomb->resultado(9, value); - EXPECT_TRUE(value == "999999999"); + EXPECT_TRUE(value == "99999"); golomb->resultado(1, value); EXPECT_FALSE(value == "7777777"); @@ -87,15 +85,15 @@ TEST_F(TestGolomb, TestDeNome) TEST_F(TestGolomb, TesteToString) { - EXPECT_STREQ(golomb->toString(',').c_str(), ",1,22,333,4444,55555,666666,7777777,88888888,999999999"); - EXPECT_STREQ(golomb->toString(';').c_str(), ";1;22;333;4444;55555;666666;7777777;88888888;999999999"); + EXPECT_STREQ(golomb->toString(',').c_str(), ",1,22,33,444,555,6666,7777,8888,99999"); + EXPECT_STREQ(golomb->toString(';').c_str(), ";1;22;33;444;555;6666;7777;8888;99999"); } TEST_F(TestGolombInterceptator, TesteDeResultadoZero) { - mocks->ExpectCall(this->interceptador, Interceptador::intercepta).With(333).Return(15); - mocks->ExpectCall(this->interceptador, Interceptador::intercepta).With(4444).Return(66); - mocks->ExpectCall(this->interceptador, Interceptador::intercepta).With(666666).Return(44); + mocks->ExpectCall(this->interceptador, Interceptador::intercepta).With(33).Return(15); + mocks->ExpectCall(this->interceptador, Interceptador::intercepta).With(444).Return(66); + mocks->ExpectCall(this->interceptador, Interceptador::intercepta).With(6666).Return(44); EXPECT_TRUE(golomb->resultado(3) == 15); EXPECT_FALSE(golomb->resultado(4) == 99); EXPECT_TRUE(golomb->resultado(6) == 44); From fbeb7ea0f19ac7eef2c9585228a1488cdcf958d3 Mon Sep 17 00:00:00 2001 From: Fredy Date: Tue, 8 Nov 2016 08:58:01 -0200 Subject: [PATCH 09/10] Remove unncessary include directive --- src/Golomb.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Golomb.cpp b/src/Golomb.cpp index 9495b98..6799641 100644 --- a/src/Golomb.cpp +++ b/src/Golomb.cpp @@ -49,7 +49,7 @@ unsigned int Golomb::numeroResultados() { return this->resultados.size(); } -#include + int Golomb::resultado(unsigned int indice) { int rtn; From 6fe412fc51a6ff89293adb633f428c5425633ebd Mon Sep 17 00:00:00 2001 From: Fredy Date: Tue, 8 Nov 2016 08:59:14 -0200 Subject: [PATCH 10/10] Remove unncessary include directive --- src/Golomb.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Golomb.cpp b/src/Golomb.cpp index 6799641..bc111aa 100644 --- a/src/Golomb.cpp +++ b/src/Golomb.cpp @@ -8,7 +8,7 @@ Golomb::Golomb(int inicio, unsigned int tamanho, Interceptador *interceptador) : this->resultados.reserve(tamanho); } -#include + void Golomb::calcula() { std::stringstream ss;