You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
347 lines
12 KiB
347 lines
12 KiB
# |
|
# This file is part of Magnum. |
|
# |
|
# Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 |
|
# Vladimír Vondruš <mosra@centrum.cz> |
|
# |
|
# Permission is hereby granted, free of charge, to any person obtaining a |
|
# copy of this software and associated documentation files (the "Software"), |
|
# to deal in the Software without restriction, including without limitation |
|
# the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|
# and/or sell copies of the Software, and to permit persons to whom the |
|
# Software is furnished to do so, subject to the following conditions: |
|
# |
|
# The above copyright notice and this permission notice shall be included |
|
# in all copies or substantial portions of the Software. |
|
# |
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
|
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
|
# DEALINGS IN THE SOFTWARE. |
|
# |
|
|
|
import unittest |
|
|
|
from magnum import * |
|
from magnum import math |
|
|
|
class Angle(unittest.TestCase): |
|
def test_init(self): |
|
a = Deg() |
|
b = Rad.zero_init() |
|
c = Deg(90.0) |
|
self.assertEqual(a, Deg(0.0)) |
|
self.assertEqual(b, Rad(0.0)) |
|
self.assertEqual(c, Deg(90.0)) |
|
|
|
def test_conversion(self): |
|
self.assertEqual(Rad(Deg(90.0)), Rad(math.pi_half)) |
|
|
|
def test_ops(self): |
|
self.assertEqual(-Deg(30.0), Deg(-30.0)) |
|
self.assertEqual(Deg(30.0) + Deg(45.0), Deg(75.0)) |
|
self.assertEqual(Deg(75.0) - Deg(45.0), Deg(30.0)) |
|
self.assertEqual(Deg(45.0)*2.0, Deg(90.0)) |
|
self.assertEqual(Deg(90.0)/2.0, Deg(45.0)) |
|
self.assertEqual(Deg(180.0)/Deg(9.0), 20.0) |
|
|
|
def test_inplace_ops(self): |
|
a = Deg(30.0) |
|
a += Deg(45.0) |
|
self.assertEqual(a, Deg(75.0)) |
|
|
|
a = Deg(75.0) |
|
a -= Deg(45.0) |
|
self.assertEqual(a, Deg(30.0)) |
|
|
|
a = Deg(45.0) |
|
a *= 2.0 |
|
self.assertEqual(a, Deg(90.0)) |
|
|
|
a = Deg(90.0) |
|
a /= 2.0 |
|
self.assertEqual(a, Deg(45.0)) |
|
|
|
def test_repr(self): |
|
self.assertEqual(repr(Deg(45.3)), 'Deg(45.3)') |
|
|
|
class BoolVector(unittest.TestCase): |
|
def test_init(self): |
|
a = BoolVector2() |
|
b = BoolVector2.zero_init() |
|
c = BoolVector2(0b11) |
|
self.assertFalse(a.any()) |
|
self.assertTrue(c.all()) |
|
self.assertEqual(a, BoolVector2(0b00)) |
|
self.assertEqual(b, BoolVector2(0b00)) |
|
self.assertEqual(c, BoolVector2(0b11)) |
|
|
|
def test_length(self): |
|
self.assertEqual(BoolVector3.__len__(), 3) |
|
#self.assertEqual(len(BoolVector3), 3) TODO: Y not? |
|
self.assertEqual(len(BoolVector4()), 4) |
|
|
|
def test_set_get(self): |
|
a = BoolVector4(0b1010) |
|
self.assertEqual(a[1], 1) |
|
|
|
a[2] = True |
|
self.assertEqual(a, BoolVector4(0b1110)) |
|
|
|
def test_iterate(self): |
|
a = [i for i in BoolVector4(0b1010)] |
|
self.assertEqual(a, [False, True, False, True]) |
|
|
|
def test_ops(self): |
|
a = BoolVector3(0b101) | BoolVector3(0b010) |
|
self.assertEqual(a, BoolVector3(0b111)) |
|
|
|
def test_repr(self): |
|
self.assertEqual(repr(BoolVector4(0b0101)), 'BoolVector(0b0101)') |
|
|
|
class Constants(unittest.TestCase): |
|
def test(self): |
|
self.assertAlmostEqual(math.sqrt2**2, 2.0, 6) |
|
self.assertAlmostEqual(math.sqrt3**2, 3.0) |
|
|
|
class Vector(unittest.TestCase): |
|
def test_init(self): |
|
a = Vector4i() |
|
b = Vector3d.zero_init() |
|
c = Vector2i(44, -3) |
|
d = Vector3((1.0, 0.3, 1.1)) |
|
e = Vector4d((1.0, 0.3, 1.1, 0.5)) |
|
self.assertEqual(a, Vector4i(0, 0, 0, 0)) |
|
self.assertEqual(b, Vector3d(0.0, 0.0, 0.0)) |
|
self.assertEqual(c, Vector2i(44, -3)) |
|
self.assertEqual(d, Vector3(1.0, 0.3, 1.1)) |
|
self.assertEqual(e, Vector4d(1.0, 0.3, 1.1, 0.5)) |
|
|
|
def test_static_methods(self): |
|
self.assertEqual(Vector2.y_scale(5), Vector2(1, 5)) |
|
self.assertEqual(Vector3d.z_axis(-3), Vector3d(0, 0, -3)) |
|
self.assertEqual(Vector3i.x_axis(), Vector3i(1, 0, 0)) |
|
|
|
def test_length(self): |
|
self.assertEqual(Vector3.__len__(), 3) |
|
#self.assertEqual(len(Vector3), 3) TODO: Y not? |
|
self.assertEqual(len(Vector4i()), 4) |
|
|
|
def test_properties(self): |
|
a = Vector2i() |
|
a.x = 1 |
|
a.y = 2 |
|
self.assertEqual(a.x, 1) |
|
self.assertEqual(a.y, 2) |
|
self.assertEqual(a, Vector2i(1, 2)) |
|
|
|
a = Vector3() |
|
a.x = 1.0 |
|
a.y = 2.0 |
|
a.z = 3.0 |
|
self.assertEqual(a.x, 1.0) |
|
self.assertEqual(a.y, 2.0) |
|
self.assertEqual(a.z, 3.0) |
|
self.assertEqual(a, Vector3(1.0, 2.0, 3.0)) |
|
|
|
a.xy = (-1.0, -2.0) |
|
self.assertEqual(a.xy, Vector2(-1.0, -2.0)) |
|
self.assertEqual(a, Vector3(-1.0, -2.0, 3.0)) |
|
|
|
a = Vector3() |
|
a.r = 1.0 |
|
a.g = 2.0 |
|
a.b = 3.0 |
|
self.assertEqual(a.r, 1.0) |
|
self.assertEqual(a.g, 2.0) |
|
self.assertEqual(a.b, 3.0) |
|
self.assertEqual(a, Vector3(1.0, 2.0, 3.0)) |
|
|
|
a = Vector4d() |
|
a.x = 1.0 |
|
a.y = 2.0 |
|
a.z = 3.0 |
|
a.w = 4.0 |
|
self.assertEqual(a.x, 1.0) |
|
self.assertEqual(a.y, 2.0) |
|
self.assertEqual(a.z, 3.0) |
|
self.assertEqual(a.w, 4.0) |
|
self.assertEqual(a, Vector4d(1.0, 2.0, 3.0, 4.0)) |
|
|
|
a = Vector4d() |
|
a.r = 1.0 |
|
a.g = 2.0 |
|
a.b = 3.0 |
|
a.a = 4.0 |
|
self.assertEqual(a.r, 1.0) |
|
self.assertEqual(a.g, 2.0) |
|
self.assertEqual(a.b, 3.0) |
|
self.assertEqual(a.a, 4.0) |
|
self.assertEqual(a, Vector4d(1.0, 2.0, 3.0, 4.0)) |
|
|
|
a.xy = (-1.0, -2.0) |
|
self.assertEqual(a.xy, Vector2d(-1.0, -2.0)) |
|
self.assertEqual(a, Vector4d(-1.0, -2.0, 3.0, 4.0)) |
|
|
|
a.xyz = (0.5, 0.25, 0.125) |
|
self.assertEqual(a.xyz, Vector3d(0.5, 0.25, 0.125)) |
|
self.assertEqual(a, Vector4d(0.5, 0.25, 0.125, 4.0)) |
|
|
|
def test_properties_rgb(self): |
|
a = Vector3() |
|
a.r = 1.0 |
|
a.g = 2.0 |
|
a.b = 3.0 |
|
self.assertEqual(a.r, 1.0) |
|
self.assertEqual(a.g, 2.0) |
|
self.assertEqual(a.b, 3.0) |
|
self.assertEqual(a, Vector3(1.0, 2.0, 3.0)) |
|
|
|
a = Vector4d() |
|
a.r = 1.0 |
|
a.g = 2.0 |
|
a.b = 3.0 |
|
a.a = 4.0 |
|
self.assertEqual(a.r, 1.0) |
|
self.assertEqual(a.g, 2.0) |
|
self.assertEqual(a.b, 3.0) |
|
self.assertEqual(a.a, 4.0) |
|
self.assertEqual(a, Vector4d(1.0, 2.0, 3.0, 4.0)) |
|
|
|
a.rgb = (0.5, 0.25, 0.125) |
|
self.assertEqual(a.rgb, Vector3d(0.5, 0.25, 0.125)) |
|
self.assertEqual(a, Vector4d(0.5, 0.25, 0.125, 4.0)) |
|
|
|
def test_set_get(self): |
|
a = Vector3(1.0, 3.14, -13.37) |
|
self.assertAlmostEqual(a[1], 3.14, 6) |
|
|
|
a[2] = 0.13 |
|
self.assertEqual(a, Vector3(1.0, 3.14, 0.13)) |
|
|
|
b = Vector4i(3, 4, 5, 6) |
|
b.b *= 3 |
|
b.xy += (1, -1) |
|
self.assertEqual(b, Vector4i(4, 3, 15, 6)) |
|
|
|
def test_iterate(self): |
|
a = [i for i in Vector4(1.0, 3.25, 3.5, -1.125)] |
|
# assertAlmostEqual doesn't work on lists so i'm using values directly |
|
# representable as floats to avoid the need for delta comparison |
|
self.assertEqual(a, [1.0, 3.25, 3.5, -1.125]) |
|
|
|
def test_ops(self): |
|
self.assertEqual(math.dot(Vector2(0.5, 3.0), Vector2(2.0, 0.5)), 2.5) |
|
self.assertEqual(Deg(math.angle( |
|
Vector2(0.5, 3.0).normalized(), |
|
Vector2(2.0, 0.5).normalized())), Deg(66.5014333443446)) |
|
self.assertEqual(Vector3(1.0, 2.0, 0.3).projected(Vector3.y_axis()), |
|
Vector3.y_axis(2.0)) |
|
self.assertEqual(Vector3(1.0, 2.0, 0.3).projected_onto_normalized(Vector3.y_axis()), |
|
Vector3.y_axis(2.0)) |
|
|
|
def test_ops_number_on_the_left(self): |
|
self.assertEqual(2.0*Vector2(1.0, -3.0), Vector2(2.0, -6.0)) |
|
self.assertEqual(6.0/Vector2(2.0, -3.0), Vector2(3.0, -2.0)) |
|
|
|
def test_repr(self): |
|
self.assertEqual(repr(Vector3(1.0, 3.14, -13.37)), 'Vector(1, 3.14, -13.37)') |
|
|
|
class Matrix(unittest.TestCase): |
|
def test_init(self): |
|
a = Matrix3x2() |
|
self.assertEqual(a[0], Vector2(0)) |
|
self.assertEqual(a[1], Vector2(0)) |
|
self.assertEqual(a[2], Vector2(0)) |
|
|
|
b = Matrix4x4.zero_init() |
|
self.assertEqual(b[0], Vector4(0)) |
|
self.assertEqual(b[1], Vector4(0)) |
|
self.assertEqual(b[2], Vector4(0)) |
|
self.assertEqual(b[3], Vector4(0)) |
|
|
|
c1 = Matrix3x3.identity_init() |
|
self.assertEqual(c1[0], Vector3.x_axis()) |
|
self.assertEqual(c1[1], Vector3.y_axis()) |
|
self.assertEqual(c1[2], Vector3.z_axis()) |
|
|
|
c3 = Matrix3x3.identity_init(3.0) |
|
self.assertEqual(c3[0], Vector3.x_axis(3.0)) |
|
self.assertEqual(c3[1], Vector3.y_axis(3.0)) |
|
self.assertEqual(c3[2], Vector3.z_axis(3.0)) |
|
|
|
d = Matrix2x3(Vector3(1.0, 2.0, 3.0), |
|
Vector3(4.0, 5.0, 6.0)) |
|
self.assertEqual(d[0], Vector3(1.0, 2.0, 3.0)) |
|
self.assertEqual(d[1], Vector3(4.0, 5.0, 6.0)) |
|
|
|
e = Matrix2x3((1.0, 2.0, 3.0), |
|
(4.0, 5.0, 6.0)) |
|
self.assertEqual(e[0], Vector3(1.0, 2.0, 3.0)) |
|
self.assertEqual(e[1], Vector3(4.0, 5.0, 6.0)) |
|
|
|
f = Matrix3x2(((1.0, 2.0), |
|
(3.0, 4.0), |
|
(5.0, 6.0))) |
|
self.assertEqual(f[0], Vector2(1.0, 2.0)) |
|
self.assertEqual(f[1], Vector2(3.0, 4.0)) |
|
self.assertEqual(f[2], Vector2(5.0, 6.0)) |
|
|
|
def test_length(self): |
|
self.assertEqual(Matrix3x4.__len__(), 3) |
|
#self.assertEqual(len(Matrix4x3), 4) TODO: Y not? |
|
self.assertEqual(len(Matrix4x3()), 4) |
|
|
|
def test_set_get(self): |
|
a = Matrix2x3((1.0, 2.0, 3.0), |
|
(4.0, 5.0, 6.0)) |
|
self.assertEqual(a[1][2], 6.0) |
|
|
|
a[1] = (4.5, 5.5, 6.5) |
|
self.assertEqual(a[1], Vector3(4.5, 5.5, 6.5)) |
|
|
|
a[0, 1] = 2.5 |
|
self.assertEqual(a[0], Vector3(1.0, 2.5, 3.0)) # yes, 2.5 |
|
|
|
@unittest.expectedFailure |
|
def test_set_two_brackets(self): |
|
a = Matrix2x3((1.0, 2.0, 3.0), |
|
(4.0, 5.0, 6.0)) |
|
a[0][1] = 2.5 |
|
self.assertEqual(a[0], Vector3(1.0, 2.5, 3.0)) |
|
|
|
def test_iterate(self): |
|
a = Matrix3x2((1.0, 2.0), |
|
(3.0, 4.0), |
|
(5.0, 6.0)) |
|
self.assertEqual([i.sum() for i in a], [3.0, 7.0, 11.0]) |
|
|
|
def test_ops(self): |
|
a = Matrix2x3((1.0, 2.0, 3.0), |
|
(4.0, 5.0, 6.0)) |
|
b = Matrix3x2((1.0, 2.0), |
|
(3.0, 4.0), |
|
(5.0, 6.0)) |
|
c = Matrix3x3((9.0, 12.0, 15.0), |
|
(19.0, 26.0, 33.0), |
|
(29.0, 40.0, 51.0)) |
|
self.assertEqual(a @ b, c) |
|
|
|
def test_ops_number_on_the_left(self): |
|
a = Matrix2x3((1.0, 2.0, 3.0), |
|
(4.0, 5.0, 6.0)) |
|
|
|
self.assertEqual(2.0*a, Matrix2x3((2.0, 4.0, 6.0), |
|
(8.0, 10.0, 12.0))) |
|
self.assertEqual(6.0/a, Matrix2x3((6.0, 3.0, 2.0), |
|
(1.5, 1.2, 1.0))) |
|
|
|
def test_repr(self): |
|
a = Matrix2x3((1.0, 2.0, 3.0), |
|
(4.0, 5.0, 6.0)) |
|
self.assertEqual(repr(a), 'Matrix(1, 4,\n' |
|
' 2, 5,\n' |
|
' 3, 6)')
|
|
|