Merge branch 'master' into master

.settings/org.eclipse.core.resources.prefs

@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+encoding//java/src/main/java/io/nayuki/qrcodegen/QrCodeGeneratorDemo.java=UTF-8

java/src/main/java/io/nayuki/qrcodegen/Ecc.java

@@ -58,4 +58,4 @@ public class Ecc {
 	public static Ecc[] values() {
 		return new Ecc[] { LOW, MEDIUM, QUARTILE, HIGH };
 	}
-}
+}

java/src/main/java/io/nayuki/qrcodegen/KanjiMode.java

@@ -20,4 +20,5 @@ public class KanjiMode extends QrMode {
 	public QrSegment making(String str) {
 		return QrSegmentAdvanced.makeKanji(str);
 	}
-}
+  
+}

java/src/main/java/io/nayuki/qrcodegen/MakeAlphaNumericToSegment.java

@@ -31,4 +31,4 @@ public class MakeAlphaNumericToSegment implements MakeSegment {
 		if (i < text.length())  // 1 character remaining
 			bitBuffer.appendBits(QrSegment.ALPHANUMERIC_CHARSET.indexOf(text.charAt(i)), 6);
 	}
-}
+}

java/src/main/java/io/nayuki/qrcodegen/MakeBytesToSegment.java

@@ -34,3 +34,4 @@ public class MakeBytesToSegment  implements MakeSegment {
 		bitBuffer.appendBits(bits & 0xFF, 8);
 	}
 }
+

java/src/main/java/io/nayuki/qrcodegen/MakeNumericToSegment.java

@@ -30,4 +30,4 @@ public class MakeNumericToSegment  implements MakeSegment {
 	public static boolean containNonNumericCharaters(String digits) {
 		return !QrSegment.NUMERIC_REGEX.matcher(digits).matches();
 	}
-}
+}

java/src/main/java/io/nayuki/qrcodegen/MakeSegment.java

@@ -1,4 +1,4 @@
 
 public interface MakeSegment {
 	public QrSegment excute(String text);
-}
+}

java/src/main/java/io/nayuki/qrcodegen/MakeSegmentFactory.java

@@ -12,4 +12,4 @@ public class MakeSegmentFactory {
 		
 		return makeSegment;
 	}
-}
+}

java/src/main/java/io/nayuki/qrcodegen/QrCodeTestEncodeSegments.java

@@ -0,0 +1,86 @@
+
+package io.nayuki.qrcodegen;
+
+import static org.junit.Assert.*;
+
+import java.util.List;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+
+public class QrCodeTestEncodeSegments {
+	private static List<QrSegment> qrSegments;
+
+	@BeforeClass
+	public static void oneTimeSetUp() {
+		qrSegments = QrSegment.makeSegments("Hello, World!");
+	}
+	
+	/**
+	 * Purpose: Make QrCode
+	 * Input:  QrSegment.makeSegments("Hello, World!"), Ecc.LOW, 10, 20, 3, true
+	 * Expected:
+	 * 			QrCode made without Exception
+	 */
+	@Test
+	public void testInRange() {
+		assertNotNull(QrCode.encodeSegments(qrSegments, Ecc.LOW, 10, 20, 3, true));
+	}
+	
+	/**
+	 * Purpose: Try to make QrCode with a invalid argument(0 is less than minimal value in valid version range)
+	 * Input:  QrSegment.makeSegments("Hello, World!"), Ecc.LOW, 0, QrCode.MAX_VERSION, 3, true
+	 * Expected:
+	 * 			throw IllegalArgumentException
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void testMinVersionOverLeftBoundary() {
+		QrCode.encodeSegments(qrSegments, Ecc.LOW, 0, QrCode.MAX_VERSION, 3, true);
+	}
+	
+	/**
+	 * Purpose: Try to make QrCode with a invalid argument(41 is greater than maximal value in valid version range)
+	 * Input:  QrSegment.makeSegments("Hello, World!"), Ecc.LOW, QrCode.MIN_VERSION, 41, 3, true
+	 * Expected:
+	 * 			throw IllegalArgumentException
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void testMaxVersionOverRightBoundary() {
+		QrCode.encodeSegments(qrSegments, Ecc.LOW, QrCode.MIN_VERSION, 41, 3, true);
+	}
+	
+	/**
+	 * Purpose: Try to make QrCode with a invalid argument(minimal version input must be small or equal than maximal version input)
+	 * Input:  QrSegment.makeSegments("Hello, World!"), Ecc.LOW, QrCode.MAX_VERSION, QrCode.MIN_VERSION, 3, true
+	 * Expected:
+	 * 			throw IllegalArgumentException
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void testMinVersionGreaterThanMaxVersion() {
+		QrCode.encodeSegments(qrSegments, Ecc.LOW, QrCode.MAX_VERSION, QrCode.MIN_VERSION, 3, true);
+	}
+	
+	/**
+	 * Purpose: Try to make QrCode with a invalid argument(mask must be -1 or greater than -1)
+	 * Input:  QrSegment.makeSegments("Hello, World!"), Ecc.LOW, QrCode.MIN_VERSION, QrCode.MAX_VERSION, -2, true
+	 * Expected:
+	 * 			throw IllegalArgumentException
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void testMaskOverLeftBoundary() {
+		QrCode.encodeSegments(qrSegments, Ecc.LOW, QrCode.MIN_VERSION, QrCode.MAX_VERSION, -2, true);
+	}
+	
+	/**
+	 * Purpose: Try to make QrCode with a invalid argument(mask must be 7 or less than 7)
+	 * Input:  QrSegment.makeSegments("Hello, World!"), Ecc.HIGH, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 8, true
+	 * Expected:
+	 * 			throw IllegalArgumentException
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void testMaksOverRightBoundary() {
+		QrCode.encodeSegments(qrSegments, Ecc.HIGH, QrCode.MIN_VERSION, QrCode.MAX_VERSION, 8, true);
+	}
+
+}

java/src/main/java/io/nayuki/qrcodegen/QrSegment.java

@@ -29,6 +29,8 @@ import java.util.List;
 import java.util.Objects;
 import java.util.regex.Pattern;
 
+import QrSegment.Mode;
+
 
 
 /**

java/src/main/java/io/nayuki/qrcodegen/QrSegmentAdvanced.java

@@ -98,12 +98,12 @@ public final class QrSegmentAdvanced {
 	}
 
 
-	private static boolean is_valid_version(int minVersion, int version) {
+	public static boolean is_valid_version(int minVersion, int version) {
 		return version == minVersion || version == 10 || version == 27;
 	}
 
 
-	private static boolean not_Valid_Version(int minVersion, int maxVersion) {
+	public static boolean not_Valid_Version(int minVersion, int maxVersion) {
 		return !(QrCode.MIN_VERSION <= minVersion && minVersion <= maxVersion && maxVersion <= QrCode.MAX_VERSION);
 	}
 	
@@ -217,12 +217,12 @@ public final class QrSegmentAdvanced {
 	}
 
 
-	private static boolean is_numeric(int convertedPoint) {
+	public static boolean is_numeric(int convertedPoint) {
 		return '0' <= convertedPoint && convertedPoint <= '9';
 	}
 
 
-	private static boolean is_alphanumeric(int convertedPoint) {
+	public static boolean is_alphanumeric(int convertedPoint) {
 		return QrSegment.ALPHANUMERIC_CHARSET.indexOf(convertedPoint) != -1;
 	}
 	

java/src/main/java/io/nayuki/qrcodegen/testQrSegmentAdvanced.java

@@ -0,0 +1,117 @@
+package io.nayuki.qrcodegen;
+import static org.junit.Assert.*;
+
+import java.util.EmptyStackException;
+
+import org.junit.Test;
+
+public class testQrSegmentAdvanced {
+	private QrSegmentAdvanced testing;
+	private String overString = "asdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasd"
+			+ "asdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasd"
+			+ "asdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasd"
+			+ "asdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasd"
+			+ "asdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasd";
+	
+	private static int min_version = QrCode.MIN_VERSION;
+	private static int max_version = QrCode.MAX_VERSION;
+	
+	private String nullstring = "";
+	
+	/**
+	*Purpose: Testing when user insert over text length
+	*Input: overString, Ecc.LOW, minversion = 1, maxversion = 40
+	*Expected:
+	*	Return throw
+	*/
+	@Test(expected=DataTooLongException.class)
+	public void makeSegmentsOptimallyThrowtest() {
+		testing.makeSegmentsOptimally(overString, Ecc.LOW, 1, 40);
+	}
+	
+	/**
+	*Purpose: Using MCDC, Testing version set correctly.
+	*Input: nin_version, 1, 10, 27, 0
+	*Expected:
+	*	All True
+	 */
+
+	@Test
+	public void is_valid_Test() {
+		assertEquals(QrSegmentAdvanced.is_valid_version(min_version, 1),true);
+		assertEquals(QrSegmentAdvanced.is_valid_version(min_version, 10),true);
+		assertEquals(QrSegmentAdvanced.is_valid_version(min_version, 27),true);
+		assertNotEquals(QrSegmentAdvanced.is_valid_version(min_version, 0),true);
+	}
+
+	/**
+	*Purpose: Using MCDC, Testing version set correctly.
+	*Input: 1, 40, 41, 0, 3, 4
+	*Expected:
+	*	Over range factor has return 0, So, not equal to 1
+	*	Unless it has correct range in version's range, if you insert min_version is bigger that max_version, it return 0;
+	 */
+	
+	@Test
+	public void not_Valid_Version_test() { 
+		assertEquals(QrSegmentAdvanced.not_Valid_Version(1, 40), false);
+		assertNotEquals(QrSegmentAdvanced.not_Valid_Version(1, 41), false);
+		assertNotEquals(QrSegmentAdvanced.not_Valid_Version(0, 40), false);
+		assertNotEquals(QrSegmentAdvanced.not_Valid_Version(5, 4), false);
+	}	
+
+	/**
+	*Purpose: This program checking whether its String is empty. SO, i test it working correctly
+	*Input: 1, nullstring, Ecc.Low, 1, 40
+	*Expected:
+	*	occur AssertError
+	 */	
+	@Test(expected = AssertionError.class)
+	public void emptyString_test() {
+		testing.makeSegmentsOptimally(nullstring, Ecc.LOW, 1, 40);
+	}
+
+	/**
+	*Purpose: This program has several mode and making these. When making these mode, find suitable mode using flag. So, i test this functions.
+	*		  is_numeric -> 0 ~ 9 's UTF-8 number, is_alphanumeric -> "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:" stinrg set,  
+	*Input: "0123456780", "A", "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:"
+	*Expected:
+	*	All is correct
+	 */	
+	@Test
+	public void is_Corredt_Mode_test() {
+		int[] correctStr = "09".codePoints().toArray();
+		for (int forcnt : correctStr){
+			assertEquals(QrSegmentAdvanced.is_numeric(forcnt), true);
+		}
+		int[] wrongStr = "a".codePoints().toArray();
+		for (int forcnt : wrongStr){
+			assertEquals(QrSegmentAdvanced.is_numeric(forcnt), false);
+		}
+		
+		correctStr = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:".codePoints().toArray();
+		for (int forcnt : correctStr){
+			assertEquals(QrSegmentAdvanced.is_alphanumeric(forcnt), true);
+		}
+		
+		wrongStr = "\\".codePoints().toArray();
+		for (int forcnt : wrongStr){
+			assertEquals(QrSegmentAdvanced.is_alphanumeric(forcnt), false);
+		}
+	}
+	
+	/**
+	*Purpose: 'toCodePoints' function is convert String to integer, if String is in UTF-8. 
+	*		  In UTF-8 has variable character why I haven't check all UTF-8's string. 
+	*		  So, I just test character that are excluded at UTF-8.  
+	*		  For checking exception occurs when a character other than UTF-8 is entered.
+	*Input: "A<>"
+	*Expected:
+	*	occur IllegalArgumentException
+	 */	
+	@Test(expected = IllegalArgumentException.class)
+	public void toCodePoints_test() {
+		String not_UTF = "A<>";
+		testing.makeSegmentsOptimally(not_UTF, Ecc.LOW, 1, 40);
+	}
+}