void test_sphere_intersection_point(void){
struct ray r = create_ray(create_point(0,0,0),create_vector(1.3,0,0));
struct sphere s = create_sphere(create_point(2.5,0,0),1.2);
struct maybe_point test = sphere_intersection_point(r,s);
checkit_double(test.p.x,1.3);
checkit_double(test.p.y,0);
checkit_double(test.p.z,0);
checkit_int(test.isPoint,1);
struct ray r2 = create_ray(create_point(-2.4,-2.9,-4.4),create_vector(-1,0,0));
struct sphere s2 = create_sphere(create_point(2.3,5.7,8.2),1);
struct maybe_point test2 = sphere_intersection_point(r2,s2);
checkit_int(test2.isPoint,0);
struct ray r3 = create_ray(create_point(-4.3,0,4.7),create_vector(3.5,0,0));
struct sphere s3 = create_sphere(create_point(2.1,0,0),4.7);
struct maybe_point test3 = sphere_intersection_point(r3,s3);
checkit_int(test3.isPoint,1);
struct ray r4 = create_ray(create_point(1.2,-5.4,4.2),create_vector(1.1,1.2,1.3));
struct sphere s4 = create_sphere(create_point(4.7,6.4,2.2),13.5);
struct maybe_point test4 = sphere_intersection_point(r4,s4);
checkit_double(test4.p.x,9.871860);
checkit_double(test4.p.y,4.060210);
checkit_double(test4.p.z,14.448561);
checkit_int(test4.isPoint,1);
}
void test_cases(void)
{
struct monster l= create_monster(2,3,4.5,6);
checkit_int(l.numEyes, 2);
checkit_int(l.numArms,3);
checkit_double(l.height, 4.5);
checkit_int(l.numTails, 6);
}
void test_cast_ray(void){
struct sphere s[2];
struct color c1 = create_color(1,0,.3);
s[0] = create_sphere(create_point(1.4,2.6,0), 2, c1);
s[1] = create_sphere(create_point(4.5, 5, 0), 1,c1);
struct ray r = create_ray(create_point(0,0,0),
create_vector(1.4,2.6,0));
struct ray r2 = create_ray(create_point(-123.2,-4,-.3),
create_vector(1.3,-2.9,-.3));
struct ray r3 = create_ray(create_point(-4.5,-4.3,0),
create_vector(-23,-100,-100));
checkit_int(cast_ray(r,s,2).r, 1);
checkit_int(cast_ray(r,s,2).g, 0);
checkit_int(cast_ray(r,s,2).b, .3);
checkit_int(cast_ray(r2,s,2).r, 1);
checkit_int(cast_ray(r2,s,2).g, 1);
checkit_int(cast_ray(r2,s,2).b, 1);
checkit_int(cast_ray(r3,s,2).r, 1);
checkit_int(cast_ray(r3,s,2).g, 1);
checkit_int(cast_ray(r3,s,2).b, 1);
}
void test_cases(void)
{
checkit_int(0 + 1, 1);
checkit_int(2 * 2, 4);
checkit_int(19 / 3, 6);
checkit_double(19.0 / 3, 6.333333);
checkit_double(19 / 3.0, 6.333333);
checkit_double(19.0 / 3.0, 6.333333);
checkit_int(4 * 2 +27 / 3 + 4, 21);
checkit_int(4 * (2 + 27) / 3 + 4, 42);
}
void test_find_intersection_points(void){
struct sphere s1 = create_sphere(create_point(4.2,0,0),1.3);
struct sphere s2 = create_sphere(create_point(2.6,0,0),5.4);
struct ray r = create_ray(create_point(-23.2,0,0),create_vector(.2,0,0));
struct sphere spheres[2] = {s1,s2};
struct sphere hit[2];
struct point pts[2];
checkit_int(find_intersection_points(spheres,2,r,hit,pts),2);
checkit_double(pts[0].x, 2.9);
checkit_double(pts[0].y, 0);
checkit_double(pts[0].z, 0);
checkit_double(pts[1].x, -2.8);
checkit_double(pts[1].y, 0);
checkit_double(pts[1].z, 0);
checkit_double(hit[0].center.x, 4.2);
checkit_double(hit[0].center.y, 0);
checkit_double(hit[0].center.z, 0);
checkit_double(hit[0].radius, 1.3);
checkit_double(hit[1].center.x, 2.6);
checkit_double(hit[1].center.y, 0);
checkit_double(hit[1].center.z, 0);
checkit_double(hit[1].radius, 5.4);
struct sphere s3 = create_sphere(create_point(4.5,1.4,3.2),1.8);
struct sphere s4 = create_sphere(create_point(2,4.3,5.4),3.2);
struct sphere s5 = create_sphere(create_point(2.9,3.4,2.1),2.3);
struct ray r2 = create_ray(create_point(1,1.3,.5),create_vector(1.3,1.4,1.8));
struct sphere spheres2[3] = {s3,s4,s5};
struct sphere hit2[3];
struct point pts2[3];
checkit_int(find_intersection_points(spheres2,3,r2,hit2,pts2),2);
checkit_double(pts2[0].x, 2.489528);
checkit_double(pts2[0].y, 2.904107);
checkit_double(pts2[0].z, 2.562423);
checkit_double(pts2[1].x, 1.492227);
checkit_double(pts2[1].y, 1.830091);
checkit_double(pts2[1].z, 1.181545);
checkit_double(hit2[0].center.x, 2);
checkit_double(hit2[0].center.y, 4.3);
checkit_double(hit2[0].center.z, 5.4);
checkit_double(hit2[0].radius, 3.2);
checkit_double(hit2[1].center.x, 2.9);
checkit_double(hit2[1].center.y, 3.4);
checkit_double(hit2[1].center.z, 2.1);
checkit_double(hit2[1].radius, 2.3);
}
int main(int argc, char * argv[]) {
FILE * fp = fopen(argv[1], "r");
if(fp!=NULL) {
char currLine[17];
fgets(currLine, 17, fp);
BST * progTree = NULL;
unsigned short currNum;
while(!feof(fp)){
currNum = convertToShort(currLine);
progTree = bst_insert(progTree,currNum);
fgets(currLine,17,fp);
}
bst_traverseInOrder(progTree);
}
fclose(fp);
/*string to short assignments */
char zero[] = "0000000000000000";
char one[] = "0000000000000001";
char sixfivefivethreefive[] = "1111111111111111";
char onethreeseven[] = "0000000010001001";
/*BST assignment */
BST * myTree = NULL;
/*string to short tests */
checkit_int(convertToShort(zero),0);
checkit_int(convertToShort(one),1);
checkit_int(convertToShort(sixfivefivethreefive),65535);
checkit_int(convertToShort(onethreeseven), 137);
/*bst tests */
checkit_int(bst_isValueInTree(myTree, 8),0);
myTree = bst_insert(myTree, 8);
checkit_int(bst_isValueInTree(myTree, 8),1);
checkit_int(bst_isValueInTree(myTree, 5),0);
checkit_int(bst_isValueInTree(myTree, 6),0);
/*bst_traverseInOrder(myTree);*/
myTree = bst_insert(myTree, 1);
myTree = bst_insert(myTree, 3);
myTree = bst_insert(myTree,6);
myTree = bst_insert(myTree,4);
myTree = bst_insert(myTree,7);
myTree = bst_insert(myTree,10);
myTree = bst_insert(myTree,14);
myTree = bst_insert(myTree,13);
bst_traverseInOrder(myTree);
checkit_int(bst_isValueInTree(myTree, 6),1);
checkit_int(bst_isValueInTree(myTree, 13),1);
return 0;
}
/* SLLcheck checks that each node in a string-linked-list against an
array of string */
void SLLcheck(SLL *list, char* strArray[]) {
int i;
SLL *p;
for ( p=list, i=0;
p!=NULL;
p=p->next, i++){
printf("SLL check : ");
checkit_string(p->s, strArray[i]);
}
/* if expected value is NULL, checks that argument evaluates
to NULL */
if (strArray==NULL) {
printf("SLL check : ");
checkit_int(1, (list==NULL));
}
return;
}
void test_is_positive(void){
checkit_int(is_positive(-3),0);
checkit_int(is_positive(2),1);
}
void test(void){
struct point p1 = create_point(1,3);
struct point p2 = create_point(3,6);
struct point p3 = create_point(5,0);
struct point p4 = create_point(7,1);
checkit_int(p1.x,1);
checkit_int(p2.y,6);
struct rect r1 = create_rect(p1, 3,2);
struct rect r2 = create_rect(p2, 4,1);
struct rect r3 = create_rect(p3,1,1);
struct rect r4 = create_rect(p4,1,1);
checkit_int(r1.w, 3);
checkit_int(r2.h, 1);
checkit_double(distance(p1,p3),5);
struct rect r[3] = {r1,r2,r3};
checkit_int(largest_rect(r,3),0);
struct point p[2];
closest_corners(r1,r2,p);
checkit_int(p[0].x,4);
checkit_int(p[0].y,5);
checkit_int(p[1].x,3);
checkit_int(p[1].y,6);
struct point pt[2];
closest_corners(r2,r3,pt);
checkit_int(pt[0].x,3);
checkit_int(pt[0].y,6);
checkit_int(pt[1].x,5);
checkit_int(pt[1].y,1);
struct point pts[2];
closest_corners(r3,r4,pts);
checkit_int(pts[0].x,6);
checkit_int(pts[0].y,1);
checkit_int(pts[1].x,7);
checkit_int(pts[1].y,1);
}
void rental_late_fee_test_cases(void)
{
checkit_int(rental_late_fee(9), 5)
checkit_int(rental_late_fee(15), 7);
}
void is_even_test_cases(void)
{
checkit_int(is_even(1), 0);
checkit_int(is_even(2), 1);
}
void in_an_interval_test_cases(void)
{
checkit_int(in_an_interval(5), 0);
checkit_int(in_an_interval(48), 1);
}
void is_between_test_cases(void)
{
checkit_int(is_between(4, 3, 6), 1);
checkit_int(is_between(5, 1, 6), 1);
}
