junit 测试矩阵的幂

一篇菜鸡的记录。

待测程序

当时的设定是，源程序不可修改。只可以设置。

/** 矩阵乘法MatrixMultiply

给定一个N阶矩阵A，输出A的M次幂（M是非负整数）
　　例如：
　　A =
　　1 2
　　3 4
　　A的2次幂
　　7 10
　　15 22
输入格式
　　第一行是一个正整数N、M（1<=N<=30, 0<=M<=5），表示矩阵A的阶数和要求的幂数
　　接下来N行，每行N个绝对值不超过10的非负整数，描述矩阵A的值
输出格式
　　输出共N行，每行N个整数，表示A的M次幂所对应的矩阵。相邻的数之间用一个空格隔开
样例输入
2 2
1 2
3 4
样例输出
7 10
15 22
 */


import java.util.*;

public class MatrixMultiply {
	public void matrixMultiplyMain() {
		MatrixMultiply main1 = new MatrixMultiply();
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int m = in.nextInt();
		int j;
		int[][] a = new int[31][31];
		int[][] b = new int[31][31];
		a = main1.inputFun(n, m, in);
		b = main1.setBOne(b, n);
		b = main1.calcFun(a, b, n, m);

		for (int i = 0; i < n; i++) {
			for (j = 0; j < n-1; j++)
				System.out.printf("%d ", b[i][j]);
			System.out.printf("%d\n", b[i][j]);
		}

	}

	int[][] inputFun(int n, int m, Scanner in) {
		// TODO Auto-generated method stub
		int[][] a = new int[31][31];
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
				a[i][j] = in.nextInt();
		return a;
	}

	private int[][] calcFun(int[][] a, int[][] b, int n, int m) {
		// TODO Auto-generated method stub
		int i, j;
		int[][] t = new int[31][31];
		while (m-- > 0) {
			for (i = 0; i * i < t.length; i++)
				for (j = 0; j * j < t.length; j++)
					t[i][j] = 0;

			for (i = 0; i < n; i++)
				for (j = 0; j < n; j++)
					for (int k = 0; k < n; k++)
						t[i][j] += b[i][k] * a[k][j];
			for (i = 0; i < n; i++)
				for (j = 0; j < n; j++)
					b[i][j] = t[i][j];
		}

		return b;
	}

	private int[][] setBOne(int[][] b, int n) {
		// TODO Auto-generated method stub
		for (int i = 0; i < n; i++)
			b[i][i] = 1;
		return b;
	}
}

分析

自己的理解是junit是自动化测试，如果在命令行输入输出太low了，又因为原文是IO代码，所以需要重定向输入输出流，还有文件读入等操作。

juni代码

讲一下大概逻辑，从一个data.txt文件里面读入，然后跑程序的结果保存在数组里面。
又从一个result.txt里面读入正确的结果，保存在数组里面，然后这两个数组对比，也就是
assertArrayEquals(数组，数组);

import static org.junit.Assert.*;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class MatrixMultiplyTest {
	
	MatrixMultiply mart ;
	int arry[][];//从result读取的正确结果
	int calArry[][];//计算的结果
	int size;//n的大小，即矩阵的大小
	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}

	@Before
	public void setUp() throws Exception {
		getRightResult();
		mart =new MatrixMultiply();
		calArry=new int[size][size];
	}

	private void getRightResult() {
		//从文件读取，太菜了，只能模拟了
		//有什么就读什么.从result.txt读取
		InputStream stdin = System.in;
		File file = new File(this.getClass().getResource("").getPath());
		//这里路径注意下。当时限制在eclipse写的，别的软件路径可能有问题
        ArrayList<Integer> list = new ArrayList<>();
        BufferedReader bf = null;
		try {
			bf = new BufferedReader(new FileReader(file+"/result.txt"));
		} catch (FileNotFoundException e2) {
			e2.printStackTrace();
		}
        int n;
        int num=0;
        size=0;
        int sign=1;
        boolean flag=true;// true represents non-number
        try {
			while ((n=bf.read())!=-1){
			    if(n>=48&&n<=57){
			        num=num*10+(n-48);
			        flag=false;
			    }else if(n==45) {
			    	sign=-1;
			    }
			    else{
			        if(flag) {//不是数字和负号
			            if(n==10) size++;
			            continue;
			        }
			        flag=true;
			        list.add(num*sign);
			        sign=1;
			        num=0;
			    }
			}
		} catch (IOException e1) {
			e1.printStackTrace();
		}
       if(size==0) {
    	   size++;
    	   list.add(num*sign);
       }else if (size*size<list.size()){
            list.add(num*sign);
        }
        size=(int)Math.sqrt(list.size());
        arry=new int[size][size];
       
        for (int i = 0; i <size; i++) {
            for (int j = 0; j <size; j++) {
                arry[i][j]=list.remove(0);
                //System.out.println(arry[i][j]);
            }
        }
        try {
			bf.close();
		} catch (IOException e) {
			
			e.printStackTrace();
		}
	}

	@After
	public void tearDown() throws Exception {
	}
	
	@Test
	public void testMatrixMultiplyMain() {
		InputStream stdin = System.in;
		PrintStream stdout=System.out;
		ArrayList<Integer> list = new ArrayList<>();
		PrintStream myStream = new PrintStream(new OutputStream() {
            @Override
            public void write(int n) throws IOException {
                list.add(n);
            }
        });
        System.setOut(myStream);
		File file = new File(this.getClass().getResource("").getPath());
		try {
			System.setIn(new FileInputStream(file+"\\data.txt"));//从文件流读入
			mart.matrixMultiplyMain();//计算即输出。需要先重定向输出流
			getCalculateResult(stdout,list);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} finally{
			System.setIn(stdin); 
		}
		assertArrayEquals(calArry,arry);
	}

	private void getCalculateResult(PrintStream stdout,ArrayList<Integer> list) {
		System.setOut(stdout);
//		list.forEach(s->System.out.println(s)); 
        int n;
        int num=0;
        boolean flag=true;
        int sign=1;
        ArrayList<Integer> list1 = new ArrayList<>();
        while (list.isEmpty()==false){
            n=list.remove(0);
            if(n>=48&&n<=57){
                num=num*10+(n-48);
                flag=false;
            }else if(n==45){
                sign=-1;
            }else{
                if(flag){
                    continue;
                }
                flag=true;
                list1.add(num*sign);
                sign=1;
                num=0;
            }

        }
       
        list1.add(num*sign);
       
        for (int i = 0; i <size; i++) {
            for (int j = 0; j <size; j++) {
                calArry[i][j]=list1.remove(0);
               //System.out.println(calArry[i][j]);
            }
        }	
	}

}

两个txt文件的位置

放在这里，然后编译的话，这俩文件会被放在编译好的文件里面

缺点

一次只能测一个样例，想过如何修改，先是多线程，发现鸡肋。就普普通通的for循环就可以了。规定在两个文件里面分别定义好读到什么字符就是一个样例。