char *test_iterationForward_arrayContainingContinousElements()
{
DArray *array = DArray_create(sizeof(intptr_t), 3);
DArray_push(array, (void *) (intptr_t) 60);
DArray_push(array, (void *) (intptr_t) 670);
DArray_push(array, (void *) (intptr_t) 90);
int index = -1;
assert(DArray_iterator_next(array, &index) == 1 && "Expected to continue to next element.");
assert(index == 0 && "Expected index was not set by iteration.");
assert(DArray_iterator_next(array, &index) == 1 && "Expected to continue to next element.");
assert(index == 1 && "Expected index was not set by iteration.");
assert(DArray_iterator_next(array, &index) == 1 && "Expected to continue to next element.");
assert(index == 2 && "Expected index was not set by iteration.");
assert(DArray_iterator_next(array, &index) == 0 && "Expected to end interation.");
/* while (DArray_iterator_next(array, &index)) { */
/* intptr_t element = (intptr_t) DArray_get(array, index); */
/* collected_elements[index] = element; */
/* } */
/* assert(collected_elements[0] == 60 && "Expected value at index not found."); */
/* assert(collected_elements[1] == 670 && "Expected value at index not found."); */
/* assert(collected_elements[2] == 90 && "Expected value at index not found."); */
DArray_destroy(array);
return NULL;
}
char *test_push_pop()
{
DArray *array = DArray_create(sizeof(intptr_t), 5);
DArray_push(array, (void *) (intptr_t) 30);
DArray_push(array, (void *) (intptr_t) 20);
DArray_push(array, (void *) (intptr_t) 10);
intptr_t value = (intptr_t) DArray_pop(array);
assert(value == 10 && "pop'ed wrong value from array.");
value = (intptr_t) DArray_pop(array);
assert(value == 20 && "pop'ed wrong value from array.");
value = (intptr_t) DArray_pop(array);
assert(value == 30 && "pop'ed wrong value from array.");
DArray_push(array, (void *) (intptr_t) 60);
value = (intptr_t) DArray_get(array, 0);
assert(value == 60 && "Getting value by index after pop'ing all values from array failed.");
DArray_destroy(array);
return NULL;
}
DArray* _merge_sort(DArray* array, DArray_compare cmp)
{
DArray_check(array);
if(array->end <= 1)
return array;
DArray* left = DArray_create(array->element_size, array->max);
check_mem(left);
DArray* right = DArray_create(array->element_size, array->max);
check_mem(right);
int middle = array->end/2;
int i = 0;
for(i = 0; i < array->end; i++) {
if(i < middle) {
DArray_push(left, DArray_get(array, i));
} else {
DArray_push(right, DArray_get(array, i));
}
}
DArray* sort_left = _merge_sort(left, cmp);
check(left != NULL, "Error in left merge sort");
DArray* sort_right = _merge_sort(right, cmp);
check(right != NULL, "Error in right merge sort");
if(sort_left != left) DArray_destroy(left);
if(sort_right != right) DArray_destroy(right);
return _merge_array(sort_left, sort_right, cmp);
error:
return NULL;
}
char *test_iterationBackward_arrayContainingContinousElements()
{
DArray *array = DArray_create(sizeof(intptr_t), 3);
DArray_push(array, (void *) (intptr_t) 60);
DArray_push(array, (void *) (intptr_t) 670);
DArray_push(array, (void *) (intptr_t) 90);
int index = -1;
assert(DArray_iterator_prev(array, &index) == 1 && "Expected to continue to prev element.");
assert(index == 2 && "Expected index was not set by iteration.");
assert(DArray_iterator_prev(array, &index) == 1 && "Expected to continue to prev element.");
assert(index == 1 && "Expected index was not set by iteration.");
assert(DArray_iterator_prev(array, &index) == 1 && "Expected to continue to prev element.");
assert(index == 0 && "Expected index was not set by iteration.");
assert(DArray_iterator_prev(array, &index) == 0 && "Expected to end interation.");
DArray_destroy(array);
return NULL;
}
TileMapParseStatus TileMap_parse_map(xmlTextReaderPtr reader, Engine *engine,
TileMap *map) {
TileMapParseStatus status = TILEMAP_PARSE_OK;
xmlChar *name = xmlTextReaderName(reader);
if (!(streq(name, "map") &&
xmlTextReaderNodeType(reader) == XML_ELEMENT_NODE)) {
return TILEMAP_PARSE_INVALID_FORMAT;
}
while (xmlTextReaderMoveToNextAttribute(reader)) {
xmlChar *attrName = xmlTextReaderName(reader);
xmlChar *attrVal = xmlTextReaderValue(reader);
if (streq(attrName, "orientation")) {
if (!streq(attrVal, "orthogonal")) {
return TILEMAP_PARSE_INVALID_ORIENTATION;
}
} else if (streq(attrName, "width")) {
map->cols = atoi((const char *)attrVal);
} else if (streq(attrName, "height")) {
map->rows = atoi((const char *)attrVal);
} else if (streq(attrName, "tilewidth")) {
map->tile_size.w = atoi((const char *)attrVal);
} else if (streq(attrName, "tileheight")) {
map->tile_size.h = atoi((const char *)attrVal);
}
}
while (xmlTextReaderRead(reader)) {
xmlChar *childName = xmlTextReaderName(reader);
if (xmlTextReaderNodeType(reader) == XML_ELEMENT_DECL &&
streq(childName, "map")) {
break;
} else if (streq(childName, "tileset")) {
Tileset *tileset = NULL;
status = TileMap_parse_tileset(reader, engine, map, &tileset);
if (status != TILEMAP_PARSE_OK) return status;
DArray_push(map->tilesets, tileset);
} else if (streq(childName, "layer")) {
TileMapLayer *layer = NULL;
status = TileMap_parse_layer(reader, map, &layer);
if (status != TILEMAP_PARSE_OK) return status;
DArray_push(map->layers, layer);
}
}
return status;
}
int gen_keys(DArray *keys, int num_keys) {
int i = 0;
FILE *urand = fopen("/dev/urandom", "r");
check(urand != NULL, "Failed to open /dev/urandom");
struct bStream *stream = bsopen((bNread)fread, urand);
check(stream != NULL, "Failed to open /dev/urandom");
bstring key = bfromcstr("");
int rc = 0;
// FNVla histogram
for(i = 0; i < num_keys; i++) {
rc = bsread(key, stream, BUFFER_LEN);
check(rc >= 0, "Failed to read from /dev/urandom.");
DArray_push(keys, bstrcpy(key));
}
bsclose(stream);
fclose(urand);
return 0;
error:
return -1;
}
static inline TSTree *TSTree_insert_base(TSTree *root, TSTree *node,
const char *key, size_t len, void *value)
{
if(node == NULL) {
node = (TSTree *) calloc(1, sizeof(TSTree));
check(node != NULL, "Failed creating node");
node->values = DArray_create(DEFAULT_DARRAY_SIZE, DEFAULT_DARRAY_SIZE);
if(root == NULL) root = node;
node->splitchar = *key;
}
if(*key < node->splitchar) {
node->low = TSTree_insert_base(root, node->low, key, len, value);
} else if(*key == node->splitchar) {
if(len > 1) {
node->equal = TSTree_insert_base(root, node->equal, key + 1, len - 1, value);
} else {
DArray_push(node->values, value);
return node;
// assert(node->value == NULL && "Duplicate insert into tst.");
}
} else {
node->high = TSTree_insert_base(root, node->high, key, len, value);
}
return node;
error:
return NULL;
}
static inline DArray*
kernel_files(STATE)
{
DArray *entries = DArray_create(sizeof(bstring), 10);
bstring kernel_relative_path = bfromcstr("../kernel");
bstring absolute_path = resolve_path(state, kernel_relative_path);
struct dirent **namelist;
int n = scandir(bdata(absolute_path), &namelist, 0, alphasort);
if (n < 0) {
perror("scandir");
} else {
for(int i = 0; i < n; i++) {
if(strcmp(namelist[i]->d_name, ".") != 0 && strcmp(namelist[i]->d_name, "..") != 0) {
DArray_push(entries, bfromcstr(namelist[i]->d_name));
}
free(namelist[i]);
}
free(namelist);
}
bdestroy(absolute_path);
bdestroy(kernel_relative_path);
return entries;
}
DArray DArray_group_by(DArray array, DArray_group_by_fn *group_by_fn)
{
if (DArray_is_empty(array) || !group_by_fn) return NULL;
DArray groups = DArray_create(sizeof(DArray), 10);
DArray group;
int idx;
void *el;
size_t count = (size_t) DArray_count(array);
for (size_t i = 0; i < count; i++) {
el = DArray_remove(array, i);
if (!el) continue;
idx = group_by_fn(el);
if (idx == -1) continue;
group = DArray_get(groups, idx);
if (!group) {
group = DArray_create(array->element_size, DArray_count(array) + 1);
DArray_ensure_capacity(groups, idx + 1);
DArray_set(groups, idx, group);
}
DArray_push(group, el);
}
return groups;
}
int gen_keys(DArray * keys, int num_keys)
{
int i = 0;
FILE *urand = fopen("/dev/urandom", "r");
check(urand != NULL, "Failed to open /dev/urandom");
int result = -1; // default to failure condition
int rc = 0;
struct bStream *stream = bsopen((bNread) fread, urand);
check(stream != NULL, "Failed to open /dev/urandom");
bstring key = bfromcstr("");
// FNV1a histogram
for (i = 0; i < num_keys; i++) {
rc = bsread(key, stream, BUFFER_LEN);
check(rc >= 0, "Failed to read from /dev/urandom.");
DArray_push(keys, bstrcpy(key));
}
result = 0; // all good
error: // fallthrough
if(stream) bsclose(stream);
if(urand) fclose(urand);
if(key) bdestroy(key);
return result;
}
Object*
String_to_object(bstring string)
{
Object *obj = NULL;
if (bchar(string, 0) == '"') {
int len = blength(string) - 2;
obj = Object_create_string(bmidstr(string, 1, len));
} else if (bchar(string, 0) == '[') {
int strlen = blength(string) - 2;
bstring inner_str = bmidstr(string, 1, strlen);
struct bstrList *elements = bsplit(inner_str, ',');
int len = elements->qty;
int i = 0;
DArray *array = DArray_create(sizeof(Object*), len);
bstring *ptr = elements->entry;
for(i = 0; i < len; i++) {
btrimws(*ptr);
DArray_push(array, String_to_object(*ptr));
ptr++;
}
obj = Object_create_array(array);
} else {
int value = atoi(bdata(string));
if (value != 0) {
obj = Object_create_integer(atoi(bdata(string)));
} else {
return NULL;
}
}
return obj;
}
char *test_contains()
{
DArray *array = DArray_create(sizeof(intptr_t), 3);
DArray_push(array, (void *) (intptr_t) 60);
DArray_push(array, (void *) (intptr_t) 90);
assert(DArray_contains(array, (void *) (intptr_t) 90, _test_predicate) == 1 && "Expected to find value in array.");
assert(DArray_contains(array, (void *) (intptr_t) 60, _test_predicate) == 1 && "Expected to find value in array.");
assert(DArray_contains(array, (void *) (intptr_t) 100, _test_predicate) == 0 && "Expected to not find value in array.");
assert(DArray_contains(array, NULL, _test_predicate) == 0 && "Expected to not find value in array.");
DArray_destroy(array);
return NULL;
}
static void _TSTree_collect_sub_nodes(TSTree *node, DArray *matches, char *cur_match, size_t len)
{
if (!node) {
return;
}
len += 1;
char *match = malloc(sizeof(char) * len);
sprintf(match, "%s%c", cur_match, node->splitchar);
if (node->low) {
_TSTree_collect_sub_nodes(node->low, matches, match, len);
}
if (node->equal) {
_TSTree_collect_sub_nodes(node->equal, matches, match, len);
}
if (node->high) {
_TSTree_collect_sub_nodes(node->high, matches, match, len);
}
if (node->value) {
DArray_push(matches, match);
} else {
free(match);
}
}
int
CloseNodes_Add(CloseNodes *close, Node *node)
{
assert(close != NULL && "NULL CloseNodes pointer");
assert(node != NULL && "NULL Node pointer");
Distance distance = Hash_Distance(&close->id, &node->id);
int i = FindIndex(close->close_nodes, &distance);
if (i < 0)
return 0;
struct CloseNode *close_node = malloc(sizeof(struct CloseNode));
check_mem(close_node);
close_node->node = node;
close_node->distance = distance;
if (DArray_count(close->close_nodes) < BUCKET_K)
DArray_push(close->close_nodes, NULL);
ShiftFrom(close->close_nodes, i);
DArray_set(close->close_nodes, i, close_node);
return 0;
error:
return -1;
}
char *test_copy() {
DArray *orig = DArray_create(sizeof(int), 11);
DArray *dest = DArray_create(sizeof(int), 11);
int i = 0;
for(i = 0; i < 10; i++) {
int *el_to_add = DArray_new(orig);
*el_to_add = i;
mu_assert(DArray_push(orig, el_to_add) == 0, "Pushing to DArray failed.");
}
int rc = DArray_copy(orig, dest);
mu_assert(rc == 0, "Copy failed.")
mu_assert(orig->max == dest->max, "max did not copy properly.");
mu_assert(orig->end == dest->end, "end did not copy properly.");
mu_assert(orig->element_size == dest->element_size,
"element_size did not copy properly.");
mu_assert(orig->expand_rate == dest->expand_rate,
"expand_rate did not copy properly.");
for(i = 0; i < 10; i++) {
int *val = DArray_get(dest, i);
mu_assert(val != NULL, "Got NULL from copy.");
mu_assert(*val == i,
"Failed to copy contents correctly.");
}
return NULL;
}
DArray *
CloseNodes_GetNodes(CloseNodes *close)
{
assert(close != NULL && "NULL CloseNodes pointer");
DArray *nodes = DArray_create(sizeof(Node *),
DArray_max(close->close_nodes));
check(nodes != NULL, "DArray_create failed");
int i = 0;
for (i = 0; i < DArray_count(close->close_nodes); i++)
{
struct CloseNode *close_node = DArray_get(close->close_nodes, i);
check(close_node != NULL, "NULL CloseNodes entry");
check(close_node->node != NULL, "NULL Node pointer in CloseNodes entry");
int rc = DArray_push(nodes, close_node->node);
check(rc == 0, "DArray_push failed");
}
return nodes;
error:
DArray_destroy(nodes);
return NULL;
}
void addNSToList(NodeAddress *nsAddress) {
int pos = checkNSExists(nsList, nsAddress->ip, nsAddress->portNumber);
if (pos == -1) {
DArray_push(nsList, nsAddress);
nsCount++;
}
}
int DArray_mergesort(DArray *array, DArray_compare cmp)
{
int count = array->end;
if (count > 1) {
int pivot = count / 2;
int after_pivot = count - pivot;
DArray *left = DArray_create(array->element_size, pivot);
DArray *right = DArray_create(array->element_size, after_pivot);
for (int i = 0; i < pivot; i++) {
DArray_push(left, DArray_get(array, i));
}
for (int i = pivot; i < count; i++) {
DArray_push(right, DArray_get(array, i));
}
DArray_mergesort(left, cmp);
DArray_mergesort(left, cmp);
int i = 0;
int l_ptr = 0;
int r_ptr = 0;
for (i = 0; i < count; i++) {
if (l_ptr >= pivot) {
DArray_set(array, i, DArray_get(right, r_ptr));
r_ptr++;
} else if (r_ptr >= after_pivot) {
DArray_set(array, i, DArray_get(left, l_ptr));
l_ptr++;
} else if (cmp(DArray_get(left, l_ptr), DArray_get(right, r_ptr)) < 0) {
DArray_set(array, i, DArray_get(left, l_ptr));
l_ptr++;
} else {
DArray_set(array, i, DArray_get(right, r_ptr));
r_ptr++;
}
}
DArray_destroy(left);
DArray_destroy(right);
}
return 0;
}
char *test_each()
{
DArray *ary = DArray_create(sizeof(VALUE), 10);
VALUE one = Number_new(state, 1);
VALUE two = Number_new(state, 2);
VALUE three = Number_new(state, 3);
DArray_push(ary, one);
DArray_push(ary, two);
DArray_push(ary, three);
VALUE vector = Vector_new(state, ary);
__block int counter = 0;
Vector_each(vector, ^ void (VALUE val) {
counter = counter + VAL2NUM(val);
});
int Parallax_add_layer(Parallax *parallax, ParallaxLayer *layer) {
check(parallax != NULL, "No parallax to add to");
check(layer != NULL, "No parallax layer to add");
DArray_push(parallax->layers, layer);
return 1;
error:
return 0;
}
void add_feature(FeatureGroup group, char* value, Hashmap *featuremap, DArray *list) {
struct FeatureKey ro;
ro.grp = group;
ro.value = value;
FeatureValue fv;
fv = (FeatureValue) Hashmap_get(featuremap, &ro);
if (fv != NULL)
DArray_push(list, &(fv->feature_id));
}
DArray *create_words()
{
DArray *result = DArray_create(0, 5);
char *words[] = {"asdfasfd", "werwar", "13234", "asdfasfd", "oioj"};
for(int i = 0; i < 5; i++) {
DArray_push(result, words[i]);
}
return result;
}
char *test_destroy_arrayContainingMallocedValues()
{
DArray *array = DArray_create(sizeof(intptr_t), 100);
char *test_str_1 = malloc(sizeof(char) * TEST_STR_1_LEN);
strncpy(test_str_1, TEST_STR_1, TEST_STR_1_LEN);
char *test_str_2 = malloc(sizeof(char) * TEST_STR_2_LEN);
strncpy(test_str_2, TEST_STR_2, TEST_STR_2_LEN);
DArray_push(array, test_str_1);
DArray_push(array, test_str_2);
DArray_destroy(array);
free(test_str_1);
free(test_str_2);
return NULL;
}
DArray *create_words()
{
DArray *result = DArray_create(0, 7);
char *words[] = { "werwar", "asdasd", "13234", "oioj", "gthht", "lkluil", "xswcde" };
int i = 0;
for (i = 0; i < 7; i++) {
DArray_push(result, words[i]);
}
return result;
}
DArray DArray_find(DArray array, DArray_find_fn *filter_fn, void* args)
{
if (DArray_is_empty(array)) return NULL;
DArray filtered = DArray_create(array->element_size, array->size);
for (int i = 0; i < DArray_count(array); i++) {
void *item = DArray_get(array, i);
if (filter_fn(item, args))
DArray_push(filtered, item);
}
return filtered;
}
int Hashmap_set(Hashmap* map, void* key, void* data) {
uint32_t hash = 0;
DArray* bucket = Hashmap_find_bucket(map, key, 1, &hash);
check(bucket, "Can't create bucket.");
HashmapNode* node = Hashmap_node_create(hash, key, data);
check_mem(node);
DArray_push(bucket, node);
return 0;
error:
return 01;
}
int Hashmap_set(Hashmap *map, void *key, void *data)//finds a bucket create node add node to bucket
{
uint32_t hash = 0;
DArray *bucket = Hashmap_find_bucket(map, key, 1, &hash);//int 1 tells fn to create bucket if none found
check(bucket, "Error can't create bucket.");
HashmapNode *node = Hashmap_node_create(hash, key, data);
check_mem(node);
DArray_push(bucket, node);
return 0;
error:
return -1;
}
static inline DArray *TSTree_all_values(TSTree *node, DArray *values)
{
if(node == NULL) return NULL;
if(values == NULL) values = DArray_create(DEFAULT_DARRAY_SIZE, DEFAULT_DARRAY_SIZE);
if(!DArray_empty(node->values)) DArray_push(values, DArray_first(node->values));
if(node->low) TSTree_all_values(node->low, values);
if(node->equal) TSTree_all_values(node->equal, values);
if(node->high) TSTree_all_values(node->high, values);
return values;
}
Object*
Array_new(Object **contents, int count) {
DArray *array = DArray_create(sizeof(Object*), count || 1);
int i=0;
for(i=0; i < count; i++) {
retain((Object*)contents[i]);
DArray_push(array, contents[i]);
}
Object *object = Object_new();
object->type = tArray;
object->value.other = array;
Object_define_native_method(object, bfromcstr("[]"), Primitive_Array_at, 1);
return object;
}
DArray* _merge_array(DArray* left, DArray* right, DArray_compare cmp)
{
DArray* result = DArray_create(left->element_size,
left->max > right->max ? left->max : right->max);
DArray_check(left);
DArray_check(right);
DArray_check(result);
void* element = NULL;
while(left->end > 0 || right->end > 0) {
int i = 0;
DArray_debug(left);
DArray_debug(right);
debug("Left end: %d\tRight end: %d", left->end, right->end);
if(left->end > 0 && right->end > 0) {
check(left->contents[i] != NULL,
"left->contents[%i] is NULL!", i);
check(right->contents[i] != NULL,
"right->contents[%i] is NULL!", i);
if(cmp(&left->contents[i], &right->contents[i]) <= 0) {
debug("Fire left!");
element = DArray_fpop(left);
} else {
debug("Fire right!");
element = DArray_fpop(right);
}
} else if(left->end > 0) {
debug("Fire left?");
element = DArray_fpop(left);
} else if(right->end > 0) {
debug("Fire right?");
element = DArray_fpop(right);
} else sentinel("_merge_array shouldn't get here.");
check_mem(element);
DArray_push(result, element);
i++;
}
DArray_destroy(left);
DArray_destroy(right);
return result;
error:
DArray_destroy(left);
DArray_destroy(right);
if(result) DArray_destroy(result);
return NULL;
}
