自学教程：C++ spListElementDestroy函数代码示例

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;}

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;}

static bool bpqPeekLastTest() {	SPBPQueue source, source2;	SPListElement e1, e2, e3, e4, last, last2;	source = spBPQueueCreate(maxSize);	ASSERT_TRUE(spBPQueuePeekLast(source) == NULL); // check edge case	// e1, e2, e3, e4	CREATE_4_ELEMENTS()	// insert element in unsorted order	source2 = quickQ(4, e3, e1, e4, e2);	last = spBPQueuePeekLast(source2);	last2 = spBPQueuePeekLast(source2);	ASSERT_TRUE(spListElementCompare(e4, last) == 0); // check that peekLast is the maximum	ASSERT_TRUE(spListElementCompare(last, last2) == 0 && last2 != last); // new copy so not ==	// free memory	spBPQueueDestroy(source);	spBPQueueDestroy(source2);	spListElementDestroy(last);	spListElementDestroy(last2);	// e1, e2, e3, e4	DESTROY_4_ELEMENTS()	return true;}

// tester for spBPQueueCopystatic bool bpqCopyTest() {	SPBPQueue source, source2, copy, copy2;	SPListElement e1, e2, e3, e4, epeek;	ASSERT_TRUE(spBPQueueCopy(NULL) == NULL); // check edge case	source = spBPQueueCreate(10);	copy = spBPQueueCopy(source);	ASSERT_TRUE(copy != NULL);	ASSERT_TRUE(0 == spBPQueueSize(copy));	// e1, e2, e3, e4	CREATE_4_ELEMENTS()	spBPQueueEnqueue(source, e1);	ASSERT_TRUE(0 == spBPQueueSize(copy)); // ensure the copy is a NEW COPY	source2 = quickQ(4, e1, e2, e3, e4);	copy2 = spBPQueueCopy(source2);	ASSERT_TRUE(4 == spBPQueueSize(copy2)); // check that size of copy is correct	// check that all elements copied correctly	epeek = spBPQueuePeek(copy2);	ASSERT_TRUE(spListElementCompare(e1, epeek) == 0);	spBPQueueDequeue(copy2);	spListElementDestroy(epeek); // free the element	// repeat	epeek = spBPQueuePeek(copy2);	ASSERT_TRUE(spListElementCompare(e2, epeek) == 0);	spBPQueueDequeue(copy2);	spListElementDestroy(epeek);	epeek = spBPQueuePeek(copy2);	ASSERT_TRUE(spListElementCompare(e3, epeek) == 0);	spBPQueueDequeue(copy2);	spListElementDestroy(epeek);	epeek = spBPQueuePeek(copy2);	ASSERT_TRUE(spListElementCompare(e4, epeek) == 0);	spBPQueueDequeue(copy2);	spListElementDestroy(epeek);	epeek = spBPQueuePeek(copy2);	ASSERT_TRUE(epeek == NULL);	// free all remaining memory	spListElementDestroy(epeek);	spBPQueueDestroy(source);	spBPQueueDestroy(source2);	spBPQueueDestroy(copy);	spBPQueueDestroy(copy2);	// e1, e2, e3, e4	DESTROY_4_ELEMENTS()	return true;}

static bool testListGetPrevious() {	ASSERT_TRUE(spListGetNext(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(4, e1, e2, e3, e4);	ASSERT_TRUE(spListGetPrevious(list2) == NULL);	spListDestroy(list2);	spListElementDestroy(e1);	spListElementDestroy(e2);	spListElementDestroy(e3);	spListElementDestroy(e4);	return true;}

static bool testIsElementGetValue() {	SPListElement element1 = spListElementCreate(1, 0.0);	SPListElement element2 = spListElementCreate(2, 1.0);	SPListElement element3 = spListElementCreate(3, 1.0);	SPListElement element4 = spListElementCreate(4, 2.0);	ASSERT_TRUE(spListElementGetValue(element1) == 0.0);	ASSERT_TRUE(spListElementGetValue(element2) == 1.0);	ASSERT_TRUE(spListElementGetValue(element3) == 1.0);	ASSERT_TRUE(spListElementGetValue(element4) == 2.0);	spListElementDestroy(element1);	spListElementDestroy(element2);	spListElementDestroy(element3);	spListElementDestroy(element4);	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;}

/** * internal help method to find the k nearest neighbors */void spKNNSearch(SPPoint queryFeature, const SPKDTreeNode node, SPBPQueue q){    SPListElement element;    int index, distance;    bool distanceFlag = false;    if(!node){        return;    }    if(node->dim==INVALID){				//** this is a leaf **//        index = spPointGetIndex(node->data);        distance = spPointL2SquaredDistance(queryFeature, node->data);        element = spListElementCreate(index, distance);        spBPQueueEnqueue(q, element);        spListElementDestroy(element);        return;    }    			//** go to the left sub tree **//    if(spPointGetAxisCoor(queryFeature, node->dim)<= node->val){        spKNNSearch(queryFeature, node->left, q);        distance = pow((spPointGetAxisCoor(queryFeature,        									node->dim) - node->val),2);        distanceFlag = distance < spBPQueueMaxValue(q);        if(!spBPQueueIsFull(q) || distanceFlag){            spKNNSearch(queryFeature, node->right, q);        }    }else{        spKNNSearch(queryFeature, node->right, q);        distance = pow((spPointGetAxisCoor(queryFeature,        									node->dim) - node->val),2);        distanceFlag = distance < spBPQueueMaxValue(q);        if(!spBPQueueIsFull(q) || distanceFlag){            spKNNSearch(queryFeature, node->left, q);        }    }    return;}

static bool testElementGetIndex() {	SPListElement element1 = spListElementCreate(1, 0.0);	SPListElement element2 = spListElementCreate(2, 0.0);	SPListElement element3 = spListElementCreate(3, 1.0);	SPListElement element4 = spListElementCreate(4, 0.0);	ASSERT_TRUE(spListElementGetIndex(element1) == 1);	ASSERT_TRUE(spListElementGetIndex(element2) == 2);	ASSERT_TRUE(spListElementGetIndex(element3) == 3);	ASSERT_TRUE(spListElementGetIndex(element4) == 4);	ASSERT_TRUE(spListElementGetIndex(NULL) == -1);	spListElementDestroy(element1);	spListElementDestroy(element2);	spListElementDestroy(element3);	spListElementDestroy(element4);	return true;}

static bool bpqGetMaxSizeTest() {	SPBPQueue source = NULL;	SPListElement e1;	ASSERT_TRUE(-1 == spBPQueueGetMaxSize(source)); //check edge case	// check that max size is always maxSize	source = quickQ(0);	ASSERT_TRUE(maxSize == spBPQueueGetMaxSize(source));	// insert a new element and check max size	e1 = spListElementCreate(1, 1.0);	spBPQueueEnqueue(source, e1);	ASSERT_TRUE(maxSize == spBPQueueGetMaxSize(source));	// insert another element and check max size	spListElementSetIndex(e1, 2);	spListElementSetValue(e1, 2.0);	spBPQueueEnqueue(source, e1);	ASSERT_TRUE(maxSize == spBPQueueGetMaxSize(source));	// remove an element and check max size	spBPQueueDequeue(source);	ASSERT_TRUE(maxSize == spBPQueueGetMaxSize(source));	// free memory	spBPQueueDestroy(source);	spListElementDestroy(e1);	return true;}

static bool bpqEmptyTest() {	SPBPQueue source, source2;	SPListElement e1;	source = NULL;	ASSERT_TRUE(spBPQueueIsEmpty(source) == true); // check edge case	source = spBPQueueCreate(maxSize);	ASSERT_TRUE(spBPQueueIsEmpty(source) == true); // check that new queue is empty	// insert a new element and check that not empty	e1 = spListElementCreate(1, 1.0);	source2 = quickQ(1, e1);	ASSERT_TRUE(spBPQueueIsEmpty(source2) == false);	// remove the element and check that empty	spBPQueueDequeue(source2);	ASSERT_TRUE(spBPQueueIsEmpty(source) == true);	// free memory	spBPQueueDestroy(source);	spBPQueueDestroy(source2);	spListElementDestroy(e1);	return true;}

static bool testElementCopy() {	ASSERT_TRUE(spListElementCopy(NULL) == NULL);	SPListElement element = spListElementCreate(1, 0.0);	SPListElement elementCopy = spListElementCopy(element);	ASSERT_TRUE(elementCopy!=NULL);	ASSERT_TRUE(spListElementCompare(element, elementCopy) == 0);	ASSERT_TRUE(spListElementSetIndex(elementCopy, 2) == SP_ELEMENT_SUCCESS);	ASSERT_TRUE(spListElementCompare(element, elementCopy) < 0);	ASSERT_TRUE(spListElementGetIndex(elementCopy) == 2);	ASSERT_TRUE(spListElementGetIndex(element) == 1);	ASSERT_TRUE(spListElementSetValue(element, 1.0) == SP_ELEMENT_SUCCESS);	ASSERT_TRUE(spListElementCompare(element, elementCopy) > 0);	spListElementDestroy(element);	spListElementDestroy(elementCopy);	return true;}

static bool testElementCompare() {	SPListElement element1 = spListElementCreate(1, 0.0);	SPListElement element2 = spListElementCreate(2, 0.0);	SPListElement element3 = spListElementCreate(1, 1.0);	SPListElement element4 = spListElementCreate(1, 0.0);	ASSERT_TRUE(spListElementCompare(element1, element1) == 0);	ASSERT_TRUE(spListElementCompare(element1, element2) < 0);	ASSERT_TRUE(spListElementCompare(element2, element1) > 0);	ASSERT_TRUE(spListElementCompare(element1, element3) < 0);	ASSERT_TRUE(spListElementCompare(element3, element1) > 0);	ASSERT_TRUE(spListElementCompare(element1, element4) == 0);	ASSERT_TRUE(spListElementCompare(element4, element1) == 0);	spListElementDestroy(element1);	spListElementDestroy(element2);	spListElementDestroy(element3);	spListElementDestroy(element4);	return true;}

void destroyNode(Node node) {	if (node == NULL) {		return;	}	if (node->data != NULL) {		spListElementDestroy(node->data);	}	free(node);}

void spBPQueueClear(SPBPQueue source) {	if (source != NULL && source->queue != NULL) {		spListClear(source->queue);		if (source->maxElement) {			spListElementDestroy(source->maxElement);			source->maxElement = NULL;		}	}}

static bool testListClear() {	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);	ASSERT_TRUE(spListClear(list2) == SP_LIST_SUCCESS);	ASSERT_TRUE(0 == spListGetSize(list2));	SPList list = spListCreate();	spListClear(list);	ASSERT_TRUE(0 == spListGetSize(list));	spListDestroy(list);	spListDestroy(list2);	spListElementDestroy(e1);	spListElementDestroy(e2);	spListElementDestroy(e3);	spListElementDestroy(e4);	return true;}

void spBPQueueDestroy(SPBPQueue source) {	if (source != NULL) {		if (source->queue != NULL)			spListDestroy(source->queue);		spListElementDestroy(source->maxElement);		source->maxElement = NULL;		free(source);		source = NULL;	}}

void SPKDTreeKNNRecursive(SPKDTreeNode treeNode, SPPoint p, SPBPQueue bpq, SP_KDTREE_MSG* msg){	SPListElement listElement;	SPPoint treePoint;	bool searchedLeft;	double dist;	if(bpq == NULL || treeNode == NULL)	{		*msg = SP_KDTREE_INVALID_ARGUMENT;		return;	}	// If treeNode is a leaf	if(treeNode->left == NULL && treeNode->right == NULL)	{		treePoint = *(treeNode->data);		listElement = spListElementCreate(spPointGetIndex(treePoint), spPointL2SquaredDistance(p, treePoint));		spBPQueueEnqueue(bpq, listElement);		spListElementDestroy(listElement);		*msg = SP_KDTREE_SUCCESS;		return;	}	// Turn to search the tree that would've contain the point p (if it was in the tree)	if(spPointGetAxisCoor(p, treeNode->dim) <= treeNode->val)	{		searchedLeft = true;		SPKDTreeKNNRecursive(treeNode->left, p, bpq, msg);		if (*msg != SP_KDTREE_SUCCESS)			return;	}	else	{		searchedLeft = false;		SPKDTreeKNNRecursive(treeNode->right, p, bpq, msg);		if (*msg != SP_KDTREE_SUCCESS)			return;	}	// dist = |treeNode.val - p[treeNode.dim]|	dist = treeNode->val - spPointGetAxisCoor(p, treeNode->dim);	if(dist < 0)		dist *= -1;	//dist *= dist;	if(!spBPQueueIsFull(bpq) || dist < spBPQueueMaxValue(bpq))	{		if(searchedLeft)			SPKDTreeKNNRecursive(treeNode->right, p, bpq, msg);		else			SPKDTreeKNNRecursive(treeNode->left, p, bpq, msg);	}	}

double returnValueFrom(SPBPQueue source, SPListElement (*func)(SPBPQueue)) {	SPListElement item;	double returnValue;	spMinimalVerifyArguments(source != NULL, DEFAULT_INVALID_NUMBER);	item = (*func)(source);	returnValue = spListElementGetValue(item);	spListElementDestroy(item);	return returnValue;}

bool runKnnEdgeTestCase1(knnTestCaseData caseData){	SPListElement curr_elem;	bool successFlag;	if (caseData == NULL){		spLoggerSafePrintError(COULD_NOT_CREATE_CASE_DATA,						__FILE__, __FUNCTION__,								__LINE__);		FAIL(COULD_NOT_CREATE_CASE_DATA);		return false;	}	if (caseData->tree == NULL){		spLoggerSafePrintError(COULD_NOT_CREATE_POINTS_ARRAY,						__FILE__, __FUNCTION__,								__LINE__);		FAIL(COULD_NOT_CREATE_POINTS_ARRAY);		return false;	}	if (caseData->points == NULL){		spLoggerSafePrintError(COULD_NOT_INITIALIZE_TREE,						__FILE__, __FUNCTION__,								__LINE__);		FAIL(COULD_NOT_INITIALIZE_TREE);		return false;	}	if (caseData->queue == NULL){		spLoggerSafePrintError(COULD_NOT_INITIALIZE_QUEUE,						__FILE__, __FUNCTION__,								__LINE__);		FAIL(COULD_NOT_INITIALIZE_TREE);		return false;	}	if (caseData->queryPoint == NULL){		spLoggerSafePrintError(COULD_NOT_INITIALIZE_QUERY_POINT,						__FILE__, __FUNCTION__,								__LINE__);		FAIL(COULD_NOT_INITIALIZE_TREE);		return false;	}	successFlag = kNearestNeighbors(caseData->tree, caseData->queue, caseData->queryPoint);	//general success	ASSERT_TRUE(successFlag);	ASSERT_TRUE(verifyKNN(caseData->queue, caseData->k, caseData->points, caseData->queryPoint,caseData->size));	//elements should be 1	curr_elem = spBPQueuePeek(caseData->queue);	ASSERT_TRUE(spListElementGetIndex(curr_elem) == 1);	spListElementDestroy(curr_elem);	return true;}

static bool testListGetLast() {	SPList list = spListCreate();	ASSERT_TRUE(spListGetLast(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 last = spListGetLast(list2);	ASSERT_TRUE(spListElementCompare(e4, last) == 0);	ASSERT_TRUE(			spListElementCompare(last, spListGetLast(list2)) == 0					&& spListGetLast(list2) == last);	spListDestroy(list);	spListDestroy(list2);	spListElementDestroy(e1);	spListElementDestroy(e2);	spListElementDestroy(e3);	spListElementDestroy(e4);	return true;}

static bool bpqGetSizeTest() {	SPBPQueue source = NULL;	SPListElement e1, e;	ASSERT_TRUE(-1 == spBPQueueSize(source)); //check edge case	source = quickQ(0);	ASSERT_TRUE(0 == spBPQueueSize(source));	// insert a new element and check size	e1 = spListElementCreate(1, 1.0);	spBPQueueEnqueue(source, e1);	ASSERT_TRUE(1 == spBPQueueSize(source));	// make sure that inserting same element twice works	spListElementSetIndex(e1, 2);	spListElementSetValue(e1, 2.0);	spBPQueueEnqueue(source, e1);	ASSERT_TRUE(2 == spBPQueueSize(source));	// remove an element and check size	spBPQueueDequeue(source);	ASSERT_TRUE(1 == spBPQueueSize(source));	// insert more then maxSize elements and check that size is always less then maxSize	for (int i = 0; i < 2 * maxSize; i++) {		ASSERT_TRUE(spBPQueueSize(source) <= maxSize);		e = spListElementCreate(i, 1.0);		spBPQueueEnqueue(source, e);		spListElementDestroy(e);	}	// free memory	spBPQueueDestroy(source);	spListElementDestroy(e1);	return true;}

static bool testElementSetIndex() {	ASSERT_TRUE(spListElementGetIndex(NULL) == -1);	ASSERT_TRUE(spListElementSetIndex(NULL,-1) ==SP_ELEMENT_INVALID_ARGUMENT);	ASSERT_TRUE(spListElementSetIndex(NULL,1) ==SP_ELEMENT_INVALID_ARGUMENT);	ASSERT_TRUE(spListElementSetIndex(NULL,-1) ==SP_ELEMENT_INVALID_ARGUMENT);	SPListElement element = spListElementCreate(1, 0.0);	ASSERT_TRUE(			spListElementSetIndex(element, -1) == SP_ELEMENT_INVALID_ARGUMENT);	ASSERT_TRUE(spListElementGetIndex(element) == 1);	ASSERT_TRUE(spListElementSetIndex(element, 2) == SP_ELEMENT_SUCCESS);	ASSERT_TRUE(spListElementGetIndex(element) == 2);	spListElementDestroy(element);	return true;}

int* SPKDTreeKNN(SPKDTreeNode tree, SPPoint p, int k, SP_KDTREE_MSG* msg){	int i;	int* res;	SPBPQueue bpq;	SPListElement head;	if(tree == NULL || k <= 0)	{		*msg = SP_KDTREE_INVALID_ARGUMENT;		return NULL;	}	bpq = spBPQueueCreate(k);	if(bpq == NULL)	{		*msg = SP_KDTREE_ALLOC_FAIL;		return NULL;	}	res = (int*) malloc(k * sizeof(int));	if(res == NULL)	{		*msg = SP_KDTREE_ALLOC_FAIL;		spBPQueueDestroy(bpq);		return NULL;	}	// Call SPKDTreeKNNRecursive to fill the bpq with the k nearest neighbors	SPKDTreeKNNRecursive(tree, p, bpq, msg);	if (*msg != SP_KDTREE_SUCCESS)	{		spBPQueueDestroy(bpq);		return NULL;	}	// Cast the bpq to an array	for(i = 0; i < k; i++)	{		head = spBPQueuePeek(bpq);		res[i] = spListElementGetIndex(head);		spListElementDestroy(head);		spBPQueueDequeue(bpq);	}	spBPQueueDestroy(bpq);	*msg = SP_KDTREE_SUCCESS;	return res;}

SP_BPQUEUE_MSG spBPQueueDequeue(SPBPQueue source){    struct Qnode* nextNode;    if (!source) return SP_BPQUEUE_INVALID_ARGUMENT;    if (source->size == 0) return SP_BPQUEUE_EMPTY;    nextNode = source->first->next;    spListElementDestroy(source->first->element);    free(source->first);    source->first = nextNode;    source->size -= 1;    return SP_BPQUEUE_SUCCESS;}

static bool testElementSetValue() {	ASSERT_TRUE(spListElementGetValue(NULL) == -1.0);	ASSERT_TRUE(spListElementSetValue(NULL,-1.0) ==SP_ELEMENT_INVALID_ARGUMENT);	ASSERT_TRUE(spListElementSetValue(NULL,1.0) ==SP_ELEMENT_INVALID_ARGUMENT);	ASSERT_TRUE(spListElementSetValue(NULL,-1.0) ==SP_ELEMENT_INVALID_ARGUMENT);	SPListElement element = spListElementCreate(1, 0.0);	ASSERT_TRUE(			spListElementSetValue(element, -1.0)					== SP_ELEMENT_INVALID_ARGUMENT);	ASSERT_TRUE(spListElementGetValue(element) == 0.0);	ASSERT_TRUE(spListElementSetValue(element, 1.0) == SP_ELEMENT_SUCCESS);	ASSERT_TRUE(spListElementGetValue(element) == 1.0);	spListElementDestroy(element);	return true;}

SP_BPQUEUE_MSG spBPQueueInsertNotEmptyButLast(SPBPQueue source, SPListElement element) {	SP_LIST_MSG retVal;	retVal = spListInsertLast(source->queue, element);	if (retVal == SP_LIST_OUT_OF_MEMORY)		return SP_BPQUEUE_OUT_OF_MEMORY;	spListElementDestroy(source->maxElement);	source->maxElement = spListElementCopy(element);	if (source->maxElement == NULL)		return SP_BPQUEUE_OUT_OF_MEMORY;	return SP_BPQUEUE_SUCCESS;}

Node createNode(Node previous, Node next, SPListElement element) {	SPListElement newElement = spListElementCopy(element);	if (newElement == NULL) {		return NULL;	}	Node newNode = (Node) malloc(sizeof(*newNode));	if (newNode == NULL) {		spListElementDestroy(newElement);		return NULL;	}	newNode->data = newElement;	newNode->previous = previous;	newNode->next = next;	return newNode;}

//general testbool verifyKNN(SPBPQueue rsltQueue, int k,SPPoint* pointsArray,SPPoint queryPoint, int numOfPoints){	SPBPQueue workingQueue = NULL;	SPListElement tempElement = NULL;	SP_BPQUEUE_MSG msg;	bool emptyFlag;	int i, queueSize;	int* rsltsArray;	if (rsltQueue == NULL || pointsArray == NULL || queryPoint == NULL)		return false;	workingQueue = spBPQueueCopy(rsltQueue);	ASSERT_TRUE(workingQueue != NULL);	rsltsArray = getRealRsltsArray(k,pointsArray,queryPoint,numOfPoints);	if (rsltsArray == NULL){		spBPQueueDestroy(workingQueue);		return false;	}	queueSize = spBPQueueSize(workingQueue);	for (i = 0; i< queueSize ; i++){		tempElement = spBPQueuePeek(workingQueue);		if (spListElementGetIndex(tempElement) != rsltsArray[i]){			free(rsltsArray);			spBPQueueDestroy(workingQueue);			return false;		}		spListElementDestroy(tempElement);		msg = spBPQueueDequeue(workingQueue);		if (msg != SP_BPQUEUE_SUCCESS){			free(rsltsArray);			spBPQueueDestroy(workingQueue);			return false;		}	}	emptyFlag = spBPQueueIsEmpty(workingQueue);	spBPQueueDestroy(workingQueue);	free(rsltsArray);	return emptyFlag;}

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;}