6132588926

Committed 09 Sep 2023 06:38PM UTC coverage: 14.013% (-44.7%) from 58.701%

Build # 6132588926

Build Type

push

github

Committed by

FatalError42O

Commit Message

fixed Busted support (hopefully)

Run Details

975 of 6958 relevant lines covered (14.01%)

10.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.5

/spec/vec2_spec.lua

local vec2        = require "modules.vec2"
local DBL_EPSILON = require("modules.constants").DBL_EPSILON
local abs, sqrt   = math.abs, math.sqrt

describe("vec2:", function()
        it("creates an empty vector", function()
                local a = vec2()
                assert.is.equal(0, a.x)
                assert.is.equal(0, a.y)
                assert.is_true(a:is_vec2())
                assert.is_true(a:is_zero())
        end)

        it("creates a vector from a number", function()
                local a = vec2(3)
                assert.is.equal(3, a.x)
                assert.is.equal(3, a.y)
        end)

        it("creates a vector from numbers", function()
                local a = vec2(3, 5)
                assert.is.equal(3, a.x)
                assert.is.equal(5, a.y)
        end)

        it("creates a vector from a list", function()
                local a = vec2 { 3, 5 }
                assert.is.equal(3, a.x)
                assert.is.equal(5, a.y)
        end)

        it("creates a vector from a record", function()
                local a = vec2 { x=3, y=5 }
                assert.is.equal(3, a.x)
                assert.is.equal(5, a.y)
        end)

        it("creates a vector from nan", function()
                local a = vec2(0/0)
                assert.is_true(a:has_nan())
        end)

        it("clones a vector", function()
                local a = vec2(3, 5)
                local b = a:clone()
                assert.is.equal(a, b)
        end)

        it("clones a vector using the constructor", function()
                local a = vec2(3, 5)
                local b = vec2(a)
                assert.is.equal(a, b)
        end)

        it("adds a vector to another", function()
                local a = vec2(3, 5)
                local b = vec2(7, 4)
                local c = a:add(b)
                local d = a + b
                assert.is.equal(10, c.x)
                assert.is.equal(9,  c.y)
                assert.is.equal(c,  d)
        end)

        it("subracts a vector from another", function()
                local a = vec2(3, 5)
                local b = vec2(7, 4)
                local c = a:sub(b)
                local d = a - b
                assert.is.equal(-4, c.x)
                assert.is.equal( 1, c.y)
                assert.is.equal( c, d)
        end)

        it("multiplies a vector by a scale factor", function()
                local a = vec2(3, 5)
                local s = 2
                local c = a:scale(s)
                local d = a * s
                assert.is.equal(6,  c.x)
                assert.is.equal(10, c.y)
                assert.is.equal(c,  d)
        end)

        it("divides a vector by another vector", function()
                local a = vec2(3, 5)
                local s = vec2(2, 2)
                local c = a:div(s)
                local d = a / s
                assert.is.equal(1.5, c.x)
                assert.is.equal(2.5, c.y)
                assert.is.equal(c,   d)
        end)

        it("inverts a vector", function()
                local a = vec2(3, -5)
                local b = -a
                assert.is.equal(-a.x, b.x)
                assert.is.equal(-a.y, b.y)
        end)

        it("gets the length of a vector", function()
                local a = vec2(3, 5)
                assert.is.equal(sqrt(34), a:len())
                end)

        it("gets the square length of a vector", function()
                local a = vec2(3, 5)
                assert.is.equal(34, a:len2())
        end)

        it("normalizes a vector", function()
                local a = vec2(3, 5)
                local b = a:normalize()
                assert.is_true(abs(b:len()-1) < DBL_EPSILON)
                end)

        it("trims the length of a vector", function()
                local a = vec2(3, 5)
                local b = a:trim(0.5)
                assert.is_true(abs(b:len()-0.5) < DBL_EPSILON)
        end)

        it("gets the distance between two vectors", function()
                local a = vec2(3, 5)
                local b = vec2(7, 4)
                local c = a:dist(b)
                assert.is.equal(sqrt(17), c)
        end)

        it("gets the square distance between two vectors", function()
                local a = vec2(3, 5)
                local b = vec2(7, 4)
                local c = a:dist2(b)
                assert.is.equal(17, c)
        end)

        it("crosses two vectors", function()
                local a = vec2(3, 5)
                local b = vec2(7, 4)
                local c = a:cross(b)
                assert.is.equal(-23, c)
        end)

        it("dots two vectors", function()
                local a = vec2(3, 5)
                local b = vec2(7, 4)
                local c = a:dot(b)
                assert.is.equal(41, c)
        end)

        it("interpolates between two vectors", function()
                local a = vec2(3, 5)
                local b = vec2(7, 4)
                local s = 0.1
                local c = a:lerp(b, s)
                assert.is.equal(3.4, c.x)
                assert.is.equal(4.9, c.y)
        end)

        it("unpacks a vector", function()
                local a    = vec2(3, 5)
                local x, y = a:unpack()
                assert.is.equal(3, x)
                assert.is.equal(5, y)
        end)

        it("rotates a vector", function()
                local a = vec2(3, 5)
                local b = a:rotate( math.pi)
                local c = b:rotate(-math.pi)
                assert.is_not.equal(a, b)
                assert.is.equal(a, c)
        end)

        it("converts between polar and cartesian coordinates", function()
                local a    = vec2(3, 5)
                local r, t = a:to_polar()
                local b    = vec2.from_cartesian(r, t)
                assert.is_true(abs(a.x - b.x) <= DBL_EPSILON*2) -- Allow 2X epsilon error because there were 2 operations.
                assert.is_true(abs(a.y - b.y) <= DBL_EPSILON*2)
        end)

        it("gets a perpendicular vector", function()
                local a = vec2(3, 5)
                local b = a:perpendicular()
                assert.is.equal(-5, b.x)
                assert.is.equal( 3, b.y)
        end)

        it("gets a string representation of a vector", function()
                local a = vec2()
                local b = a:to_string()
                assert.is.equal("(+0.000,+0.000)", b)
        end)

        it("rounds a 2-vector", function()
                local a = vec2(1.1,1.9):round()
                assert.is.equal(a.x, 1)
                assert.is.equal(a.y, 2)
        end)

        it("flips a 2-vector", function()
                local a = vec2(1,2)
                local temp = a:flip_x()
                assert.is.equal(temp, vec2(-1, 2))
                temp = temp:flip_y()
                assert.is.equal(temp, vec2(-1, -2))
        end)

        it("finds angle from one 2-vector to another", function()
                local d = {
                        right = vec2(1,  0),
                        down  = vec2(0,  -1),
                        left  = vec2(-1, 0),
                        up    = vec2(0,  1),
                }
                assert.is.equal(math.deg(d.right:angle_to(d.right)), 0.0)
                assert.is.equal(math.deg(d.right:angle_to(d.down)), -90.0)
                assert.is.equal(math.deg(d.right:angle_to(d.left)), 180.0)
                assert.is.equal(math.deg(d.right:angle_to(d.up)), 90.0)

                assert.is.equal(math.deg(d.down:angle_to(d.right)), 90.0)
                assert.is.equal(math.deg(d.down:angle_to(d.down)), 0.0)
                assert.is.equal(math.deg(d.down:angle_to(d.left)), -90.0)
                assert.is.equal(math.deg(d.down:angle_to(d.up)), 180.0)

                assert.is.equal(math.deg(d.left:angle_to(d.right)), 180.0)
                assert.is.equal(math.deg(d.left:angle_to(d.down)), 90.0)
                assert.is.equal(math.deg(d.left:angle_to(d.left)), 0.0)
                assert.is.equal(math.deg(d.left:angle_to(d.up)), -90.0)

                assert.is.equal(math.deg(d.up:angle_to(d.right)), -90.0)
                assert.is.equal(math.deg(d.up:angle_to(d.down)), 180.0)
                assert.is.equal(math.deg(d.up:angle_to(d.left)), 90.0)
                assert.is.equal(math.deg(d.up:angle_to(d.up)), 0.0)
        end)

        it("finds angle between two 2-vectors", function()
                local d = {
                        right = vec2(1,  0),
                        down  = vec2(0,  -1),
                        left  = vec2(-1, 0),
                        up    = vec2(0,  1),
                }
                assert.is.equal(math.deg(d.right:angle_between(d.right)), 0.0)
                assert.is.equal(math.deg(d.right:angle_between(d.down)), 90.0)
                assert.is.equal(math.deg(d.right:angle_between(d.left)), 180.0)
                assert.is.equal(math.deg(d.right:angle_between(d.up)), 90.0)

                assert.is.equal(math.deg(d.down:angle_between(d.right)), 90.0)
                assert.is.equal(math.deg(d.down:angle_between(d.down)), 0.0)
                assert.is.equal(math.deg(d.down:angle_between(d.left)), 90.0)
                assert.is.equal(math.deg(d.down:angle_between(d.up)), 180.0)

                assert.is.equal(math.deg(d.left:angle_between(d.right)), 180.0)
                assert.is.equal(math.deg(d.left:angle_between(d.down)), 90.0)
                assert.is.equal(math.deg(d.left:angle_between(d.left)), 0.0)
                assert.is.equal(math.deg(d.left:angle_between(d.up)), 90.0)

                assert.is.equal(math.deg(d.up:angle_between(d.right)), 90.0)
                assert.is.equal(math.deg(d.up:angle_between(d.down)), 180.0)
                assert.is.equal(math.deg(d.up:angle_between(d.left)), 90.0)
                assert.is.equal(math.deg(d.up:angle_between(d.up)), 0.0)
        end)

        -- Do this last, to insulate tests from accidental state contamination
        -- Do vec3 tests last, to insulate tests from accidental state contamination
        it("converts a 2-vector to a 3-vector", function()
                local vec3 = require "modules.vec3"
                local a = vec2(1,2)
                local b = a:to_vec3()
                local c = a:to_vec3(3)
                assert.is.equal(b, vec3(1,2,0))
                assert.is.equal(c, vec3(1,2,3))
        end)

        it("converts a vec3 to vec2 using the constructor", function()
                local vec3 = require "modules.vec3"
                local a = vec2(3, 5)
                local b = vec3(3, 5, 7)
                local c = vec2(b)
                assert.is.equal(a, c)
        end)
end)

1	local vec2 = require "modules.vec2"	5✔
2	local DBL_EPSILON = require("modules.constants").DBL_EPSILON	×
3	local abs, sqrt = math.abs, math.sqrt	×
4
5	describe("vec2:", function()	×
6	it("creates an empty vector", function()	×
7	local a = vec2()	×
8	assert.is.equal(0, a.x)	×
9	assert.is.equal(0, a.y)	×
10	assert.is_true(a:is_vec2())	×
11	assert.is_true(a:is_zero())	×
12	end)
13
14	it("creates a vector from a number", function()	×
15	local a = vec2(3)	×
16	assert.is.equal(3, a.x)	×
17	assert.is.equal(3, a.y)	×
18	end)
19
20	it("creates a vector from numbers", function()	×
21	local a = vec2(3, 5)	×
22	assert.is.equal(3, a.x)	×
23	assert.is.equal(5, a.y)	×
24	end)
25
26	it("creates a vector from a list", function()	×
27	local a = vec2 { 3, 5 }	×
28	assert.is.equal(3, a.x)	×
29	assert.is.equal(5, a.y)	×
30	end)
31
32	it("creates a vector from a record", function()	×
33	local a = vec2 { x=3, y=5 }	×
34	assert.is.equal(3, a.x)	×
35	assert.is.equal(5, a.y)	×
36	end)
37
38	it("creates a vector from nan", function()	×
39	local a = vec2(0/0)	×
40	assert.is_true(a:has_nan())	×
41	end)
42
43	it("clones a vector", function()	×
44	local a = vec2(3, 5)	×
45	local b = a:clone()	×
46	assert.is.equal(a, b)	×
47	end)
48
49	it("clones a vector using the constructor", function()	×
50	local a = vec2(3, 5)	×
51	local b = vec2(a)	×
52	assert.is.equal(a, b)	×
53	end)
54
55	it("adds a vector to another", function()	×
56	local a = vec2(3, 5)	×
57	local b = vec2(7, 4)	×
58	local c = a:add(b)	×
59	local d = a + b	×
60	assert.is.equal(10, c.x)	×
61	assert.is.equal(9, c.y)	×
62	assert.is.equal(c, d)	×
63	end)
64
65	it("subracts a vector from another", function()	×
66	local a = vec2(3, 5)	×
67	local b = vec2(7, 4)	×
68	local c = a:sub(b)	×
69	local d = a - b	×
70	assert.is.equal(-4, c.x)	×
71	assert.is.equal( 1, c.y)	×
72	assert.is.equal( c, d)	×
73	end)
74
75	it("multiplies a vector by a scale factor", function()	×
76	local a = vec2(3, 5)	×
77	local s = 2	×
78	local c = a:scale(s)	×
79	local d = a * s	×
80	assert.is.equal(6, c.x)	×
81	assert.is.equal(10, c.y)	×
82	assert.is.equal(c, d)	×
83	end)
84
85	it("divides a vector by another vector", function()	×
86	local a = vec2(3, 5)	×
87	local s = vec2(2, 2)	×
88	local c = a:div(s)	×
89	local d = a / s	×
90	assert.is.equal(1.5, c.x)	×
91	assert.is.equal(2.5, c.y)	×
92	assert.is.equal(c, d)	×
93	end)
94
95	it("inverts a vector", function()	×
96	local a = vec2(3, -5)	×
97	local b = -a	×
98	assert.is.equal(-a.x, b.x)	×
99	assert.is.equal(-a.y, b.y)	×
100	end)
101
102	it("gets the length of a vector", function()	×
103	local a = vec2(3, 5)	×
104	assert.is.equal(sqrt(34), a:len())	×
105	end)
106
107	it("gets the square length of a vector", function()	×
108	local a = vec2(3, 5)	×
109	assert.is.equal(34, a:len2())	×
110	end)
111
112	it("normalizes a vector", function()	×
113	local a = vec2(3, 5)	×
114	local b = a:normalize()	×
115	assert.is_true(abs(b:len()-1) < DBL_EPSILON)	×
116	end)
117
118	it("trims the length of a vector", function()	×
119	local a = vec2(3, 5)	×
120	local b = a:trim(0.5)	×
121	assert.is_true(abs(b:len()-0.5) < DBL_EPSILON)	×
122	end)
123
124	it("gets the distance between two vectors", function()	×
125	local a = vec2(3, 5)	×
126	local b = vec2(7, 4)	×
127	local c = a:dist(b)	×
128	assert.is.equal(sqrt(17), c)	×
129	end)
130
131	it("gets the square distance between two vectors", function()	×
132	local a = vec2(3, 5)	×
133	local b = vec2(7, 4)	×
134	local c = a:dist2(b)	×
135	assert.is.equal(17, c)	×
136	end)
137
138	it("crosses two vectors", function()	×
139	local a = vec2(3, 5)	×
140	local b = vec2(7, 4)	×
141	local c = a:cross(b)	×
142	assert.is.equal(-23, c)	×
143	end)
144
145	it("dots two vectors", function()	×
146	local a = vec2(3, 5)	×
147	local b = vec2(7, 4)	×
148	local c = a:dot(b)	×
149	assert.is.equal(41, c)	×
150	end)
151
152	it("interpolates between two vectors", function()	×
153	local a = vec2(3, 5)	×
154	local b = vec2(7, 4)	×
155	local s = 0.1	×
156	local c = a:lerp(b, s)	×
157	assert.is.equal(3.4, c.x)	×
158	assert.is.equal(4.9, c.y)	×
159	end)
160
161	it("unpacks a vector", function()	×
162	local a = vec2(3, 5)	×
163	local x, y = a:unpack()	×
164	assert.is.equal(3, x)	×
165	assert.is.equal(5, y)	×
166	end)
167
168	it("rotates a vector", function()	×
169	local a = vec2(3, 5)	×
170	local b = a:rotate( math.pi)	×
171	local c = b:rotate(-math.pi)	×
172	assert.is_not.equal(a, b)	×
173	assert.is.equal(a, c)	×
174	end)
175
176	it("converts between polar and cartesian coordinates", function()	×
177	local a = vec2(3, 5)	×
178	local r, t = a:to_polar()	×
179	local b = vec2.from_cartesian(r, t)	×
180	assert.is_true(abs(a.x - b.x) <= DBL_EPSILON*2) -- Allow 2X epsilon error because there were 2 operations.	×
181	assert.is_true(abs(a.y - b.y) <= DBL_EPSILON*2)	×
182	end)
183
184	it("gets a perpendicular vector", function()	×
185	local a = vec2(3, 5)	×
186	local b = a:perpendicular()	×
187	assert.is.equal(-5, b.x)	×
188	assert.is.equal( 3, b.y)	×
189	end)
190
191	it("gets a string representation of a vector", function()	×
192	local a = vec2()	×
193	local b = a:to_string()	×
194	assert.is.equal("(+0.000,+0.000)", b)	×
195	end)
196
197	it("rounds a 2-vector", function()	×
198	local a = vec2(1.1,1.9):round()	×
199	assert.is.equal(a.x, 1)	×
200	assert.is.equal(a.y, 2)	×
201	end)
202
203	it("flips a 2-vector", function()	×
204	local a = vec2(1,2)	×
205	local temp = a:flip_x()	×
206	assert.is.equal(temp, vec2(-1, 2))	×
207	temp = temp:flip_y()	×
208	assert.is.equal(temp, vec2(-1, -2))	×
209	end)
210
211	it("finds angle from one 2-vector to another", function()	×
212	local d = {	×
213	right = vec2(1, 0),
214	down = vec2(0, -1),
215	left = vec2(-1, 0),
216	up = vec2(0, 1),
217	}
218	assert.is.equal(math.deg(d.right:angle_to(d.right)), 0.0)	×
219	assert.is.equal(math.deg(d.right:angle_to(d.down)), -90.0)	×
220	assert.is.equal(math.deg(d.right:angle_to(d.left)), 180.0)	×
221	assert.is.equal(math.deg(d.right:angle_to(d.up)), 90.0)	×
222
223	assert.is.equal(math.deg(d.down:angle_to(d.right)), 90.0)	×
224	assert.is.equal(math.deg(d.down:angle_to(d.down)), 0.0)	×
225	assert.is.equal(math.deg(d.down:angle_to(d.left)), -90.0)	×
226	assert.is.equal(math.deg(d.down:angle_to(d.up)), 180.0)	×
227
228	assert.is.equal(math.deg(d.left:angle_to(d.right)), 180.0)	×
229	assert.is.equal(math.deg(d.left:angle_to(d.down)), 90.0)	×
230	assert.is.equal(math.deg(d.left:angle_to(d.left)), 0.0)	×
231	assert.is.equal(math.deg(d.left:angle_to(d.up)), -90.0)	×
232
233	assert.is.equal(math.deg(d.up:angle_to(d.right)), -90.0)	×
234	assert.is.equal(math.deg(d.up:angle_to(d.down)), 180.0)	×
235	assert.is.equal(math.deg(d.up:angle_to(d.left)), 90.0)	×
236	assert.is.equal(math.deg(d.up:angle_to(d.up)), 0.0)	×
237	end)
238
239	it("finds angle between two 2-vectors", function()	×
240	local d = {	×
241	right = vec2(1, 0),
242	down = vec2(0, -1),
243	left = vec2(-1, 0),
244	up = vec2(0, 1),
245	}
246	assert.is.equal(math.deg(d.right:angle_between(d.right)), 0.0)	×
247	assert.is.equal(math.deg(d.right:angle_between(d.down)), 90.0)	×
248	assert.is.equal(math.deg(d.right:angle_between(d.left)), 180.0)	×
249	assert.is.equal(math.deg(d.right:angle_between(d.up)), 90.0)	×
250
251	assert.is.equal(math.deg(d.down:angle_between(d.right)), 90.0)	×
252	assert.is.equal(math.deg(d.down:angle_between(d.down)), 0.0)	×
253	assert.is.equal(math.deg(d.down:angle_between(d.left)), 90.0)	×
254	assert.is.equal(math.deg(d.down:angle_between(d.up)), 180.0)	×
255
256	assert.is.equal(math.deg(d.left:angle_between(d.right)), 180.0)	×
257	assert.is.equal(math.deg(d.left:angle_between(d.down)), 90.0)	×
258	assert.is.equal(math.deg(d.left:angle_between(d.left)), 0.0)	×
259	assert.is.equal(math.deg(d.left:angle_between(d.up)), 90.0)	×
260
261	assert.is.equal(math.deg(d.up:angle_between(d.right)), 90.0)	×
262	assert.is.equal(math.deg(d.up:angle_between(d.down)), 180.0)	×
263	assert.is.equal(math.deg(d.up:angle_between(d.left)), 90.0)	×
264	assert.is.equal(math.deg(d.up:angle_between(d.up)), 0.0)	×
265	end)
266
267	-- Do this last, to insulate tests from accidental state contamination
268	-- Do vec3 tests last, to insulate tests from accidental state contamination
269	it("converts a 2-vector to a 3-vector", function()	×
270	local vec3 = require "modules.vec3"	×
271	local a = vec2(1,2)	×
272	local b = a:to_vec3()	×
273	local c = a:to_vec3(3)	×
274	assert.is.equal(b, vec3(1,2,0))	×
275	assert.is.equal(c, vec3(1,2,3))	×
276	end)
277
278	it("converts a vec3 to vec2 using the constructor", function()	×
279	local vec3 = require "modules.vec3"	×
280	local a = vec2(3, 5)	×
281	local b = vec3(3, 5, 7)	×
282	local c = vec2(b)	×
283	assert.is.equal(a, c)	×
284	end)
285	end)

excessive / cpml / 6132588926

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous