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 spBPQueueCopy
static 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 test
bool 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;
}
