raytracing/raytracer_challenge
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[FIX] Just rename tests

Browse Source
This commit is contained in:
NADAL Jean-Baptiste
2024-01-31 11:42:27 +01:00
parent 033ec18577
commit 3c88427371
2 changed files with 36 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
tests/01_tuples.cpp
View File

@@ -35,7 +35,7 @@ using namespace Raytracer;
/* ------------------------------------------------------------------------- */
TEST_CASE("a tuple with w=1.0 is a point", "[Tuple]")
TEST_CASE("[Tuple] a tuple with w=1.0 is a point", "[Tuple]")
{
Tuple a(4.3, -4.2, 3.1, 1.0);
@@ -50,7 +50,7 @@ TEST_CASE("a tuple with w=1.0 is a point", "[Tuple]")
/* ------------------------------------------------------------------------- */
TEST_CASE("a tuple with w=0 is a vector", "[Tuple]")
TEST_CASE("[Tuple] a tuple with w=0 is a vector", "[Tuple]")
{
Tuple a(4.3, -4.2, 3.1, 0.0);
@@ -64,7 +64,7 @@ TEST_CASE("a tuple with w=0 is a vector", "[Tuple]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Tuple could be copy", "[Tuple]")
TEST_CASE("[Tuple] Tuple could be copy", "[Tuple]")
{
Tuple p = Tuple::Point(4, -4, 3);
Tuple n;
@@ -76,7 +76,7 @@ TEST_CASE("Tuple could be copy", "[Tuple]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Point() creates tuples with w=1", "[Tuple][Point]")
TEST_CASE("[Tuple] Point() creates tuples with w=1", "[Tuple][Point]")
{
Tuple p = Tuple::Point(4, -4, 3);
@@ -85,7 +85,7 @@ TEST_CASE("Point() creates tuples with w=1", "[Tuple][Point]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Vector() creates tuples with w=0", "[Tuple][Vector]")
TEST_CASE("[Tuple] Vector() creates tuples with w=0", "[Tuple][Vector]")
{
Tuple v = Tuple::Vector(4, -4, 3);
@@ -94,7 +94,7 @@ TEST_CASE("Vector() creates tuples with w=0", "[Tuple][Vector]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Adding two tuples", "[Tuple][Operations]")
TEST_CASE("[Tuple] Adding two tuples", "[Tuple][Operations]")
{
Tuple a1(3, -2, 5, 1);
Tuple a2(-2, 3, 1, 0);
@@ -104,7 +104,7 @@ TEST_CASE("Adding two tuples", "[Tuple][Operations]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Adding two tuples without modify a1", "[Tuple][Operations]")
TEST_CASE("[Tuple] Adding two tuples without modify a1", "[Tuple][Operations]")
{
Tuple a1(3, -2, 5, 1);
Tuple a2(-2, 3, 1, 0);
@@ -116,7 +116,7 @@ TEST_CASE("Adding two tuples without modify a1", "[Tuple][Operations]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Subtracting two points", "[Tuple][Operations]")
TEST_CASE("[Tuple] Subtracting two points", "[Tuple][Operations]")
{
Tuple p1 = Tuple::Point(3, 2, 1);
Tuple p2 = Tuple::Point(5, 6, 7);
@@ -126,7 +126,7 @@ TEST_CASE("Subtracting two points", "[Tuple][Operations]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Subtracting two points without modify p1", "[Tuple][Operations]")
TEST_CASE("[Tuple] Subtracting two points without modify p1", "[Tuple][Operations]")
{
Tuple p1 = Tuple::Point(3, 2, 1);
Tuple p2 = Tuple::Point(5, 6, 7);
@@ -138,7 +138,7 @@ TEST_CASE("Subtracting two points without modify p1", "[Tuple][Operations]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Subtracting a vector from a point", "[Tuple][Operations]")
TEST_CASE("[Tuple] Subtracting a vector from a point", "[Tuple][Operations]")
{
Tuple p = Tuple::Point(3, 2, 1);
Tuple v = Tuple::Vector(5, 6, 7);
@@ -148,7 +148,7 @@ TEST_CASE("Subtracting a vector from a point", "[Tuple][Operations]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Subtracting two vectors", "[Tuple][Operations]")
TEST_CASE("[Tuple] Subtracting two vectors", "[Tuple][Operations]")
{
Tuple v1 = Tuple::Vector(3, 2, 1);
Tuple v2 = Tuple::Vector(5, 6, 7);
@@ -158,7 +158,7 @@ TEST_CASE("Subtracting two vectors", "[Tuple][Operations]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Subtracting a vector from the zero vector", "[Tuple][Operations]")
TEST_CASE("[Tuple] Subtracting a vector from the zero vector", "[Tuple][Operations]")
{
Tuple zero = Tuple::Vector(0, 0, 0);
Tuple v = Tuple::Vector(1, -2, 3);
@@ -168,7 +168,7 @@ TEST_CASE("Subtracting a vector from the zero vector", "[Tuple][Operations]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Negative a tuple", "[Tuple][Operations]")
TEST_CASE("[Tuple] Negative a tuple", "[Tuple][Operations]")
{
Tuple a(1, -2, 3, -4);
@@ -177,7 +177,7 @@ TEST_CASE("Negative a tuple", "[Tuple][Operations]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Multiplying a tuple by a scalar", "[Tuple][Multiplication]")
TEST_CASE("[Tuple] Multiplying a tuple by a scalar", "[Tuple][Multiplication]")
{
Tuple a(1, -2, 3, -4);
@@ -186,7 +186,7 @@ TEST_CASE("Multiplying a tuple by a scalar", "[Tuple][Multiplication]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Multiplying a tuple by a scalar without modify a", "[Tuple][Multiplication]")
TEST_CASE("[Tuple] Multiplying a tuple by a scalar without modify a", "[Tuple][Multiplication]")
{
Tuple a(1, -2, 3, -4);
@@ -197,7 +197,7 @@ TEST_CASE("Multiplying a tuple by a scalar without modify a", "[Tuple][Multiplic
/* ------------------------------------------------------------------------- */
TEST_CASE("Dividing a tuple by a scalar", "[Tuple][Multiplication]")
TEST_CASE("[Tuple] Dividing a tuple by a scalar", "[Tuple][Multiplication]")
{
Tuple a(1, -2, 3, -4);
@@ -206,7 +206,7 @@ TEST_CASE("Dividing a tuple by a scalar", "[Tuple][Multiplication]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Dividing a tuple by a scalar without modify a", "[Tuple][Multiplication]")
TEST_CASE("[Tuple] Dividing a tuple by a scalar without modify a", "[Tuple][Multiplication]")
{
Tuple a(1, -2, 3, -4);
@@ -217,7 +217,7 @@ TEST_CASE("Dividing a tuple by a scalar without modify a", "[Tuple][Multiplicati
/* ------------------------------------------------------------------------- */
TEST_CASE("Computing the magnitude of vector(1,0,0)", "[Tuple][Magnitude]")
TEST_CASE("[Tuple] Computing the magnitude of vector(1,0,0)", "[Tuple][Magnitude]")
{
Tuple v = Tuple::Vector(1, 0, 0);
@@ -226,7 +226,7 @@ TEST_CASE("Computing the magnitude of vector(1,0,0)", "[Tuple][Magnitude]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Computing the magnitude of vector(0,1,0)", "[Tuple][Magnitude]")
TEST_CASE("[Tuple] Computing the magnitude of vector(0,1,0)", "[Tuple][Magnitude]")
{
Tuple v = Tuple::Vector(0, 1, 0);
@@ -235,7 +235,7 @@ TEST_CASE("Computing the magnitude of vector(0,1,0)", "[Tuple][Magnitude]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Computing the magnitude of vector(0,0,1)", "[Tuple][Magnitude]")
TEST_CASE("[Tuple] Computing the magnitude of vector(0,0,1)", "[Tuple][Magnitude]")
{
Tuple v = Tuple::Vector(0, 0, 1);
@@ -244,7 +244,7 @@ TEST_CASE("Computing the magnitude of vector(0,0,1)", "[Tuple][Magnitude]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Computing the magnitude of vector(1,2,3)", "[Tuple][Magnitude]")
TEST_CASE("[Tuple] Computing the magnitude of vector(1,2,3)", "[Tuple][Magnitude]")
{
Tuple v = Tuple::Vector(1, 2, 3);
@@ -253,7 +253,7 @@ TEST_CASE("Computing the magnitude of vector(1,2,3)", "[Tuple][Magnitude]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Computing the magnitude of vector(-1,-2,-3)", "[Tuple][Magnitude]")
TEST_CASE("[Tuple] Computing the magnitude of vector(-1,-2,-3)", "[Tuple][Magnitude]")
{
Tuple v = Tuple::Vector(-1, -2, -3);
@@ -262,7 +262,7 @@ TEST_CASE("Computing the magnitude of vector(-1,-2,-3)", "[Tuple][Magnitude]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Normalize vector(4,0,0) gives (1,0,0)", "[Tuple][Normalize]")
TEST_CASE("[Tuple] Normalize vector(4,0,0) gives (1,0,0)", "[Tuple][Normalize]")
{
Tuple v = Tuple::Vector(4, 0, 0);
@@ -271,7 +271,7 @@ TEST_CASE("Normalize vector(4,0,0) gives (1,0,0)", "[Tuple][Normalize]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Normalize vector(1,2,3)", "[Tuple][Normalize]")
TEST_CASE("[Tuple] Normalize vector(1,2,3)", "[Tuple][Normalize]")
{
Tuple v = Tuple::Vector(1, 2, 3);
@@ -280,7 +280,7 @@ TEST_CASE("Normalize vector(1,2,3)", "[Tuple][Normalize]")
/* ------------------------------------------------------------------------- */
TEST_CASE("The magnitude of a normalized vector", "[Tuple][Normalize]")
TEST_CASE("[Tuple] The magnitude of a normalized vector", "[Tuple][Normalize]")
{
Tuple norm;
Tuple v = Tuple::Vector(1, 2, 3);
@@ -292,7 +292,7 @@ TEST_CASE("The magnitude of a normalized vector", "[Tuple][Normalize]")
/* ------------------------------------------------------------------------- */
TEST_CASE("The dot product of two tuples", "[Tuple][Dot]")
TEST_CASE("[Tuple] The dot product of two tuples", "[Tuple][Dot]")
{
Tuple a = Tuple::Vector(1, 2, 3);
Tuple b = Tuple::Vector(2, 3, 4);
@@ -302,7 +302,7 @@ TEST_CASE("The dot product of two tuples", "[Tuple][Dot]")
/* ------------------------------------------------------------------------- */
TEST_CASE("The cross product of two vector", "[Tuple][Cross]")
TEST_CASE("[Tuple] The cross product of two vector", "[Tuple][Cross]")
{
Tuple a = Tuple::Vector(1, 2, 3);
Tuple b = Tuple::Vector(2, 3, 4);

18
tests/02_colors.cpp
View File

@@ -33,7 +33,7 @@ using namespace Raytracer;
/* ------------------------------------------------------------------------- */
TEST_CASE("colors are (red,green,blue) tuples", "[Colors]")
TEST_CASE("[Color] colors are (red,green,blue) tuples", "[Colors]")
{
Color c(-0.5, 0.4, 1.7);
@@ -44,7 +44,7 @@ TEST_CASE("colors are (red,green,blue) tuples", "[Colors]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Colors could be copied", "[Colors]")
TEST_CASE("[Color] Colors could be copied", "[Colors]")
{
Color c1(-0.5, 0.4, 1.7);
Color c2;
@@ -58,7 +58,7 @@ TEST_CASE("Colors could be copied", "[Colors]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Adding colors", "[Colors]")
TEST_CASE("[Color] Adding colors", "[Colors]")
{
Color c1(0.9, 0.6, 0.75);
Color c2(0.7, 0.1, 0.25);
@@ -68,7 +68,7 @@ TEST_CASE("Adding colors", "[Colors]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Adding colors without modify c1", "[Colors]")
TEST_CASE("[Color] Adding colors without modify c1", "[Colors]")
{
Color c1(0.9, 0.6, 0.75);
Color c2(0.7, 0.1, 0.25);
@@ -80,7 +80,7 @@ TEST_CASE("Adding colors without modify c1", "[Colors]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Subtracting colors", "[Colors]")
TEST_CASE("[Color] Subtracting colors", "[Colors]")
{
Color c1(0.9, 0.6, 0.75);
Color c2(0.7, 0.1, 0.25);
@@ -90,7 +90,7 @@ TEST_CASE("Subtracting colors", "[Colors]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Subtracting colors without modify c1", "[Colors]")
TEST_CASE("[Color] Subtracting colors without modify c1", "[Colors]")
{
Color c1(0.9, 0.6, 0.75);
Color c2(0.7, 0.1, 0.25);
@@ -102,7 +102,7 @@ TEST_CASE("Subtracting colors without modify c1", "[Colors]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Multiplying a color by a scalar", "[Colors]")
TEST_CASE("[Color] Multiplying a color by a scalar", "[Colors]")
{
Color c(0.2, 0.3, 0.4);
@@ -111,7 +111,7 @@ TEST_CASE("Multiplying a color by a scalar", "[Colors]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Multiplying a color by a scalar without modify c", "[Colors]")
TEST_CASE("[Color] Multiplying a color by a scalar without modify c", "[Colors]")
{
Color c(0.2, 0.3, 0.4);
@@ -122,7 +122,7 @@ TEST_CASE("Multiplying a color by a scalar without modify c", "[Colors]")
/* ------------------------------------------------------------------------- */
TEST_CASE("Multiplying a colors", "[Colors]")
TEST_CASE("[Color] Multiplying a colors", "[Colors]")
{
Color c1(1, 0.2, 0.4);
Color c2(0.9, 1, 0.1);