API tools faq
paste
Advertisement
michatch

Untitled

michatch
Dec 7th, 2016
80
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 21.44 KB | None | 0 0
raw download clone embed print report
  1. #include "pokemon.h"
  2. #include <assert.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5.  
  6. #define MINIMUM_EXPERIENCE 1
  7. #define MAXIMUM_EXPERIENCE 9901
  8. /* static bool*/
  9. Pokemon pokemonCreate(char* name, PokemonType type, int experience,
  10.                       int max_number_of_moves) {
  11.    
  12.     Pokemon pokemon = malloc(sizeof(*pokemon));
  13.     if (pokemon == NULL) {
  14.         return NULL;
  15.     }
  16.     pokemon->moves = malloc(sizeof(*(pokemon->moves)) * max_number_of_moves);
  17.     if (pokemon->moves == NULL) {
  18.         return NULL;
  19.     }
  20.     for(int i= 0; i < max_number_of_moves; i++) {
  21.         pokemon->moves[i] = malloc(sizeof(*(pokemon->moves[i])));
  22.         if(pokemon->moves[i] == NULL) {
  23.             return NULL;
  24.         }
  25.     }
  26.     pokemon->name = name;
  27.     char* empty_string = "";
  28.     if ((name == NULL) || (!(strcmp(name, empty_string)))) {
  29.         return NULL;
  30.     }
  31.     pokemon->type = type;
  32.     if (!(type >= TYPE_NORMAL && type <= TYPE_ELECTRIC)) {
  33.         return NULL;
  34.     }
  35.     pokemon->experience = experience;
  36.     if ((experience < MINIMUM_EXPERIENCE)
  37.         || (experience > MAXIMUM_EXPERIENCE)) {
  38.         return NULL;
  39.     }
  40.     pokemon->max_number_of_moves = max_number_of_moves;
  41.     if ((max_number_of_moves) < 1) {
  42.         return NULL;
  43.     }
  44.     pokemon->number_of_moves = 0;
  45.     int level = (experience / 100) + 1;
  46.     pokemon->health_points = (100 + level) * 10;
  47.     return pokemon;
  48. }
  49.  
  50. void pokemonDestroy(Pokemon pokemon) {
  51.     if (pokemon == NULL) {
  52.         return;
  53.     }
  54.     free(pokemon->moves);
  55.     free(pokemon);
  56.     return;
  57. }
  58.  
  59. Pokemon pokemonCopy(Pokemon pokemon) {
  60.     if (pokemon == NULL) {
  61.         return NULL;
  62.     }
  63.     Pokemon pokemon_copy = malloc(sizeof(*pokemon));
  64.     if (pokemon_copy == NULL) {
  65.         return NULL;
  66.     }
  67.     pokemon_copy->name = pokemon->name;
  68.     pokemon_copy->type = pokemon->type;
  69.     pokemon_copy->experience = pokemon->experience;
  70.     pokemon_copy->health_points = pokemon->health_points;
  71.     pokemon_copy->moves = pokemon->moves;
  72.     pokemon_copy->number_of_moves = pokemon->number_of_moves;
  73.     pokemon_copy->max_number_of_moves = pokemon->max_number_of_moves;
  74.    
  75.     return pokemon_copy;
  76. }
  77.  
  78. PokemonResult pokemonTeachMove(Pokemon pokemon, char* move_name,
  79.                                PokemonType type, int max_power_points,
  80.                                int strength) {
  81.    
  82.     char* empty_string = "";
  83.     if ((pokemon == NULL) || (move_name == NULL)) {
  84.         return POKEMON_NULL_ARG;
  85.     }
  86.     if (!(strcmp(empty_string, move_name))) {
  87.         return POKEMON_INVALID_MOVE_NAME;
  88.     }
  89.     if (!(type >= TYPE_NORMAL) && (type <= TYPE_ELECTRIC)) {
  90.         return POKEMON_INVALID_TYPE;
  91.     }
  92.     if (max_power_points < 1) {
  93.         return POKEMON_INVALID_POWER_POINTS;
  94.     }
  95.     if (strength < 1) {
  96.         return POKEMON_INVALID_STRENGTH;
  97.     }
  98.     if ((type != pokemon->type) && (type != TYPE_NORMAL)) {
  99.         return POKEMON_INCOMPATIBLE_MOVE_TYPE;
  100.     }
  101.    
  102.     PokemonMove learning_move = malloc(sizeof(*learning_move));
  103.     if (learning_move == NULL) {
  104.         return POKEMON_OUT_OF_MEM;
  105.     }
  106.     char* copied_move_name = malloc(sizeof(char) * strlen(move_name));
  107.     if (copied_move_name == NULL) {
  108.         free(learning_move);
  109.         return POKEMON_OUT_OF_MEM;
  110.     }
  111.     strcpy(copied_move_name, move_name);
  112.    
  113.     learning_move->name = copied_move_name;
  114.     learning_move->type = type;
  115.     learning_move->max_power_points = max_power_points;
  116.     learning_move->power_points = max_power_points;
  117.     learning_move->strength = strength;
  118.  
  119.     for (int i = 0; i < (pokemon->number_of_moves); i++) {
  120.         if ((strcmp(((pokemon->moves[i])->name),
  121.                     learning_move->name) == 0)) {
  122.             free(copied_move_name);
  123.             free(learning_move);
  124.             return POKEMON_MOVE_ALREADY_EXISTS;
  125.         }
  126.     }
  127.     int i = 0;
  128.     if ((pokemon->number_of_moves) == (pokemon->max_number_of_moves)) {
  129.         int position_of_grater_move = 0;
  130.         for (i = 0; i < (pokemon->number_of_moves); i++) {
  131.             if ((strcmp(((pokemon->moves[position_of_grater_move])->name),
  132.                         ((pokemon->moves[i])->name)) < 0)) {
  133.                 position_of_grater_move = i;
  134.             }
  135.         }
  136.     }
  137.     pokemon->moves[i] = learning_move;
  138.     pokemon->number_of_moves++;
  139.     //free(copied_move_name);
  140.    // free(learning_move);
  141.     return POKEMON_SUCCESS;
  142. }
  143.  
  144. PokemonResult pokemonUnteachMove(Pokemon pokemon, char* move_name) {
  145.     if ((pokemon == NULL) || (move_name == NULL)) {
  146.         return POKEMON_NULL_ARG;
  147.     }
  148.     char* empty_string = "";
  149.     if ((strcmp(move_name, empty_string)) == 0) {
  150.         return POKEMON_INVALID_MOVE_NAME;
  151.     }
  152.    
  153.     for (int i = 0; i < (pokemon->number_of_moves); i++) {
  154.         if (strcmp((pokemon->moves[i])->name, move_name) == 0) {
  155.             (pokemon->moves[i])->name = "";
  156.             (pokemon->moves[i])->type = 0;
  157.             (pokemon->moves[i])->power_points = 0;
  158.             (pokemon->moves[i])->max_power_points = 0;
  159.             (pokemon->moves[i])->strength = 0;
  160.             pokemon->number_of_moves--;
  161.             return POKEMON_SUCCESS;
  162.         }
  163.     }
  164.     return POKEMON_MOVE_DOES_NOT_EXIST;
  165. }
  166.  
  167. int pokemonGetLevel(Pokemon pokemon) {
  168.     assert(pokemon != NULL);
  169.     int level = ((pokemon->experience / 100) + 1);
  170.     return level;
  171. }
  172.  
  173. int pokemonGetRank(Pokemon pokemon) {
  174.     assert(pokemon != NULL);
  175.     if (pokemon->number_of_moves == 0) {
  176.         return 0;
  177.     }
  178.     int average_move_strength = 0;
  179.     int i;
  180.     for (i = 0; i < pokemon->number_of_moves; i++) {
  181.         average_move_strength += (pokemon->moves[i])->strength;
  182.     }
  183.     average_move_strength /= 2;
  184.     return (pokemonGetLevel(pokemon) + average_move_strength);
  185. }
  186.  
  187. PokemonResult pokemonUseMove(Pokemon pokemon, Pokemon opponent_pokemon,
  188.                              char* move_name) {
  189.     if (pokemon == NULL || opponent_pokemon == NULL || move_name == NULL) {
  190.         return POKEMON_NULL_ARG;
  191.     }
  192.     char* empty_move_name = "";
  193.     if (strcmp(move_name, empty_move_name) == 0) {
  194.         return POKEMON_INVALID_MOVE_NAME;
  195.     }
  196.     int i;
  197.     int check_move = 0;
  198.     for (i = 0; i < pokemon->number_of_moves; i++) {
  199.         if (strcmp((pokemon->moves[i])->name, move_name) == 0) {
  200.             check_move = 1;
  201.             break;
  202.         }
  203.     }
  204.     if (!check_move) {
  205.         return POKEMON_MOVE_DOES_NOT_EXIST;
  206.     }
  207.     if (((pokemon->moves[i])->power_points) == 0) {
  208.         return POKEMON_NO_POWER_POINTS;
  209.     }
  210.     if (((pokemon->health_points) == 0)
  211.         || ((opponent_pokemon->health_points) == 0)) {
  212.         return POKEMON_NO_HEALTH_POINTS;
  213.     }
  214.     int factor = 1;
  215.     if ((((pokemon->moves[i])->type == TYPE_FIRE)
  216.          && (opponent_pokemon->type == TYPE_GRASS))
  217.         || (((pokemon->moves[i])->type == TYPE_WATER)
  218.             && (opponent_pokemon->type == TYPE_FIRE))
  219.         || (((pokemon->moves[i])->type == TYPE_GRASS)
  220.             && (opponent_pokemon->type == TYPE_WATER))
  221.         || (((pokemon->moves[i])->type == TYPE_ELECTRIC)
  222.             && (opponent_pokemon->type == TYPE_WATER))) {
  223.             factor = 2;
  224.         }
  225.     int health_points_lost = ((2 * pokemonGetLevel(pokemon)
  226.                                + ((pokemon->moves[i])->strength)) * factor);
  227.     opponent_pokemon->health_points -= health_points_lost;
  228.     if (opponent_pokemon->health_points < 0) {
  229.         health_points_lost += opponent_pokemon->health_points;
  230.         opponent_pokemon->health_points = 0;
  231.     }
  232.     ((pokemon->moves[i])->power_points)--;
  233.     pokemon->experience += health_points_lost;
  234.     if (pokemon->experience > MAXIMUM_EXPERIENCE) {
  235.         pokemon->experience = MAXIMUM_EXPERIENCE;
  236.     }
  237.     return POKEMON_SUCCESS;
  238. }
  239.  
  240. PokemonResult pokemonHeal(Pokemon pokemon) {
  241.     if (pokemon == NULL) {
  242.         return POKEMON_NULL_ARG;
  243.     }
  244.     pokemon->health_points = (100 + pokemonGetLevel(pokemon)) * 10;
  245.     int i = 0;
  246.     for (i = 0; i < pokemon->number_of_moves; i++) {
  247.         (pokemon->moves[i])->power_points =
  248.         (pokemon->moves[i])->max_power_points;
  249.     }
  250.     return POKEMON_SUCCESS;
  251. }
  252.  
  253. PokemonResult pokemonEvolve(Pokemon pokemon, char* new_name) {
  254.     if (pokemon == NULL || new_name == NULL) {
  255.         return POKEMON_NULL_ARG;
  256.     }
  257.     char* empty_new_name = "";
  258.     if (strcmp(new_name, empty_new_name) == 0) {
  259.         return POKEMON_INVALID_MOVE_NAME;
  260.     }
  261.     if (pokemon->experience >= MAXIMUM_EXPERIENCE) {
  262.         return POKEMON_CANNOT_EVOLVE;
  263.     }
  264.     pokemon->name = new_name;
  265.     if ((pokemon->experience) % 100 == 0) {
  266.         (pokemon->experience)++;
  267.     } else
  268.         pokemon->experience += (((pokemon->experience) / 100) * 100 + 101);
  269.     return POKEMON_SUCCESS;
  270. }
  271.  
  272. PokemonResult pokemonPrintName(Pokemon pokemon, FILE* file) {
  273.     if ((pokemon == NULL) || (file == NULL)) {
  274.         return POKEMON_NULL_ARG;
  275.     }
  276.     fprintf(file, "%s", pokemon->name);
  277.     return POKEMON_SUCCESS;
  278. }
  279.  
  280. PokemonResult pokemonPrintVoice(Pokemon pokemon, FILE* file) {
  281.     if ((pokemon == NULL) || (file == NULL)) {
  282.         return POKEMON_NULL_ARG;
  283.     }
  284.     int i = 0;
  285.     int count = (int)strlen(pokemon->name);
  286.     for (i = 0; i < strlen(pokemon->name); i++) {
  287.         if (!((((pokemon->name[i]) >= 'A') && ((pokemon->name[i]) <= 'Z'))
  288.               || (((pokemon->name[i]) >= 'a') && ((pokemon->name[i]) <= 'z')))) {
  289.             count--;
  290.         }
  291.     }
  292.     char* name_only_letters = malloc(sizeof(char) * count);
  293.     if (name_only_letters == NULL) {
  294.         return POKEMON_OUT_OF_MEM;
  295.     }
  296.     int j = 0;
  297.     for (i = 0; i < strlen(pokemon->name); i++) {
  298.         if ((((pokemon->name[i]) >= 'A') && ((pokemon->name[i]) <= 'Z'))
  299.             || (((pokemon->name[i]) >= 'a') && ((pokemon->name[i]) <= 'z'))) {
  300.             name_only_letters[j] = pokemon->name[i];
  301.             j++;
  302.         }
  303.     }
  304.     int length_voice = count - (count / 2);
  305.     if (count < 4) {
  306.         fprintf(file, "%s-%s", name_only_letters, name_only_letters);
  307.         free(name_only_letters);
  308.     } else {
  309.         char* half_name = malloc(sizeof(char) * length_voice);
  310.         if (half_name == NULL) {
  311.             return POKEMON_OUT_OF_MEM;
  312.         }
  313.         for (i = 0; i < length_voice; i++) {
  314.             half_name[i] = name_only_letters[i];
  315.         }
  316.         fprintf(file, "%s-%s", half_name, half_name);
  317.         free(name_only_letters);
  318.         free(half_name);
  319.     }
  320.     return POKEMON_SUCCESS;
  321. }
  322. //now I will pass pokemon_test.c
  323. #include <stdbool.h>
  324. #include "aux_macros.h"
  325. #include "pokemon.h"
  326.  
  327. static bool testCombo() {
  328.     bool result = true;
  329.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 20, 4);
  330.     TEST_DIFFERENT(result, pikachu, NULL);
  331.     Pokemon pikachu_copy = pokemonCopy(pikachu);
  332.     TEST_DIFFERENT(result, pikachu_copy, NULL);
  333.     pokemonDestroy(pikachu_copy);
  334.     TEST_EQUALS(result, pokemonTeachMove(
  335.                                          pikachu, "Thunder", TYPE_ELECTRIC, 10, 110), POKEMON_SUCCESS);
  336.     TEST_EQUALS(result, pokemonUnteachMove(pikachu, "Thunder"), POKEMON_SUCCESS);
  337.     TEST_EQUALS(result, pokemonGetLevel(pikachu), 1);
  338.     TEST_EQUALS(result, pokemonGetRank(pikachu), 0);
  339.     Pokemon squirtle = pokemonCreate("Squirtle", TYPE_WATER, 10, 4);
  340.     pokemonTeachMove(squirtle, "Bubble", TYPE_WATER, 30, 40);
  341.     TEST_EQUALS(result, pokemonUseMove(
  342.                                        squirtle, pikachu, "Bubble"), POKEMON_SUCCESS);
  343.     TEST_EQUALS(result, pokemonHeal(pikachu), POKEMON_SUCCESS);
  344.     TEST_EQUALS(result, pokemonEvolve(squirtle, "Wartortle"), POKEMON_SUCCESS);
  345.     pokemonDestroy(pikachu);
  346.     pokemonDestroy(squirtle);
  347.     return result;
  348. }
  349.  
  350. static bool testPokemonCreate() {
  351.     bool result = true;
  352.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 20, 4);
  353.     TEST_DIFFERENT(result, pikachu, NULL);
  354.     pikachu = pokemonCreate("", TYPE_ELECTRIC, 20, 4);
  355.     TEST_EQUALS(result, pikachu, NULL);
  356.     pikachu = pokemonCreate(NULL, TYPE_ELECTRIC, 20, 4);
  357.     TEST_EQUALS(result, pikachu, NULL);
  358.     pikachu = pokemonCreate("Pikachu", 666, 20, 4);
  359.     TEST_EQUALS(result, pikachu, NULL);
  360.     pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, -20, 4);
  361.     TEST_EQUALS(result, pikachu, NULL);
  362.     pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 9902, 4);
  363.     TEST_EQUALS(result, pikachu, NULL);
  364.     pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 20, 0);
  365.     TEST_EQUALS(result, pikachu, NULL);
  366.     pokemonDestroy(pikachu);
  367.     return result;
  368. }
  369.  
  370. static bool testPokemonDestroy() {
  371.     bool result = true;
  372.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 20, 4);
  373.     pokemonDestroy(NULL);
  374.     TEST_DIFFERENT(result, pikachu, NULL);
  375.     pokemonDestroy(pikachu);
  376.     TEST_EQUALS(result, pikachu, NULL);
  377.     return result;
  378. }
  379.  
  380. static bool testPokemonCopy() {
  381.     bool result = true;
  382.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 20, 4);
  383.     Pokemon pikachu_copy = pokemonCopy(pikachu);
  384.     TEST_DIFFERENT(result, pikachu_copy, NULL);
  385.     pikachu_copy = pokemonCopy(NULL);
  386.     TEST_EQUALS(result, pikachu_copy, NULL);
  387.     pokemonDestroy(pikachu);
  388.     pokemonDestroy(pikachu_copy);
  389.     return result;
  390. }
  391.  
  392. static bool testPokemonTeachMove() {
  393.     bool result = true;
  394.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 20, 4);
  395.     TEST_EQUALS(result, pokemonTeachMove(pikachu, "Thunder", TYPE_ELECTRIC, 10, 110), POKEMON_SUCCESS);
  396.     TEST_EQUALS(result, pokemonTeachMove(NULL, "Thunder", TYPE_ELECTRIC, 10, 110), POKEMON_NULL_ARG);
  397.     TEST_EQUALS(result, pokemonTeachMove(pikachu, NULL, TYPE_ELECTRIC, 10, 110), POKEMON_NULL_ARG);
  398.     TEST_EQUALS(result, pokemonTeachMove(pikachu, "", TYPE_ELECTRIC, 10, 110), POKEMON_INVALID_MOVE_NAME);
  399.     TEST_EQUALS(result, pokemonTeachMove(pikachu, "Thunder", 666, 10, 110), POKEMON_INVALID_TYPE);
  400.     TEST_EQUALS(result, pokemonTeachMove(pikachu, "Thunder", 100, 10, 110), POKEMON_INVALID_TYPE);
  401.     TEST_EQUALS(result, pokemonTeachMove(pikachu, "Thunder", TYPE_ELECTRIC, 0, 110), POKEMON_INVALID_POWER_POINTS);
  402.     TEST_EQUALS(result, pokemonTeachMove(pikachu, "Thunder", TYPE_ELECTRIC, 10, 0), POKEMON_INVALID_STRENGTH);
  403.     TEST_EQUALS(result, pokemonTeachMove(pikachu, "Bubble", TYPE_WATER, 10, 110), POKEMON_INCOMPATIBLE_MOVE_TYPE);
  404.     TEST_EQUALS(result, pokemonTeachMove(pikachu, "Thunder", TYPE_ELECTRIC, 10, 110), POKEMON_MOVE_ALREADY_EXISTS);
  405.     pokemonDestroy(pikachu);
  406.     return result;
  407. }
  408.  
  409. static bool testPokemonUnteachMove() {
  410.     bool result = true;
  411.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 20, 4);
  412.     pokemonTeachMove(pikachu, "Thunder", TYPE_ELECTRIC, 10, 110);
  413.     TEST_EQUALS(result, pokemonUnteachMove(pikachu, "Thunder"), POKEMON_SUCCESS);
  414.     TEST_EQUALS(result, pokemonUnteachMove(NULL, "Thunder"), POKEMON_NULL_ARG);
  415.     TEST_EQUALS(result, pokemonUnteachMove(pikachu, NULL), POKEMON_NULL_ARG);
  416.     TEST_EQUALS(result, pokemonUnteachMove(pikachu, ""), POKEMON_INVALID_MOVE_NAME);
  417.     TEST_EQUALS(result, pokemonUnteachMove(pikachu, "Bubble"), POKEMON_MOVE_DOES_NOT_EXIST);
  418.     pokemonDestroy(pikachu);
  419.     return result;
  420. }
  421.  
  422. static bool testPokemonGetLevel() {
  423.     bool result = true;
  424.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 20, 4);
  425.     int actual_level = (20 / 100) + 1;
  426.     TEST_EQUALS(result, pokemonGetLevel(pikachu), actual_level);
  427.     pokemonDestroy(pikachu);
  428.     return result;
  429. }
  430.  
  431. static bool testPokemonGetRank() {
  432.     bool result = true;
  433.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 20, 4);
  434.     TEST_EQUALS(result, pokemonGetRank(pikachu), 0);
  435.     int expected_rank = 0;
  436.     pokemonTeachMove(pikachu, "Thunder", TYPE_ELECTRIC, 10, 110);
  437.     expected_rank = pokemonGetLevel(pikachu) + 110;
  438.     TEST_EQUALS(result, pokemonGetRank(pikachu), expected_rank);
  439.     pokemonTeachMove(pikachu, "Thundershock", TYPE_ELECTRIC, 15, 45);
  440.     expected_rank = pokemonGetLevel(pikachu) + (110 + 45) / 2;
  441.     TEST_EQUALS(result, pokemonGetRank(pikachu), expected_rank);
  442.     pokemonTeachMove(pikachu, "Quick Attack", TYPE_NORMAL, 20, 40);
  443.     expected_rank = pokemonGetLevel(pikachu) + (110 + 45 + 40) / 3;
  444.     TEST_EQUALS(result, pokemonGetRank(pikachu), expected_rank);
  445.     pokemonTeachMove(pikachu, "Thunderbolt", TYPE_ELECTRIC, 15, 90);
  446.     expected_rank = pokemonGetLevel(pikachu) + (110 + 45 + 40 + 90) / 4;
  447.     TEST_EQUALS(result, pokemonGetRank(pikachu), expected_rank);
  448.     pokemonDestroy(pikachu);
  449.     return result;
  450. }
  451.  
  452. static bool testPokemonUseMove() {
  453.     bool result = true;
  454.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 1000, 4);
  455.     Pokemon squirtle = pokemonCreate("Squirtle", TYPE_WATER, 10, 4);
  456.     pokemonTeachMove(pikachu, "Thunder", TYPE_ELECTRIC, 1, 110);
  457.     TEST_EQUALS(result, pokemonUseMove(pikachu, squirtle, "Thunder"), POKEMON_SUCCESS);
  458.     TEST_EQUALS(result, pokemonUseMove(pikachu, squirtle, "Thunder"), POKEMON_NO_POWER_POINTS);
  459.     TEST_EQUALS(result, pokemonUseMove(NULL, squirtle, "Thunder"), POKEMON_NULL_ARG);
  460.     TEST_EQUALS(result, pokemonUseMove(pikachu, NULL, "Thunder"), POKEMON_NULL_ARG);
  461.     TEST_EQUALS(result, pokemonUseMove(pikachu, squirtle, NULL), POKEMON_NULL_ARG);
  462.     TEST_EQUALS(result, pokemonUseMove(pikachu, squirtle, ""), POKEMON_INVALID_MOVE_NAME);
  463.     TEST_EQUALS(result, pokemonUseMove(pikachu, squirtle, "Tackle"), POKEMON_MOVE_DOES_NOT_EXIST);
  464.     pokemonTeachMove(pikachu, "Thunderbolt", TYPE_ELECTRIC, 15, 1000);
  465.     pokemonUseMove(pikachu, squirtle, "Thunderbolt");
  466.     TEST_EQUALS(result, pokemonUseMove(pikachu, squirtle, "Thunderbolt"), POKEMON_NO_HEALTH_POINTS);//caso in cui va a -0
  467.     Pokemon charizard = pokemonCreate("Charizard", TYPE_FIRE, 200, 4);
  468.     TEST_EQUALS(result, pokemonUseMove(pikachu, charizard, "Thunderbolt"), POKEMON_NO_HEALTH_POINTS);//caso in cui va a 0
  469.     Pokemon charmander = pokemonCreate("Charmander", TYPE_FIRE, 5000, 4);
  470.     pokemonUseMove(pikachu, charmander, "Thunderbolt");
  471.     TEST_DIFFERENT(result, pokemonUseMove(pikachu, charmander, "Thunderbolt"), POKEMON_NO_HEALTH_POINTS);//caso in cui e ancora vivo
  472.     pokemonTeachMove(squirtle, "Bubble", TYPE_WATER, 30, 40);
  473.     TEST_EQUALS(result, pokemonUseMove(squirtle, pikachu, "Bubble"), POKEMON_NO_HEALTH_POINTS);
  474.     pokemonDestroy(pikachu);
  475.     pokemonDestroy(squirtle);
  476.     pokemonDestroy(charizard);
  477.     pokemonDestroy(charmander);
  478.     return result;
  479. }
  480.  
  481. static bool testPokemonHeal() {
  482.     bool result = true;
  483.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 900, 4);
  484.     Pokemon squirtle = pokemonCreate("Squirtle", TYPE_WATER, 10, 4);
  485.     pokemonTeachMove(pikachu, "Thunderbolt", TYPE_ELECTRIC, 2, 500);
  486.     pokemonUseMove(pikachu, squirtle, "Thunderbolt");
  487.     TEST_EQUALS(result, pokemonHeal(squirtle), POKEMON_SUCCESS);
  488.     TEST_EQUALS(result, pokemonHeal(NULL), POKEMON_NULL_ARG);
  489.     TEST_DIFFERENT(result, pokemonUseMove(pikachu, squirtle, "Thunderbolt"), POKEMON_NO_HEALTH_POINTS);
  490.     pokemonHeal(pikachu);
  491.     pokemonHeal(squirtle);
  492.     TEST_DIFFERENT(result, pokemonUseMove(pikachu, squirtle, "Thunderbolt"), POKEMON_NO_POWER_POINTS);
  493.     pokemonDestroy(pikachu);
  494.     pokemonDestroy(squirtle);
  495.     return result;
  496. }
  497.  
  498. static bool testPokemonEvolve() {
  499.     bool result = true;
  500.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 900, 4);
  501.     TEST_EQUALS(result, pokemonEvolve(pikachu, "Raichu"), POKEMON_SUCCESS);
  502.     TEST_EQUALS(result, pokemonEvolve(NULL, "Raichu"), POKEMON_NULL_ARG);
  503.     TEST_EQUALS(result, pokemonEvolve(pikachu, NULL), POKEMON_NULL_ARG);
  504.     TEST_EQUALS(result, pokemonEvolve(pikachu, ""), POKEMON_INVALID_MOVE_NAME);
  505.     Pokemon squirtle = pokemonCreate("Squirtle", TYPE_WATER, 9901, 4);
  506.     TEST_EQUALS(result, pokemonEvolve(squirtle, "Wartartle"), POKEMON_CANNOT_EVOLVE);
  507.     Pokemon bulbasaur = pokemonCreate("Bulbasaur", TYPE_GRASS, 9900, 4);
  508.     pokemonEvolve(bulbasaur, "Ivysaur");
  509.     TEST_DIFFERENT(result, pokemonEvolve(bulbasaur, "Venusaur"), POKEMON_CANNOT_EVOLVE);
  510.     Pokemon charmander = pokemonCreate("Charmander", TYPE_FIRE, 9850, 4);
  511.     pokemonEvolve(charmander, "Charmeleon");
  512.     TEST_DIFFERENT(result, pokemonEvolve(charmander, "Charizard"), POKEMON_CANNOT_EVOLVE);
  513.     pokemonDestroy(pikachu);
  514.     pokemonDestroy(squirtle);
  515.     pokemonDestroy(bulbasaur);
  516.     pokemonDestroy(charmander);
  517.     return result;
  518. }
  519.  
  520. static bool testPokemonPrintName() {
  521.     bool result = true;
  522.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 20, 4);
  523.     TEST_EQUALS(result, pokemonPrintName(NULL, stdout), POKEMON_NULL_ARG);
  524.     TEST_EQUALS(result, pokemonPrintName(pikachu, NULL), POKEMON_NULL_ARG);
  525.     TEST_EQUALS(result, pokemonPrintName(pikachu, stdout), POKEMON_SUCCESS);
  526.     pokemonDestroy(pikachu);
  527.     return result;
  528. }
  529.  
  530. static bool testPokemonPrintVoice() {
  531.     bool result = true;
  532.     Pokemon pikachu = pokemonCreate("Pikachu", TYPE_ELECTRIC, 20, 4);
  533.     TEST_EQUALS(result, pokemonPrintName(NULL, stdout), POKEMON_NULL_ARG);
  534.     TEST_EQUALS(result, pokemonPrintName(pikachu, NULL), POKEMON_NULL_ARG);
  535.     TEST_EQUALS(result, pokemonPrintName(pikachu, stdout), POKEMON_SUCCESS);
  536.     pokemonDestroy(pikachu);
  537.     return result;
  538. }
  539.  
  540. int main() {
  541.     RUN_TEST(testCombo);
  542.     RUN_TEST(testPokemonCreate);
  543.     RUN_TEST(testPokemonDestroy);
  544.     RUN_TEST(testPokemonCopy);
  545.     RUN_TEST(testPokemonTeachMove);
  546.     RUN_TEST(testPokemonUnteachMove);
  547.     RUN_TEST(testPokemonGetLevel);
  548.     RUN_TEST(testPokemonGetRank);
  549.     RUN_TEST(testPokemonUseMove);
  550.     RUN_TEST(testPokemonHeal);
  551.     RUN_TEST(testPokemonEvolve);
  552.     RUN_TEST(testPokemonPrintName);
  553.     RUN_TEST(testPokemonPrintVoice);
  554.     return 0;
  555. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!