ray-tracer-challenge/test/test_tuples.c

#include <stdbool.h>
#include <stdio.h>

#include "tuples.h"
#include "runner.h"

static bool tuple_test_0(const char ** scenario)
{
  *scenario = "A tuple with w=1.0 is a point";

  struct tuple a = tuple(4.3f, -4.2f, 3.1f, 1.0f);
  return
    a.x ==  4.3f &&
    a.y == -4.2f &&
    a.z ==  3.1f &&
    a.w ==  1.0f &&
    tuple_is_point(a) &&
    !tuple_is_vector(a)
    ;
}

static bool tuple_test_1(const char ** scenario)
{
  *scenario = "A tuple with w=0.0 is a vector";

  struct tuple a = tuple(4.3f, -4.2f, 3.1f, 0.0f);
  return
    a.x ==  4.3f &&
    a.y == -4.2f &&
    a.z ==  3.1f &&
    a.w ==  0.0f &&
    !tuple_is_point(a) &&
    tuple_is_vector(a)
    ;
}

static bool tuple_test_2(const char ** scenario)
{
  *scenario = "point() creates tuples with w=1.0";
  struct tuple v = point(4.0f, -4.0f, 3.0f);
  return tuple_equal(v, tuple(4.0f, -4.0f, 3.0f, 1.0f));
}

static bool tuple_test_3(const char ** scenario)
{
  *scenario = "vector() creates tuples with w=0.0";
  struct tuple v = vector(4.0f, -4.0f, 3.0f);
  return tuple_equal(v, tuple(4.0f, -4.0f, 3.0f, 0.0f));
}

static bool tuple_test_4(const char ** scenario)
{
  *scenario = "Adding two tuples";
  struct tuple a1 = tuple(3.0f, -2.0f, 5.0f, 1.0f);
  struct tuple a2 = tuple(-2.0f, 3.0f, 1.0f, 0.0f);
  return tuple_equal(tuple_add(a1, a2), point(1.0f, 1.0f, 6.0f));
}

static bool tuple_test_5(const char ** scenario)
{
  *scenario = "Subtracting two points";
  struct tuple p1 = point(3.0f, 2.0f, 1.0f);
  struct tuple p2 = point(5.0f, 6.0f, 7.0f);
  return tuple_equal(tuple_sub(p1, p2), vector(-2.0f, -4.0f, -6.0f));
}

static bool tuple_test_6(const char ** scenario)
{
  *scenario = "Subtracting a vector from a point";
  struct tuple p = point(3.0f, 2.0f, 1.0f);
  struct tuple v = vector(5.0f, 6.0f, 7.0f);
  return tuple_equal(tuple_sub(p, v), point(-2.0f, -4.0f, -6.0f));
}

static bool tuple_test_7(const char ** scenario)
{
  *scenario = "Subtracting two vectors";
  struct tuple v1 = vector(3.0f, 2.0f, 1.0f);
  struct tuple v2 = vector(5.0f, 6.0f, 7.0f);
  return tuple_equal(tuple_sub(v1, v2), vector(-2.0f, -4.0f, -6.0f));
}

static bool tuple_test_8(const char ** scenario)
{
  *scenario = "Subtracting a vector from the zero vector";
  struct tuple zero = vector(0.0f, 0.0f, 0.0f);
  struct tuple v = vector(1.0f, -2.0f, 3.0f);
  return tuple_equal(tuple_sub(zero, v), vector(-1.0f, 2.0f, -3.0f));
}

static bool tuple_test_9(const char ** scenario)
{
  *scenario = "Negating a tuple";
  struct tuple a = tuple(1.0f, -2.0f, 3.0f, -4.0f);
  return tuple_equal(tuple_neg(a), tuple(-1.0f, 2.0f, -3.0f, 4.0f));
}

static bool tuple_test_10(const char ** scenario)
{
  *scenario = "Multiplying a tuple by a scalar";
  struct tuple a = tuple(1.0f, -2.0f, 3.0f, -4.0f);
  return tuple_equal(tuple_mul(a, 3.5f), tuple(3.5f, -7.0f, 10.5f, -14.0f));
}

static bool tuple_test_11(const char ** scenario)
{
  *scenario = "Multiplying a tuple by a fraction";
  struct tuple a = tuple(1.0f, -2.0f, 3.0f, -4.0f);
  return tuple_equal(tuple_mul(a, 0.5f), tuple(0.5f, -1.0f, 1.5f, -2.0f));
}

static bool tuple_test_12(const char ** scenario)
{
  *scenario = "Dividing a tuple by a scalar";
  struct tuple a = tuple(1.0f, -2.0f, 3.0f, -4.0f);
  return tuple_equal(tuple_div(a, 2.0f), tuple(0.5f, -1.0f, 1.5f, -2.0f));
}

static bool tuple_test_13(const char ** scenario)
{
  *scenario = "Computing the magnitude of vector(1, 0, 0)";
  struct tuple a = vector(1.0f, 0.0f, 0.0f);
  return float_equal(tuple_magnitude(a), 1.0f);
}

static bool tuple_test_14(const char ** scenario)
{
  *scenario = "Computing the magnitude of vector(0, 1, 0)";
  struct tuple a = vector(0.0f, 1.0f, 0.0f);
  return float_equal(tuple_magnitude(a), 1.0f);
}

static bool tuple_test_15(const char ** scenario)
{
  *scenario = "Computing the magnitude of vector(0, 0, 1)";
  struct tuple a = vector(0.0f, 0.0f, 1.0f);
  return float_equal(tuple_magnitude(a), 1.0f);
}

static bool tuple_test_16(const char ** scenario)
{
  *scenario = "Computing the magnitude of vector(1, 2, 3)";
  struct tuple a = vector(1.0f, 2.0f, 3.0f);
  return float_equal(tuple_magnitude(a), 3.7416573867739413);
}

static bool tuple_test_17(const char ** scenario)
{
  *scenario = "Computing the magnitude of vector(-1, -2, -3)";
  struct tuple a = vector(-1.0f, -2.0f, -3.0f);
  return float_equal(tuple_magnitude(a), 3.7416573867739413);
}

static bool tuple_test_18(const char ** scenario)
{
  *scenario = "Normalizing vector(4, 0, 0)";
  struct tuple v = vector(4.0f, 0.0f, 0.0f);
  return tuple_equal(tuple_normalize(v), vector(1.0f, 0.0f, 0.0f));
}

static bool tuple_test_19(const char ** scenario)
{
  *scenario = "Normalizing vector(1, 2, 3)";
  struct tuple v = vector(1.0f, 2.0f, 3.0f);
  return tuple_equal(tuple_normalize(v), vector(0.2672612419124244,
                                                0.5345224838248488,
                                                0.8017837257372732));
}

static bool tuple_test_20(const char ** scenario)
{
  *scenario = "The magnitude of a normalized vector";
  struct tuple v = vector(1.0f, 2.0f, 3.0f);
  struct tuple norm = tuple_normalize(v);
  return float_equal(tuple_magnitude(norm), 1.0f);
}

static bool tuple_test_21(const char ** scenario)
{
  *scenario = "The dot product of two tuples";
  struct tuple a = vector(1.0f, 2.0f, 3.0f);
  struct tuple b = vector(2.0f, 3.0f, 4.0f);
  return float_equal(tuple_dot(a, b), 20.0f);
}

static bool tuple_test_22(const char ** scenario)
{
  *scenario = "The cross product of two vectors";
  struct tuple a = vector(1.0f, 2.0f, 3.0f);
  struct tuple b = vector(2.0f, 3.0f, 4.0f);
  return
    tuple_equal(tuple_cross(a, b), vector(-1.0f,  2.0f, -1.0f)) &&
    tuple_equal(tuple_cross(b, a), vector( 1.0f, -2.0f,  1.0f))
    ;
}

static bool tuple_test_23(const char ** scenario)
{
  *scenario = "Colors are (red, green, blue) tuples";
  struct tuple c = color(-0.5, 0.4, 1.7);
  return
    float_equal(c.r, -0.5) &&
    float_equal(c.g,  0.4) &&
    float_equal(c.b,  1.7);
}

static bool tuple_test_24(const char ** scenario)
{
  *scenario = "Adding colors";
  struct tuple c1 = color(0.9f, 0.6f, 0.75f);
  struct tuple c2 = color(0.7f, 0.1f, 0.25f);
  return tuple_equal(tuple_add(c1, c2), color(1.6f, 0.7f, 1.0f));
}

static bool tuple_test_25(const char ** scenario)
{
  *scenario = "Subtracting colors";
  struct tuple c1 = color(0.9f, 0.6f, 0.75f);
  struct tuple c2 = color(0.7f, 0.1f, 0.25f);
  return tuple_equal(tuple_sub(c1, c2), color(0.2f, 0.5f, 0.5f));
}

static bool tuple_test_26(const char ** scenario)
{
  *scenario = "Multiplying a color by a scalar";
  struct tuple c = color(0.2f, 0.3f, 0.4f);
  return tuple_equal(tuple_mul(c, 2.0f), color(0.4f, 0.6f, 0.8f));
}

static bool tuple_test_27(const char ** scenario)
{
  *scenario = "Multiplying colors";
  struct tuple c1 = color(1.0f, 0.2f, 0.4f);
  struct tuple c2 = color(0.9f, 1.0f, 0.1f);
  return tuple_equal(hadmard_product(c1, c2), color(0.9f, 0.2f, 0.04f));
}

static bool tuple_test_28(const char ** scenario)
{
  *scenario = "Reflecting a vector approacing at 45 degrees";

  struct tuple v = vector(1.0f, -1.0f, 0.0f);
  struct tuple n = vector(0.0f, 1.0f, 0.0f);
  struct tuple r = tuple_reflect(v, n);
  return tuple_equal(r, vector(1.0f, 1.0f, 0.0f));
}

static bool tuple_test_29(const char ** scenario)
{
  *scenario = "Reflecting a vector off a slanted surface";

  struct tuple v = vector(0.0f, -1.0f, 0.0f);
  struct tuple n = vector(0.7071067811865476f, 0.7071067811865476f, 0.0f);
  struct tuple r = tuple_reflect(v, n);
  return tuple_equal(r, vector(1.0f, 0.0f, 0.0f));
}

test_t tuple_tests[] = {
  tuple_test_0,
  tuple_test_1,
  tuple_test_2,
  tuple_test_3,
  tuple_test_4,
  tuple_test_5,
  tuple_test_6,
  tuple_test_7,
  tuple_test_8,
  tuple_test_9,
  tuple_test_10,
  tuple_test_11,
  tuple_test_12,
  tuple_test_13,
  tuple_test_14,
  tuple_test_15,
  tuple_test_16,
  tuple_test_17,
  tuple_test_18,
  tuple_test_19,
  tuple_test_20,
  tuple_test_21,
  tuple_test_22,
  tuple_test_23,
  tuple_test_24,
  tuple_test_25,
  tuple_test_26,
  tuple_test_27,
  tuple_test_28,
  tuple_test_29,
};

RUNNER(tuple_tests)