FFTTest.java

packagecom.thealgorithms.maths;

importstaticorg.junit.jupiter.api.Assertions.assertEquals;
importstaticorg.junit.jupiter.api.Assertions.assertNotEquals;

importjava.util.ArrayList;
importorg.junit.jupiter.api.Test;

classFFTTest {

// Testing the simple function getReal
@Test
voidgetRealtest() {
FFT.Complexcomplex = newFFT.Complex(1.0, 1.0);
assertEquals(1.0, complex.getReal());
 }

// Testing the simple function getImaginary
@Test
voidgetImaginaryTest() {
FFT.Complexcomplex = newFFT.Complex();
assertEquals(0.0, complex.getImaginary());
 }

// Testing the function add, assertEqual test
@Test
voidaddTest() {
FFT.Complexcomplex1 = newFFT.Complex(1.0, 1.0);
FFT.Complexcomplex2 = newFFT.Complex(2.0, 2.0);
doubleadd = complex1.add(complex2).getReal();
assertEquals(3.0, add);
 }

// Testing the function add, assertNotEqual test
@Test
voidaddFalseTest() {
FFT.Complexcomplex1 = newFFT.Complex(1.0, 1.0);
FFT.Complexcomplex2 = newFFT.Complex(2.0, 2.0);
doubleadd = complex1.add(complex2).getReal();
assertNotEquals(2.0, add);
 }

// Testing the function subtract, assertEqual test
@Test
voidsubtractTest() {
FFT.Complexcomplex1 = newFFT.Complex(2.0, 2.0);
FFT.Complexcomplex2 = newFFT.Complex(1.0, 1.0);
doublesub = complex1.subtract(complex2).getReal();
assertEquals(1.0, sub);
 }

// Testing the function multiply complex, assertEqual test
@Test
voidmultiplyWithComplexTest() {
FFT.Complexcomplex1 = newFFT.Complex(2.0, 2.0);
FFT.Complexcomplex2 = newFFT.Complex(1.0, 1.0);
doublemultiReal = complex1.multiply(complex2).getReal();
doublemultiImg = complex1.multiply(complex2).getImaginary();
assertEquals(0.0, multiReal);
assertEquals(4.0, multiImg);
 }

// Testing the function multiply scalar, assertEqual test
@Test
voidmultiplyWithScalarTest() {
FFT.Complexcomplex1 = newFFT.Complex(2.0, 2.0);

doublemultiReal = complex1.multiply(2).getReal();
doublemultiImg = complex1.multiply(3).getImaginary();
assertEquals(4.0, multiReal);
assertEquals(6.0, multiImg);
 }

// Testing the function conjugate, assertEqual test
@Test
voidconjugateTest() {
FFT.Complexcomplex1 = newFFT.Complex(2.0, 2.0);
doubleconReal = complex1.conjugate().getReal();
doubleconImg = complex1.conjugate().getImaginary();
assertEquals(2.0, conReal);
assertEquals(-2.0, conImg);
 }

// Testing the function abs, assertEqual test
@Test
voidabs() {
FFT.Complexcomplex1 = newFFT.Complex(2.0, 3.0);
doubleabs = complex1.abs();
assertEquals(Math.sqrt(13), abs);
 }

// Testing the function divide complex, assertEqual test.
@Test
voiddivideWithComplexTest() {
FFT.Complexcomplex1 = newFFT.Complex(2.0, 2.0);
FFT.Complexcomplex2 = newFFT.Complex(1.0, 2.0);
doubledivReal = complex1.divide(complex2).getReal();
doubledivImg = complex1.divide(complex2).getImaginary();
assertEquals(1.2, divReal);
assertEquals(-0.4, divImg);
 }

// Testing the function divide scalar, assertEqual test.
@Test
voiddivideWithScalarTest() {
FFT.Complexcomplex1 = newFFT.Complex(2.0, 2.0);
doubledivReal = complex1.divide(2).getReal();
doubledivImg = complex1.divide(2).getImaginary();
assertEquals(1, divReal);
assertEquals(1, divImg);
 }

// Testing the function fft, assertEqual test.
// https://scistatcalc.blogspot.com/2013/12/fft-calculator.html used this link to
// ensure the result
@Test
voidfft() {
ArrayList<FFT.Complex> arr = newArrayList<FFT.Complex>();
FFT.Complexcomplex1 = newFFT.Complex(2.0, 2.0);
FFT.Complexcomplex2 = newFFT.Complex(1.0, 3.0);
FFT.Complexcomplex3 = newFFT.Complex(3.0, 1.0);
FFT.Complexcomplex4 = newFFT.Complex(2.0, 2.0);

arr.add(complex1);
arr.add(complex2);
arr.add(complex3);
arr.add(complex4);
arr = FFT.fft(arr, false);
doublerealV1 = arr.get(0).getReal();
doublerealV2 = arr.get(2).getReal();
doubleimgV1 = arr.get(0).getImaginary();
doubleimgV2 = arr.get(2).getImaginary();
assertEquals(8.0, realV1);
assertEquals(2.0, realV2);
assertEquals(8.0, imgV1);
assertEquals(-2.0, imgV2);
 }
}