static void
test_free(TestCaseState_t *tcs, Allctr_t *a, Ulong bsz)
{
Block_t *blk;
void *p[7];
testcase_printf(tcs," --- Testing free() with block size %lu ---\n",bsz);
setup_sequence(tcs, a, bsz, 7, p);
check_ablk(tcs, a, p[0], bsz);
check_ablk(tcs, a, p[1], bsz);
check_ablk(tcs, a, p[2], bsz);
check_ablk(tcs, a, p[3], bsz);
check_ablk(tcs, a, p[4], bsz);
check_ablk(tcs, a, p[5], bsz);
check_ablk(tcs, a, p[6], bsz);
/* Coalescing with previous block */
FREE(a, p[2]);
FREE(a, p[3]);
blk = NXT_BLK(UMEM2BLK(p[1]));
ASSERT(tcs, IS_FREE_BLK(blk));
ASSERT(tcs, NXT_BLK(blk) == UMEM2BLK(p[4]));
/* Coalescing with next block */
FREE(a, p[1]);
blk = NXT_BLK(UMEM2BLK(p[0]));
ASSERT(tcs, IS_FREE_BLK(blk));
ASSERT(tcs, NXT_BLK(blk) == UMEM2BLK(p[4]));
/* Coalescing with next and previous block */
FREE(a, p[5]);
FREE(a, p[4]);
blk = NXT_BLK(UMEM2BLK(p[0]));
ASSERT(tcs, IS_FREE_BLK(blk));
ASSERT(tcs, NXT_BLK(blk) == UMEM2BLK(p[6]));
/* Cleanup */
FREE(a, p[0]);
FREE(a, p[6]);
testcase_printf(tcs," --- free() with block size %lu succeded ---\n",bsz);
}
int main() {
//initialize and clear 7-Segment Display (assembly subroutine)
setup_sequence();
seg_driver_initialize();
seg_driver(0);
//check for wav file
lcd.cls();
lcd.printf("Locating WAV file...");
FILE *test_file;
while(1) {
test_file=fopen(BOMB_WAVFILE,"r");
if(test_file != NULL) {
lcd.printf("File not found");
break;
}
wait(0.5);
}
fclose(test_file);
lcd.cls();
//notification
lcd.cls();
lcd.printf("Battleship");
wait(1);
while(1) {
//synchronize front end display
startGame();
print("Lets play!");
//Re-Init board
for(int i = 0; i<10; i++) {
for(int j = 0; j<10; j++) {
board[i][j] = -2;
}
}
//Re-Init gloabls
int shipsizes[] = {2, 3, 3, 4, 5};
aliveSize[0] = 2;
aliveSize[1] = 3;
aliveSize[2] = 3;
aliveSize[3] = 4;
aliveSize[4] = 5;
sunkenShips = 0; //# of sunken ships
numBombs = 0;
int shotResult = -1;
while(sunkenShips<5) {
//Calculate board probability
probality();
//bomb best move
chooseNext();
//print("Hitting Row: %d, Col: %d", max_row, max_col);
shotResult = placeBomb(max_row, max_col);
//print("Result: %d", shotResult);
//Got a hit, sink the bastard
if(shotResult == HIT) {
sinkIt(max_row, max_col);
}
}//Finished game!
lcd.cls();
lcd.printf("GAME OVER!");
}
}
static void
test_realloc(TestCaseState_t *tcs, Allctr_t *a, Ulong bsz)
{
Block_t *blk;
void *ptr;
void *p[3];
Ulong nbsz;
testcase_printf(tcs," --- Testing realloc() with block size %lu ---\n",
bsz);
setup_sequence(tcs, a, bsz, 3, p);
check_ablk(tcs, a, p[0], bsz);
check_ablk(tcs, a, p[1], bsz);
check_ablk(tcs, a, p[2], bsz);
/* Grow to the end of the carrier */
blk = NXT_BLK(UMEM2BLK(p[2]));
ASSERT(tcs, IS_FREE_BLK(blk));
ASSERT(tcs, IS_LAST_BLK(blk));
nbsz = bsz + BLK_SZ(blk);
ptr = REALLOC(a, p[2], nbsz);
ASSERT(tcs, p[2] == ptr);
check_ablk(tcs, a, p[2], nbsz);
blk = UMEM2BLK(p[2]);
ASSERT(tcs, IS_LAST_BLK(blk));
/* Shrink from the end of the carrier */
ptr = REALLOC(a, p[2], bsz);
ASSERT(tcs, p[2] == ptr);
blk = UMEM2BLK(p[2]);
ASSERT(tcs, !IS_LAST_BLK(blk));
blk = NXT_BLK(blk);
ASSERT(tcs, IS_LAST_BLK(blk));
check_ablk(tcs, a, p[2], bsz);
/* Shrink and coalecse with next free */
FREE(a, p[1]);
blk = NXT_BLK(UMEM2BLK(p[0]));
ASSERT(tcs, IS_FREE_BLK(blk));
nbsz = bsz/2;
ptr = REALLOC(a, p[0], nbsz);
ASSERT(tcs, p[0] == ptr);
check_ablk(tcs, a, p[0], nbsz);
blk = NXT_BLK(UMEM2BLK(p[0]));
ASSERT(tcs, IS_FREE_BLK(blk));
ASSERT(tcs, NXT_BLK(blk) == UMEM2BLK(p[2]));
/* Grow into next free; but leave free block at end */
nbsz *= 3;
ptr = REALLOC(a, p[0], nbsz);
ASSERT(tcs, p[0] == ptr);
check_ablk(tcs, a, p[0], nbsz);
blk = NXT_BLK(UMEM2BLK(p[0]));
ASSERT(tcs, IS_FREE_BLK(blk));
ASSERT(tcs, NXT_BLK(blk) == UMEM2BLK(p[2]));
/* Grow upto next alloced block by allocating just enough so that no
free block fits between them */
nbsz = BLK_SZ(blk) + UMEM_SZ(UMEM2BLK(p[0]));
nbsz -= MIN_BLK_SZ(a) - 1;
ptr = REALLOC(a, p[0], nbsz);
ASSERT(tcs, p[0] == ptr);
check_ablk(tcs, a, p[0], nbsz);
blk = NXT_BLK(UMEM2BLK(p[0]));
ASSERT(tcs, !IS_FREE_BLK(blk));
ASSERT(tcs, blk == UMEM2BLK(p[2]));
/* Grow into unused part at end */
nbsz += MIN_BLK_SZ(a) - 1;
ptr = REALLOC(a, p[0], nbsz);
ASSERT(tcs, p[0] == ptr);
check_ablk(tcs, a, p[0], nbsz);
ASSERT(tcs, !IS_FREE_BLK(blk));
ASSERT(tcs, blk == UMEM2BLK(p[2]));
/* Shrink *almost* as much so that a free block would fit between the
allocated blocks, and make sure that we don't get a free block
in between */
nbsz -= MIN_BLK_SZ(a) - 1;
ptr = REALLOC(a, p[0], nbsz);
ASSERT(tcs, p[0] == ptr);
check_ablk(tcs, a, p[0], nbsz);
blk = NXT_BLK(UMEM2BLK(p[0]));
ASSERT(tcs, !IS_FREE_BLK(blk));
ASSERT(tcs, blk == UMEM2BLK(p[2]));
/* Shrink just as much so that a free block can fit between
the alloced blocks */
nbsz -= 1;
ptr = REALLOC(a, p[0], nbsz);
ASSERT(tcs, p[0] == ptr);
check_ablk(tcs, a, p[0], nbsz);
blk = NXT_BLK(UMEM2BLK(p[0]));
ASSERT(tcs, IS_FREE_BLK(blk));
ASSERT(tcs, blk < UMEM2BLK(p[2]));
ASSERT(tcs, NXT_BLK(blk) == UMEM2BLK(p[2]));
/* Shrink so little that no free block would fit between allocated
blocks, and make sure that we shrink the allocated block and
coalesce the extra free part with the next free block. */
nbsz -= MIN_BLK_SZ(a) - 1;
ptr = REALLOC(a, p[0], nbsz);
ASSERT(tcs, p[0] == ptr);
check_ablk(tcs, a, p[0], nbsz);
blk = NXT_BLK(UMEM2BLK(p[0]));
ASSERT(tcs, IS_FREE_BLK(blk));
ASSERT(tcs, blk < UMEM2BLK(p[2]));
ASSERT(tcs, NXT_BLK(blk) == UMEM2BLK(p[2]));
/* Cleanup */
FREE(a, p[0]);
FREE(a, p[2]);
testcase_printf(tcs, " --- realloc() with block size %lu succeded ---\n",
bsz);
}
