//Matrix/src/test/java/com/mattrixwv/matrix/TestLongMatrix.java
//Mattrixwv
// Created: 02-10-22
//Modified: 07-09-22
package com.mattrixwv.matrix;


import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.Arrays;

import org.junit.jupiter.api.Test;

import com.mattrixwv.matrix.exceptions.InvalidCoordinatesException;
import com.mattrixwv.matrix.exceptions.InvalidGeometryException;
import com.mattrixwv.matrix.exceptions.InvalidRowSizeException;
import com.mattrixwv.matrix.exceptions.InvalidScalarException;
import com.mattrixwv.matrix.exceptions.NullMatrixException;


public class TestLongMatrix{
	//Grid 1x1
	private static final long[][] grid1 = {
		{1}
	};
	private static final long[][] transformGrid1_1 = {
		{1}
	};
	private static final long[][] transformGrid1_2 = {
		{2}
	};

	//Grid 2x2
	private static final long[][] grid2 = {
		{1, 2},
		{1, 2}
	};
	private static final long[][] transformGrid2_1 = {
		{1, 0},
		{1, 0}
	};
	private static final long[][] transformGrid2_2 = {
		{2, 3},
		{2, 3}
	};

	//Grid 3x3
	private static final long[][] grid3 = {
		{1, 2, 3},
		{1, 2, 3},
		{1, 2, 3}
	};
	private static final long[][] transformGrid3_1 = {
		{2, 1, 0},
		{2, 1, 0},
		{2, 1, 0}
	};
	private static final long[][] transformGrid3_2 = {
		{2, 3, 4},
		{2, 3, 4},
		{2, 3, 4}
	};

	//Grid 4x4
	private static final long[][] grid4 = {
		{1, 2, 3, 4},
		{1, 2, 3, 4},
		{1, 2, 3, 4},
		{1, 2, 3, 4}
	};
	private static final long[][] transformGrid4_1 = {
		{3, 2, 1, 0},
		{3, 2, 1, 0},
		{3, 2, 1, 0},
		{3, 2, 1, 0}
	};
	private static final long[][] transformGrid4_2 = {
		{2, 3, 4, 5},
		{2, 3, 4, 5},
		{2, 3, 4, 5},
		{2, 3, 4, 5}
	};

	//Grid 10x10
	private static final long[][] grid10 = {
		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
		{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	};
	private static final long[][] transformGrid10_1 = {
		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
		{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
	};
	private static final long[][] transformGrid10_2 = {
		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
		{2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
	};


	@Test
	public void testConstructor(){
		//Default constructor
		LongMatrix matrix = new LongMatrix();
		assertEquals(0, matrix.getNumRows());
		assertEquals(0, matrix.getNumCols());

		//Filler constructor
		//0 rows
		assertThrows(InvalidGeometryException.class, () -> {
			new LongMatrix(0, 0, 0);
		});
		assertThrows(InvalidGeometryException.class, () -> {
			new LongMatrix(1, 0, 0);
		});
		//Good values
		matrix = new LongMatrix(2, 2, 0);
		assertEquals(2, matrix.getNumRows());
		assertEquals(2, matrix.getNumCols());
		assertEquals(0, matrix.get(0, 0));
		assertEquals(0, matrix.get(0, 1));
		assertEquals(0, matrix.get(1, 0));
		assertEquals(0, matrix.get(1, 1));

		//Matrix constructor
		matrix.set(0, 0, 1);
		matrix.set(0, 1, 2);
		matrix.set(1, 0, 1);
		matrix.set(1, 1, 2);
		LongMatrix matrix2 = new LongMatrix(matrix);
		assertEquals(2, matrix2.getNumRows());
		assertEquals(2, matrix2.getNumCols());
		assertEquals(1, matrix2.get(0, 0));
		assertEquals(2, matrix2.get(0, 1));
		assertEquals(1, matrix.get(1, 0));
		assertEquals(2, matrix.get(1, 1));

		//Array constructor
		//0 length
		long[][] grid = new long[0][0];
		matrix = new LongMatrix(grid);
		assertEquals(0, matrix.getNumRows());
		assertEquals(0, matrix.getNumCols());
		//0 cols
		grid = new long[1][0];
		matrix = new LongMatrix(grid);
		assertEquals(1, matrix.getNumRows());
		assertEquals(0, matrix.getNumCols());
		//Uneven rows
		assertThrows(InvalidRowSizeException.class, () -> {
			long[][] grid1 = new long[2][];
			grid1[0] = new long[1];
			grid1[0][0] = 0;
			grid1[1] = new long[2];
			grid1[1][0] = 1;
			grid1[1][1] = 2;
			new LongMatrix(grid1);
		});

		//2x2
		grid = grid2;
		matrix = new LongMatrix(grid);
		assertEquals(2, matrix.getNumRows());
		assertEquals(2, matrix.getNumCols());
		assertEquals(1, matrix.get(0, 0));
		assertEquals(2, matrix.get(0, 1));
		assertEquals(1, matrix.get(1, 0));
		assertEquals(2, matrix.get(1, 1));
	}

	@Test
	public void testEquals(){
		//Invalid equals
		LongMatrix matrix = new LongMatrix(grid1);
		assertNotEquals(null, matrix);
		assertNotEquals(new int[0], matrix);

		//1x1
		matrix = new LongMatrix(grid1);
		boolean gridEquals = matrix.equals(matrix);
		assertTrue(gridEquals);
		@SuppressWarnings("unlikely-arg-type")
		boolean gridEquals1 = matrix.equals(grid1);
		assertTrue(gridEquals1);

		//2x2
		matrix = new LongMatrix(grid2);
		boolean gridEquals2 = matrix.equals(matrix);
		assertTrue(gridEquals2);
		@SuppressWarnings("unlikely-arg-type")
		boolean gridEquals21 = matrix.equals(grid2);
		assertTrue(gridEquals21);
		//false
		@SuppressWarnings("unlikely-arg-type")
		boolean gridEquals22 = matrix.equals(transformGrid2_1);
		assertFalse(gridEquals22);
		gridEquals2 = matrix.equals(new LongMatrix(grid3));
		assertFalse(gridEquals2);
		gridEquals2 = matrix.equals(new LongMatrix(new long[][]{
			{0, 1, 2},
			{0, 1, 2}
		}));
		assertFalse(gridEquals2);

		//3x3
		matrix = new LongMatrix(grid3);
		boolean gridEquals3 = matrix.equals(matrix);
		assertTrue(gridEquals3);
		@SuppressWarnings("unlikely-arg-type")
		boolean gridEquals31 = matrix.equals(grid3);
		assertTrue(gridEquals31);

		//4x4
		matrix = new LongMatrix(grid4);
		boolean gridEquals4 = matrix.equals(matrix);
		assertTrue(gridEquals4);
		@SuppressWarnings("unlikely-arg-type")
		boolean gridEquals41 = matrix.equals(grid4);
		assertTrue(gridEquals41);

		//10x10
		matrix = new LongMatrix(grid10);
		boolean gridEquals10 = matrix.equals(matrix);
		assertTrue(gridEquals10);
		@SuppressWarnings("unlikely-arg-type")
		boolean gridEquals101 = matrix.equals(grid10);
		assertTrue(gridEquals101);
	}

	@Test
	public void testGet(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		assertEquals(1, matrix.get(0, 0));

		//Invalid gets
		final LongMatrix testMatrix = new LongMatrix(grid1);
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.get(3, 3);
		});
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.get(-1, -1);
		});
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.get(0, 3);
		});
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.get(0, -1);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		assertEquals(1, matrix.get(0, 0));

		//3x3
		matrix = new LongMatrix(grid3);
		assertEquals(1, matrix.get(0, 0));

		//4x4
		matrix = new LongMatrix(grid4);
		assertEquals(1, matrix.get(0, 0));

		//10x10
		matrix = new LongMatrix(grid10);
		assertEquals(1, matrix.get(0, 0));
	}

	@Test
	public void testGetRow(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{1}});
		assertEquals(correctMatrix, matrix.getRow(0));

		//Invalid gets
		final LongMatrix testMatrix = new LongMatrix(matrix);
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.getRow(-1);
		});
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.getRow(3);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		correctMatrix = new LongMatrix(new long[][]{{1, 2}});
		assertEquals(correctMatrix, matrix.getRow(0));

		//3x3
		matrix = new LongMatrix(grid3);
		correctMatrix = new LongMatrix(new long[][]{{1, 2, 3}});
		assertEquals(correctMatrix, matrix.getRow(0));

		//4x4
		matrix = new LongMatrix(grid4);
		matrix = new LongMatrix(grid4);
		correctMatrix = new LongMatrix(new long[][]{{1, 2, 3, 4}});
		assertEquals(correctMatrix, matrix.getRow(0));

		//10x10
		matrix = new LongMatrix(grid10);
		correctMatrix = new LongMatrix(new long[][]{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}});
		assertEquals(correctMatrix, matrix.getRow(0));
	}

	@Test
	public void testGetCol(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{1}});
		assertEquals(correctMatrix, matrix.getCol(0));

		//Invalid gets
		final LongMatrix testMatrix = new LongMatrix();
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.getCol(-1);
		});
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.getCol(3);
		});
		final LongMatrix testMatrix2 = new LongMatrix(grid1);
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix2.getCol(3);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		correctMatrix = new LongMatrix(new long[][]{
			{1},
			{1}
		});
		assertEquals(correctMatrix, matrix.getCol(0));

		//3x3
		matrix = new LongMatrix(grid3);
		correctMatrix = new LongMatrix(new long[][]{
			{1},
			{1},
			{1}
		});
		assertEquals(correctMatrix, matrix.getCol(0));

		//4x4
		matrix = new LongMatrix(grid4);
		correctMatrix = new LongMatrix(new long[][]{
			{1},
			{1},
			{1},
			{1}
		});
		assertEquals(correctMatrix, matrix.getCol(0));

		//10x10
		matrix = new LongMatrix(grid10);
		correctMatrix = new LongMatrix(new long[][]{
			{1},
			{1},
			{1},
			{1},
			{1},
			{1},
			{1},
			{1},
			{1},
			{1}
		});
		assertEquals(correctMatrix, matrix.getCol(0));
	}

	@Test
	public void testSet(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		matrix.set(0, 0, 2);
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{2}});
		assertEquals(correctMatrix, matrix);

		//Invalid sets
		final LongMatrix testMatrix = new LongMatrix(grid1);
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.set(-1, -1, 0);
		});
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.set(2, 2, 0);
		});
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.set(0, -1, 0);
		});
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.set(0, 2, 0);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		matrix.set(0, 0, 3);
		correctMatrix = new LongMatrix(new long[][]{
			{3, 2},
			{1, 2}
		});
		assertEquals(correctMatrix, matrix);

		//3x3
		matrix = new LongMatrix(grid3);
		matrix.set(0, 0, 3);
		correctMatrix = new LongMatrix(new long[][]{
			{3, 2, 3},
			{1, 2, 3},
			{1, 2, 3},
		});
		assertEquals(correctMatrix, matrix);

		//4x4
		matrix = new LongMatrix(grid4);
		matrix.set(0, 0, 3);
		correctMatrix = new LongMatrix(new long[][]{
			{3, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4}
		});
		assertEquals(correctMatrix, matrix);

		//10x10
		matrix = new LongMatrix(grid10);
		matrix.set(0, 0, 3);
		correctMatrix = new LongMatrix(new long[][]{
			{3, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
		});
		assertEquals(correctMatrix, matrix);
	}

	@Test
	public void testSetRow(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		matrix.setRow(0, new long[]{0});
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{0}});
		assertEquals(correctMatrix, matrix);

		//Invalid setRows
		final LongMatrix testMatrix = new LongMatrix(grid1);
		final long[] testGrid = {0, 0};
		final LongMatrix testMatrix2 = new LongMatrix(grid2);
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.setRow(-1, testGrid);
		});
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.setRow(2, testGrid);
		});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.setRow(0, testGrid);
		});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.setRow(0, (long[])null);
		});
		assertThrows(NullMatrixException.class, () -> {
			testMatrix.setRow(0, (LongMatrix)null);
		});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.setRow(0, testMatrix2);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		matrix.setRow(1, new long[]{2, 1});
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2},
			{2, 1}
		});
		assertEquals(correctMatrix, matrix);
		//Matrix
		LongMatrix matrix2 = new LongMatrix(new long[][]{{0, 0}});
		matrix.setRow(1, matrix2);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2},
			{0, 0}
		});
		assertEquals(correctMatrix, matrix);

		//3x3
		matrix = new LongMatrix(grid3);
		matrix.setRow(0, new long[]{0, 1, 2});
		correctMatrix = new LongMatrix(new long[][]{
			{0, 1, 2},
			{1, 2, 3},
			{1, 2, 3}
		});
		assertEquals(correctMatrix, matrix);

		//4x4
		matrix = new LongMatrix(grid4);
		matrix.setRow(0, new long[]{4, 3, 2, 1});
		correctMatrix = new LongMatrix(new long[][]{
			{4, 3, 2, 1},
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4}
		});
		assertEquals(correctMatrix, matrix);

		//10x10
		matrix = new LongMatrix(grid10);
		matrix.setRow(0, new long[]{10, 9, 8, 7, 6, 5, 4, 3, 2, 1});
		correctMatrix = new LongMatrix(new long[][]{
			{10, 9, 8, 7, 6, 5, 4, 3, 2, 1},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
		});
		assertEquals(correctMatrix, matrix);
	}

	@Test
	public void testSetCol(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		matrix.setCol(0, new long[]{1});
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{1}});
		assertEquals(correctMatrix, matrix);

		//Invalid setCols
		final LongMatrix testMatrix = new LongMatrix(grid1);
		final LongMatrix testMatrix2 = new LongMatrix();
		final long[] testGrid = {0, 0};
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.setCol(-1, testGrid);
		});
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.setCol(2, testGrid);
		});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.setCol(0, (long[])null);
		});
		assertThrows(InvalidCoordinatesException.class, () -> {
			testMatrix.setCol(0, testGrid);
		});
		assertThrows(NullMatrixException.class, () -> {
			testMatrix.setCol(0, (LongMatrix)null);
		});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.setCol(0, testMatrix2);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		matrix.setCol(0, new long[]{3, 3});
		correctMatrix = new LongMatrix(new long[][]{
			{3, 2},
			{3, 2}
		});
		assertEquals(correctMatrix, matrix);
		//Matrix
		LongMatrix vector = new LongMatrix(new long[][]{{0}, {0}});
		matrix.setCol(1, vector);
		correctMatrix = new LongMatrix(new long[][]{
			{3, 0},
			{3, 0}
		});
		assertEquals(correctMatrix, matrix);

		//3x3
		matrix = new LongMatrix(grid3);
		matrix.setCol(0, new long[]{0, 0, 0});
		correctMatrix = new LongMatrix(new long[][]{
			{0, 2, 3},
			{0, 2, 3},
			{0, 2, 3}
		});
		assertEquals(correctMatrix, matrix);

		//4x4
		matrix = new LongMatrix(grid4);
		matrix.setCol(0, new long[]{0, 0, 0, 0});
		correctMatrix = new LongMatrix(new long[][]{
			{0, 2, 3, 4},
			{0, 2, 3, 4},
			{0, 2, 3, 4},
			{0, 2, 3, 4}
		});
		assertEquals(correctMatrix, matrix);

		//10x10
		matrix = new LongMatrix(grid10);
		matrix.setCol(0, new long[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
		correctMatrix = new LongMatrix(new long[][]{
			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{0, 2, 3, 4, 5, 6, 7, 8, 9, 10}
		});
		assertEquals(correctMatrix, matrix);
	}

	@Test
	public void testAddRow(){
		//0x0
		LongMatrix matrix = new LongMatrix();
		matrix.addRow(new long[]{0});
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{0}});
		assertEquals(correctMatrix, matrix);

		//1x1
		matrix = new LongMatrix(grid1);
		matrix.addRow(new long[]{1});
		correctMatrix = new LongMatrix(new long[][]{{1}, {1}});
		assertEquals(correctMatrix, matrix);

		//Invalid adds
		final LongMatrix testMatrix = new LongMatrix(grid1);
		final LongMatrix testMatrix2 = new LongMatrix(grid2);
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.addRow(new long[]{0, 0});
		});
		assertThrows(NullMatrixException.class, () -> {
			testMatrix.addRow((long[])null);
		});
		assertThrows(NullMatrixException.class, () -> {
			testMatrix.addRow((LongMatrix)null);
		});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.addRow(testMatrix2);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		matrix.addRow(new long[]{1, 2});
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2},
			{1, 2},
			{1, 2}
		});
		assertEquals(correctMatrix, matrix);
		//Matrix
		matrix = new LongMatrix(grid2);
		matrix.addRow(new LongMatrix(new long[][]{{0, 0}}));
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2},
			{1, 2},
			{0, 0}
		});
		assertEquals(correctMatrix, matrix);

		//3x3
		matrix = new LongMatrix(grid3);
		matrix.addRow(new long[]{1, 2, 3});
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3},
			{1, 2, 3},
			{1, 2, 3},
			{1, 2, 3}
		});
		assertEquals(correctMatrix, matrix);

		//4x4
		matrix = new LongMatrix(grid4);
		matrix.addRow(new long[]{1, 2, 3, 4});
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4}
		});
		assertEquals(correctMatrix, matrix);

		//10x10
		matrix = new LongMatrix(grid10);
		matrix.addRow(new long[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
		});
		assertEquals(correctMatrix, matrix);
	}

	@Test
	public void testAddCol(){
		//0x0
		LongMatrix matrix = new LongMatrix();
		matrix.addCol(new long[]{0});
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{0}});
		assertEquals(correctMatrix, matrix);

		//1x1
		matrix = new LongMatrix(grid1);
		matrix.addCol(new long[]{1});
		correctMatrix = new LongMatrix(new long[][]{{1, 1}});
		assertEquals(correctMatrix, matrix);

		//Invalid adds
		final LongMatrix testMatrix = new LongMatrix(grid1);
		final LongMatrix testMatrix2 = new LongMatrix(grid2);
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.addCol(new long[]{0, 0});
		});
		assertThrows(NullMatrixException.class, () -> {
			testMatrix.addCol((long[])null);
		});
		assertThrows(NullMatrixException.class, () -> {
			testMatrix.addCol((LongMatrix)null);
		});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.addCol(testMatrix2);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		matrix.addCol(new long[]{3, 3});
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3},
			{1, 2, 3}
		});
		assertEquals(correctMatrix, matrix);
		//Matrix
		matrix = new LongMatrix(grid2);
		matrix.addCol(new LongMatrix(new long[][]{{0}, {0}}));
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 0},
			{1, 2, 0}
		});
		assertEquals(correctMatrix, matrix);

		//3x3
		matrix = new LongMatrix(grid3);
		matrix.addCol(new long[]{4, 4, 4});
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4}
		});
		assertEquals(correctMatrix, matrix);

		//4x4
		matrix = new LongMatrix(grid4);
		matrix.addCol(new long[]{5, 5, 5, 5});
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4, 5},
			{1, 2, 3, 4, 5},
			{1, 2, 3, 4, 5},
			{1, 2, 3, 4, 5}
		});
		assertEquals(correctMatrix, matrix);

		//10x10
		matrix = new LongMatrix(grid10);
		matrix.addCol(new long[]{11, 11, 11, 11, 11, 11, 11, 11, 11, 11});
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
		});
		assertEquals(correctMatrix, matrix);
	}

	@Test
	public void testAppendRight(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix secondMatrix = new LongMatrix(grid1);
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{1, 1}});
		assertEquals(correctMatrix, matrix.appendRight(secondMatrix));

		//Invalid appends
		final LongMatrix testMatrix = new LongMatrix(grid1);
		final LongMatrix testMatrix2 = new LongMatrix(grid2);
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.appendRight(testMatrix2);
		});
		assertThrows(NullMatrixException.class, () -> {
			testMatrix.appendRight(null);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		secondMatrix = new LongMatrix(grid2);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 1, 2},
			{1, 2, 1, 2}
		});
		assertEquals(correctMatrix, matrix.appendRight(secondMatrix));

		//3x3
		matrix = new LongMatrix(grid3);
		secondMatrix = new LongMatrix(grid3);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3, 1, 2, 3},
			{1, 2, 3, 1, 2, 3},
			{1, 2, 3, 1, 2, 3}
		});
		assertEquals(correctMatrix, matrix.appendRight(secondMatrix));

		//4x4
		matrix = new LongMatrix(grid4);
		secondMatrix = new LongMatrix(grid4);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4, 1, 2, 3, 4},
			{1, 2, 3, 4, 1, 2, 3, 4},
			{1, 2, 3, 4, 1, 2, 3, 4},
			{1, 2, 3, 4, 1, 2, 3, 4}
		});
		assertEquals(correctMatrix, matrix.appendRight(secondMatrix));

		//10x10
		matrix = new LongMatrix(grid10);
		secondMatrix = new LongMatrix(grid10);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
		});
		assertEquals(correctMatrix, matrix.appendRight(secondMatrix));
	}

	@Test
	public void testAppendBottom(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix secondMatrix = new LongMatrix(grid1);
		LongMatrix correctMatrix = new LongMatrix(new long[][]{
			{1},
			{1}
		});
		assertEquals(correctMatrix, matrix.appendBottom(secondMatrix));

		//Invalid appends
		final LongMatrix testMatrix = new LongMatrix(grid1);
		final LongMatrix testMatrix2 = new LongMatrix(grid2);
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.appendBottom(testMatrix2);
		});
		assertThrows(NullMatrixException.class, () -> {
			testMatrix.appendBottom(null);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		secondMatrix = new LongMatrix(grid2);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2},
			{1, 2},
			{1, 2},
			{1, 2}
		});
		assertEquals(correctMatrix, matrix.appendBottom(secondMatrix));

		//3x3
		matrix = new LongMatrix(grid3);
		secondMatrix = new LongMatrix(grid3);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3},
			{1, 2, 3},
			{1, 2, 3},
			{1, 2, 3},
			{1, 2, 3},
			{1, 2, 3}
		});
		assertEquals(correctMatrix, matrix.appendBottom(secondMatrix));

		//4x4
		matrix = new LongMatrix(grid4);
		secondMatrix = new LongMatrix(grid4);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4}
		});
		assertEquals(correctMatrix, matrix.appendBottom(secondMatrix));

		//10x10
		matrix = new LongMatrix(grid10);
		secondMatrix = new LongMatrix(grid10);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
		});
		assertEquals(correctMatrix, matrix.appendBottom(secondMatrix));
	}

	@Test
	public void testIsSquare(){
		LongMatrix matrix = new LongMatrix();
		assertFalse(matrix.isSquare());

		matrix = new LongMatrix(2, 2, 0);
		assertTrue(matrix.isSquare());

		matrix = new LongMatrix(2, 3, 0);
		assertFalse(matrix.isSquare());
	}

	@Test
	public void testAddition(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix transformMatrix = new LongMatrix(transformGrid1_1);
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{2}});
		assertEquals(correctMatrix, matrix.add(transformMatrix));
		assertEquals(correctMatrix, matrix.add(1));

		//Invalid adds
		final LongMatrix testMatrix = new LongMatrix(grid1);
		final LongMatrix testMatrix2 = new LongMatrix(new long[][]{{0}, {0}});
		final LongMatrix testMatrix3 = new LongMatrix(new long[][]{{0, 0}});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.add(testMatrix2);
		});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.add(testMatrix3);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		transformMatrix = new LongMatrix(transformGrid2_1);
		correctMatrix = new LongMatrix(new long[][]{
			{2, 2},
			{2, 2}
		});
		assertEquals(correctMatrix, matrix.add(transformMatrix));
		correctMatrix = new LongMatrix(new long[][]{
			{2, 3},
			{2, 3}
		});
		assertEquals(correctMatrix, matrix.add(1));

		//3x3
		matrix = new LongMatrix(grid3);
		transformMatrix = new LongMatrix(transformGrid3_1);
		correctMatrix = new LongMatrix(new long[][]{
			{3, 3, 3},
			{3, 3, 3},
			{3, 3, 3}
		});
		assertEquals(correctMatrix, matrix.add(transformMatrix));
		correctMatrix = new LongMatrix(new long[][]{
			{2, 3, 4},
			{2, 3, 4},
			{2, 3, 4}
		});
		assertEquals(correctMatrix, matrix.add(1));

		//4x4
		matrix = new LongMatrix(grid4);
		transformMatrix = new LongMatrix(transformGrid4_1);
		correctMatrix = new LongMatrix(new long[][]{
			{4, 4, 4, 4},
			{4, 4, 4, 4},
			{4, 4, 4, 4},
			{4, 4, 4, 4}
		});
		assertEquals(correctMatrix, matrix.add(transformMatrix));
		correctMatrix = new LongMatrix(new long[][]{
			{2, 3, 4, 5},
			{2, 3, 4, 5},
			{2, 3, 4, 5},
			{2, 3, 4, 5}
		});
		assertEquals(correctMatrix, matrix.add(1));

		//10x10
		matrix = new LongMatrix(grid10);
		transformMatrix = new LongMatrix(transformGrid10_1);
		correctMatrix = new LongMatrix(new long[][]{
			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10}
		});
		assertEquals(correctMatrix, matrix.add(transformMatrix));
		correctMatrix = new LongMatrix(new long[][]{
			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11},
			{2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
		});
		assertEquals(correctMatrix, matrix.add(1));
	}

	@Test
	public void testSubtraction(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix transformMatrix = new LongMatrix(grid1);
		LongMatrix correctMatrix = new LongMatrix(new long[][]{
			{0}
		});
		assertEquals(correctMatrix, matrix.subtract(transformMatrix));
		assertEquals(correctMatrix, matrix.subtract(1));

		//Invalid subtracts
		final LongMatrix testMatrix = new LongMatrix(grid1);
		final LongMatrix testMatrix2 = new LongMatrix(new long[][]{{0}, {0}});
		final LongMatrix testMatrix3 = new LongMatrix(new long[][]{{0, 0}});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.subtract(testMatrix2);
		});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.subtract(testMatrix3);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		transformMatrix = new LongMatrix(grid2);
		correctMatrix = new LongMatrix(2, 2, 0);
		assertEquals(correctMatrix, matrix.subtract(transformMatrix));
		correctMatrix = new LongMatrix(new long[][]{
			{0, 1},
			{0, 1}
		});
		assertEquals(correctMatrix, matrix.subtract(1));

		//3x3
		matrix = new LongMatrix(grid3);
		transformMatrix = new LongMatrix(grid3);
		correctMatrix = new LongMatrix(3, 3, 0);
		assertEquals(correctMatrix, matrix.subtract(transformMatrix));
		correctMatrix = new LongMatrix(new long[][]{
			{0, 1, 2},
			{0, 1, 2},
			{0, 1, 2}
		});
		assertEquals(correctMatrix, matrix.subtract(1));

		//4x4
		matrix = new LongMatrix(grid4);
		transformMatrix = new LongMatrix(grid4);
		correctMatrix = new LongMatrix(4, 4, 0);
		assertEquals(correctMatrix, matrix.subtract(transformMatrix));
		correctMatrix = new LongMatrix(new long[][]{
			{0, 1, 2, 3},
			{0, 1, 2, 3},
			{0, 1, 2, 3},
			{0, 1, 2, 3}
		});
		assertEquals(correctMatrix, matrix.subtract(1));

		//10x10
		matrix = new LongMatrix(grid10);
		transformMatrix = new LongMatrix(grid10);
		correctMatrix = new LongMatrix(10, 10, 0);
		assertEquals(correctMatrix, matrix.subtract(transformMatrix));
		correctMatrix = new LongMatrix(new long[][]{
			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
		});
		assertEquals(correctMatrix, matrix.subtract(1));
	}

	@Test
	public void testMultiplication(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix transformMatrix = new LongMatrix(transformGrid1_2);
		LongMatrix correctMatrix = new LongMatrix(transformGrid1_2);
		assertEquals(correctMatrix, matrix.multiply(transformMatrix));
		assertEquals(correctMatrix, matrix.multiply(2));

		//Invalid multiplication
		final LongMatrix testMatrix = new LongMatrix(grid1);
		final LongMatrix testMatrix2 = new LongMatrix(grid2);
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.multiply(testMatrix2);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		transformMatrix = new LongMatrix(transformGrid2_2);
		correctMatrix = new LongMatrix(new long[][]{
			{6, 9},
			{6, 9}
		});
		assertEquals(correctMatrix, matrix.multiply(transformMatrix));
		LongMatrix vector = new LongMatrix(new long[][]{
			{2},
			{3}
		});
		correctMatrix = new LongMatrix(new long[][]{
			{8},
			{8}
		});
		assertEquals(correctMatrix, matrix.multiply(vector));
		correctMatrix = new LongMatrix(new long[][]{
			{2, 4},
			{2, 4}
		});
		assertEquals(correctMatrix, matrix.multiply(2));

		//3x3
		matrix = new LongMatrix(grid3);
		transformMatrix = new LongMatrix(transformGrid3_2);
		correctMatrix = new LongMatrix(new long[][]{
			{12, 18, 24},
			{12, 18, 24},
			{12, 18, 24}
		});
		assertEquals(correctMatrix, matrix.multiply(transformMatrix));
		vector = new LongMatrix(new long[][]{
			{2},
			{3},
			{4}
		});
		correctMatrix = new LongMatrix(new long[][]{
			{20},
			{20},
			{20}
		});
		assertEquals(correctMatrix, matrix.multiply(vector));
		correctMatrix = new LongMatrix(new long[][]{
			{2, 4, 6},
			{2, 4, 6},
			{2, 4, 6}
		});
		assertEquals(correctMatrix, matrix.multiply(2));

		//4x4
		matrix = new LongMatrix(grid4);
		transformMatrix = new LongMatrix(transformGrid4_2);
		correctMatrix = new LongMatrix(new long[][]{
			{20, 30, 40, 50},
			{20, 30, 40, 50},
			{20, 30, 40, 50},
			{20, 30, 40, 50},
		});
		assertEquals(correctMatrix, matrix.multiply(transformMatrix));
		vector = new LongMatrix(new long[][]{
			{2},
			{3},
			{4},
			{5}
		});
		correctMatrix = new LongMatrix(new long[][]{
			{40},
			{40},
			{40},
			{40}
		});
		assertEquals(correctMatrix, matrix.multiply(vector));
		correctMatrix = new LongMatrix(new long[][]{
			{2, 4, 6, 8},
			{2, 4, 6, 8},
			{2, 4, 6, 8},
			{2, 4, 6, 8}
		});
		assertEquals(correctMatrix, matrix.multiply(2));

		//10x10
		matrix = new LongMatrix(grid10);
		transformMatrix = new LongMatrix(transformGrid10_2);
		correctMatrix = new LongMatrix(new long[][]{
			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605},
			{110, 165, 220, 275, 330, 385, 440, 495, 550, 605}
		});
		assertEquals(correctMatrix, matrix.multiply(transformMatrix));
		vector = new LongMatrix(new long[][]{
			{2},
			{3},
			{4},
			{5},
			{6},
			{7},
			{8},
			{9},
			{10},
			{11}
		});
		correctMatrix = new LongMatrix(new long[][]{
			{440},
			{440},
			{440},
			{440},
			{440},
			{440},
			{440},
			{440},
			{440},
			{440}
		});
		assertEquals(correctMatrix, matrix.multiply(vector));
		correctMatrix = new LongMatrix(new long[][]{
			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
			{2, 4, 6, 8, 10, 12, 14, 16, 18, 20}
		});
		assertEquals(correctMatrix, matrix.multiply(2));
	}

	@Test
	public void testDotProduct(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix transformMatrix = new LongMatrix(transformGrid1_2);
		assertEquals(2, matrix.dotProduct(transformMatrix));

		//Invalid products
		LongMatrix testMatrix = new LongMatrix(grid1);
		LongMatrix testMatrix2 = new LongMatrix(grid2);
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.dotProduct(testMatrix2);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		transformMatrix = new LongMatrix(transformGrid2_2);
		assertEquals(30, matrix.dotProduct(transformMatrix));

		//3x3
		matrix = new LongMatrix(grid3);
		transformMatrix = new LongMatrix(transformGrid3_2);
		assertEquals(162, matrix.dotProduct(transformMatrix));

		//4x4
		matrix = new LongMatrix(grid4);
		transformMatrix = new LongMatrix(transformGrid4_2);
		assertEquals(560, matrix.dotProduct(transformMatrix));

		//10x10
		matrix = new LongMatrix(grid10);
		transformMatrix = new LongMatrix(transformGrid10_2);
		assertEquals(35750, matrix.dotProduct(transformMatrix));
	}

	@Test
	public void testHadamardProduct(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix transformMatrix = new LongMatrix(transformGrid1_2);
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{2}});
		assertEquals(correctMatrix, matrix.hadamardProduct(transformMatrix));

		//Invalid hadamard products
		LongMatrix testMatrix = new LongMatrix(grid1);
		LongMatrix testMatrix2 = new LongMatrix(new long[][]{{0}, {0}});
		LongMatrix testMatrix3 = new LongMatrix(new long[][]{{0, 0}});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.hadamardProduct(testMatrix2);
		});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.hadamardProduct(testMatrix3);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		transformMatrix = new LongMatrix(transformGrid2_2);
		correctMatrix = new LongMatrix(new long[][]{
			{2, 6},
			{2, 6}
		});
		assertEquals(correctMatrix, matrix.hadamardProduct(transformMatrix));

		//3x3
		matrix = new LongMatrix(grid3);
		transformMatrix = new LongMatrix(transformGrid3_2);
		correctMatrix = new LongMatrix(new long[][]{
			{2, 6, 12},
			{2, 6, 12},
			{2, 6, 12}
		});
		assertEquals(correctMatrix, matrix.hadamardProduct(transformMatrix));

		//4x4
		matrix = new LongMatrix(grid4);
		transformMatrix = new LongMatrix(transformGrid4_2);
		correctMatrix = new LongMatrix(new long[][]{
			{2, 6, 12, 20},
			{2, 6, 12, 20},
			{2, 6, 12, 20},
			{2, 6, 12, 20}
		});
		assertEquals(correctMatrix, matrix.hadamardProduct(transformMatrix));

		//10x10
		matrix = new LongMatrix(grid10);
		transformMatrix = new LongMatrix(transformGrid10_2);
		correctMatrix = new LongMatrix(new long[][]{
			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110},
			{2, 6, 12, 20, 30, 42, 56, 72, 90, 110}
		});
		assertEquals(correctMatrix, matrix.hadamardProduct(transformMatrix));
	}

	@Test
	public void testTranspose(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{1}});
		assertEquals(correctMatrix, matrix.transpose());

		//2x2
		matrix = new LongMatrix(grid2);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 1},
			{2, 2}
		});
		assertEquals(correctMatrix, matrix.transpose());

		//3x3
		matrix = new LongMatrix(grid3);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 1, 1},
			{2, 2, 2},
			{3, 3, 3}
		});
		assertEquals(correctMatrix, matrix.transpose());

		//4x4
		matrix = new LongMatrix(grid4);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 1, 1, 1},
			{2, 2, 2, 2},
			{3, 3, 3, 3},
			{4, 4, 4, 4}
		});
		assertEquals(correctMatrix, matrix.transpose());

		//10x10
		matrix = new LongMatrix(grid10);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
			{2, 2, 2, 2, 2, 2, 2, 2, 2, 2},
			{3, 3, 3, 3, 3, 3, 3, 3, 3, 3},
			{4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
			{5, 5, 5, 5, 5, 5, 5, 5, 5, 5},
			{6, 6, 6, 6, 6, 6, 6, 6, 6, 6},
			{7, 7, 7, 7, 7, 7, 7, 7, 7, 7},
			{8, 8, 8, 8, 8, 8, 8, 8, 8, 8},
			{9, 9, 9, 9, 9, 9, 9, 9, 9, 9},
			{10, 10, 10, 10, 10, 10, 10, 10, 10, 10},
		});
		assertEquals(correctMatrix, matrix.transpose());
	}

	@Test
	public void testDeterminant(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		assertEquals(1, matrix.determinant());

		//Invalid determinants
		LongMatrix testMatrix = new LongMatrix(new long[][]{{0, 0}});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.determinant();
		});

		//2x2
		matrix = new LongMatrix(grid2);
		assertEquals(0, matrix.determinant());
		matrix = new LongMatrix(new long[][]{
			{1, 4},
			{4, 1}
		});
		assertEquals(-15, matrix.determinant());
		//det
		assertEquals(matrix.determinant(), matrix.det());

		//3x3
		matrix = new LongMatrix(grid3);
		assertEquals(0, matrix.determinant());
		matrix = new LongMatrix(new long[][]{
			{1, 4, 2},
			{2, 4, 1},
			{4, 1, 2}
		});
		assertEquals(-21, matrix.determinant());

		//4x4
		matrix = new LongMatrix(grid4);
		assertEquals(0, matrix.determinant());
		matrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4},
			{2, 3, 4, 1},
			{3, 4, 1, 2},
			{4, 1, 2, 3}
		});
		assertEquals(160, matrix.determinant());
		//Column
		matrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4},
			{1, 0, 3, 4},
			{1, 0, 3, 4},
			{0, 0, 3, 4}
		});
		assertEquals(0, matrix.determinant());
		//Column2
		matrix = new LongMatrix(new long[][]{
			{1, 2, 0, 4},
			{1, 2, 0, 4},
			{1, 2, 0, 4},
			{0, 2, 0, 4},
		});
		assertEquals(0, matrix.determinant());

		//10x10
		matrix = new LongMatrix(grid10);
		assertEquals(0, matrix.determinant());
		matrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
			{2, 3, 4, 5, 6, 7, 8, 9, 10, 1},
			{3, 4, 5, 6, 7, 8, 9, 10, 1, 2},
			{4, 5, 6, 7, 8, 9, 10, 1, 2, 3},
			{5, 6, 7, 8, 9, 10, 1, 2, 3, 4},
			{6, 7, 8, 9, 10, 1, 2, 3, 4, 5},
			{7, 8, 9, 10, 1, 2, 3, 4, 5, 6},
			{8, 9, 10, 1, 2, 3, 4, 5, 6, 7},
			{9, 10, 1, 2, 3, 4, 5, 6, 7, 8},
			{0,  0, 0, 0, 0, 0, 0, 0, 0, 1}
		});
		assertEquals(-10000000, matrix.determinant());
	}

	@Test
	public void testCofactor(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix correctMatrix = new LongMatrix(grid1);
		assertEquals(correctMatrix, matrix.cofactor());

		//Invalid cofactor
		LongMatrix testMatrix = new LongMatrix(new long[][]{{0, 0}});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.cofactor();
		});

		//2x2
		matrix = new LongMatrix(grid2);
		correctMatrix = new LongMatrix(new long[][]{
			{2, -1},
			{-2, 1}
		});
		assertEquals(correctMatrix, matrix.cofactor());
		//cof
		assertEquals(matrix.cofactor(), matrix.cof());

		//3x3
		matrix = new LongMatrix(grid3);
		correctMatrix = new LongMatrix(3, 3, 0);
		assertEquals(correctMatrix, matrix.cofactor());
		matrix = new LongMatrix(new long[][]{
			{1, 4, 2},
			{2, 4, 1},
			{4, 1, 2}
		});
		correctMatrix = new LongMatrix(new long[][]{
			{7, 0, -14},
			{-6, -6, 15},
			{-4, 3, -4}
		});
		assertEquals(correctMatrix, matrix.cofactor());

		//4x4
		matrix = new LongMatrix(grid4);
		correctMatrix = new LongMatrix(4, 4, 0);
		assertEquals(correctMatrix, matrix.cofactor());
		matrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4},
			{2, 3, 4, 1},
			{3, 4, 1, 2},
			{4, 1, 2, 3}
		});
		correctMatrix = new LongMatrix(new long[][]{
			{-36, 4, 4, 44},
			{4, 4, 44, -36},
			{4, 44, -36, 4},
			{44, -36, 4, 4}
		});
		assertEquals(correctMatrix, matrix.cofactor());

		//10x10
		//?Skipping 10x10 test because test took > 5s by itself
		/*
		matrix = new LongMatrix(grid10);
		correctMatrix = new LongMatrix(10, 10, 0);
		assertEquals(correctMatrix, matrix.cofactor());
		*/
	}

	@Test
	public void testPower(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{1}});
		assertEquals(correctMatrix, matrix.pow(3));

		//Invalid powers
		final LongMatrix testMatrix = new LongMatrix(new long[][]{{0}, {0}});
		final LongMatrix testMatrix2 = new LongMatrix(grid1);
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.pow(1);
		});
		assertThrows(InvalidScalarException.class, () -> {
			testMatrix2.pow(-1);
		});

		//2x2
		matrix = new LongMatrix(grid2);
		correctMatrix = new LongMatrix(new long[][]{
			{9, 18},
			{9, 18}
		});
		assertEquals(correctMatrix, matrix.pow(3));

		//3x3
		matrix = new LongMatrix(grid3);
		correctMatrix = new LongMatrix(new long[][]{
			{36, 72, 108},
			{36, 72, 108},
			{36, 72, 108}
		});
		assertEquals(correctMatrix, matrix.pow(3));

		//4x4
		//0
		matrix = new LongMatrix(grid4);
		correctMatrix = new LongMatrix(new long[][]{
			{1, 1, 1, 1},
			{1, 1, 1, 1},
			{1, 1, 1, 1},
			{1, 1, 1, 1}
		});
		assertEquals(correctMatrix, matrix.pow(0));
		//1
		correctMatrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4},
			{1, 2, 3, 4}
		});
		assertEquals(correctMatrix, matrix.pow(1));
		//3
		correctMatrix = new LongMatrix(new long[][]{
			{100, 200, 300, 400},
			{100, 200, 300, 400},
			{100, 200, 300, 400},
			{100, 200, 300, 400}
		});
		assertEquals(correctMatrix, matrix.pow(3));

		//10x10
		matrix = new LongMatrix(grid10);
		correctMatrix = new LongMatrix(new long[][]{
			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250},
			{3025, 6050, 9075, 12100, 15125, 18150, 21175, 24200, 27225, 30250}
		});
		assertEquals(correctMatrix, matrix.pow(3));
	}

	@Test
	public void testAdjoint(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix correctMatrix = new LongMatrix(grid1);
		assertEquals(correctMatrix, matrix.adjoint());

		//2x2
		matrix = new LongMatrix(grid2);
		correctMatrix = new LongMatrix(new long[][]{
			{2, -2},
			{-1, 1}
		});
		assertEquals(correctMatrix, matrix.adjoint());
		//adj
		assertEquals(matrix.adjoint(), matrix.adj());

		//3x3
		matrix = new LongMatrix(grid3);
		correctMatrix = new LongMatrix(3, 3, 0);
		assertEquals(correctMatrix, matrix.adjoint());

		//4x4
		matrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4},
			{2, 3, 4, 1},
			{3, 4, 1, 2},
			{4, 1, 2, 3}
		});
		correctMatrix = new LongMatrix(new long[][]{
			{-36, 4, 4, 44},
			{4, 4, 44, -36},
			{4, 44, -36, 4},
			{44, -36, 4, 4}
		});
		assertEquals(correctMatrix, matrix.adjoint());

		//10x10
		//?Skipping 10x10 test because test took > 5s by itself
		/*
		matrix = new LongMatrix(grid10);
		correctMatrix = new LongMatrix(10, 10, 0);
		assertEquals(correctMatrix, matrix.adjoint());
		*/
	}

	@Test
	public void testInverse(){
		//1x1
		LongMatrix matrix = new LongMatrix(grid1);
		LongMatrix correctMatrix = new LongMatrix(grid1);
		assertEquals(correctMatrix, matrix.inverse());

		//Invalid inverse
		LongMatrix testMatrix = new LongMatrix(new long[][]{{0, 0}});
		LongMatrix testMatrix2 = new LongMatrix(new long[][]{
			{1, 2, 3},
			{1, 2, 3},
			{1, 2, 3}
		});
		assertThrows(InvalidGeometryException.class, () -> {
			testMatrix.inverse();
		});
		assertThrows(InvalidScalarException.class, () -> {
			testMatrix2.inverse();
		});

		//2x2
		matrix = new LongMatrix(new long[][]{
			{1, 4},
			{4, 1}
		});
		correctMatrix = new LongMatrix(new long[][]{
			{-0, 0},
			{0, -0}
		});
		assertEquals(correctMatrix, matrix.inverse());

		//3x3
		matrix = new LongMatrix(new long[][]{
			{1, 4, 2},
			{2, 4, 1},
			{4, 1, 2}
		});
		correctMatrix = new LongMatrix(new long[][]{
			{-0, 0, 0},
			{0, 0, -0},
			{0, -0, 0}
		});
		assertEquals(correctMatrix, matrix.inverse());

		//4x4
		matrix = new LongMatrix(new long[][]{
			{1, 2, 3, 4},
			{2, 3, 4, 1},
			{3, 4, 1, 2},
			{4, 1, 2, 3}
		});
		correctMatrix = new LongMatrix(new long[][]{
			{-0, 0, 0, 0},
			{0, 0, 0, -0},
			{0, 0, -0, 0},
			{0, -0, 0, 0}
		});
		assertEquals(correctMatrix, matrix.inverse());

		//10x10
		//?Skipped 10x10 because it would take a long time to compute
	}

	@Test
	public void testGenerateIdentity(){
		//0x0
		assertThrows(InvalidGeometryException.class, () -> {
			LongMatrix.generateIdentity(0);
		});

		//1x1
		LongMatrix correctMatrix = new LongMatrix(new long[][]{{1}});
		assertEquals(correctMatrix, LongMatrix.generateIdentity(1));

		//2x2
		correctMatrix = new LongMatrix(new long[][]{
			{1, 0},
			{0, 1}
		});
		assertEquals(correctMatrix, LongMatrix.generateIdentity(2));

		//3x3
		correctMatrix = new LongMatrix(new long[][]{
			{1, 0, 0},
			{0, 1, 0},
			{0, 0, 1}
		});
		assertEquals(correctMatrix, LongMatrix.generateIdentity(3));

		//4x4
		correctMatrix = new LongMatrix(new long[][]{
			{1, 0, 0, 0},
			{0, 1, 0, 0},
			{0, 0, 1, 0},
			{0, 0, 0, 1}
		});
		assertEquals(correctMatrix, LongMatrix.generateIdentity(4));

		//10x10
		correctMatrix = new LongMatrix(new long[][]{
			{1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
			{0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
			{0, 0, 1, 0, 0, 0, 0, 0, 0, 0},
			{0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
			{0, 0, 0, 0, 1, 0, 0, 0, 0, 0},
			{0, 0, 0, 0, 0, 1, 0, 0, 0, 0},
			{0, 0, 0, 0, 0, 0, 1, 0, 0, 0},
			{0, 0, 0, 0, 0, 0, 0, 1, 0, 0},
			{0, 0, 0, 0, 0, 0, 0, 0, 1, 0},
			{0, 0, 0, 0, 0, 0, 0, 0, 0, 1},
		});
		assertEquals(correctMatrix, LongMatrix.generateIdentity(10));
	}

	@Test
	public void testHashCode(){
		LongMatrix matrix = new LongMatrix();
		assertEquals(Arrays.hashCode(new int[0][0]), matrix.hashCode());
	}

	@Test
	public void testToString(){
		LongMatrix matrix = new LongMatrix(grid3);
		String matrixString = "[1,2,3]\n[1,2,3]\n[1,2,3]";
		assertEquals(matrixString, matrix.toString());
	}
}