/// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {

            int N = n / M; 	//number of blocks that can be made from the binary string

            //for each block calculate the proportion of ones
            double sum = 0.0;
            for (int i = 0; i < N; i++) {
                double pi = (double)model.epsilon.GetRange(i * M, M).Sum() / (double)M;   //sum of bits in block / length of the block
                sum += Math.Pow((pi - 0.5), 2);
            }

            //calculate p_value
            double chi_squared = 4.0 * M * sum;
            double p_value = Cephes.igamc(N / 2.0, chi_squared / 2.0);

            if (printResults) {
                Report report = new Report("2: Frequency Test within a Block");
                report.Write("\t\t\tBLOCK FREQUENCY TEST");
                report.Write("\t\t---------------------------------------------");
                report.Write("\t\tCOMPUTATIONAL INFORMATION:");
                report.Write("\t\t---------------------------------------------");
                report.Write("\t\t(a) Chi^2           = " + chi_squared);
                report.Write("\t\t(b) # of substrings = " + N);
                report.Write("\t\t(c) block length    = " + M);
                report.Write("\t\t(d) Note: " + n % M + " bits were discarded.");
                report.Write("\t\t---------------------------------------------");
                report.Write(p_value < ALPHA ? "FAILURE" : "SUCCESS" + "\t\tp_value = " + p_value);
                model.reports.Add(report.title, report);
            }

            return new double[] { p_value };
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {

            //calculate all psi_squares
            double psim0 = psi2(m, n);
            double psim1 = psi2(m - 1, n);
            double psim2 = psi2(m - 2, n);
            double del1 = psim0 - psim1;
            double del2 = psim0 - 2.0 * psim1 + psim2;

            //calculate p_values
            double p_value1 = Cephes.igamc(Math.Pow(2, m - 1) / 2, del1 / 2.0);
            double p_value2 = Cephes.igamc(Math.Pow(2, m - 2) / 2, del2 / 2.0);

            if (printResults) {
                Report report = new Report("11: Serial Test");
                report.Write("\t\t\t       SERIAL TEST");
                report.Write("\t\t---------------------------------------------");
                report.Write("\t\t COMPUTATIONAL INFORMATION:		  ");
                report.Write("\t\t---------------------------------------------");
                report.Write("\t\t(a) Block length    (m) = " + m);
                report.Write("\t\t(b) Sequence length (n) = " + n);
                report.Write("\t\t(c) Psi_m               = " + psim0);
                report.Write("\t\t(d) Psi_m-1             = " + psim1);
                report.Write("\t\t(e) Psi_m-2             = " + psim2);
                report.Write("\t\t(f) Del_1               = " + del1);
                report.Write("\t\t(g) Del_2               = " + del2);
                report.Write("\t\t---------------------------------------------\n");
                report.Write(p_value1 < ALPHA ? "FAILURE" : "SUCCESS" + "\t\tp_value1 = " + p_value1);
                report.Write(p_value2 < ALPHA ? "FAILURE" : "SUCCESS" + "\t\tp_value2 = " + p_value2);
                model.reports.Add(report.title, report);
            }

            return new double[] { p_value1, p_value2 };
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {
            
            double pi = (double)model.epsilon.GetRange(0, n).Sum() / (double)n;    //number of ones in the binary string / length

            //prerequisite for test, if not passed test is not applicable   
            if (Math.Abs(pi - 0.5) > (2.0 / Math.Sqrt(n))) {
                if (printResults) {
                    Report report = new Report("3: Runs Test");
                    report.Write("\t\t\t\tRUNS TEST");
                    report.Write("\t\t------------------------------------------");
                    report.Write("\t\tPI ESTIMATOR CRITERIA NOT MET! PI = " + pi);
                    model.reports.Add(report.title, report);
                }
                return new double[] { 0.0 };
            } else {
                //count number of runs in the binary string (where e(i) = e(i+1) is considered to be a run)
                int V_obs = 1;
                for (int i = 1; i < n; i++) {
                    if (model.epsilon[i] != model.epsilon[i - 1]) {
                        V_obs++;
                    }
                }

                //calculate p_value
                double p_value = Cephes.erfc(Math.Abs(V_obs - 2.0 * n * pi * (1 - pi)) / (2.0 * pi * (1 - pi) * Math.Sqrt(2 * n)));

                if (printResults) {
                    Report report = new Report("3: Runs Test");
                    report.Write("\t\t\t\tRUNS TEST");
                    report.Write("\t\t------------------------------------------");
                    report.Write("\t\tCOMPUTATIONAL INFORMATION:");
                    report.Write("\t\t------------------------------------------");
                    report.Write("\t\t(a) Pi                        = " + pi);
                    report.Write("\t\t(b) V_n_obs (Total # of runs) = " + (int)V_obs);
                    report.Write("\t\t(c) V_n_obs - 2 n pi (1-pi)", false);
                    report.Write("\t\t      2 sqrt(2n) pi (1-pi)");
                    report.Write("\t\t------------------------------------------");
                    if (p_value < 0 || p_value > 1) {
                        report.Write("WARNING:  P_VALUE IS OUT OF RANGE.");
                    }
                    report.Write(p_value < ALPHA ? "FAILURE" : "SUCCESS"+"\t\tp_value = "+p_value);
                    model.reports.Add(report.title, report);
                }
                return new double[] { p_value };
            }
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {

            //calculate the sum of all bits in the string after mapping (0->-1, 1->1)
            double S_n = model.epsilon.GetRange(0, n).Sum(delegate(int i) { return 2 * i - 1; });

            //calculate p_value
            double S_obs = Math.Abs(S_n) / Math.Sqrt(n);
            double p_value = Cephes.erfc(S_obs / Math.Sqrt(2));

            if (printResults) {
                Report report = new Report("1: Frequency (Monobit) Test");
                report.Write("\t\t\t      FREQUENCY TEST");
                report.Write("\t\t---------------------------------------------");
                report.Write("\t\tCOMPUTATIONAL INFORMATION:");
                report.Write("\t\t---------------------------------------------");
                report.Write("\t\t(a) The nth partial sum = " + (int)S_n);
                report.Write("\t\t(b) S_n/n               = " + S_n / n);
                report.Write("\t\t---------------------------------------------");
                report.Write(p_value < ALPHA ? "FAILURE" : "SUCCESS" + "\t\tp_value = " + p_value);
                model.reports.Add(report.title, report);
            }

            return new double[] { p_value };
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {

            int[] stateX = { -4, -3, -2, -1, 1, 2, 3, 4 };
  
            double[,] pi = { {0.0000000000, 0.00000000000, 0.00000000000, 0.00000000000, 0.00000000000, 0.0000000000}, 
						     {0.5000000000, 0.25000000000, 0.12500000000, 0.06250000000, 0.03125000000, 0.0312500000},
						     {0.7500000000, 0.06250000000, 0.04687500000, 0.03515625000, 0.02636718750, 0.0791015625},
						     {0.8333333333, 0.02777777778, 0.02314814815, 0.01929012346, 0.01607510288, 0.0803755143},
						     {0.8750000000, 0.01562500000, 0.01367187500, 0.01196289063, 0.01046752930, 0.0732727051} };

            Report report = new Report("14: Random Excursions Test");   

            //determine cycles
            int J = 0;
            int[] S_k = new int[n];
            S_k[0] = 2 * (int)model.epsilon[0] - 1;
            int[] cycle = new int[Math.Max(1000, n / 100)];
            for (int i = 1; i < n; i++) {
                S_k[i] = S_k[i - 1] + 2 * model.epsilon[i] - 1;
                if (S_k[i] == 0) {
                    J++;
                    if (J > Math.Max(1000, n / 100)) {
                        if (printResults) {
                            report.Write("ERROR IN FUNCTION randomExcursions:  EXCEEDING THE MAX NUMBER OF CYCLES EXPECTED.");
                        }
                        return null;
                    }
                    cycle[J] = i;
                }
            }
            if (S_k[n - 1] != 0) {
                J++;
            }
            cycle[J] = n;

            if (printResults) {
                report.Write("\t\t\t  RANDOM EXCURSIONS TEST");
                report.Write("\t\t--------------------------------------------");
                report.Write("\t\tCOMPUTATIONAL INFORMATION:");
                report.Write("\t\t--------------------------------------------");
                report.Write("\t\t(a) Number Of Cycles (J) = " + J);
                report.Write("\t\t(b) Sequence Length (n)  = " + n);
            }

            double constraint = Math.Max(0.005 * Math.Pow(n, 0.5), 500);
            double[] p_values = new double[8];
            if (J < constraint) {
                if (printResults) {
                    report.Write("\t\t---------------------------------------------");
                    report.Write("\t\tWARNING:  TEST NOT APPLICABLE.  THERE ARE AN");
                    report.Write("\t\t\t  INSUFFICIENT NUMBER OF CYCLES.");
                    report.Write("\t\t---------------------------------------------");
                    for (int i = 0; i < 8; i++) {
                        report.Write(0.0.ToString());
                    }
                }
            } else {
                if (printResults) {
                    report.Write("\t\t(c) Rejection Constraint = " + constraint);
                    report.Write("\t\t-------------------------------------------");
                }

                double[,] v = new double[6, 8];
                int cycleStart = 0;
                int cycleStop = cycle[1];
                for (int k = 0; k < 6; k++) {
                    for (int i = 0; i < 8; i++) {
                        v[k, i] = 0.0;
                    }
                }
                int[] counter = new int[8];
                //for each cycle compute frequency of x
                for (int j = 1; j <= J; j++) {
                    for (int i = 0; i < 8; i++) {
                        counter[i] = 0;
                    }
                    for (int i = cycleStart; i < cycleStop; i++) {
                        if ((S_k[i] >= 1 && S_k[i] <= 4) || (S_k[i] >= -4 && S_k[i] <= -1)) {
                            int b = S_k[i]<0 ? 4 : 3;
                            counter[S_k[i] + b]++;
                        }
                    }
                    cycleStart = cycle[j] + 1;
                    if (j < J) {
                        cycleStop = cycle[j + 1];
                    }

                    for (int i = 0; i < 8; i++) {
                        if ((counter[i] >= 0) && (counter[i] <= 4)) {
                            v[counter[i], i]++;
                        } else if (counter[i] >= 5) {
                            v[5, i]++;
                        }
                    }
                }

                //calculate p_values
                for (int i = 0; i < 8; i++) {
                    int x = stateX[i];
                    double sum = 0;
                    for (int k = 0; k < 6; k++) {
                        sum += Math.Pow(v[k, i] - J * pi[(int)Math.Abs(x), k], 2) / (J * pi[(int)Math.Abs(x), k]);
                    }
                    p_values[i] = Cephes.igamc(2.5, sum / 2.0);

                    if (printResults) {
                        if (p_values[i] < 0 || p_values[i] > 1) {
                            report.Write("WARNING:  P_VALUE IS OUT OF RANGE.");
                        }

                        report.Write(p_values[i] < ALPHA ? "FAILURE" : "SUCCESS"+"\t\tx = "+x+" chi^2 = "+sum+" p_value = "+p_values[i]);
                    }

                }
            }
            if (printResults) {
                model.reports.Add(report.title, report);
            }
            return p_values;
        }
        private double[] run(int[] B, bool printResults) {
            if (n > model.epsilon.Count || n <= 0) {
                throw new ArgumentException("The value of n must be smaller than the size of the input data, and be greater than 0", "Frequency n");
            }

            int[] Wj = new int[N];

            for (int i = 0; i < N; i++) { //for each start position
                for (int j = 0; j < M - B.Length + 1; j++) {    //is there a match for the template
                    bool match = true;
                    for (int k = 0; k < B.Length; k++) {
                        if ((int)B[k] != (int)model.epsilon[i * M + j + k]) {
                            match = false;  
                            break;
                        }
                    }
                    if (match) {
                        Wj[i]++;    //if there was a match, record it
                    }
                }
            }

            //calculate p_value
            double chi2 = 0.0;
            for (int i = 0; i < N; i++) {
                chi2 += Math.Pow(((double)Wj[i] - mu) / Math.Pow(sigma, 0.5), 2);
            }
            double p_value = Cephes.igamc(N / 2.0, chi2 / 2.0);

            if (printResults) {
                Report report = new Report("7: Non-overlapping Template Matching Test");
                report.Write("chi^2   = " + chi2);
                report.Write("p_value = " + p_value);
                model.reports.Add(report.title, report);
            }

            return new double[] { p_value };
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        /// <exception cref="ArgumentException"/>
        /// <exception cref="FormatException"/>
        /// <exception cref="OverflowException"/>
        /// <exception cref="FileNotFoundException"/>
        /// <exception cref="DirectoryNotFoundException"/>
        /// <exception cref="UnauthorizedAccessException"/>
        /// <exception cref="IOException"/>
        /// <exception cref="OutOfMemoryException"/>
        public override double[] run(bool printResults) {

            if (B != null) { //as we know it is to run on a single test
                mu = (M - B.Length + 1) / Math.Pow(2, B.Length);
                sigma = M * (1.0 / Math.Pow(2.0, B.Length) - (2.0 * B.Length - 1.0) / Math.Pow(2.0, 2.0 * B.Length));
                return run(B, printResults);
            }
            //otherwise on a template of tests

            int[] numOfTemplates = {0, 0, 2, 4, 6, 12, 20, 40, 74, 148, 284, 568, 1116,
						    2232, 4424, 8848, 17622, 35244, 70340, 140680, 281076, 562152};
	        

            //compute predicted probabilities
            int K = 5;
            mu = (M - m + 1) / Math.Pow(2, m);
            sigma = M * (1.0 / Math.Pow(2.0, m) - (2.0 * m - 1.0) / Math.Pow(2.0, 2.0 * m));

            Report report = new Report("7: Non-overlapping Template Matching Test");
            if (printResults) {
                report.Write("\t\t  NONPERIODIC TEMPLATES TEST");
                report.Write("-------------------------------------------------------------------------------------");
                report.Write("\t\t  COMPUTATIONAL INFORMATION");
                report.Write("-------------------------------------------------------------------------------------");
                report.Write("\tLAMBDA = " + mu + "\tM = " + M + "\tN = " + N + "\tm = " + m + "\tn = " + n + "");
                report.Write("-------------------------------------------------------------------------------------");
            }

            double[] p_values = new double[numOfTemplates[m]];
            try {
                using (StreamReader sr = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(TEMPLATE_DIR + ".template" + m))) {
                    for (int i = 0; i < numOfTemplates[m]; i++) {

                        String line = sr.ReadLine();    //load in the template string
                        String[] numbers = Regex.Split(line, TEMPLATESPLITSTR);
                        B = new int[m];
                        for (int k = 0; k < m; k++) {
                            try {
                                B[k] = Convert.ToInt32(numbers[k]); //parse into an array
                            } catch (FormatException) {
                                throw new FormatException("The input data did not consist of a an optional " +
                                        "sign followed by a sequence of digits (0 through 9):\r\n\r\n" + line);
                            } catch (OverflowException) {
                                throw new OverflowException("The input string was not of a number within the program's ranges:\r\n\r\n" + line);
                            }
                        }

                        p_values[i] = this.run(B, false)[0];    //get p_value for this template string

                        if (printResults) {
                            if (p_values[i] < 0 || p_values[i] > 1) {
                                report.Write("\t\tWARNING:  P_VALUE IS OUT OF RANGE.");
                            }
                            report.Write(i + "\t: " + (p_values[i] < ALPHA ? "FAILURE" : "SUCCESS") + "\t\t" + p_values[i]);
                        }

                    }
                }
            } catch (ArgumentException) {
                throw new ArgumentException("The input file path is not a valid one:\r\n\r\n" + TEMPLATE_DIR + "template" + m);
            } catch (FileNotFoundException) {
                throw new FileNotFoundException("The input file does not exist:\r\n\r\n" + TEMPLATE_DIR + "template" + m);
            } catch (DirectoryNotFoundException) {
                throw new DirectoryNotFoundException("The input directory does not exist:\r\n\r\n" + TEMPLATE_DIR + "template" + m);
            } catch (UnauthorizedAccessException) {
                throw new UnauthorizedAccessException("The user does not have the permissions to access this file:\r\n\r\n" + TEMPLATE_DIR + "template" + m);
            } catch (IOException) {
                throw new IOException("Failed to read from file successfully:\r\n\r\n" + TEMPLATE_DIR + "template" + m);
            } catch (OutOfMemoryException) {
                throw new OutOfMemoryException("System out of memory");
            }
            model.reports.Add(report.title, report);
            return p_values;
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {
            
	        double[]    pi = { 0.01047, 0.03125, 0.12500, 0.50000, 0.25000, 0.06250, 0.020833 };

            int N = n/M;    //number of blocks
	       
            double mu = M / 2.0 + (9.0 + Math.Pow(-1, M+1)) / 36.0 - 1.0 / Math.Pow(2, M) * (M / 3.0 + 2.0 / 9.0);

            double[] v = new double[K+1];

	        for ( int i=0; i<N; i++ ) {
                int[] T = new int[M];   //initialize the work arrays
                int[] P = new int[M];
                int[] C = new int[M];
                int[] B = new int[M];
		        
		        int L = 0;
		        int m = -1;
		        int d = 0;
		        C[0] = 1;
		        B[0] = 1;
		
		        //calculate the linear complexity of the block
		        int blockPos = 0;
		        while ( blockPos < M ) {
                    d = (int)model.epsilon[i * M + blockPos];
                    for (int j = 1; j <= L; j++) {
                        d += C[j] * model.epsilon[i * M + blockPos - j];
                    }
                    d = d % 2;
			        if ( d == 1 ) {
                        for (int j = 0; j < M; j++) {
                            T[j] = C[j];
                            P[j] = 0;
                        }
                        for (int j = 0; j < M; j++) {
                            if (B[j] == 1) {
                                P[j + blockPos - m] = 1;
                            }
                        }
                        for (int j = 0; j < M; j++) {
                            C[j] = (C[j] + P[j]) % 2;
                        }
				        if ( L <= blockPos/2 ) {
					        L = blockPos + 1 - L;
					        m = blockPos;
                            for (int j = 0; j < M; j++) {
                                B[j] = T[j];
                            }
				        }
			        }
			        blockPos++;
		        }
                
                double Ti = Math.Pow(-1, M) * (L - mu) + 2.0 / 9.0;
		
                //record result of complexity test
		        if ( Ti <= -2.5 )
			        v[0]++;
		        else if ( Ti > -2.5 && Ti <= -1.5 )
			        v[1]++;
		        else if ( Ti > -1.5 && Ti <= -0.5 )
			        v[2]++;
		        else if ( Ti > -0.5 && Ti <= 0.5 )
			        v[3]++;
		        else if ( Ti > 0.5 && Ti <= 1.5 )
			        v[4]++;
		        else if ( Ti > 1.5 && Ti <= 2.5 )
			        v[5]++;
		        else
			        v[6]++;
	        }

            //calculate p_value
	        double chi_squared = 0;
            for (int i = 0; i < K + 1; i++) {
                chi_squared += Math.Pow(v[i] - N * pi[i], 2) / (N * pi[i]);
            }
	        double p_value = Cephes.igamc(K/2.0, chi_squared/2.0);

            if (printResults) {
                Report report = new Report("10: Linear Complexity Test");
                report.Write("-----------------------------------------------------");
                report.Write("\tL I N E A R  C O M P L E X I T Y");
                report.Write("-----------------------------------------------------");
                report.Write("\tM (substring length)     = {0}" + M);
                report.Write("\tN (number of substrings) = {0}" + N);
                report.Write("-----------------------------------------------------");
                report.Write("        F R E Q U E N C Y                            ");
                report.Write("-----------------------------------------------------");
                report.Write("  C0   C1   C2   C3   C4   C5   C6    CHI2    P-value");
                report.Write("-----------------------------------------------------");
                report.Write("\tNote: " + n % M + " bits were discarded!");
                for (int i = 0; i < K + 1; i++) {
                    report.Write(((int)v[i]).ToString(), false);
                }
                report.Write("");
                report.Write(p_value < ALPHA ? "FAILURE" : "SUCCESS" + "\t\tp_value = " + p_value);
                model.reports.Add(report.title, report);
            }

            return new double[] { p_value };
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {

            int[] stateX = { -9, -8, -7, -6, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

            int J = 0;
            int[] S = new int[n];
            //compute partial sums
            S[0] = 2 * (int)model.epsilon[0] - 1;
            for (int i = 1; i < n; i++) {
                S[i] = S[i - 1] + 2 * model.epsilon[i] - 1;
                if (S[i] == 0) {
                    J++;
                }
            }
            if (S[n - 1] != 0) {
                J++;
            }

            Report report = new Report("15: Random Excursions Variant Test");
            if (printResults) {
                report.Write("\t\t\tRANDOM EXCURSIONS VARIANT TEST");
                report.Write("\t\t--------------------------------------------");
                report.Write("\t\tCOMPUTATIONAL INFORMATION:");
                report.Write("\t\t--------------------------------------------");
                report.Write("\t\t(a) Number Of Cycles (J) = " + J);
                report.Write("\t\t(b) Sequence Length (n)  = " + n);
            }

            double[] p_values = new double[18];
            int constraint = (int)Math.Max(0.005 * Math.Pow(n, 0.5), 500);
            if (J < constraint) {
                if (printResults) {
                    report.Write("\t\tWARNING:  TEST NOT APPLICABLE.  THERE ARE AN");
                    report.Write("\t\t\t  INSUFFICIENT NUMBER OF CYCLES.");
                    report.Write("\t\t---------------------------------------------");
                }
                for (int i = 0; i < 18; i++) {
                    report.Write(0.0.ToString());
                }
            } else {
                for (int p = 0; p < 18; p++) {
                    int x = stateX[p];
                    int count = 0;
                    //count occurences of state x
                    for (int i = 0; i < n; i++) {
                        if (S[i] == x) {
                            count++;
                        }
                    }
                    //compute p_value
                    p_values[p] = Cephes.erfc(Math.Abs(count - J) / (Math.Sqrt(2.0 * J * (4.0 * Math.Abs(x) - 2))));

                    if (printResults) {
                        if (p_values[p] < 0 || p_values[p] > 1) {
                            report.Write("\t\t(b) WARNING: P_VALUE IS OUT OF RANGE.");
                        }
                        report.Write(p_values[p] < ALPHA ? "FAILURE" : "SUCCESS" + "\t\t");
                        report.Write("(x = " + x + ") Total visits = " + count + "; p-value = " + p_values[p]);
                        report.Write(p_values[p].ToString());
                    }
                }
            }
            if (printResults) {
                model.reports.Add(report.title, report);
            }
            return p_values;
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {
	
	        int r = 0;
	        double[] apEn = new double[2];
	        for ( int blockSize=m; blockSize<=m+1; blockSize++ ) {
		        if ( blockSize == 0 ) {
			        apEn[0] = 0;
			        r++;
		        }
		        else {

                    int[] P = new int[(int)Math.Pow(2, blockSize+1)-1];

                    for (int i = 1; i < Math.Pow(2, blockSize + 1) - 1; i++) {
                        P[i] = 0;
                    }
                    //calculate frequency of n overlapping blocks
                    for (int i = 0; i < n; i++) {
                        int k = 1;
                        for (int j = 0; j < blockSize; j++) {
                            k *= 2;
                            if ((int)model.epsilon[(i + j) % n] == 1) {
                                k++;
                            }
                        }
                        P[k - 1]++;
                    }
                    //calculate approximate entropy entry from frequency
			        double sum = 0;
			        int index = (int)Math.Pow(2, blockSize)-1;
			        for ( int i=0; i<(int)Math.Pow(2, blockSize); i++ ) {
                        if (P[index] > 0) {
                            sum += P[index] * Math.Log(P[index] / (double)n);
                        }
				        index++;
			        }
			        apEn[r] = sum / n;
			        r++;
		        }
	        }
	        double approximateEntropy = apEn[0] - apEn[1];
	
            //calculate p_value
	        double chi_squared = 2.0*n*(Math.Log(2) - approximateEntropy);
	        double p_value = Cephes.igamc(Math.Pow(2, m-1), chi_squared/2.0);

            if (printResults) {
                Report report = new Report("12: Approximate Entropy Test");
                report.Write("\t\t\tAPPROXIMATE ENTROPY TEST");
                report.Write("\t\t--------------------------------------------");
                report.Write("\t\tCOMPUTATIONAL INFORMATION:");
                report.Write("\t\t--------------------------------------------");
                report.Write("\t\t(a) m (block length)    = "+ m);
                report.Write("\t\t(b) n (sequence length) = " + n);
                report.Write("\t\t(c) Chi^2               = " + chi_squared);
                report.Write("\t\t(d) Phi(m)	          = " + apEn[0]);
                report.Write("\t\t(e) Phi(m+1)	          = " + apEn[1]);
                report.Write("\t\t(f) ApEn                = " + approximateEntropy);
                report.Write("\t\t--------------------------------------------");
                if (m > (int)(Math.Log(n) / Math.Log(2) - 5)) {
                    report.Write("\t\tNote: The blockSize = "+m+" exceeds recommended value of "+
                        Math.Max(1, (int)(Math.Log(n) / Math.Log(2) - 5)));
                    report.Write("\t\tResults are inaccurate!");
                    report.Write("\t\t--------------------------------------------");
                }
                report.Write((p_value < ALPHA ? "FAILURE" : "SUCCESS")+"\t\tp_value = "+ p_value);
                model.reports.Add(report.title, report);
            }

            return new double[] { p_value };
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {

            double[] pi;
            int K, M, V0;
            init(out K, out M, out V0, out pi);  //initialize variables to sensible values

            int[] V = new int[pi.Length];
            int N = n / M;    //number of blocks that can be made from the binary string
            for (int i = 0; i < N; i++) {
                //count the longest run of ones in each block
                int longestRun = 0;
                int currentRun = 0;
                for (int j = 0; j < M; j++) {
                    if (model.epsilon[i * M + j] == 1) {
                        longestRun = Math.Max(longestRun, ++currentRun);
                    } else {
                        currentRun = 0;
                    }
                }
                //record the longest run of ones found in the correct counter
                if (longestRun < V0) {
                    V[0]++;
                } else if (longestRun > V0 + K) {
                    V[K]++;
                } else {
                    V[longestRun - V0]++;
                }
            }

            //calculate p_value
            double chi_squared = 0.0;
            for (int i = 0; i <= K; i++) {
                chi_squared += ((V[i] - N * pi[i]) * (V[i] - N * pi[i])) / (N * pi[i]);
            }
            double p_value = Cephes.igamc((double)(K / 2.0), chi_squared / 2.0);

            if (printResults) {
                Report report = new Report("4: Test for the Longest Run of Ones in a Block");
                report.Write("\t\t\t  LONGEST RUNS OF ONES TEST\n");
                report.Write("\t\t---------------------------------------------\n");
                report.Write("\t\tCOMPUTATIONAL INFORMATION:\n");
                report.Write("\t\t---------------------------------------------\n");
                report.Write("\t\t(a) N (# of substrings)  = "+ N);
                report.Write("\t\t(b) M (Substring Length) = " + M);
                report.Write("\t\t(c) Chi^2                = " + chi_squared);
                report.Write("\t\t---------------------------------------------\n");
                report.Write("\t\t      F R E Q U E N C Y\n");
                report.Write("\t\t---------------------------------------------\n");
                if (K == 3) {
                    report.Write("\t\t  <=1     2     3    >=4   P-value  Assignment");
                    report.Write("\t\t "+V[0]+" "+V[1]+" "+V[2]+" "+V[3]);
                } else if (K == 5) {
                    report.Write("\t\t<=4  5  6  7  8  >=9 P-value  Assignment");
                    report.Write("\t\t "+V[0]+" "+V[1]+" "+V[2]+" "+V[3]+" "+V[4]+" "+V[5]);
                } else {
                    report.Write("\t\t<=10  11  12  13  14  15 >=16 P-value  Assignment");
                    report.Write("\t\t "+V[0]+" "+V[1]+" "+V[2]+" "+V[3]+" "+V[4]+" "+V[5]+" "+V[6]);
                }
                if (p_value < 0 || p_value > 1) {
                    report.Write("WARNING:  P_VALUE IS OUT OF RANGE.\n");
                }
                report.Write(p_value < ALPHA ? "FAILURE" : "SUCCESS"+"{0}\t\tp_value = "+ p_value);
                model.reports.Add(report.title, report);
            }

            return new double[] { p_value };
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {
	        
            double[] pi = new double[6];
            double lambda = (double)(M - B.Length + 1) / Math.Pow(2, B.Length);
            double eta = lambda / 2.0;
            double total = 0.0;
            for (int i = 0; i < K; i++) { //compute prior probabilities
                pi[i] = probability(i, eta);
                total += pi[i];
            }
            pi[K] = 1 - total;

            int[] v = new int[K+1];
            for (int i = 0; i < N; i++) {   //search for a match of the template in each block
                int count = 0;
                for (int j = 0; j < M - B.Length + 1; j++) {
                    bool match = true;
                    for (int k = 0; k < B.Length; k++) {
                        if (B[k] != model.epsilon[i * M + j + k]) {
                            match = false;
                        }
                    }
                    if (match) {
                        count++;
                    }
                }
                if (count < K) {   //record the matches found
                    v[count]++;
                } else {
                    v[K]++;
                }
            }

            //compute p_value
	        double sum = 0.0;
	        double chiSquared = 0.0;
            for (int i = 0; i < K + 1; i++) {
                chiSquared += Math.Pow((double)v[i] - (double)N * pi[i], 2) / ((double)N * pi[i]);
                sum += v[i];
            }

            double p_value = Cephes.igamc(5.0 / 2.0, chiSquared / 2.0);

            if (printResults) {
                Report report = new Report("8: Overlapping Template Matching Test");
                report.Write("\t\t    OVERLAPPING TEMPLATE OF ALL ONES TEST");
                report.Write("\t\t-----------------------------------------------");
                report.Write("\t\tCOMPUTATIONAL INFORMATION:");
                report.Write("\t\t-----------------------------------------------");
                report.Write("\t\t(a) n (sequence_length)      = " + n);
                report.Write("\t\t(b) m (block length of 1s)   = " + B.Length);
                report.Write("\t\t(c) M (length of substring)  = " + M);
                report.Write("\t\t(d) N (number of substrings) = " + N);
                report.Write("\t\t(e) lambda [(M-m+1)/2^m]     = " + lambda);
                report.Write("\t\t(f) eta                      = " + eta);
                report.Write("\t\t(g) Chi^2                    = " + chiSquared);
                report.Write("\t\t(h) P-value                  = " + p_value);
                report.Write("\t\t-----------------------------------------------");
                report.Write("\t\t   F R E Q U E N C Y");
                report.Write("\t\t", false);
                for (int i = 0; i < K; i++) {
                    report.Write("   " + i + " ");
                }
                report.Write("  >=" + K);
                report.Write("\t\t-----------------------------------------------");
                report.Write("\t\t", false);
                for (int i = 0; i < K + 1; i++) {
                    report.Write(" " + v[i] + " ");
                }
                if (p_value < 0 || p_value > 1) { 
                    report.Write("WARNING:  P_VALUE IS OUT OF RANGE.");
                }
                report.Write(p_value+" "+(p_value < ALPHA ? "FAILURE" : "SUCCESS"));
                model.reports.Add(report.title, report);
            }

            return new double[] { p_value };
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public unsafe override double[] run(bool printResults) {
            
            double[] X = new double[n];
            

            for (int i = 0; i < n; i++) {
                X[i] = 2 * (int)model.epsilon[i] - 1; //map all bits in binary string (0->-1,1->1)
            }
            double[] m = new double[n / 2 + 1];
            //generate DFT of the binary string, using the unsafe functions implemented in C
            fixed (double* wsavePtr = &(new double[2 * n])[0]) {
                fixed (int* ifacPtr = &(new int[15])[0]) {
                    fixed (double* mPtr = &m[0]) {
                        fixed (double* XPtr = &X[0]) {
                            FFT.__ogg_fdrffti(n, wsavePtr, ifacPtr);		//init stage for work arrays
                            FFT.__ogg_fdrfftf(n, XPtr, wsavePtr, ifacPtr);  //apply FFT on data
                        }
                    }
                }
            }

            //get magnitude of the DFT produced (to convert complex domain to real domain)
            m[0] = Math.Sqrt(X[0] * X[0]);
            for (int i = 0; i < n / 2; i++) {
                if (2 * i + 2 >= X.Length) {
                    m[i + 1] = Math.Sqrt(Math.Pow(X[2 * i + 1], 2));
                } else {
                    m[i + 1] = Math.Sqrt(Math.Pow(X[2 * i + 1], 2) + Math.Pow(X[2 * i + 2], 2));
                }
            }

	        int N_l = 0;
	        double T = Math.Sqrt(2.995732274*n); //calculate upper bound (T) (the 95% peak height threshold)

            for (int i = 0; i < n / 2; i++) {
                if (m[i] < T) {
                    N_l++;    //count observed number of peaks in |DFT| greater than T
                }
            }
            double N_0 = 0.95 * n / 2.0; //expected number of peaks
            double d = (N_l - N_0) / Math.Sqrt(n / 4.0 * 0.95 * 0.05);

            //calculate p_value
            double p_value = Cephes.erfc(Math.Abs(d) / Math.Sqrt(2.0));

            if (printResults) {
                Report report = new Report("6: Discrete Fourier Transform (Sprectral) Test");
                report.Write("\t\t\t\tFFT TEST");
                report.Write("\t\t-------------------------------------------");
                report.Write("\t\tCOMPUTATIONAL INFORMATION:");
                report.Write("\t\t-------------------------------------------");
                report.Write("\t\t(-) Upper Bound= " + T);
                report.Write("\t\t(b) N_l        = " + N_l);
                report.Write("\t\t(c) N_o        = " + N_0);
                report.Write("\t\t(d) d          = " + d);
                report.Write("\t\t-------------------------------------------");

                report.Write(p_value < ALPHA ? "FAILURE" : "SUCCESS" + "\t\tp_value = " + p_value);
                model.reports.Add(report.title, report);
            }
            return new double[] { p_value };
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {

            double[] Pm = new double[3];
	        int r = Math.Min(M, Q);		//compute predicted probabilities
		    double product = 1;
            for (int i = 0; i <= r - 1; i++) {
                product *= ((1.0 - Math.Pow(2, i - Q)) * (1.0 - Math.Pow(2, i - M))) / (1.0 - Math.Pow(2, i - r));
            }
            Pm[0] = Math.Pow(2, r * (M + Q - r) - M * Q) * product;
            r--;
		    product = 1;
            for (int i = 0; i <= r - 1; i++) {
                product *= ((1.0 - Math.Pow(2, i - Q)) * (1.0 - Math.Pow(2, i - M))) / (1.0 - Math.Pow(2, i - r));
            }
            Pm[1] = Math.Pow(2, r * (M + Q - r) - M * Q) * product;
            Pm[2] = 1 - (Pm[0] + Pm[1]);

            int N = n / (M * Q); //number of blocks
            int[] Fm = new int[3];
            for (int k = 0; k < N; k++) {
                //construct the matrix of MxQ in size
                int[,] matrix = new int[M, Q];
                for (int i = 0; i < M; i++) {
                    for (int j = 0; j < Q; j++) {
                        matrix[i,j] = model.epsilon[k * (M * Q) + j + i * M];
                    }
                }

                int R = computeRank(M, Q, matrix); //get the rank of the matrix

                if (R == M) {
                    Fm[0]++;	//full rank
                } else if (R == M - 1) {
                    Fm[1]++;    //full rank - 1
                }
            }
            Fm[2] = N - (Fm[0] + Fm[1]); //full rank - 2

            //compute p_value
            double chi_squared = (Math.Pow(Fm[0] - N * Pm[0], 2) / (double)(N * Pm[0]) +
                                  Math.Pow(Fm[1] - N * Pm[1], 2) / (double)(N * Pm[1]) +
                                  Math.Pow(Fm[2] - N * Pm[2], 2) / (double)(N * Pm[2]));
            double p_value = Cephes.igamc(1, chi_squared / 2.0);

            if (printResults) {
                Report report = new Report("2.5 Binary Matrix Rank Test");
                report.Write("\t\t\t\tRANK TEST");
                report.Write("\t\t---------------------------------------------");
                report.Write("\t\tCOMPUTATIONAL INFORMATION:");
                report.Write("\t\t---------------------------------------------");
                report.Write("\t\t(a) Probability P_"+M+" = " + Pm[0]);
                report.Write("\t\t(b)             P_"+(M - 1)+" = " + Pm[1]);
                report.Write("\t\t(c)             P_"+(M - 2)+" = " + Pm[2]);
                report.Write("\t\t(d) Frequency   F_"+M+" = " + Fm[0]);
                report.Write("\t\t(e)             F_"+(M - 1)+" = "+ Fm[1]);
                report.Write("\t\t(f)             F_"+(M - 2)+" = " + Fm[2]);
                report.Write("\t\t(g) # of matrices    = " + N);
                report.Write("\t\t(h) Chi^2            = "+chi_squared);
                report.Write("\t\t(i) NOTE: "+n % (M * Q)+" BITS WERE DISCARDED.");
                report.Write("\t\t---------------------------------------------");
                report.Write(p_value < ALPHA ? "FAILURE" : "SUCCESS"+"\t\tp_value = "+p_value);
                if (p_value < 0 || p_value > 1) {
                    report.Write("WARNING:  P_VALUE IS OUT OF RANGE.");
                }
                model.reports.Add(report.title, report);
            }

            return new double[] { p_value };
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {

	        double[] expected_value = { 0, 0, 0, 0, 0, 0, 5.2177052, 6.1962507, 7.1836656,
				                        8.1764248, 9.1723243, 10.170032, 11.168765,
				                        12.168070, 13.167693, 14.167488, 15.167379 };
	        double[] variance = { 0, 0, 0, 0, 0, 0, 2.954, 3.125, 3.238, 3.311, 3.356, 3.384,
				                  3.401, 3.410, 3.416, 3.419, 3.421 };
	        
	        int K = (int) (n/L - (double)Q); //number of test blocks
	
	        int p = (int)Math.Pow(2, L);
	        long[] T = new long[p];

            //initialization segment
            for (int i = 1; i <= Q; i++) {
                long decValue = 0;
                for (int j = 0; j < L; j++) {
                    decValue += model.epsilon[(i - 1) * L + j] * (long)Math.Pow(2, L - 1 - j);  //calculate decimal value of segment
                }
                T[decValue] = i;
            }

            //test segment
            double sum = 0;
	        for ( int i=Q+1; i<=Q+K; i++ ) {
		        long decValue = 0;
                for (int j = 0; j < L; j++) {
                    decValue += model.epsilon[(i - 1) * L + j] * (long)Math.Pow(2, L - 1 - j);  //calculate decimal value of segment
                }
		        sum += Math.Log(i - T[decValue])/Math.Log(2);
		        T[decValue] = i;
	        }
            double phi = (double)(sum / (double)K);

            //forumla from 2.9.4(5)
            double c = 0.7 - 0.8 / (double)L + (4 + 32 / (double)L) * Math.Pow(K, -3 / (double)L) / 15;
            double sigma = c * Math.Sqrt(variance[L] / (double)K);

            //calculate p_value
	        double arg = Math.Abs(phi-expected_value[L])/(Math.Sqrt(2) * sigma);
	        double p_value = Cephes.erfc(arg);
            
            if (printResults) {
                Report report = new Report("9: Maurer’s “Universal Statistical” Test");
                report.Write("\t\tUNIVERSAL STATISTICAL TEST");
                report.Write("\t\t--------------------------------------------");
                report.Write("\t\tCOMPUTATIONAL INFORMATION:");
                report.Write("\t\t--------------------------------------------");
                report.Write("\t\t(a) L         = "+ L);
                report.Write("\t\t(b) Q         = " + Q);
                report.Write("\t\t(c) K         = " + K);
                report.Write("\t\t(d) sum       = " + sum);
                report.Write("\t\t(f) variance  = " + variance[L]);
                report.Write("\t\t(g) exp_value = " + expected_value[L]);
                report.Write("\t\t(h) phi       = " + phi);
                report.Write("\t\t(i) WARNING:  "+(n - (Q + K) * L)+" bits were discarded.");
                report.Write("\t\t-----------------------------------------");
                if (p_value < 0 || p_value > 1) {
                    report.Write("\t\tWARNING:  P_VALUE IS OUT OF RANGE");
                }
                report.Write((p_value < ALPHA ? "FAILURE" : "SUCCESS")+"\t\tp_value = "+p_value);
                model.reports.Add(report.title, report);
            }

            return new double[] { p_value };
        }
        /// <summary>
        /// Runs the test
        /// </summary>
        /// <param name="printResults">If true text output will be added to a log, otherwise not</param>
        /// <returns>The p_value(s) of the test based upon the input data</returns>
        public override double[] run(bool printResults) {
            int S = 0;
            int sup = 0;
            int inf = 0;
            int z = 0;
            
            for (int k = 0; k < n; k++) {
                //calculate the partial sum
                if (model.epsilon[k] == 1) {
                    S++;
                } else {
                    S--;
                }
                if (S > sup) {
                    sup++;
                }
                if (S < inf) {
                    inf--;
                }
                //compute the test statistic
                if (mode) {
                    z = (sup > -inf) ? sup : -inf;
                } else {
                    z = (sup - S > S - inf) ? sup - S : S - inf;
                }
            }

            //compute p_value
            double sum1 = 0.0;
            for (int k = (-n / z + 1) / 4; k <= (n / z - 1) / 4; k++) {
                sum1 += Cephes.normal(((4 * k + 1) * z) / Math.Sqrt(n));
                sum1 -= Cephes.normal(((4 * k - 1) * z) / Math.Sqrt(n));
            }
            double sum2 = 0.0;
            for (int k = (-n / z - 3) / 4; k <= (n / z - 1) / 4; k++) {
                sum2 += Cephes.normal(((4 * k + 3) * z) / Math.Sqrt(n));
                sum2 -= Cephes.normal(((4 * k + 1) * z) / Math.Sqrt(n));
            }
            double p_value = 1.0 - sum1 + sum2;

            if (printResults) {
                Report report = new Report("13: Cumulative Sums (Cusum) Test");
                report.Write("\t\t      CUMULATIVE SUMS (" + (mode ? "FORWARD" : "REVERSE") + ") TEST");
                report.Write("\t\t-------------------------------------------");
                report.Write("\t\tCOMPUTATIONAL INFORMATION:");
                report.Write("\t\t-------------------------------------------");
                report.Write("\t\t(a) The maximum partial sum = "+ z);
                report.Write("\t\t-------------------------------------------");

                if (p_value < 0 || p_value > 1) {
                    report.Write("\t\tWARNING:  P_VALUE IS OUT OF RANGE");
                }

                report.Write((p_value < ALPHA ? "FAILURE" : "SUCCESS")+"\t\tp_value = "+p_value);
                model.reports.Add(report.title, report);
            }

            return new double[] { p_value };
        }
 /// <summary>
 /// Method for running tests selected in the view
 /// </summary>
 /// <remarks>
 /// Gets data from the view object, such as file for binary string file, and which tests to run with which data
 /// </remarks>
 internal void runTests() {
     Model model = new Model(Util.str2ints(Util.loadData(view.getFilePath()), view.getSplitStr()));
     List<Test> tests = new List<Test>();
     if (view.performFrequencyTest()) {
         tests.Add(new Frequency(view.getFrequency_n(), ref model));
     }
     if (view.performBlockFrequencyTest()) {
         tests.Add(new BlockFrequency(view.getBlockFrequency_M(), view.getBlockFrequency_n(), ref model));
     }
     if (view.performRunsTest()) {
         tests.Add(new Runs(view.getRuns_n(), ref model));
     }
     if (view.performLongestRunOfOnesTest()) {
         tests.Add(new LongestRunOfOnes(view.getLongestRunOfOnes_n(), ref model));
     }
     if (view.performMatrixRankTest()) {
         tests.Add(new Rank(view.getMatrixRank_n(), ref model));
     }
     if (view.performDiscreteFourierTransformTest()) {
         tests.Add(new DiscreteFourierTransform(view.getDiscreteFourierTransform_n(), ref model));
     }
     if (view.performNonOverlappingTemplateMatchingTest()) {
         if (view.performSingleNonOverlappingTemplateMatchingTest()) {
             tests.Add(new NonOverlappingTemplateMatching(view.getNonOverlappingTemplateMatching_B(), view.getNonOverlappingTemplateMatching_n(), ref model));
         } else {
             tests.Add(new NonOverlappingTemplateMatching(view.getNonOverlappingTemplateMatching_m(), view.getNonOverlappingTemplateMatching_n(), ref model));
         }
     }
     if (view.performOverlappingTemplateMatchingTest()) {
         tests.Add(new OverlappingTemplateMatching(view.getOverlappingTemplateMatching_B(), view.getOverlappingTemplateMatching_n(), ref model));
     }
     if (view.performUniversalTest()) {
         if (view.performCustomUniversalTest()) {
             tests.Add(new Universal(view.getUniversal_L(), view.getUniversal_Q(), view.getUniversal_n(), ref model));
         } else {
             tests.Add(new Universal(view.getUniversal_n(), ref model));
         }
     }
     if (view.performLinearComplexityTest()) {
         tests.Add(new LinearComplexity(view.getLinearComplexity_M(), view.getLinearComplexity_n(), ref model));
     }
     if (view.performSerialTest()) {
         tests.Add(new Serial(view.getSerial_m(), view.getSerial_n(), ref model));
     }
     if (view.performApproximateEntropyTest()) {
         tests.Add(new ApproximateEntropy(view.getApproximateEntropy_m(), view.getApproximateEntropy_n(), ref model));
     }
     if (view.performCumulativeSumsTest()) {
         tests.Add(new CumulativeSums(view.performForwardCumulativeSumsTest(), view.getCumulativeSums_n(), ref model));
     }
     if (view.performRandomExcursionsTest()) {
         tests.Add(new RandomExcursions(view.getRandomExcursions_n(), ref model));
     }
     if (view.performRandomExcursionsVariantTest()) {
         tests.Add(new RandomExcursionsVariant(view.getRandomExcursionsVariant_n(), ref model));
     }
     view.showProgressBar();
     view.updateProgressBar(10);
     Report full = new Report("All Tests");
     foreach (Test t in tests) {
         t.run(true);
         view.updateProgressBar(90 / tests.Count);
         full.Write(model.reports.Last().Value.body);
     }
     model.reports.Add(full.title, full);
     new ReportsForm(model.reports).Show();
     view.hideProgressBar();
 }