diff --git a/Makefile b/Makefile index fd5b1e3..354f754 100644 --- a/Makefile +++ b/Makefile @@ -61,5 +61,3 @@ clean: rm -Rf $(OBJ_DIR) rm -Rf $(DIST_DIR) rm -Rf $(COVERAGE_DIR) - - 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. - - - - - - - - - - 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/Golomb.cpp b/src/Golomb.cpp new file mode 100644 index 0000000..bc111aa --- /dev/null +++ b/src/Golomb.cpp @@ -0,0 +1,109 @@ +#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; + unsigned int gV; + for (int i = inicio; i < (int)(inicio + tamanho); ++i) { + gV = this->golombValue(i); + + for (unsigned int j = 0; j < gV; ++j) { + ss << i; + } + this->resultados.push_back(ss.str()); + ss.str(""); + } +} + +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(); +} + +unsigned int Golomb::numeroResultados() +{ + return this->resultados.size(); +} + +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(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]; + ss << value; + ss >> rtn; + + this->interceptador->intercepta(rtn); + 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..cbcabb8 --- /dev/null +++ b/src/Golomb.h @@ -0,0 +1,88 @@ +#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(); + + /** + * @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: + + /** + * Lista de resultados + */ + std::vector resultados; + +}; + +#endif /* GOLOMB_H */ + diff --git a/src/Main.cpp b/src/Main.cpp index f916175..6412606 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 @@ -33,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)); + } } } @@ -55,7 +63,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 d784f73..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,8 +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() { 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..d68c75c 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_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 new file mode 100644 index 0000000..cad5309 --- /dev/null +++ b/test/TestGolomb.cpp @@ -0,0 +1,100 @@ +#include +#include + +#include "Golomb.h" + +class TestGolomb: public ::testing::Test { + +protected: + Calculo* golomb; + + virtual void SetUp() + { + golomb = new Golomb(0, 10); + golomb->calcula(); + } + + virtual void TearDown() + { + 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 == "33"); + golomb->resultado(4, value); + EXPECT_TRUE(value == "444"); + golomb->resultado(5, value); + EXPECT_TRUE(value == "555"); + golomb->resultado(6, value); + EXPECT_TRUE(value == "6666"); + golomb->resultado(7, value); + EXPECT_TRUE(value == "7777"); + golomb->resultado(8, value); + EXPECT_TRUE(value == "8888"); + golomb->resultado(9, value); + EXPECT_TRUE(value == "99999"); + 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,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(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); +} 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"); +}