DecompositionTest.java

import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;

public class DecompositionTest extends Assert {
 private static String readFile(String path) throws IOException {
 byte[] encoded = Files.readAllBytes(Paths.get(path));
 return new String(encoded, Charset.forName("UTF-8")).trim();
 }

 @Test
 public void test1() {
 Decomposition t = new Decomposition(1);
 assertEquals(1, t.N);
 // Заменяю System.out на свой объект, который будет печатать в строчку
 ByteArrayOutputStream os = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os));
 t.gen();
 assertEquals(String.format("1 = 1%n"), os.toString());
 }

 @Test
 public void test2() {
 Decomposition t = new Decomposition(2);
 assertEquals(2, t.N);
 // Заменяю System.out на свой объект, который будет печатать в строчку
 ByteArrayOutputStream os = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os));
 t.gen();
 assertEquals(String.format("2 = 2%n2 = 1 + 1%n"), os.toString());
 }

 @Test
 public void testPrint() {
 Decomposition t = new Decomposition(2);
 // Заменяю System.out на свой объект, который будет печатать в строчку
 ByteArrayOutputStream os = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os));
 int[] A = {1, 1};
 t.print(A, A.length);
 assertEquals(String.format("2 = 1 + 1%n"), os.toString());
 }

 @Test
 public void test3() throws IOException {
 checkFile(3);
 }

 @Test
 public void test4() throws IOException {
 checkFile(4);
 }

 @Test
 public void test5() throws IOException {
 checkFile(5);
 }

 @Test
 public void test6() throws IOException {
 checkFile(6);
 }

 @Test
 public void test7() throws IOException {
 checkFile(7);
 }

 private void checkFile(int n) throws IOException {
 Decomposition t = new Decomposition(n);
 ByteArrayOutputStream os = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os));
 t.gen();
 assertEquals(readFile(String.format("%02d.a", n)), os.toString().trim());
 }

 @Test
 @Ignore // Тест производительности (слишком долгий)
 public void test40() {
 Decomposition t = new Decomposition(40);
 t.gen();
 }

 // Additional edge case tests for 100% coverage

 /**
 * Test constructor stores N and creates correct sized array
 */
 @Test
 public void testConstructorInitialization() {
 Decomposition t = new Decomposition(5);
 assertEquals(5, t.N);
 assertNotNull(t.A);
 assertEquals(5, t.A.length);
 }

 /**
 * Test print method with single element
 */
 @Test
 public void testPrintSingleElement() {
 Decomposition t = new Decomposition(3);
 ByteArrayOutputStream os = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os));
 int[] A = {3};
 t.print(A, 1);
 assertEquals(String.format("3 = 3%n"), os.toString());
 }

 /**
 * Test print method with three elements
 */
 @Test
 public void testPrintThreeElements() {
 Decomposition t = new Decomposition(4);
 ByteArrayOutputStream os = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os));
 int[] A = {2, 1, 1};
 t.print(A, 3);
 assertEquals(String.format("4 = 2 + 1 + 1%n"), os.toString());
 }

 /**
 * Test print method with all ones
 */
 @Test
 public void testPrintAllOnes() {
 Decomposition t = new Decomposition(4);
 ByteArrayOutputStream os = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os));
 int[] A = {1, 1, 1, 1};
 t.print(A, 4);
 assertEquals(String.format("4 = 1 + 1 + 1 + 1%n"), os.toString());
 }

 /**
 * Test that array is correctly sized for N
 */
 @Test
 public void testArraySize() {
 Decomposition t = new Decomposition(10);
 assertEquals(10, t.A.length);
 }

 /**
 * Test gen method generates correct number of decompositions for N=8
 */
 @Test
 public void test8() throws IOException {
 checkFile(8);
 }

 /**
 * Test gen method generates correct number of decompositions for N=9
 */
 @Test
 public void test9() throws IOException {
 checkFile(9);
 }

 /**
 * Test gen method generates correct number of decompositions for N=10
 */
 @Test
 public void test10() throws IOException {
 checkFile(10);
 }

 /**
 * Test multiple decomposition instances are independent
 */
 @Test
 public void testMultipleInstances() {
 Decomposition t1 = new Decomposition(3);
 Decomposition t2 = new Decomposition(4);

 assertEquals(3, t1.N);
 assertEquals(4, t2.N);
 assertNotSame(t1.A, t2.A);
 }

 /**
 * Test gen can be called multiple times
 */
 @Test
 public void testMultipleGenCalls() {
 Decomposition t = new Decomposition(2);

 ByteArrayOutputStream os1 = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os1));
 t.gen();
 String result1 = os1.toString();

 ByteArrayOutputStream os2 = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os2));
 t.gen();
 String result2 = os2.toString();

 assertEquals(result1, result2);
 }

 /**
 * Test decomposition contains all expected values
 */
 @Test
 public void testDecompositionContents3() {
 Decomposition t = new Decomposition(3);
 ByteArrayOutputStream os = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os));
 t.gen();

 String output = os.toString();
 assertTrue(output.contains("3 = 3"));
 assertTrue(output.contains("3 = 2 + 1"));
 assertTrue(output.contains("3 = 1 + 1 + 1"));
 }

 /**
 * Test that first decomposition is N itself
 */
 @Test
 public void testFirstDecomposition() {
 Decomposition t = new Decomposition(5);
 ByteArrayOutputStream os = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os));
 t.gen();

 String output = os.toString();
 assertTrue(output.startsWith(String.format("5 = 5%n")));
 }

 /**
 * Test that last decomposition is all ones
 */
 @Test
 public void testLastDecomposition() {
 Decomposition t = new Decomposition(4);
 ByteArrayOutputStream os = new ByteArrayOutputStream();
 System.setOut(new PrintStream(os));
 t.gen();

 String output = os.toString();
 assertTrue(output.endsWith(String.format("4 = 1 + 1 + 1 + 1%n")));
 }
}