Построить проверочную тест функцию, которая сортирует матрицу с 100 элементами в течение 1 секунды

public static void sort(int[] a){
    .......................................
}
 
 
 
//[B]CLASS MAIN[/B]
public class Main {
    public static void main(String []args){
        Matrix matrix = new Matrix (100);
    }
}
 
//[B]CLASS MATRIX[/B]
import java.util.Scanner;
 
public class Matrix {
    private static int n;
    private static int i;
    private int[] a;
 
    public Matrix(int n) {
        this.n=n;
        int[] a = new int[n];
    }
 
    public static void sort(int[] a){
        a = new int[n];
 
        System.out.println ("Enter the matrix: ");
        Scanner in = new Scanner (System.in);
        for(i=0;i<n;i++){
            a[i]=in.nextInt ();
        }
        System.out.println (a[i]);
    }
}
 
 
//[B]CLASS MATRIX TEST[/B]
import org.junit.BeforeClass;
 
import static org.junit.Assert.*;
 
public class MatrixTest {
    static Matrix[] matrix;
 
    @BeforeClass
 
 
    @Test
    public void sort() throws Exception {
        Matrix m = new Matrix (100);
        assertEquals();
    }
}

import java.util.Arrays;
import java.util.Random;
 
public class Matrix {
    private long ms;
 
    public long getTime() {
        return ms;
    }
 
    public int[] sort(int[] array) {
        start();
        if (array != null && array.length > 1) {
            int[][] matrix = convertArrayToDeepArray(array);
            for (int i = 0; i < matrix.length; i++) {
                quickSort(matrix[i]);
            }
            if (matrix.length > 1) {
                int[] result = margeSort(matrix[0], matrix[1]);
                for (int i = 2; i < matrix.length; i++) {
                    result = margeSort(result, matrix[i]);
                }
                array = result;
            } else {
                array = matrix[0];
            }
        }
        stop();
        return array;
    }
 
    private int[][] convertArrayToDeepArray(int[] array) {
        int m = (int) Math.sqrt(array.length);
        int n = array.length / m;
        if (array.length % m != 0) {
            n++;
        }
        int lastLine = m * n - array.length;
        int[][] deep = new int[n][m];
        int count = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (count < array.length) {
                    deep[i][j] = array[count++];
                }
            }
            if (i == n - 1 && lastLine != 0) {
                deep[i] = Arrays.copyOf(deep[i], deep[i].length - lastLine);
            }
        }
        return deep;
    }
 
    private void start() {
        this.ms = System.currentTimeMillis();
    }
 
    private void stop() {
        this.ms = System.currentTimeMillis() - this.ms;
    }
 
    private int[] margeSort(int[] arrayFirst, int[] arraySecond) {
        int[] array = new int[arrayFirst.length + arraySecond.length];
        int i = 0;
        int j = 0;
        int index = 0;
        while (i < arrayFirst.length && j < arraySecond.length) {
            if (arrayFirst[i] < arraySecond[j]) {
                array[index++] = arrayFirst[i++];
            } else {
                array[index++] = arraySecond[j++];
            }
        }
 
        while (j < arraySecond.length) {
            array[index++] = arraySecond[j++];
        }
        while (i < arrayFirst.length) {
            array[index++] = arrayFirst[i++];
        }
        return array;
    }
 
    private void quickSort(int[] array) {
        if (array != null && array.length > 1) {
            int startIndex = 0;
            int endIndex = array.length - 1;
            doSort(startIndex, endIndex, array);
        }
    }
 
    private static void doSort(int start, int end, int[] array) {
        int startMain = start;
        int endMain = end;
        if (start < end) {
            int cur = start - (start - end) / 2;
            while (start < end) {
                while (start < cur && array[start] <= array[cur]) {
                    start++;
                }
                while (end > cur && array[cur] <= array[end]) {
                    end--;
                }
                if (start < end) {
                    int temp = array[start];
                    array[start] = array[end];
                    array[end] = temp;
                    if (start == cur) {
                        cur = end;
                    } else if (end == cur) {
                        cur = start;
                    }
                }
            }
            doSort(startMain, cur, array);
            doSort(cur + 1, endMain, array);
        }
    }
}
 
class MainMatrix {
    public static void main(String[] args) {
        int[] array = createArray(1000, -99, 99);
        Matrix m = new Matrix();
        System.out.println("Был: " + Arrays.toString(array));
        array = m.sort(array);
        System.out.println("Стал: " + Arrays.toString(array));
        System.out.printf("Затрачено времени: %d sec. %d ms.;", m.getTime() / 1000, m.getTime() % 1000);
 
    }
 
    public static int[] createArray(int n, int min, int max) {
        int[] array = new int[n];
        Random rand = new Random();
        for (int i = 0; i < n; i++) {
            array[i] = rand.nextInt(Math.abs(max - min) + 1) + min;
        }
        return array;
    }
}