[nikiroo-utils.git] / test_code / StringUtilsTest.java

package be.nikiroo.utils.test_code;

import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import be.nikiroo.utils.StringUtils;
import be.nikiroo.utils.StringUtils.Alignment;
import be.nikiroo.utils.test.TestCase;
import be.nikiroo.utils.test.TestLauncher;

class StringUtilsTest extends TestLauncher {
	public StringUtilsTest(String[] args) {
		super("StringUtils test", args);

		addTest(new TestCase("Time serialisation") {
			@Override
			public void test() throws Exception {
				for (long fullTime : new Long[] { 0l, 123456l, 123456000l,
						new Date().getTime() }) {
					// precise to the second, no more
					long time = (fullTime / 1000) * 1000;

					String displayTime = StringUtils.fromTime(time);
					assertNotNull("The stringified time for " + time
							+ " should not be null", displayTime);
					assertEquals("The stringified time for " + time
							+ " should not be empty", false, displayTime.trim()
							.isEmpty());

					assertEquals("The time " + time
							+ " should be loop-convertable", time,
							StringUtils.toTime(displayTime));

					assertEquals("The time " + displayTime
							+ " should be loop-convertable", displayTime,
							StringUtils.fromTime(StringUtils
									.toTime(displayTime)));
				}
			}
		});

		addTest(new TestCase("MD5") {
			@Override
			public void test() throws Exception {
				String mess = "The String we got is not what 'md5sum' said it should heve been";
				assertEquals(mess, "34ded48fcff4221d644be9a37e1cb1d9",
						StringUtils.getMd5Hash("fanfan la tulipe"));
				assertEquals(mess, "7691b0cb74ed0f94b4d8cd858abe1165",
						StringUtils.getMd5Hash("je te do-o-o-o-o-o-nne"));
			}
		});

		addTest(new TestCase("Padding") {
			@Override
			public void test() throws Exception {
				for (String data : new String[] { "fanfan", "la tulipe",
						"1234567890", "12345678901234567890", "1", "" }) {
					String result = StringUtils.padString(data, -1);
					assertEquals("A size of -1 is expected to produce a noop",
							true, data.equals(result));
					for (int size : new Integer[] { 0, 1, 5, 10, 40 }) {
						result = StringUtils.padString(data, size);
						assertEquals(
								"Padding a String at a certain size should give a String of the given size",
								size, result.length());
						assertEquals(
								"Padding a String should not change the content",
								true, data.trim().startsWith(result.trim()));

						result = StringUtils.padString(data, size, false, null);
						assertEquals(
								"Padding a String without cutting should not shorten the String",
								true, data.length() <= result.length());
						assertEquals(
								"Padding a String without cutting should keep the whole content",
								true, data.trim().equals(result.trim()));

						result = StringUtils.padString(data, size, false,
								Alignment.RIGHT);
						if (size > data.length()) {
							assertEquals(
									"Padding a String to the end should work as expected",
									true, result.endsWith(data));
						}

						result = StringUtils.padString(data, size, false,
								Alignment.JUSTIFY);
						if (size > data.length()) {
							String unspacedData = data.trim();
							String unspacedResult = result.trim();
							for (int i = 0; i < size; i++) {
								unspacedData = unspacedData.replace("  ", " ");
								unspacedResult = unspacedResult.replace("  ",
										" ");
							}

							assertEquals(
									"Justified text trimmed with all spaces collapsed "
											+ "sould be identical to original text "
											+ "trimmed with all spaces collapsed",
									unspacedData, unspacedResult);
						}

						result = StringUtils.padString(data, size, false,
								Alignment.CENTER);
						if (size > data.length()) {
							int before = 0;
							for (int i = 0; i < result.length()
									&& result.charAt(i) == ' '; i++) {
								before++;
							}

							int after = 0;
							for (int i = result.length() - 1; i >= 0
									&& result.charAt(i) == ' '; i--) {
								after++;
							}

							if (result.trim().isEmpty()) {
								after = before / 2;
								if (before > (2 * after)) {
									before = after + 1;
								} else {
									before = after;
								}
							}

							assertEquals(
									"Padding a String on center should work as expected",
									result.length(), before + data.length()
											+ after);
							assertEquals(
									"Padding a String on center should not uncenter the content",
									true, Math.abs(before - after) <= 1);
						}
					}
				}
			}
		});

		addTest(new TestCase("Justifying") {
			@Override
			public void test() throws Exception {
				Map<String, Map<Integer, Entry<Alignment, List<String>>>> source = new HashMap<String, Map<Integer, Entry<Alignment, List<String>>>>();
				addValue(source, Alignment.LEFT, "testy", -1, "testy");
				addValue(source, Alignment.RIGHT, "testy", -1, "testy");
				addValue(source, Alignment.CENTER, "testy", -1, "testy");
				addValue(source, Alignment.JUSTIFY, "testy", -1, "testy");
				addValue(source, Alignment.LEFT, "testy", 5, "testy");
				addValue(source, Alignment.LEFT, "testy", 3, "te-", "sty");
				addValue(source, Alignment.LEFT,
						"Un petit texte qui se mettra sur plusieurs lignes",
						10, "Un petit", "texte qui", "se mettra", "sur",
						"plusieurs", "lignes");
				addValue(source, Alignment.LEFT,
						"Un petit texte qui se mettra sur plusieurs lignes", 7,
						"Un", "petit", "texte", "qui se", "mettra", "sur",
						"plusie-", "urs", "lignes");
				addValue(source, Alignment.RIGHT,
						"Un petit texte qui se mettra sur plusieurs lignes", 7,
						"     Un", "  petit", "  texte", " qui se", " mettra",
						"    sur", "plusie-", "    urs", " lignes");
				addValue(source, Alignment.CENTER,
						"Un petit texte qui se mettra sur plusieurs lignes", 7,
						"  Un   ", " petit ", " texte ", "qui se ", "mettra ",
						"  sur  ", "plusie-", "  urs  ", "lignes ");
				addValue(source, Alignment.JUSTIFY,
						"Un petit texte qui se mettra sur plusieurs lignes", 7,
						"Un pet-", "it tex-", "te  qui", "se met-", "tra sur",
						"plusie-", "urs li-", "gnes");
				addValue(source, Alignment.JUSTIFY,
						"Un petit texte qui se mettra sur plusieurs lignes",
						14, "Un       petit", "texte  qui  se",
						"mettra     sur", "plusieurs lig-", "nes");
				addValue(source, Alignment.JUSTIFY, "le dash-test", 9,
						"le  dash-", "test");

				for (String data : source.keySet()) {
					for (int size : source.get(data).keySet()) {
						Alignment align = source.get(data).get(size).getKey();
						List<String> values = source.get(data).get(size)
								.getValue();

						List<String> result = StringUtils.justifyText(data,
								size, align);

						// System.out.println("[" + data + " (" + size + ")" +
						// "] -> [");
						// for (int i = 0; i < result.size(); i++) {
						// String resultLine = result.get(i);
						// System.out.println(i + ": " + resultLine);
						// }
						// System.out.println("]");

						assertEquals(values, result);
					}
				}
			}
		});

		addTest(new TestCase("unhtml") {
			@Override
			public void test() throws Exception {
				Map<String, String> data = new HashMap<String, String>();
				data.put("aa", "aa");
				data.put("test with spaces ", "test with spaces ");
				data.put("<a href='truc://target/'>link</a>", "link");
				data.put("<html>Digimon</html>", "Digimon");
				data.put("", "");
				data.put(" ", " ");

				for (Entry<String, String> entry : data.entrySet()) {
					String result = StringUtils.unhtml(entry.getKey());
					assertEquals("Result is not what we expected",
							entry.getValue(), result);
				}
			}
		});

		addTest(new TestCase("zip64") {
			@Override
			public void test() throws Exception {
				String orig = "test";
				String zipped = StringUtils.zip64(orig);
				String unzipped = StringUtils.unzip64s(zipped);
				assertEquals(orig, unzipped);
			}
		});

		addTest(new TestCase("format/toNumber simple") {
			@Override
			public void test() throws Exception {
				assertEquals(263l, StringUtils.toNumber("263"));
				assertEquals(21200l, StringUtils.toNumber("21200"));
				assertEquals(0l, StringUtils.toNumber("0"));
				assertEquals("263", StringUtils.formatNumber(263l));
				assertEquals("21 k", StringUtils.formatNumber(21000l));
				assertEquals("0", StringUtils.formatNumber(0l));
			}
		});

		addTest(new TestCase("format/toNumber not 000") {
			@Override
			public void test() throws Exception {
				assertEquals(263200l, StringUtils.toNumber("263.2 k"));
				assertEquals(42000l, StringUtils.toNumber("42.0 k"));
				assertEquals(12000000l, StringUtils.toNumber("12 M"));
				assertEquals(2000000000l, StringUtils.toNumber("2 G"));
				assertEquals("263 k", StringUtils.formatNumber(263012l));
				assertEquals("42 k", StringUtils.formatNumber(42012l));
				assertEquals("12 M", StringUtils.formatNumber(12012121l));
				assertEquals("7 G", StringUtils.formatNumber(7364635928l));
			}
		});

		addTest(new TestCase("format/toNumber decimals") {
			@Override
			public void test() throws Exception {
				assertEquals(263200l, StringUtils.toNumber("263.2 k"));
				assertEquals(1200l, StringUtils.toNumber("1.2 k"));
				assertEquals(42700000l, StringUtils.toNumber("42.7 M"));
				assertEquals(1220l, StringUtils.toNumber("1.22 k"));
				assertEquals(1432l, StringUtils.toNumber("1.432 k"));
				assertEquals(6938l, StringUtils.toNumber("6.938 k"));
				assertEquals("1.3 k", StringUtils.formatNumber(1300l, 1));
				assertEquals("263.2020 k", StringUtils.formatNumber(263202l, 4));
				assertEquals("1.26 k", StringUtils.formatNumber(1267l, 2));
				assertEquals("42.7 M", StringUtils.formatNumber(42712121l, 1));
				assertEquals("5.09 G", StringUtils.formatNumber(5094837485l, 2));
			}
		});
	}

	static private void addValue(
			Map<String, Map<Integer, Entry<Alignment, List<String>>>> source,
			final Alignment align, String input, int size,
			final String... result) {
		if (!source.containsKey(input)) {
			source.put(input,
					new HashMap<Integer, Entry<Alignment, List<String>>>());
		}

		source.get(input).put(size, new Entry<Alignment, List<String>>() {
			@Override
			public Alignment getKey() {
				return align;
			}

			@Override
			public List<String> getValue() {
				return Arrays.asList(result);
			}

			@Override
			public List<String> setValue(List<String> value) {
				return null;
			}
		});
	}
}
Commit	Line	Data
fbcc2a2a	1	package be.nikiroo.utils.test_code;
db31c358	2
771c4ba4	3	import java.util.Arrays;
451f434b NR	4	import java.util.Date;
451f434b NR	5	import java.util.HashMap;
6a493e05	6	import java.util.List;
451f434b NR	7	import java.util.Map;
	8	import java.util.Map.Entry;
	9
db31c358	10	import be.nikiroo.utils.StringUtils;
451f434b	11	import be.nikiroo.utils.StringUtils.Alignment;
fbcc2a2a NR	12	import be.nikiroo.utils.test.TestCase;
fbcc2a2a NR	13	import be.nikiroo.utils.test.TestLauncher;
db31c358 NR	14
	15	class StringUtilsTest extends TestLauncher {
	16	public StringUtilsTest(String[] args) {
	17	super("StringUtils test", args);
	18
451f434b NR	19	addTest(new TestCase("Time serialisation") {
	20	@Override
	21	public void test() throws Exception {
	22	for (long fullTime : new Long[] { 0l, 123456l, 123456000l,
	23	new Date().getTime() }) {
	24	// precise to the second, no more
	25	long time = (fullTime / 1000) * 1000;
	26
	27	String displayTime = StringUtils.fromTime(time);
	28	assertNotNull("The stringified time for " + time
	29	+ " should not be null", displayTime);
	30	assertEquals("The stringified time for " + time
	31	+ " should not be empty", false, displayTime.trim()
	32	.isEmpty());
	33
	34	assertEquals("The time " + time
	35	+ " should be loop-convertable", time,
	36	StringUtils.toTime(displayTime));
	37
	38	assertEquals("The time " + displayTime
	39	+ " should be loop-convertable", displayTime,
	40	StringUtils.fromTime(StringUtils
	41	.toTime(displayTime)));
	42	}
	43	}
	44	});
	45
	46	addTest(new TestCase("MD5") {
	47	@Override
	48	public void test() throws Exception {
	49	String mess = "The String we got is not what 'md5sum' said it should heve been";
	50	assertEquals(mess, "34ded48fcff4221d644be9a37e1cb1d9",
	51	StringUtils.getMd5Hash("fanfan la tulipe"));
	52	assertEquals(mess, "7691b0cb74ed0f94b4d8cd858abe1165",
	53	StringUtils.getMd5Hash("je te do-o-o-o-o-o-nne"));
	54	}
	55	});
	56
	57	addTest(new TestCase("Padding") {
	58	@Override
	59	public void test() throws Exception {
	60	for (String data : new String[] { "fanfan", "la tulipe",
	61	"1234567890", "12345678901234567890", "1", "" }) {
	62	String result = StringUtils.padString(data, -1);
	63	assertEquals("A size of -1 is expected to produce a noop",
	64	true, data.equals(result));
	65	for (int size : new Integer[] { 0, 1, 5, 10, 40 }) {
	66	result = StringUtils.padString(data, size);
	67	assertEquals(
	68	"Padding a String at a certain size should give a String of the given size",
	69	size, result.length());
	70	assertEquals(
	71	"Padding a String should not change the content",
	72	true, data.trim().startsWith(result.trim()));
	73
	74	result = StringUtils.padString(data, size, false, null);
	75	assertEquals(
	76	"Padding a String without cutting should not shorten the String",
	77	true, data.length() <= result.length());
	78	assertEquals(
	79	"Padding a String without cutting should keep the whole content",
	80	true, data.trim().equals(result.trim()));
	81
	82	result = StringUtils.padString(data, size, false,
cc3e7291	83	Alignment.RIGHT);
451f434b NR	84	if (size > data.length()) {
	85	assertEquals(
	86	"Padding a String to the end should work as expected",
	87	true, result.endsWith(data));
	88	}
	89
	90	result = StringUtils.padString(data, size, false,
cc3e7291 NR	91	Alignment.JUSTIFY);
	92	if (size > data.length()) {
	93	String unspacedData = data.trim();
	94	String unspacedResult = result.trim();
	95	for (int i = 0; i < size; i++) {
	96	unspacedData = unspacedData.replace(" ", " ");
	97	unspacedResult = unspacedResult.replace(" ",
	98	" ");
	99	}
	100
	101	assertEquals(
	102	"Justified text trimmed with all spaces collapsed "
	103	+ "sould be identical to original text "
	104	+ "trimmed with all spaces collapsed",
	105	unspacedData, unspacedResult);
	106	}
	107
	108	result = StringUtils.padString(data, size, false,
	109	Alignment.CENTER);
451f434b NR	110	if (size > data.length()) {
	111	int before = 0;
	112	for (int i = 0; i < result.length()
	113	&& result.charAt(i) == ' '; i++) {
	114	before++;
	115	}
	116
	117	int after = 0;
	118	for (int i = result.length() - 1; i >= 0
	119	&& result.charAt(i) == ' '; i--) {
	120	after++;
	121	}
	122
	123	if (result.trim().isEmpty()) {
	124	after = before / 2;
	125	if (before > (2 * after)) {
	126	before = after + 1;
	127	} else {
	128	before = after;
	129	}
	130	}
	131
	132	assertEquals(
	133	"Padding a String on center should work as expected",
	134	result.length(), before + data.length()
	135	+ after);
	136	assertEquals(
	137	"Padding a String on center should not uncenter the content",
	138	true, Math.abs(before - after) <= 1);
	139	}
	140	}
	141	}
	142	}
	143	});
	144
cc3e7291 NR	145	addTest(new TestCase("Justifying") {
	146	@Override
	147	public void test() throws Exception {
771c4ba4	148	Map<String, Map<Integer, Entry<Alignment, List<String>>>> source = new HashMap<String, Map<Integer, Entry<Alignment, List<String>>>>();
620f7329 NR	149	addValue(source, Alignment.LEFT, "testy", -1, "testy");
	150	addValue(source, Alignment.RIGHT, "testy", -1, "testy");
	151	addValue(source, Alignment.CENTER, "testy", -1, "testy");
	152	addValue(source, Alignment.JUSTIFY, "testy", -1, "testy");
771c4ba4 NR	153	addValue(source, Alignment.LEFT, "testy", 5, "testy");
	154	addValue(source, Alignment.LEFT, "testy", 3, "te-", "sty");
	155	addValue(source, Alignment.LEFT,
	156	"Un petit texte qui se mettra sur plusieurs lignes",
	157	10, "Un petit", "texte qui", "se mettra", "sur",
	158	"plusieurs", "lignes");
	159	addValue(source, Alignment.LEFT,
	160	"Un petit texte qui se mettra sur plusieurs lignes", 7,
	161	"Un", "petit", "texte", "qui se", "mettra", "sur",
	162	"plusie-", "urs", "lignes");
	163	addValue(source, Alignment.RIGHT,
	164	"Un petit texte qui se mettra sur plusieurs lignes", 7,
	165	" Un", " petit", " texte", " qui se", " mettra",
	166	" sur", "plusie-", " urs", " lignes");
	167	addValue(source, Alignment.CENTER,
	168	"Un petit texte qui se mettra sur plusieurs lignes", 7,
	169	" Un ", " petit ", " texte ", "qui se ", "mettra ",
	170	" sur ", "plusie-", " urs ", "lignes ");
	171	addValue(source, Alignment.JUSTIFY,
	172	"Un petit texte qui se mettra sur plusieurs lignes", 7,
620f7329 NR	173	"Un pet-", "it tex-", "te qui", "se met-", "tra sur",
620f7329 NR	174	"plusie-", "urs li-", "gnes");
771c4ba4 NR	175	addValue(source, Alignment.JUSTIFY,
	176	"Un petit texte qui se mettra sur plusieurs lignes",
	177	14, "Un petit", "texte qui se",
	178	"mettra sur", "plusieurs lig-", "nes");
ef34f6f7 NR	179	addValue(source, Alignment.JUSTIFY, "le dash-test", 9,
ef34f6f7 NR	180	"le dash-", "test");
771c4ba4	181
771c4ba4 NR	182	for (String data : source.keySet()) {
	183	for (int size : source.get(data).keySet()) {
	184	Alignment align = source.get(data).get(size).getKey();
	185	List<String> values = source.get(data).get(size)
	186	.getValue();
	187
	188	List<String> result = StringUtils.justifyText(data,
	189	size, align);
	190
620f7329 NR	191	// System.out.println("[" + data + " (" + size + ")" +
	192	// "] -> [");
	193	// for (int i = 0; i < result.size(); i++) {
	194	// String resultLine = result.get(i);
	195	// System.out.println(i + ": " + resultLine);
	196	// }
	197	// System.out.println("]");
6a493e05	198
620f7329	199	assertEquals(values, result);
771c4ba4	200	}
cc3e7291 NR	201	}
	202	}
	203	});
	204
451f434b NR	205	addTest(new TestCase("unhtml") {
	206	@Override
	207	public void test() throws Exception {
	208	Map<String, String> data = new HashMap<String, String>();
	209	data.put("aa", "aa");
	210	data.put("test with spaces ", "test with spaces ");
	211	data.put("<a href='truc://target/'>link</a>", "link");
	212	data.put("<html>Digimon</html>", "Digimon");
	213	data.put("", "");
	214	data.put(" ", " ");
	215
	216	for (Entry<String, String> entry : data.entrySet()) {
	217	String result = StringUtils.unhtml(entry.getKey());
	218	assertEquals("Result is not what we expected",
	219	entry.getValue(), result);
	220	}
	221	}
	222	});
	223
db31c358 NR	224	addTest(new TestCase("zip64") {
	225	@Override
	226	public void test() throws Exception {
	227	String orig = "test";
29fd216d	228	String zipped = StringUtils.zip64(orig);
a6a73de3	229	String unzipped = StringUtils.unzip64s(zipped);
db31c358 NR	230	assertEquals(orig, unzipped);
	231	}
	232	});
5b46737c NR	233
	234	addTest(new TestCase("format/toNumber simple") {
	235	@Override
	236	public void test() throws Exception {
	237	assertEquals(263l, StringUtils.toNumber("263"));
	238	assertEquals(21200l, StringUtils.toNumber("21200"));
	239	assertEquals(0l, StringUtils.toNumber("0"));
	240	assertEquals("263", StringUtils.formatNumber(263l));
c8ce09c4	241	assertEquals("21 k", StringUtils.formatNumber(21000l));
5b46737c NR	242	assertEquals("0", StringUtils.formatNumber(0l));
	243	}
	244	});
	245
	246	addTest(new TestCase("format/toNumber not 000") {
	247	@Override
	248	public void test() throws Exception {
c8ce09c4 NR	249	assertEquals(263200l, StringUtils.toNumber("263.2 k"));
	250	assertEquals(42000l, StringUtils.toNumber("42.0 k"));
	251	assertEquals(12000000l, StringUtils.toNumber("12 M"));
	252	assertEquals(2000000000l, StringUtils.toNumber("2 G"));
	253	assertEquals("263 k", StringUtils.formatNumber(263012l));
	254	assertEquals("42 k", StringUtils.formatNumber(42012l));
	255	assertEquals("12 M", StringUtils.formatNumber(12012121l));
	256	assertEquals("7 G", StringUtils.formatNumber(7364635928l));
5b46737c NR	257	}
	258	});
	259
	260	addTest(new TestCase("format/toNumber decimals") {
00b43c19 NR	261	@Override
00b43c19 NR	262	public void test() throws Exception {
c8ce09c4 NR	263	assertEquals(263200l, StringUtils.toNumber("263.2 k"));
	264	assertEquals(1200l, StringUtils.toNumber("1.2 k"));
	265	assertEquals(42700000l, StringUtils.toNumber("42.7 M"));
	266	assertEquals(1220l, StringUtils.toNumber("1.22 k"));
	267	assertEquals(1432l, StringUtils.toNumber("1.432 k"));
	268	assertEquals(6938l, StringUtils.toNumber("6.938 k"));
	269	assertEquals("1.3 k", StringUtils.formatNumber(1300l, 1));
	270	assertEquals("263.2020 k", StringUtils.formatNumber(263202l, 4));
	271	assertEquals("1.26 k", StringUtils.formatNumber(1267l, 2));
	272	assertEquals("42.7 M", StringUtils.formatNumber(42712121l, 1));
	273	assertEquals("5.09 G", StringUtils.formatNumber(5094837485l, 2));
00b43c19 NR	274	}
00b43c19 NR	275	});
db31c358	276	}
771c4ba4 NR	277
	278	static private void addValue(
	279	Map<String, Map<Integer, Entry<Alignment, List<String>>>> source,
	280	final Alignment align, String input, int size,
	281	final String... result) {
	282	if (!source.containsKey(input)) {
	283	source.put(input,
	284	new HashMap<Integer, Entry<Alignment, List<String>>>());
	285	}
	286
	287	source.get(input).put(size, new Entry<Alignment, List<String>>() {
	288	@Override
	289	public Alignment getKey() {
	290	return align;
	291	}
	292
	293	@Override
	294	public List<String> getValue() {
	295	return Arrays.asList(result);
	296	}
	297
	298	@Override
	299	public List<String> setValue(List<String> value) {
	300	return null;
	301	}
	302	});
	303	}
db31c358	304	}