testGame.c~

/****************
 *  testGame.c  *
 *****************************************
 * Tests the interface functions of the  *
 * Game ADT to ensure the model of the   *
 * game state responds appropriately to  *
 * actions and requests.                 *
 *****************************************
 *
 * Group Members:
 * Bruce Huang, David Zhao, James Payor, Lucas Pickup
 *
 * HS1917 - Hornsby Tute (Karla Burnett, Beth Crane)
 *
 *  Created 21/04/12
 *  Version 1.3 - Last Modified 10:00 24/4
[Please increment the sub-version & update the rough time]
 *
 */


#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "Game.h"

#define BQN STUDENT_BQN
#define MMON STUDENT_MMONEY
#define MJ STUDENT_MJ
#define BPS STUDENT_BPS
#define MTV STUDENT_MTV
#define THD STUDENT_THD

#define NUM_STUDENT_TYPES 6
#define VAL_BQN 0
#define VAL_MMON 1
#define VAL_MJ 2
#define VAL_BPS 3
#define VAL_MTV 4
#define VAL_THD 5

#define DEFAULT_DISCIPLINES {BQN,MMON,MJ,MMON,MJ,BPS,MTV,MTV,BPS,MTV,BQN,MJ,BQN,THD,MJ,MMON,MTV,BQN,BPS}
#define DEFAULT_DICE {9,10,8,12,6,5,3,11,3,11,4,6,4,9,9,2,8,10,5}

#define MIN_DICE_VALUE 2
#define MAX_DICE_VALUE 12

#define TEST_NEW_GAME_CASES 4
#define TEST_GET_TURN_NUMBER_TURNS 150

#define NUM_ACTIONS 8

void testNewGame (void);
void testGetTurnNumber (void);
void testStudentAllocationAndMakeAction (void);
int randomValue (int start, int end);
void testisLegalAction (void)

int main (int argc, const char * argv[]) {

    // Tests creating the new game, the initial turn number,
    // and getDiscipline and getDiceValue for random maps.
    testNewGame();

    // Checks that the turn number is incremented correctly
    // after each dice throw, using throwDice and getTurnNumber.
    testGetTurnNumber();

    // Checks that the game state is updated correctly after each dice
    // throw (e.g. students allocated to universities, conversions to
    // THDs) and that the game state is updated correctly after each
    // action (students removed, game state updated) using a sample
    // sequence of dice throws and actions.
    testStudentAllocationAndMakeAction();


    printf ("All tests passed!\nYou are Awesome\n");
    return EXIT_SUCCESS;
}

int randomValue (int start, int end) {

    int range = end - start;
    int value = rand() / (double)RAND_MAX * range + start;

    return value;

}

void testNewGame (void) {

    printf ("Now testing 'newGame':\n");
    printf ("1) First turn number == -1\n");
    prinft ("2) Regions initialised correctly (displine and dice values correct)\n");

    // check makes a game without crashing
    int disciplines[NUM_REGIONS];
    int dice [NUM_REGIONS];

    int testCase = 0;
    while (testCase < TEST_NEW_GAME_CASES) {

        int regionID = 0;
        while (regionID < NUM_REGIONS) {

            int studentVal = randomValue(0, NUM_STUDENT_TYPES);
            int student = 0;

            if (studentVal == VAL_BQN) {
                student = BQN;
            } else if (studentVal == VAL_MMON) {
                student = MMON;
            } else if (studentVal == VAL_MJ) {
                student = MJ;
            } else if (studentVal == VAL_BPS) {
                student = BPS;
            } else if (studentVal == VAL_MTV) {
                student = MTV;
            } else {
                student = THD;
            }

            disciplines[regionID] = student;
            dice[regionID] = randomValue(MIN_DICE_VAL, MAX_DICE_VAL);

            regionID++;
        }

        Game g = newGame (disciplines, dice);

        assert (getTurnNumber(g) == -1);

        regionID = 0;
        while (regionID < NUM_REGIONS) {

            assert (getDiscipline(g, regionID) == disciplines[regionID]);
            assert (getDiceValue(g, regionID) == dice[regionID]);

            regionID++;
        }

        disposeGame (g);

        testCase++;
    }

    printf ("Passed\n");
}

void testGetTurnNumber (void) {

    printf ("Now testing getTurnNumber...   ");

    // Create game:
    int disciplines[] = DEFAULT_DISCIPLINES;
    int dice[] = DEFAULT_DICE;
    Game g = newGame (disciplines, dice);

    // Check turns:
    int turnNum = -1;
    while (turnNum < TEST_GET_TURN_NUMBER_TURNS) {
        assert (getTurnNumber(g) == turnNum);

        throwDice(g, randomValue(2,12))
        turnNum++;
    }

    disposeGame (g);
    printf ("Passed\n");
}


// NOTE:  IS MAKEACTION(g, PASS_ACTION) required to end turn?  or just THROWDICE?
// Unsure on this, might ahve to ask a tutor.
void testStudentAllocationAndMakeAction (void) {

    printf ("Now testing updating of students after dice throws and actions.\n");

    // Create game:
    int disciplines[] = DEFAULT_DISCIPLINES;
    int dice[] = DEFAULT_DICE;
    Game g = newGame (disciplines, dice);

    // Throw the dice once, not giving any players students, to move the
    // current turn to '0' rather than '-1':
    throwDice(g, 3);

    // Allocate 300 students to each player through numerous dice throws!
    int throws = 0;
    while (throws < 150) {

        // Trigger each hexagon with an adjoined campus:

        throwDice(g, 11); // 1 MTV to player 1
        throwDice(g, 6);  // 1 MJ to player 1

        throwDice(g, 9); // 1 BQN to player 2
        throwDice(g, 9); // 1 BQN to player 2
        throwDice(g, 9); // 1 BQN to player 2
        throwDice(g, 5); // 1 BPS to player 2
        throwDice(g, 5); // 1 BPS to player 2
        throwDice(g, 5); // 1 BPS to player 2

        throwDice(g, 8); // 1 MJ and 1 MTV to player 3
    }

    /* At this point:
     *  - Turn number is [150 * 9 = ] 1350
     *  - Number of turns mod 3 is 0, therefore player 1's (UNI_A) turn to roll.
     *  - Player 1 has 150 MJs and 150 MTVs
     *  - Player 2 has 450 BQNs and 450 BPSs
     *  - Player 3 has 150 MJs and 150 MTVs
    */

    // Ensure game state has been updated correctly:

    printf ("Ensuring 'getTurnNumber' and 'getWhoseTurn' return correct values.\n");
    assert (getTurnNumber(g) == 750);
    assert (getWhoseTurn(g) == UNI_A);

    printf ("Ensuring UNI_A has been allocated the correct number of players.\n");
    assert (getStudents(g, UNI_A, STUDENT_BPS)    == 0);
    assert (getStudents(g, UNI_A, STUDENT_BQN)    == 0);
    assert (getStudents(g, UNI_A, STUDENT_MJ)     == 150);
    assert (getStudents(g, UNI_A, STUDENT_MTV)    == 150);
    assert (getStudents(g, UNI_A, STUDENT_MMONEY) == 0);
    assert (getStudents(g, UNI_A, STUDENT_THD)    == 0);

    printf ("Ensuring UNI_B has been allocated the correct number of players.\n");
    assert (getStudents(g, UNI_B, STUDENT_BPS)    == 450);
    assert (getStudents(g, UNI_B, STUDENT_BQN)    == 450);
    assert (getStudents(g, UNI_B, STUDENT_MJ)     == 0);
    assert (getStudents(g, UNI_B, STUDENT_MTV)    == 0);
    assert (getStudents(g, UNI_B, STUDENT_MMONEY) == 0);
    assert (getStudents(g, UNI_B, STUDENT_THD)    == 0);

    printf ("Ensuring UNI_C has been allocated the correct number of players.\n");
    assert (getStudents(g, UNI_C, STUDENT_BPS)    == 0);
    assert (getStudents(g, UNI_C, STUDENT_BQN)    == 0);
    assert (getStudents(g, UNI_C, STUDENT_MJ)     == 150);
    assert (getStudents(g, UNI_C, STUDENT_MTV)    == 150);
    assert (getStudents(g, UNI_C, STUDENT_MMONEY) == 0);
    assert (getStudents(g, UNI_C, STUDENT_THD)    == 0);



    // Convert UNI_B's BQNs and BPSs into MJs and MTVs, so that each
    // UNI has the same numbers of students:
    printf ("Testing basic student conversion.\n");

    // Move turn to UNI_B from UNI_A (without giving the UNIs students):
    throwDice(g, 3);

    action convertStudents;
    convertStudents.actionCode = RETRAIN_STUDENTS;

    // Convert BPSs into MJs:
    convertStudents.disciplineFrom = STUDENT_BPS;
    convertStudents.disciplineTo = STUDENT_MJ;

    int numConversions = 0;
    while (numConversions < 150) {
        makeAction(g, convertStudents);
    }

    // Ensure the counts have been updated correctly:
    assert (getStudents(g, UNI_B, STUDENT_BPS) == 0);
    assert (getStudents(g, UNI_B, STUDENT_MJ)  == 150);


    // Convert BQNs into MTVs:
    convertStudents.disciplineFrom = STUDENT_BQN;
    convertStudents.disciplineTo = STUDENT_MTV;

    int numConversions = 0;
    while (numConversions < 150) {
        makeAction(g, convertStudents);
    }

    // Ensure the counts have been updated correctly:
    assert (getStudents(g, UNI_B, STUDENT_BQN) == 0);
    assert (getStudents(g, UNI_B, STUDENT_MTV) == 150);


    // Now each UNI has 150 MTVs and 150 MJs.

    // Set turn to UNI_A:
    throwDice(g, 3); // Now UNI_C's turn
    throwDice(g, 3); // Now UNI_A's turn



    // Get each UNI to perform path-based and path-less actions:
    int activeUNI = UNI_A;
    while (activeUNI != NO_ONE) {

        action testAction;

        testAction.actionCode = PASS


        // Set activeUNI to the next UNI
        // Note: incrementing not used because the values of the
        //       constants are not guaranteed.
        throwDice(g, 3);
        if (activeUNI == UNI_A) {
            activeUNI = UNI_B;
        } else if (activeUNI == UNI_B) {
            activeUNI = UNI_C;
        } else {
            activeUNI = NO_ONE;
        }
    }



    disposeGame (g);
    printf ("Passed\n");
}

// Tests weather a games isLegalAction function will allow a player to
// directly obtain IP or Paper. As well as moves during 'terra-nullis'.
void testisLegalAction (void) {
    action testAction;

    // Create game:
    int disciplines[] = DEFAULT_DISCIPLINES;
    int dice[] = DEFAULT_DICE;
    Game g = newGame (disciplines, dice);

    int actionLoop = 0;
    while (actionLoop < NUM_ACTIONS){
        testAction.actionCode = actionLoop;
        assert (isLegalAction(g, testAction.actionCode) == FALSE);
    }

    // Advance from 'terra-nullis' where normal actions are legal.
    throwDice(g, 3);
    throwDice(g, 3);

    // Test OBTAIN_IP_PATENT
    testAction.actionCode = OBTAIN_IP_PATENT;
    assert (isLegalAction(g, testAction.actionCode) == FALSE);

    // Test OBTAIN_PUBLICATION
    testAction.actionCode = OBTAIN_PUBLICATION;
    assert (isLegalAction(g, testAction.actionCode) == FALSE);

    // Test that PASS is allowed
    testAction.actionCode = PASS;
    assert (isLegalAction(g, testAction.actionCode) == TRUE);
}