вот тесты для Vector3f: package com.cgvsu.math.tests;
import com.cgvsu.math.Vector3f;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

public class Vector3fTest {
    @Test
    public void testConstructorAndGetters() {
        Vector3f vector = new Vector3f(3, 4, 7);
        Assertions.assertEquals(3, vector.getX(), "Значение x должно быть 3.0");
        Assertions.assertEquals(4, vector.getY(), "Значение y должно быть 4.0");
        Assertions.assertEquals(7, vector.getZ(), "Значение y должно быть 7.0");
    }

    // Тестирование сложения векторов
    @Test
    public void testAddition() {
        Vector3f v1 = new Vector3f(1, 2, 3);
        Vector3f v2 = new Vector3f(3, 4, 7);
        Vector3f result = v1.add(v2);
        Assertions.assertEquals(new Vector3f(4, 6, 10), result, "Сложение векторов неверно");
    }
    // Тестирование вычитания векторов
    @Test
    public void testSubtraction() {
        Vector3f v1 = new Vector3f(5, 7, 8);
        Vector3f v2 = new Vector3f(2, 3, 3);
        Vector3f result = v1.subtract(v2);
        Assertions.assertEquals(new Vector3f(3, 4, 5), result, "Вычитание векторов неверно");
    }
    // Тестирование умножения на скаляр
    @Test
    public void testMultiply() {
        Vector3f v = new Vector3f(2, -3, 10);
        float scalar = 4;
        v.multiply(scalar);
        Assertions.assertEquals(new Vector3f(8, -12, 40), v, "Умножение на скаляр неверно");
    }
    // Тестирование деления на скаляр
    @Test
    public void testDivide() {
        Vector3f v = new Vector3f(9.0f, -6.0f, 12);
        float scalar = 3.0f;
        v.divide(scalar);
        Assertions.assertEquals(new Vector3f(3.0f, -2.0f, 4), v, "Деление на скаляр неверно");
    }

    @Test
    public void testDivideByZero() {
        Vector3f v = new Vector3f(9.0f, -6.0f, 12);
        float scalar = 0.0f;
        Exception exception = Assertions.assertThrows(ArithmeticException.class, () -> {
            v.divide(scalar);
        });
        Assertions.assertEquals("Division by zero", exception.getMessage(), "Исключение при делении на ноль неверно");
    }
    // Тест на размер... вектора, конечно
    @Test
    public void testLength() {
        Vector3f v = new Vector3f(3, 4, 10);
        float length = v.length();
        Assertions.assertEquals(Math.sqrt(125), length, 1e-6, "Длина вектора неверна");
    }

    // Тестирование нормализации ненулевого вектора
    @Test
    public void testNormalize() {
        Vector3f v = new Vector3f(1, 1, 1);
        v.normalize();
        Assertions.assertEquals(new Vector3f((float) (1/Math.sqrt(3)), (float) (1/Math.sqrt(3)), (float) (1/Math.sqrt(3))), v, "Нормализация вектора неверна");
        Assertions.assertEquals(1, v.length(), 1e-6, "Нормализованный вектор должен иметь длину 1");
    }

    // Тестирование нормализации нулевого вектора
    @Test
    public void testNormalizeZeroVector() {
        Vector3f zeroVector = new Vector3f(0, 0, 0);
        zeroVector.normalize();
        Assertions.assertEquals(new Vector3f(0, 0, 0), zeroVector, "Нормализация нулевого вектора должна возвращать сам вектор");
    }
    // Тестирование скалярного произведения
    @Test
    public void testDotProduct() {
        Vector3f v1 = new Vector3f(-1, 2, -5);
        Vector3f v2 = new Vector3f(3, -3, -3);
        float dot = v1.dot(v2);
        Assertions.assertEquals(6, dot, 1e-6, "Скалярное произведение неверно");
    }

    @Test
    public void testCrossProduct() {
        Vector3f v1 = new Vector3f(-1, 2, -3);
        Vector3f v2 = new Vector3f(0, -4, 1);
        Vector3f result = v1.cross(v2);
        Assertions.assertEquals(new Vector3f(-10,1,4), result, "Скалярное произведение неверно");
    }

    @Test
    public void testEqualsAndHashCode() {
        Vector3f v1 = new Vector3f(2.5f, -7.1f, 14);
        Vector3f v2 = new Vector3f(2.5f, -7.1f, 14);
        Vector3f v3 = new Vector3f(2.5f, -7.2f, 17);

        // Проверка равенства
        Assertions.assertEquals(v1, v2, "Векторы с одинаковыми компонентами должны быть равны");
        Assertions.assertNotEquals(v1, v3, "Векторы с разными компонентами не должны быть равны");

        // Проверка хэш-кодов
        Assertions.assertEquals(v1.hashCode(), v2.hashCode(), "Хэш-коды равных объектов должны совпадать");
        Assertions.assertNotEquals(v1.hashCode(), v3.hashCode(), "Хэш-коды разных объектов не совпадают");
    }

    // Тестирование метода toString
    @Test
    public void testToString() {
        Vector3f v = new Vector3f(5.0f, -3.0f, 10);
        String expected = "Vector3f{x=5.0, y=-3.0, z=10.0}";
        Assertions.assertEquals(expected, v.toString(), "Метод toString возвращает неверное представление");
    }

    // доп тесты для сложения/умножения на 0 вектор
    @Test
    public void testOperationsWithZeroVector() {
        Vector3f zero = new Vector3f(0.0f, 0.0f, 0);
        Vector3f v = new Vector3f(1.0f, -1.0f, 9);

        // Сложение с нулевым вектором
        Vector3f addResult = v.add(zero);
        Assertions.assertEquals(v, addResult, "Сложение с нулевым вектором должно возвращать исходный вектор");

        // Вычитание нулевого вектора
        Vector3f subtractResult = v.subtract(zero);
        Assertions.assertEquals(v, subtractResult, "Вычитание нулевого вектора должно возвращать исходный вектор");

        // Скалярное произведение с нулевым вектором
        float dot = v.dot(zero);
        Assertions.assertEquals(0.0f, dot, 1e-6, "Скалярное произведение с нулевым вектором должно быть 0");
    }
}
мне нужны тесты для Vector4f. Вот его структура: package com.cgvsu.math;

import java.util.Objects;

public class Vector4f extends AbstractVector {
    private float x, y, z, w;
    private float lenght;

    // Конструкторы + getters and setters
    public Vector4f(float x, float y, float z, float w) {
        this.x = x;
        this.y = y;
        this.z = z;
        this.w = w;
    }

    public float getX() {
        return x;
    }

    public void setX(float x) {
        this.x = x;
    }

    public float getY() {
        return y;
    }

    public void setY(float y) {
        this.y = y;
    }

    public float getZ() {
        return z;
    }

    public void setZ(float z) {
        this.z = z;
    }

    public float getW() {
        return w;
    }

    public void setW(float w) {
        this.w = w;
    }

    private void calcLength() {
        lenght = (float) Math.sqrt(x * x + y * y + z * z + w * w);
    }

    @Override
    public float length() {
        calcLength();
        return lenght;
    }

    // логика такая: если длина != 0 - просто делим, если = 0, то возвращаем текущий вектор
    private void calcNormalize() {
        calcLength();
        if (lenght == 0) {
            return;
        }
        divide(lenght);
    }

    @Override
    public void normalize() {
        calcNormalize();
    }

    @Override
    public Vector4f add(AbstractVector other) {
        if (!isVector4f(other)) {
            throw new IllegalArgumentException("Invalid vector type for dot product");
        }
        Vector4f o = (Vector4f) other;
        return new Vector4f(this.x + o.x, this.y + o.y, this.z + o.z, this.w + o.w);
    }

    @Override
    public Vector4f subtract(AbstractVector other) {
        if (!isVector4f(other)) {
            throw new IllegalArgumentException("Invalid vector type for dot product");
        }
        Vector4f o = (Vector4f) other;
        return new Vector4f(this.x - o.x, this.y - o.y, this.z - o.z, this.w - o.w);
    }

    @Override
    public void multiply(float scalar) {
        if (scalar == 0) throw new ArithmeticException("Division by zero");
        this.x *= scalar;
        this.y *= scalar;
        this.z *= scalar;
        this.w *= scalar;
        calcLength();
    }

    @Override
    public void divide(float scalar) {
        if (scalar == 0) throw new ArithmeticException("Division by zero");
        this.x /= scalar;
        this.y /= scalar;
        this.z /= scalar;
        this.w /= scalar;
        calcLength();
    }

    @Override
    public float dot(AbstractVector other) {
        if (!isVector4f(other)) {
            throw new IllegalArgumentException("Invalid vector type for dot product");
        }
        Vector4f o = (Vector4f) other;
        return this.x * o.x + this.y * o.y + this.z * o.z + this.w * o.w;
    }

    private boolean isVector4f(AbstractVector other) {
        return other instanceof Vector4f;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof Vector4f)) return false;
        Vector4f other = (Vector4f) obj;
        return Float.compare(x, other.x) == 0 &&
                Float.compare(y, other.y) == 0 && Float.compare(z, other.z) == 0 && Float.compare(w, other.w) == 0;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y, z, w);
    }

    @Override
    public String toString() {
        return "Vector4f{" + "x=" + x + ", y=" + y + ", z=" + z + ", w=" + w + '}';
    }
}