KUSB_EXP BOOL KUSB_API OvlK_Init(
_out KOVL_POOL_HANDLE* PoolHandle,
_in KUSB_HANDLE UsbHandle,
_in INT MaxOverlappedCount,
_inopt KOVL_POOL_FLAG Flags)
{
PKOVL_POOL_HANDLE_INTERNAL handle = NULL;
PKUSB_HANDLE_INTERNAL usbHandle;
int i;
*PoolHandle = NULL;
ErrorParamAction(!IsHandleValid(PoolHandle), "PoolHandle", return FALSE);
ErrorParamAction(MaxOverlappedCount > 256, "MaxOverlappedCount cannot be greater than 256", return FALSE);
Pub_To_Priv_UsbK(UsbHandle, usbHandle, return FALSE);
handle = PoolHandle_Acquire_OvlPoolK(Cleanup_OvlPoolK);
ErrorNoSetAction(!IsHandleValid(handle), return FALSE, "->PoolHandle_Acquire_OvlPoolK");
handle->Flags = Flags;
ErrorSet(!PoolHandle_Inc_UsbK(usbHandle), UsbHandleError, ERROR_RESOURCE_NOT_AVAILABLE, "->PoolHandle_Inc_UsbK");
handle->UsbHandle = usbHandle;
handle->MasterArray = Mem_Alloc(sizeof(KOVL_EL) * MaxOverlappedCount);
ErrorMemory(!handle->MasterArray, Error);
handle->MasterListCount = MaxOverlappedCount;
for(i = 0; i < MaxOverlappedCount; i++)
{
DL_APPEND(handle->ReleasedList, &handle->MasterArray[i]);
}
handle->Flags = Flags;
*PoolHandle = (KOVL_POOL_HANDLE)handle;
PoolHandle_Live_OvlPoolK(handle);
return TRUE;
Error:
PoolHandle_Dec_UsbK(usbHandle);
UsbHandleError:
if (handle) PoolHandle_Dec_OvlPoolK(handle);
return FALSE;
}
KUSB_EXP BOOL KUSB_API OvlK_Release(
_in KOVL_HANDLE OverlappedK)
{
PKOVL_HANDLE_INTERNAL overlapped = NULL;
BOOL success = FALSE;
Pub_To_Priv_OvlK(OverlappedK, overlapped, return FALSE);
ErrorParamAction(!PoolHandle_Inc_OvlK(overlapped), "OverlappedK", return FALSE);
success = overlapped->Pool ? (InterlockedExchange(&overlapped->IsAcquired, 0) != 0) : FALSE;
ErrorSet(!success, Done, ERROR_ACCESS_DENIED, "OverlappedK is not acquired.");
DL_DELETE(overlapped->Pool->AcquiredList, overlapped->MasterLink);
DL_PREPEND(overlapped->Pool->ReleasedList, overlapped->MasterLink);
Done:
PoolHandle_Dec_OvlK(overlapped);
return success;
}
int main()
{
struct gameState G;
struct Player P;
struct Errors E;
struct TotalErrors TE;
int i, j; //loop controllers
int r; //for game initialization
int seed = 1000;
int numPlayers = 2;
int k[10] = { adventurer, embargo, village, great_hall, mine, cutpurse,
sea_hag, tribute, smithy, council_room };
srand(time(NULL));
int randCard;
int successfulRuns = 0;
/* -----Opponent Grid-----
0 1 2
0 player 2 handCount deckCount discardCount
1 player 3 handCount deckCount discardCount
2 player 4 handCount deckCount discardCount
*/
int opponentPreGrid[MAX_PLAYERS - 1][3];
//set total errors for run
TotalErrorSet (&TE);
printf("\n-----STARTING TESTING FOR SMITHY----- \n");
for (i = 0; i < 100; i++)
{
printf("\n---TEST %d---\n", (i+1));
//initialize game
memset(&G, 23, sizeof(struct gameState));
r = initializeGame(numPlayers, k, seed, &G);
//check to make sure game initialized properly
if (r < 0)
{
printf("Game Initialization Failed!\n");
exit(-1);
}
//randomize game
do{
// set the counters
P.preTreasureCount = 0;
//randomize player hand
G.handCount[0] = rand() % MAX_HAND;
P.preHandCount = G.handCount[0];
printf("Pre Hand Count: %d\n", P.preHandCount);
//set the first card as adventurer
G.hand[0][0] = smithy;
for (j = 1; j < P.preHandCount; j++)
{
randCard = rand() % 27;
G.hand[0][j] = randCard;
if (randCard == copper || randCard == silver || randCard == gold)
{
P.preTreasureCount++;
}
}
//randomize player deck
G.deckCount[0] = rand() % (MAX_DECK - P.preHandCount);
P.preDeckCount = G.deckCount[0];
printf("Pre Deck Count: %d\n", P.preDeckCount);
for (j = 0; j < P.preDeckCount; j++)
{
randCard = rand() % 27;
G.hand[0][j] = randCard;
if (randCard == copper || randCard == silver || randCard == gold)
{
P.preTreasureCount++;
}
}
//randomize player discard
G.discardCount[0] = rand() % (MAX_DECK - P.preHandCount - P.preDeckCount + 1);
P.preDiscardCount = G.discardCount[0];
printf("Pre Discard Count: %d\n", P.preDiscardCount);
for (j = 0; j < P.preDiscardCount; j++)
{
randCard = rand() % 27;
G.hand[0][j] = randCard;
if (randCard == copper || randCard == silver || randCard == gold)
{
P.preTreasureCount++;
}
}
//treasure total
printf("Pre Treasure Count: %d\n", P.preTreasureCount);
//randomize actions, buys, and coins
G.numActions = rand() % 100;
P.preActions = G.numActions;
printf("Pre Hand Count: %d\n", P.preActions);
G.numBuys = rand() % 100;
P.preBuys = G.numBuys;
printf("Pre Hand Count: %d\n", P.preBuys);
G.coins = rand() % 100;
P.preCoins = G.coins;
printf("Pre Hand Count: %d\n", P.preCoins);
//get opponent pre-conditions
for (j = 1; j < numPlayers; j++)
{
opponentPreGrid[j][0] = G.handCount[j];
printf("Opponent %d Pre Hand Count: %d\n", (j + 1), opponentPreGrid[j][0]);
opponentPreGrid[j][1] = G.deckCount[j];
printf("Opponent %d Pre Hand Count: %d\n", (j + 1), opponentPreGrid[j][1]);
opponentPreGrid[j][2] = G.discardCount[j];
printf("Opponent %d Pre Hand Count: %d\n", (j + 1), opponentPreGrid[j][2]);
}
if ((P.preDeckCount + P.preDiscardCount) < 10)
printf("---Did not randomize properly. Trying again---\n");
}while ((P.preDeckCount + P.preDiscardCount) < 10);
//set the errors struct for the run
ErrorSet(&E);
//play the card
cardEffect(smithy, 0, 0, 0, &G, 0, 0);
//check the conditions
//check actions first
P.postActions = G.numActions;
if(P.postActions != P.preActions)
{
printf("Expected Action Count: %d. Actual: %d. Failed!\n",
P.preActions, P.postActions);
E.actionsErrors++;
E.runErrors++;
}
//check the number of buys
P.postBuys = G.numBuys;
if(P.postBuys != P.preBuys)
{
printf("Expected Buy Count: %d. Actual: %d. Failed!\n",
P.preBuys, P.postBuys);
E.buysErrors++;
E.runErrors++;
}
//check coins
P.postCoins = G.coins;
if(P.postCoins != P.preCoins)
{
printf("Expected Coin Count: %d. Actual: %d. Failed!\n",
P.preCoins, P.postCoins);
E.coinsErrors++;
E.runErrors++;
}
//set the counter for post treasure
P.postTreasureCount = 0;
//set the post conditions for hand, deck, and discard
P.postHandCount = G.handCount[0];
P.postDeckCount = G.deckCount[0];
P.postDiscardCount = G.discardCount[0];
//check the hand, deck, and discard conditions. Hand should increase by 1
// and deck + discard should decrease by 1
// hand count
if (P.postHandCount != P.preHandCount + 1)
{
printf("Expected Hand Count: %d. Actual: %d. Failed!\n",
P.preHandCount + 1, P.postHandCount);
E.handCountErrors++;
E.runErrors++;
}
//deck count + discard count
if ((P.postDeckCount + P.postDiscardCount) != (P.preDeckCount + P.preDiscardCount - 1));
{
printf("Expected Deck and Discard Count: %d. Actual: %d. Failed!\n",
(P.preDeckCount + P.preDiscardCount - 1), (P.postDeckCount + P.postDiscardCount));
E.remainingCardCountErrors++;
E.runErrors++;
}
//count through hand, deck, and discard for treasure cards verify count
// hand treasure
for (j = 0; j < P.postHandCount; j++)
{
if (G.hand[0][j] == copper || G.hand[0][j] == silver || G.hand[0][j] == gold)
{
P.postTreasureCount++;
}
}
//deck treasure count
for (j = 0; j < P.postDeckCount; j++)
{
if (G.hand[0][j] == copper || G.hand[0][j] == silver || G.hand[0][j] == gold)
{
P.postTreasureCount++;
}
}
//discard errors
for (j = 0; j < P.postDiscardCount; j++)
{
if (G.hand[0][j] == copper || G.hand[0][j] == silver || G.hand[0][j] == gold)
{
P.postTreasureCount++;
}
}
//check the total treasure count
if(P.postTreasureCount != P.preTreasureCount)
{
printf("Expected Post Treasure Count: %d. Actual: %d. Failed!\n",
P.preTreasureCount, P.postTreasureCount);
E.treasureCountErrors++;
E.runErrors++;
}
//check opponent conditions
for (j = 1; j < numPlayers; j++)
{
if (opponentPreGrid[j][0] != G.handCount[j])
{
printf("Expected Opponent %d Post Hand Count: %d. Actual: %d. Failed!\n",
(j + 1), opponentPreGrid[j][0]);
E.opponentHandErrors++;
E.runErrors++;
}
if (opponentPreGrid[j][1] != G.deckCount[j])
{
printf("Expected Opponent %d Post Deck Count: %d. Actual: %d. Failed!\n",
(j + 1), opponentPreGrid[j][1]);
E.opponentDeckErrors++;
E.runErrors++;
}
if (opponentPreGrid[j][2] != G.discardCount[j])
{
printf("Expected Opponent %d Post Discard Count: %d. Actual: %d. Failed!\n",
(j + 1), opponentPreGrid[j][1]);
E.opponentDiscardErrors++;
E.runErrors++;
}
}
//print tun results
if (E.runErrors == 0)
{
printf("---All Tests Passed---\n");
printf("---End of Test %d---\n", (i+1));
successfulRuns++;
}
else{
printf("---Results of Test %d---\n", (i+1));
printf("Actions Error: %d\n", E.actionsErrors);
printf("Buys Error: %d\n", E.buysErrors);
printf("Coins Error: %d\n", E.coinsErrors);
printf("Hand Count Error: %d\n", E.handCountErrors);
printf("Treasure Count Error: %d\n", E.treasureCountErrors);
printf("Deck and Discard Sum Error: %d\n", E.remainingCardCountErrors);
printf("Opponent Hand Error: %d\n", E.opponentHandErrors);
printf("Opponent Deck Error: %d\n", E.opponentDeckErrors);
printf("Opponent Discard Error: %d\n", E.opponentDiscardErrors);
printf("Total Run Errors: %d\n", E.runErrors);
//sum run errors into total errors
CombineErrors(&E, &TE);
}
}
//print total results
printf("\n-----FINISHED TESTING ADVENTURER-----\n");
printf("---Total Test Results---\n");
printf("Total Actions Error: %d\n", TE.totalActionsErrors);
printf("Total Buys Error: %d\n", TE.totalBuysErrors);
printf("Total Coins Error: %d\n", TE.totalCoinsErrors);
printf("Total Hand Count Error: %d\n", TE.totalHandCountErrors);
printf("Total Treasure Count Errors: %d\n", TE.totalTreasureCountErrors);
printf("Total Deck and Discard Sum Errors: %d\n", TE.totalremainingCardCountErrors);
printf("Total Opponent Hand Error: %d\n", TE.totalOpponentHandErrors);
printf("Total Opponent Deck Error: %d\n", TE.totalOpponentDeckErrors);
printf("Total Opponent Discard Error: %d\n", TE.totalOpponentDiscardErrors);
printf("Total Testing Errors: %d\n", TE.totalTestErrors);
printf("Total Successful Runs: %d\n\n\n", successfulRuns);
return 0;
}
