space/cartesian_test.go at main · jmbarzee/space · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
package space

import (
	"testing"
)

type CartesianTest struct {
	Initial   Cartesian
	Operation func(Cartesian) Cartesian
	Expected  Cartesian
}

func RunCartesianTests(t *testing.T, cases []CartesianTest) {
	for i, c := range cases {
		actual := c.Operation(c.Initial)
		if !CartesiansEqual(c.Expected, actual) {
			t.Fatalf("Test %v failed. Cartesians were not equal:\n\tExpected: %v,\n\tActual: %v", i, c.Expected, actual)
		}
	}
}

// CartesiansEqual compares Cartesians
func CartesiansEqual(a, b Cartesian) bool {
	if !near(a.X, b.X) {
		return false
	}
	if !near(a.Y, b.Y) {
		return false
	}
	if !near(a.Z, b.Z) {
		return false
	}
	return true
}

func TestNewCartesian(t *testing.T) {
	cases := []CartesianTest{
		{
			Operation: func(v Cartesian) Cartesian {
				return NewCartesian(0, 0, 0)
			},
			Expected: Cartesian{0, 0, 0},
		},
		{
			Operation: func(v Cartesian) Cartesian {
				return NewCartesian(2, 3, 5)
			},
			Expected: Cartesian{2, 3, 5},
		},
		{
			Operation: func(v Cartesian) Cartesian {
				return NewCartesian(-2, -3, -5)
			},
			Expected: Cartesian{-2, -3, -5},
		},
	}
	RunCartesianTests(t, cases)
}

func TestCartesianSpherical(t *testing.T) {

	cases := make([]SphericalTest, len(AllEquivalencies))
	for i, p := range AllEquivalencies {
		c := p.Cartesian
		cases[i] = SphericalTest{
			Operation: func(v Spherical) Spherical {
				return c.Spherical()
			},
			Expected: p.Spherical,
		}
	}
	RunSphericalTests(t, cases)
}

func TestCartesianTranslationMatrix(t *testing.T) {
	cases := []CartesianTest{
		{
			Initial: Cartesian{0, 0, 0},
			Operation: func(v Cartesian) Cartesian {
				u := Cartesian{2, 3, 5}
				m := u.TranslationMatrix()
				return v.Transform(m).Cartesian()
			},
			Expected: Cartesian{2, 3, 5},
		},
		{
			Initial: Cartesian{0, 0, 0},
			Operation: func(v Cartesian) Cartesian {
				u := Cartesian{-2, -3, -5}
				m := u.TranslationMatrix()
				return v.Transform(m).Cartesian()
			},
			Expected: Cartesian{-2, -3, -5},
		},
		{
			Initial: Cartesian{2, 3, 5},
			Operation: func(v Cartesian) Cartesian {
				u := Cartesian{0, 0, 0}
				m := u.TranslationMatrix()
				return v.Transform(m).Cartesian()
			},
			Expected: Cartesian{2, 3, 5},
		},
		{
			Initial: Cartesian{-2, -3, -5},
			Operation: func(v Cartesian) Cartesian {
				u := Cartesian{0, 0, 0}
				m := u.TranslationMatrix()
				return v.Transform(m).Cartesian()
			},
			Expected: Cartesian{-2, -3, -5},
		},
		{
			Initial: Cartesian{2, 3, 5},
			Operation: func(v Cartesian) Cartesian {
				u := Cartesian{7, 8, 9}
				m := u.TranslationMatrix()
				return v.Transform(m).Cartesian()
			},
			Expected: Cartesian{9, 11, 14},
		},
	}
	RunCartesianTests(t, cases)
}