static bool testListInsertAfterCurrent() {
ASSERT_TRUE(SP_LIST_NULL_ARGUMENT == spListInsertAfterCurrent(NULL, NULL));
SPListElement e1 = spListElementCreate(1, 1.0);
SPListElement e2 = spListElementCreate(2, 2.0);
SPListElement e3 = spListElementCreate(3, 3.0);
SPListElement e4 = spListElementCreate(4, 4.0);
SPList list2 = quickList(3, e2, e3, e4);
ASSERT_TRUE(SP_LIST_NULL_ARGUMENT == spListInsertAfterCurrent(list2,NULL));
ASSERT_TRUE(SP_LIST_INVALID_CURRENT == spListInsertAfterCurrent(list2, e1));
spListGetFirst(list2);
spListGetNext(list2);
ASSERT_TRUE(SP_LIST_SUCCESS == spListInsertAfterCurrent(list2, e1));
ASSERT_TRUE(4 == spListGetSize(list2));
ASSERT_TRUE(spListElementCompare(e2, spListGetFirst(list2))==0);
ASSERT_TRUE(spListElementCompare(e3, spListGetNext(list2))==0);
ASSERT_TRUE(spListElementCompare(e1, spListGetNext(list2))==0);
ASSERT_TRUE(spListElementCompare(e4, spListGetNext(list2))==0);
ASSERT_TRUE(spListGetNext(list2) == NULL);
ASSERT_TRUE(spListGetNext(list2) == NULL);
spListDestroy(list2);
spListElementDestroy(e1);
spListElementDestroy(e2);
spListElementDestroy(e3);
spListElementDestroy(e4);
return true;
}
double spBPQueueMinValue(SPBPQueue source){
assert(source);
if (spBPQueueIsEmpty(source)){
return -1;
}
return spListElementGetValue(spListGetFirst(source->list));
}
static bool testListCopy() {
ASSERT_TRUE(spListCopy(NULL) == NULL);
SPList list = spListCreate();
SPList copy = spListCopy(list);
ASSERT_TRUE(copy != NULL);
ASSERT_TRUE(0 == spListGetSize(copy));
SPListElement e1 = spListElementCreate(1, 1.0);
SPListElement e2 = spListElementCreate(2, 2.0);
SPListElement e3 = spListElementCreate(3, 3.0);
SPListElement e4 = spListElementCreate(4, 4.0);
spListInsertFirst(list, e1);
ASSERT_TRUE(0 == spListGetSize(copy));
SPList list2 = quickList(4, e1, e2, e3, e4);
SPList copy2 = spListCopy(list2);
ASSERT_TRUE(4 == spListGetSize(copy2));
ASSERT_TRUE(spListElementCompare(e1, spListGetFirst(copy2)) == 0);
ASSERT_TRUE(spListElementCompare(e2, spListGetNext(copy2)) == 0);
ASSERT_TRUE(spListElementCompare(e3, spListGetNext(copy2)) == 0);
ASSERT_TRUE(spListElementCompare(e4, spListGetNext(copy2)) == 0);
ASSERT_TRUE(spListGetNext(copy2) == NULL);
spListDestroy(list);
spListDestroy(list2);
spListDestroy(copy);
spListDestroy(copy2);
spListElementDestroy(e1);
spListElementDestroy(e2);
spListElementDestroy(e3);
spListElementDestroy(e4);
return true;
}
SP_BPQUEUE_MSG spBPQueueDequeue(SPBPQueue source) {
SPListElement first;
SP_LIST_MSG actionStatus;
spMinimalVerifyArguments(source != NULL, SP_BPQUEUE_INVALID_ARGUMENT);
if (spBPQueueIsEmpty(source))
return SP_BPQUEUE_EMPTY;
first = spListGetFirst(source->queue);
if (first == NULL)
return SP_BPQUEUE_EMPTY;
// if we have 1 items -> last is first -> we should free its pointer
if (spBPQueueSize(source) == 1) {
spListElementDestroy(source->maxElement);
source->maxElement = NULL;
}
actionStatus = spListRemoveCurrent(source->queue);
if (actionStatus != SP_LIST_SUCCESS)
return SP_BPQUEUE_EMPTY;
return SP_BPQUEUE_SUCCESS;
}
SPListElement spBPQueuePeek(SPBPQueue source) {
SPListElement first;
spMinimalVerifyArgumentsRn(source != NULL);
first = spListGetFirst(source->queue);
return spListElementCopy(first);
}
SP_LIST_MSG spListClear(SPList list) {
if (list == NULL) {
return SP_LIST_NULL_ARGUMENT;
}
while (spListGetFirst(list)) {
spListRemoveCurrent(list);
}
return SP_LIST_SUCCESS;
}
SPListElement spBPQueuePeek(SPBPQueue source){
assert(source);
if(spBPQueueIsEmpty(source)){
return NULL;
}
SPListElement ret = spListGetFirst(source->list);
if (!ret){ return NULL;}
return spListElementCopy(ret);
}
SP_BPQUEUE_MSG spBPQueueEnqueue(SPBPQueue source, SPListElement element){
// variables declaration//
int i;
SPList source_list = source->list;
SPListElement elem_to_comp;
int list_size = spListGetSize(source_list);
// check for bad arguments or allocation problems//
if (!source || !element || !source_list){
return SP_BPQUEUE_INVALID_ARGUMENT;
}
// insertion process//
if (spBPQueueIsEmpty(source)){
spListInsertFirst(source_list, element);
return SP_BPQUEUE_SUCCESS;
}
else{
elem_to_comp = spListGetFirst(source_list);
/*starts from the bottom and loop for next source list element up until
you find the one which is bigger than the inserted one and insert the element
before that one. you will stop after you ran out of elements to look for */
for(i=0; i<list_size; i++){
if (spListElementGetValue(element) <= spListElementGetValue(elem_to_comp)){// element is smaller than next elem, insert before current
if (spBPQueueIsFull(source)){
if (spListInsertBeforeCurrent(source_list, element) == SP_LIST_OUT_OF_MEMORY){
return SP_BPQUEUE_OUT_OF_MEMORY;
}
spListGetLast(source_list);
spListRemoveCurrent(source_list);
return SP_BPQUEUE_SUCCESS;
}
else{
if (spListInsertBeforeCurrent(source_list, element) == SP_LIST_OUT_OF_MEMORY){
return SP_BPQUEUE_OUT_OF_MEMORY;
}
return SP_BPQUEUE_SUCCESS;
}
}else{
elem_to_comp = spListGetNext(source_list);
}
}
}
if (!spBPQueueIsFull(source)){//queue isn't full but this item is the biggest
if (spListInsertLast(source_list, element)== SP_LIST_OUT_OF_MEMORY){
return SP_BPQUEUE_OUT_OF_MEMORY;
}
return SP_BPQUEUE_SUCCESS;
}
return SP_BPQUEUE_SUCCESS; // the element is larger than all others
}
static bool testListGetFirst() {
SPList list = spListCreate();
ASSERT_TRUE(spListGetFirst(list) == NULL);
SPListElement e1 = spListElementCreate(1, 1.0);
SPListElement e2 = spListElementCreate(2, 2.0);
SPListElement e3 = spListElementCreate(3, 3.0);
SPListElement e4 = spListElementCreate(4, 4.0);
SPList list2 = quickList(4, e1, e2, e3, e4);
SPListElement first = spListGetFirst(list2);
ASSERT_TRUE(spListElementCompare(e1, first) == 0);
ASSERT_TRUE(
spListElementCompare(first, spListGetFirst(list2)) == 0
&& spListGetFirst(list2) == first);
spListDestroy(list);
spListDestroy(list2);
spListElementDestroy(e1);
spListElementDestroy(e2);
spListElementDestroy(e3);
spListElementDestroy(e4);
return true;
}
SP_BPQUEUE_MSG spBPQueueDequeue(SPBPQueue source) {
if (source == NULL) {
return SP_BPQUEUE_INVALID_ARGUMENT;
}
if (spBPQueueIsEmpty(source)) {
return SP_BPQUEUE_EMPTY;
}
spListGetFirst(source->innerList);
spListRemoveCurrent(source->innerList);
return SP_BPQUEUE_SUCCESS;
}
SP_BPQUEUE_MSG spBPQueueInsertNotEmpty(SPBPQueue source, SPListElement newElement) {
SPListElement currElemInQueue = spListGetFirst(source->queue);
while (currElemInQueue != NULL && spListElementCompare(currElemInQueue, newElement) <= 0) {
currElemInQueue = spListGetNext(source->queue);
}
// currElemInQueue > newElement
if (currElemInQueue != NULL) {
currElemInQueue = NULL;
return spBPQueueInsertNotEmptyNotLast(source, newElement);
}
// we are not at full capacity because we took care of it before
return spBPQueueInsertNotEmptyButLast(source, newElement);
}
static bool testListGetSize() {
SPList list = quickList(0);
ASSERT_TRUE(0 == spListGetSize(list));
SPListElement e1 = spListElementCreate(1, 1.0);
spListInsertFirst(list, e1);
ASSERT_TRUE(1 == spListGetSize(list));
spListElementSetIndex(e1, 2);
spListElementSetValue(e1, 2.0);
spListInsertFirst(list, e1);
ASSERT_TRUE(2 == spListGetSize(list));
spListGetFirst(list);
spListRemoveCurrent(list);
ASSERT_TRUE(1 == spListGetSize(list));
spListDestroy(list);
spListElementDestroy(e1);
return true;
}
SP_BPQUEUE_MSG spBPQueueDequeue(SPBPQueue source){
// check for bad arguments//
if(!source || !source->list){
return SP_BPQUEUE_INVALID_ARGUMENT;
}
// variables declaration//
SPList source_list = source->list;
if (spBPQueueIsEmpty(source)){
return SP_BPQUEUE_EMPTY;
}
else{
spListGetFirst(source_list);
spListRemoveCurrent(source_list);
return SP_BPQUEUE_SUCCESS;
}
}
SPList spListCopy(SPList list) {
if (list == NULL) {
return NULL;
}
SPList copyList = spListCreate();
if (copyList == NULL) {
return NULL;
}
SPListElement currentElement = spListGetFirst(list);
while (currentElement) {
if (spListInsertLast(copyList, currentElement) != SP_LIST_SUCCESS) {
spListDestroy(copyList);
list->current = NULL;
return NULL;
}
currentElement = spListGetNext(list);
}
list->current = NULL;
copyList->current = NULL;
return copyList;
}
SP_BPQUEUE_MSG spBPQueueHandleFullCapacity(SPBPQueue source) {
int i;
SPListElement currElemInQueue, prevElemInQueue;
currElemInQueue = spListGetFirst(source->queue);
prevElemInQueue = currElemInQueue;
for (i=1;i<spBPQueueSize(source);i++) {
prevElemInQueue = currElemInQueue;
currElemInQueue = spListGetNext(source->queue);
}
// if we get here we assume we never reached the end of the list (meaning null)
// because we assume spBPQueueSize is valid
spListRemoveCurrent(source->queue);
spListElementDestroy(source->maxElement);
source->maxElement = spListElementCopy(prevElemInQueue);
if (source->maxElement == NULL)
return SP_BPQUEUE_OUT_OF_MEMORY;
return SP_BPQUEUE_SUCCESS;
}
SPListElement spBPQueueFirstElement(SPBPQueue source) {
if (source == NULL || spBPQueueIsEmpty(source)) {
return NULL;
}
return spListGetFirst(source->innerList);
}
