void test_9_insert_string_value_in_enqueue(){
string item="udaykant";
void *ptr=&item;
string elements[5]={"udaykant",0,0,0,0};
queue expected={elements,sizeof(string),5,0,0};
queue1=create(sizeof(string),5);
enqueue(queue1,ptr);
ASSERT(areEqual(expected,*queue1));
};
void test_3_create_a_new_string_type_Stack(){
Stack data , expected ;
string temp[] = {"","",""};
expected.starting_address = temp;
expected.each_size = sizeof(string);
expected.total_elements = 3;
data = *createStack(sizeof(string), 3);
ASSERT(1 == areEqual(data, expected));
}
void test_6_insert_char_value_in_enqueue(){
char _a='a';
void *ptr=&_a;
char elements[5]={'a',0,0,0,0};
queue expected={elements,sizeof(char),5,0,0};
queue1=create(sizeof(char),5);
enqueue(queue1,ptr);
ASSERT(areEqual(expected,*queue1));
};
void test_6_push_element_into_char_type_Stack(){
char data[] = {'a',0,0,0,0};
char arr[] = {0,0,0,0,0};
char element = 'a';
Stack expected = {data,sizeof(char),5,0};
Stack charData = create_chars(5, arr);
push(&charData, &element);
ASSERT(areEqual(charData, expected));
}
void test_5_insert_double_value_in_enqueue(){
double _5=5.0;
void *ptr=&_5;
double elements[5]={5.0,0.0,0.0,0.0,0.0};
queue expected={elements,sizeof(double),5,0,0};
queue1=create(sizeof(double),5);
enqueue(queue1,ptr);
ASSERT(areEqual(expected,*queue1));
};
void test_push_String_in_stack(){
String expected[] = {"abc","\0"};
String element = "abc";
Stack b = {expected,0,sizeof(String),2};
stringStack = create(sizeof(String),2);
push(stringStack,&element);
ASSERT(areEqual(*stringStack,b));
free(stringStack);
}
void test_2_create_a_new_char_type_Stack(){
Stack data , expected ;
char temp[] = {0,0,0,0,0};
expected.starting_address = temp;
expected.each_size = sizeof(char);
expected.total_elements = 5;
data = *createStack(sizeof(char), 5);
ASSERT(1 == areEqual(data, expected));
}
void test_areEqual_when_they_are_not_equal(){
ArrayUtil a = create(4, 7);
int * list_array = (int *)(a.base);
list_array[0] = 10;
ArrayUtil b = create(4, 10);
assert(areEqual(a,b) != 0);
dispose(a);
dispose(b);
};
void test_push_integer_in_stack(){
int expected[] = {1,0};
int element = 1;
Stack b = {expected,0,sizeof(int),2};
integerStack = create(sizeof(int),2);
push(integerStack,&element);
ASSERT(areEqual(*integerStack,b));
free(integerStack);
}
void test_4_insert_integer_value_in_enqueue(){
int _5=5;
void *ptr=&_5;
int elements[5]={5,0,0,0,0};
queue expected={elements,4,5,0,0};
queue1=create(sizeof(int),5);
enqueue(queue1,ptr);
ASSERT(areEqual(expected,*queue1));
};
void test_push_char_in_stack(){
char expected[] = {'a','\0'};
char element = 'a';
Stack b = {expected,0,sizeof(char),2};
charStack = create(sizeof(char),2);
push(charStack,&element);
ASSERT(areEqual(*charStack,b));
free(charStack);
}
void test_push_double_in_stack(){
double expected[] = {1.1,0.0,0.0,0.0};
double element = 1.1;
Stack b = {expected,0,sizeof(double),4};
doubleStack = create(sizeof(double),4);
push(doubleStack,&element);
ASSERT(areEqual(*doubleStack,b));
free(doubleStack);
}
void test_push_float_in_stack(){
float expected[] = {1.1,0.0,0.0,0.0};
float element = 1.1;
Stack b = {expected,0,sizeof(float),4};
floatStack = create(sizeof(float),4);
push(floatStack,&element);
ASSERT(areEqual(*floatStack,b));
free(floatStack);
}
void test_to_create_string_Queue(){
String expArr[2]={"Prateek","Kajal"};
Queue expected = {expArr,{2,sizeof(String),-1,-1}};
Queue* queue=create(sizeof(String), 2);
memcpy(queue->base, expected.base, sizeof(String)*2);
ASSERT(areEqual(queue, &expected));
free(queue->base);
free(queue);
}
void test_4_push_element_into_int_type_Stack(){
int data[] = {1,0,0,0,0};
int arr[] = {0,0,0,0,0};
int element = 1, result;
Stack expected = {data,sizeof(int),5,0};
Stack intData = create_ints(5, arr);
result = push(&intData, &element);
ASSERT(areEqual(intData, expected) && result == 1);
}
void test_4_create_allocates_and_assigns_zero_to_all_bytes_for_DOUBLE(){
int value;
double doubleArray[] = {0.0,0.0,0.0};
expectedInstance.baseAddress = doubleArray;
expectedInstance.typeSize = 8;
expectedInstance.length = 3;
doubleInstance = create(sizeof(double),3);
value = areEqual(expectedInstance,doubleInstance);
ASSERT(value);
}
void test_3_create_allocates_and_assigns_zero_to_all_bytes_for_FLOAT(){
int value;
float floatArray[] = {0.0,0.0,0.0};
expectedInstance.baseAddress = floatArray;
expectedInstance.typeSize = 4;
expectedInstance.length = 3;
floatInstance = create(sizeof(float),3);
value = areEqual(expectedInstance,floatInstance);
ASSERT(value);
}
void test_2_create_allocates_and_assigns_zero_to_all_bytes_for_CHAR(){
int value;
char charArray[] = {0,0,0};
expectedInstance.baseAddress = charArray;
expectedInstance.typeSize = 1;
expectedInstance.length = 3;
charInstance = create(sizeof(char),3);
value = areEqual(expectedInstance,charInstance);
ASSERT(value);
}
void test_pop_float_from_stack(){
float expected[] = {1.0,0.0};
float _one = 1.0;
Stack b = {expected,-1,sizeof(float),2};
floatStack = create(sizeof(float),2);
push(floatStack,&_one);
pop(floatStack);
ASSERT(areEqual(*floatStack,b));
free(floatStack);
}
void test_pop_char_from_stack(){
char expected[] = {'a','\0'};
char _a = 'a';
Stack b = {expected,-1,sizeof(char),2};
charStack = create(sizeof(char),2);
push(charStack,&_a);
pop(charStack);
ASSERT(areEqual(*charStack,b));
free(charStack);
}
void test_areEqual_returns_1_for_two_equal_ArrayUtils_with_elements (){
ArrayUtil list = create(4, 5);
int array[] = {1,2,3,4,5};
insertElements(&list, array);
ArrayUtil list1 = create(4, 5);
insertElements(&list1, array);
assert(areEqual(list, list1)==1);
dispose(list);
dispose(list1);
}
bool areEqual(const Sphere* s1, const Sphere* s2)
{
if(s1 == NULL || s2 == NULL)
return false;
if(areEqual(s1->center, s2->center) && s1->radius == s2->radius)
return true;
else
return false;
}
void test_pop_String_from_stack(){
String expected[] = {"abc","\0"};
String _name = "abc";
Stack b = {expected,-1,sizeof(String),2};
stringStack = create(sizeof(String),2);
push(stringStack,&_name);
pop(stringStack);
ASSERT(areEqual(*stringStack,b));
free(stringStack);
}
int countNumberOfWord(HashTable *hashTable, StringXXX *key){
int position = getHash(key);
HashCell *tmp = hashTable->cells[position];
while (tmp != nullptr){
if (areEqual(tmp->key, key))
return tmp->howMuch;
tmp = tmp->next;
}
return 0;
}
void test_1_create_a_new_int_type_Stack(){
Stack* data;
Stack expected;
int temp[] = {0,0,0,0,0};
expected.starting_address = temp;
expected.each_size = sizeof(int);
expected.total_elements = 5;
data = createStack(sizeof(int), 5);
ASSERT(1 == areEqual(*data, expected));
}
void test_1_create_allocates_and_assigns_zero_to_all_bytes_for_INT(){
int value;
int intArray[] = {0,0,0};
expectedInstance.baseAddress = intArray;
expectedInstance.typeSize = 4;
expectedInstance.length = 3;
intInstance = create(sizeof(int),3);
value = areEqual(expectedInstance,intInstance);
ASSERT(value);
}
void test_pop_double_from_stack(){
double expected[] = {1.0,0.0};
double _one = 1.0;
Stack b = {expected,-1,sizeof(double),2};
doubleStack = create(sizeof(double),2);
push(doubleStack,&_one);
pop(doubleStack);
ASSERT(areEqual(*doubleStack,b));
free(doubleStack);
}
bool BAbstractFileType::areEqual(const BracketPairList &l1, const BracketPairList &l2)
{
if (l1.size() != l2.size())
return false;
for (int i = 0; i < l1.size(); ++i) {
if (!areEqual(l1.at(i), l2.at(i)))
return false;
}
return true;
}
int search(ArrayList list, void *data, Comparator *areEqual){
Iterator it = getIteratorArray(&list);
void* currentData;
int result;
while(it.hasNext(&it)){
currentData = it.next(&it);
result = areEqual(currentData, data);
if(result) return it.position - 1;
}
return -1;
}
void test_pop_integer_from_stack(){
int expected[] = {2,0};
int _one = 1;
int _two = 2;
Stack b = {expected,0,sizeof(int),2};
integerStack = create(sizeof(int),2);
push(integerStack,&_one);
pop(integerStack);
push(integerStack,&_two);
ASSERT(areEqual(*integerStack,b));
free(integerStack);
}
