[fanfix.git] / src / be / nikiroo / fanfix / test / BasicSupportTest.java

package be.nikiroo.fanfix.test;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;

import be.nikiroo.fanfix.Instance;
import be.nikiroo.fanfix.bundles.StringId;
import be.nikiroo.fanfix.data.MetaData;
import be.nikiroo.fanfix.data.Paragraph;
import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
import be.nikiroo.fanfix.data.Story;
import be.nikiroo.fanfix.supported.BasicSupport;
import be.nikiroo.fanfix.supported.BasicSupport.SupportType;
import be.nikiroo.utils.IOUtils;
import be.nikiroo.utils.test.TestCase;
import be.nikiroo.utils.test.TestLauncher;

public class BasicSupportTest extends TestLauncher {
	// quote chars
	private char openQuote = Instance.getTrans().getChar(
			StringId.OPEN_SINGLE_QUOTE);
	private char closeQuote = Instance.getTrans().getChar(
			StringId.CLOSE_SINGLE_QUOTE);
	private char openDoubleQuote = Instance.getTrans().getChar(
			StringId.OPEN_DOUBLE_QUOTE);
	private char closeDoubleQuote = Instance.getTrans().getChar(
			StringId.CLOSE_DOUBLE_QUOTE);

	public BasicSupportTest(String[] args) {
		super("BasicSupport", args);

		addSeries(new TestLauncher("General", args) {
			{
				addTest(new TestCase("BasicSupport.makeParagraphs()") {
					@Override
					public void test() throws Exception {
						BasicSupportEmpty support = new BasicSupportEmpty() {
							@Override
							protected boolean isHtml() {
								return true;
							}

							@Override
							public void fixBlanksBreaks(List<Paragraph> paras) {
							}

							@Override
							protected List<Paragraph> requotify(Paragraph para) {
								List<Paragraph> paras = new ArrayList<Paragraph>(
										1);
								paras.add(para);
								return paras;
							}
						};

						List<Paragraph> paras = null;

						paras = support.makeParagraphs(null, "");
						assertEquals(
								"An empty content should not generate paragraphs",
								0, paras.size());

						paras = support.makeParagraphs(null,
								"Line 1</p><p>Line 2</p><p>Line 3</p>");
						assertEquals(5, paras.size());
						assertEquals("Line 1", paras.get(0).getContent());
						assertEquals(ParagraphType.BLANK, paras.get(1)
								.getType());
						assertEquals("Line 2", paras.get(2).getContent());
						assertEquals(ParagraphType.BLANK, paras.get(3)
								.getType());
						assertEquals("Line 3", paras.get(4).getContent());

						paras = support.makeParagraphs(null,
								"<p>Line1</p><p>Line2</p><p>Line3</p>");
						assertEquals(6, paras.size());
					}
				});

				addTest(new TestCase("BasicSupport.removeDoubleBlanks()") {
					@Override
					public void test() throws Exception {
						BasicSupportEmpty support = new BasicSupportEmpty() {
							@Override
							protected boolean isHtml() {
								return true;
							}
						};

						List<Paragraph> paras = null;

						paras = support
								.makeParagraphs(null,
										"<p>Line1</p><p>Line2</p><p>Line3<br/><br><p></p>");
						assertEquals(5, paras.size());

						paras = support
								.makeParagraphs(null,
										"<p>Line1</p><p>Line2</p><p>Line3<br/><br><p></p>* * *");
						assertEquals(5, paras.size());

						paras = support.makeParagraphs(null, "1<p>* * *<p>2");
						assertEquals(3, paras.size());
						assertEquals(ParagraphType.BREAK, paras.get(1)
								.getType());

						paras = support.makeParagraphs(null,
								"1<p><br/><p>* * *<p>2");
						assertEquals(3, paras.size());
						assertEquals(ParagraphType.BREAK, paras.get(1)
								.getType());

						paras = support.makeParagraphs(null,
								"1<p>* * *<br/><p><br><p>2");
						assertEquals(3, paras.size());
						assertEquals(ParagraphType.BREAK, paras.get(1)
								.getType());

						paras = support.makeParagraphs(null,
								"1<p><br/><br>* * *<br/><p><br><p>2");
						assertEquals(3, paras.size());
						assertEquals(ParagraphType.BREAK, paras.get(1)
								.getType());
					}
				});

				addTest(new TestCase("BasicSupport.processPara() quotes") {
					@Override
					public void test() throws Exception {
						BasicSupportEmpty support = new BasicSupportEmpty() {
							@Override
							protected boolean isHtml() {
								return true;
							}
						};

						Paragraph para;

						// sanity check
						para = support.processPara("");
						assertEquals(ParagraphType.BLANK, para.getType());
						//

						para = support.processPara("\"Yes, my Lord!\"");
						assertEquals(ParagraphType.QUOTE, para.getType());
						assertEquals(openDoubleQuote + "Yes, my Lord!"
								+ closeDoubleQuote, para.getContent());

						para = support.processPara("«Yes, my Lord!»");
						assertEquals(ParagraphType.QUOTE, para.getType());
						assertEquals(openDoubleQuote + "Yes, my Lord!"
								+ closeDoubleQuote, para.getContent());

						para = support.processPara("'Yes, my Lord!'");
						assertEquals(ParagraphType.QUOTE, para.getType());
						assertEquals(openQuote + "Yes, my Lord!" + closeQuote,
								para.getContent());

						para = support.processPara("‹Yes, my Lord!›");
						assertEquals(ParagraphType.QUOTE, para.getType());
						assertEquals(openQuote + "Yes, my Lord!" + closeQuote,
								para.getContent());
					}
				});

				addTest(new TestCase(
						"BasicSupport.processPara() double-simple quotes") {
					@Override
					public void setUp() throws Exception {
						super.setUp();

					};

					@Override
					public void tearDown() throws Exception {

						super.tearDown();
					}

					@Override
					public void test() throws Exception {
						BasicSupportEmpty support = new BasicSupportEmpty() {
							@Override
							protected boolean isHtml() {
								return true;
							}
						};

						Paragraph para;

						para = support.processPara("''Yes, my Lord!''");
						assertEquals(ParagraphType.QUOTE, para.getType());
						assertEquals(openDoubleQuote + "Yes, my Lord!"
								+ closeDoubleQuote, para.getContent());

						para = support.processPara("‹‹Yes, my Lord!››");
						assertEquals(ParagraphType.QUOTE, para.getType());
						assertEquals(openDoubleQuote + "Yes, my Lord!"
								+ closeDoubleQuote, para.getContent());
					}
				});

				addTest(new TestCase("BasicSupport.processPara() apostrophe") {
					@Override
					public void test() throws Exception {
						BasicSupportEmpty support = new BasicSupportEmpty() {
							@Override
							protected boolean isHtml() {
								return true;
							}
						};

						Paragraph para;

						String text = "Nous étions en été, mais cela aurait être l'hiver quand nous n'étions encore qu'à Aubeuge";
						para = support.processPara(text);
						assertEquals(ParagraphType.NORMAL, para.getType());
						assertEquals(text, para.getContent());
					}
				});
			}
		});

		addSeries(new TestLauncher("Text", args) {
			{
				addTest(new TestCase("Chapter detection simple") {
					private File tmp;

					@Override
					public void setUp() throws Exception {
						tmp = File.createTempFile("fanfix-text-file_", ".test");
						IOUtils.writeSmallFile(tmp.getParentFile(),
								tmp.getName(), "TITLE"
										+ "\n"//
										+ "By nona"
										+ "\n" //
										+ "\n" //
										+ "Chapter 0: Resumé" + "\n" + "\n"
										+ "'sume." + "\n" + "\n"
										+ "Chapter 1: chap1" + "\n" + "\n"
										+ "Fanfan." + "\n" + "\n"
										+ "Chapter 2: Chap2" + "\n" + "\n" //
										+ "Tulipe." + "\n");
					};

					@Override
					public void tearDown() throws Exception {
						tmp.delete();
					};

					@Override
					public void test() throws Exception {
						BasicSupport support = BasicSupport
								.getSupport(SupportType.TEXT);

						Story story = support
								.process(tmp.toURI().toURL(), null);

						assertEquals(2, story.getChapters().size());
						assertEquals(1, story.getChapters().get(1)
								.getParagraphs().size());
						assertEquals("Tulipe.", story.getChapters().get(1)
								.getParagraphs().get(0).getContent());
					}
				});

				addTest(new TestCase("Chapter detection with String 'Chapter'") {
					private File tmp;

					@Override
					public void setUp() throws Exception {
						tmp = File.createTempFile("fanfix-text-file_", ".test");
						IOUtils.writeSmallFile(tmp.getParentFile(),
								tmp.getName(), "TITLE"
										+ "\n"//
										+ "By nona"
										+ "\n" //
										+ "\n" //
										+ "Chapter 0: Resumé" + "\n" + "\n"
										+ "'sume." + "\n" + "\n"
										+ "Chapter 1: chap1" + "\n" + "\n"
										+ "Chapter fout-la-merde" + "\n"
										+ "\n"//
										+ "Fanfan." + "\n" + "\n"
										+ "Chapter 2: Chap2" + "\n" + "\n" //
										+ "Tulipe." + "\n");
					};

					@Override
					public void tearDown() throws Exception {
						tmp.delete();
					};

					@Override
					public void test() throws Exception {
						BasicSupport support = BasicSupport
								.getSupport(SupportType.TEXT);

						Story story = support
								.process(tmp.toURI().toURL(), null);

						assertEquals(2, story.getChapters().size());
						assertEquals(1, story.getChapters().get(1)
								.getParagraphs().size());
						assertEquals("Tulipe.", story.getChapters().get(1)
								.getParagraphs().get(0).getContent());
					}
				});
			}
		});
	}

	private class BasicSupportEmpty extends BasicSupport {
		@Override
		protected String getSourceName() {
			return null;
		}

		@Override
		protected boolean supports(URL url) {
			return false;
		}

		@Override
		protected boolean isHtml() {
			return false;
		}

		@Override
		protected MetaData getMeta(URL source, InputStream in)
				throws IOException {
			return null;
		}

		@Override
		protected String getDesc(URL source, InputStream in) throws IOException {
			return null;
		}

		@Override
		protected List<Entry<String, URL>> getChapters(URL source,
				InputStream in) throws IOException {
			return null;
		}

		@Override
		protected String getChapterContent(URL source, InputStream in,
				int number) throws IOException {
			return null;
		}

		@Override
		// and make it public!
		public List<Paragraph> makeParagraphs(URL source, String content)
				throws IOException {
			return super.makeParagraphs(source, content);
		}

		@Override
		// and make it public!
		public void fixBlanksBreaks(List<Paragraph> paras) {
			super.fixBlanksBreaks(paras);
		}

		@Override
		// and make it public!
		public Paragraph processPara(String line) {
			return super.processPara(line);
		}
	}
}
Commit	Line	Data
68e370a4 NR	1	package be.nikiroo.fanfix.test;
68e370a4 NR	2
22848428	3	import java.io.File;
68e370a4 NR	4	import java.io.IOException;
	5	import java.io.InputStream;
	6	import java.net.URL;
	7	import java.util.ArrayList;
	8	import java.util.List;
	9	import java.util.Map.Entry;
	10
22848428 NR	11	import be.nikiroo.fanfix.Instance;
22848428 NR	12	import be.nikiroo.fanfix.bundles.StringId;
68e370a4 NR	13	import be.nikiroo.fanfix.data.MetaData;
	14	import be.nikiroo.fanfix.data.Paragraph;
	15	import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
22848428	16	import be.nikiroo.fanfix.data.Story;
68e370a4	17	import be.nikiroo.fanfix.supported.BasicSupport;
22848428 NR	18	import be.nikiroo.fanfix.supported.BasicSupport.SupportType;
22848428 NR	19	import be.nikiroo.utils.IOUtils;
68e370a4 NR	20	import be.nikiroo.utils.test.TestCase;
	21	import be.nikiroo.utils.test.TestLauncher;
	22
	23	public class BasicSupportTest extends TestLauncher {
22848428 NR	24	// quote chars
	25	private char openQuote = Instance.getTrans().getChar(
	26	StringId.OPEN_SINGLE_QUOTE);
	27	private char closeQuote = Instance.getTrans().getChar(
	28	StringId.CLOSE_SINGLE_QUOTE);
	29	private char openDoubleQuote = Instance.getTrans().getChar(
	30	StringId.OPEN_DOUBLE_QUOTE);
	31	private char closeDoubleQuote = Instance.getTrans().getChar(
	32	StringId.CLOSE_DOUBLE_QUOTE);
68e370a4 NR	33
	34	public BasicSupportTest(String[] args) {
	35	super("BasicSupport", args);
	36
	37	addSeries(new TestLauncher("General", args) {
	38	{
	39	addTest(new TestCase("BasicSupport.makeParagraphs()") {
	40	@Override
	41	public void test() throws Exception {
	42	BasicSupportEmpty support = new BasicSupportEmpty() {
	43	@Override
	44	protected boolean isHtml() {
	45	return true;
	46	}
	47
	48	@Override
	49	public void fixBlanksBreaks(List<Paragraph> paras) {
	50	}
	51
	52	@Override
	53	protected List<Paragraph> requotify(Paragraph para) {
	54	List<Paragraph> paras = new ArrayList<Paragraph>(
	55	1);
	56	paras.add(para);
	57	return paras;
	58	}
	59	};
	60
	61	List<Paragraph> paras = null;
	62
	63	paras = support.makeParagraphs(null, "");
	64	assertEquals(
	65	"An empty content should not generate paragraphs",
	66	0, paras.size());
	67
	68	paras = support.makeParagraphs(null,
	69	"Line 1</p><p>Line 2</p><p>Line 3</p>");
	70	assertEquals(5, paras.size());
	71	assertEquals("Line 1", paras.get(0).getContent());
	72	assertEquals(ParagraphType.BLANK, paras.get(1)
	73	.getType());
	74	assertEquals("Line 2", paras.get(2).getContent());
	75	assertEquals(ParagraphType.BLANK, paras.get(3)
	76	.getType());
	77	assertEquals("Line 3", paras.get(4).getContent());
	78
	79	paras = support.makeParagraphs(null,
	80	"<p>Line1</p><p>Line2</p><p>Line3</p>");
	81	assertEquals(6, paras.size());
	82	}
	83	});
	84
	85	addTest(new TestCase("BasicSupport.removeDoubleBlanks()") {
	86	@Override
	87	public void test() throws Exception {
	88	BasicSupportEmpty support = new BasicSupportEmpty() {
	89	@Override
	90	protected boolean isHtml() {
	91	return true;
	92	}
	93	};
	94
	95	List<Paragraph> paras = null;
	96
97	paras = support
98	.makeParagraphs(null,
99	"<p>Line1</p><p>Line2</p><p>Line3<br/><br><p></p>");
100	assertEquals(5, paras.size());
101
102	paras = support
103	.makeParagraphs(null,
104	"<p>Line1</p><p>Line2</p><p>Line3<br/><br><p></p>* * *");
105	assertEquals(5, paras.size());
106
107	paras = support.makeParagraphs(null, "1<p>* * *<p>2");
108	assertEquals(3, paras.size());
109	assertEquals(ParagraphType.BREAK, paras.get(1)
110	.getType());
111
112	paras = support.makeParagraphs(null,
113	"1<p><br/><p>* * *<p>2");
114	assertEquals(3, paras.size());
115	assertEquals(ParagraphType.BREAK, paras.get(1)
116	.getType());
117
118	paras = support.makeParagraphs(null,
119	"1<p>* * *<br/><p><br><p>2");
120	assertEquals(3, paras.size());
121	assertEquals(ParagraphType.BREAK, paras.get(1)
122	.getType());
123
124	paras = support.makeParagraphs(null,
125	"1<p><br/><br>* * *<br/><p><br><p>2");
126	assertEquals(3, paras.size());
127	assertEquals(ParagraphType.BREAK, paras.get(1)
128	.getType());
129	}
130	});
22848428 NR	131
	132	addTest(new TestCase("BasicSupport.processPara() quotes") {
	133	@Override
	134	public void test() throws Exception {
	135	BasicSupportEmpty support = new BasicSupportEmpty() {
	136	@Override
	137	protected boolean isHtml() {
	138	return true;
	139	}
	140	};
	141
	142	Paragraph para;
	143
	144	// sanity check
	145	para = support.processPara("");
	146	assertEquals(ParagraphType.BLANK, para.getType());
	147	//
	148
	149	para = support.processPara("\"Yes, my Lord!\"");
	150	assertEquals(ParagraphType.QUOTE, para.getType());
	151	assertEquals(openDoubleQuote + "Yes, my Lord!"
	152	+ closeDoubleQuote, para.getContent());
	153
	154	para = support.processPara("«Yes, my Lord!»");
	155	assertEquals(ParagraphType.QUOTE, para.getType());
	156	assertEquals(openDoubleQuote + "Yes, my Lord!"
	157	+ closeDoubleQuote, para.getContent());
	158
	159	para = support.processPara("'Yes, my Lord!'");
	160	assertEquals(ParagraphType.QUOTE, para.getType());
	161	assertEquals(openQuote + "Yes, my Lord!" + closeQuote,
	162	para.getContent());
	163
	164	para = support.processPara("‹Yes, my Lord!›");
	165	assertEquals(ParagraphType.QUOTE, para.getType());
	166	assertEquals(openQuote + "Yes, my Lord!" + closeQuote,
	167	para.getContent());
	168	}
	169	});
	170
	171	addTest(new TestCase(
	172	"BasicSupport.processPara() double-simple quotes") {
	173	@Override
	174	public void setUp() throws Exception {
	175	super.setUp();
	176
	177	};
	178
	179	@Override
	180	public void tearDown() throws Exception {
	181
	182	super.tearDown();
	183	}
	184
	185	@Override
	186	public void test() throws Exception {
	187	BasicSupportEmpty support = new BasicSupportEmpty() {
	188	@Override
	189	protected boolean isHtml() {
	190	return true;
	191	}
	192	};
	193
	194	Paragraph para;
195
196	para = support.processPara("''Yes, my Lord!''");
197	assertEquals(ParagraphType.QUOTE, para.getType());
198	assertEquals(openDoubleQuote + "Yes, my Lord!"
199	+ closeDoubleQuote, para.getContent());
200
201	para = support.processPara("‹‹Yes, my Lord!››");
202	assertEquals(ParagraphType.QUOTE, para.getType());
203	assertEquals(openDoubleQuote + "Yes, my Lord!"
204	+ closeDoubleQuote, para.getContent());
205	}
206	});
207
208	addTest(new TestCase("BasicSupport.processPara() apostrophe") {
209	@Override
210	public void test() throws Exception {
211	BasicSupportEmpty support = new BasicSupportEmpty() {
212	@Override
213	protected boolean isHtml() {
214	return true;
215	}
216	};
217
218	Paragraph para;
219
220	String text = "Nous étions en été, mais cela aurait être l'hiver quand nous n'étions encore qu'à Aubeuge";
221	para = support.processPara(text);
222	assertEquals(ParagraphType.NORMAL, para.getType());
223	assertEquals(text, para.getContent());
224	}
225	});
226	}
227	});
228
229	addSeries(new TestLauncher("Text", args) {
230	{
231	addTest(new TestCase("Chapter detection simple") {
232	private File tmp;
233
234	@Override
235	public void setUp() throws Exception {
236	tmp = File.createTempFile("fanfix-text-file_", ".test");
237	IOUtils.writeSmallFile(tmp.getParentFile(),
238	tmp.getName(), "TITLE"
239	+ "\n"//
240	+ "By nona"
241	+ "\n" //
242	+ "\n" //
243	+ "Chapter 0: Resumé" + "\n" + "\n"
244	+ "'sume." + "\n" + "\n"
245	+ "Chapter 1: chap1" + "\n" + "\n"
246	+ "Fanfan." + "\n" + "\n"
247	+ "Chapter 2: Chap2" + "\n" + "\n" //
248	+ "Tulipe." + "\n");
249	};
250
251	@Override
252	public void tearDown() throws Exception {
253	tmp.delete();
254	};
255
256	@Override
257	public void test() throws Exception {
258	BasicSupport support = BasicSupport
259	.getSupport(SupportType.TEXT);
260
261	Story story = support
262	.process(tmp.toURI().toURL(), null);
263
264	assertEquals(2, story.getChapters().size());
265	assertEquals(1, story.getChapters().get(1)
266	.getParagraphs().size());
267	assertEquals("Tulipe.", story.getChapters().get(1)
268	.getParagraphs().get(0).getContent());
269	}
270	});
271
272	addTest(new TestCase("Chapter detection with String 'Chapter'") {
273	private File tmp;
274
275	@Override
276	public void setUp() throws Exception {
277	tmp = File.createTempFile("fanfix-text-file_", ".test");
278	IOUtils.writeSmallFile(tmp.getParentFile(),
279	tmp.getName(), "TITLE"
280	+ "\n"//
281	+ "By nona"
282	+ "\n" //
283	+ "\n" //
284	+ "Chapter 0: Resumé" + "\n" + "\n"
285	+ "'sume." + "\n" + "\n"
286	+ "Chapter 1: chap1" + "\n" + "\n"
287	+ "Chapter fout-la-merde" + "\n"
288	+ "\n"//
289	+ "Fanfan." + "\n" + "\n"
290	+ "Chapter 2: Chap2" + "\n" + "\n" //
291	+ "Tulipe." + "\n");
292	};
293
294	@Override
295	public void tearDown() throws Exception {
296	tmp.delete();
297	};
298
299	@Override
300	public void test() throws Exception {
301	BasicSupport support = BasicSupport
302	.getSupport(SupportType.TEXT);
303
304	Story story = support
305	.process(tmp.toURI().toURL(), null);
306
307	assertEquals(2, story.getChapters().size());
308	assertEquals(1, story.getChapters().get(1)
309	.getParagraphs().size());
310	assertEquals("Tulipe.", story.getChapters().get(1)
311	.getParagraphs().get(0).getContent());
312	}
313	});
68e370a4 NR	314	}
	315	});
	316	}
	317
	318	private class BasicSupportEmpty extends BasicSupport {
	319	@Override
	320	protected String getSourceName() {
	321	return null;
	322	}
	323
	324	@Override
	325	protected boolean supports(URL url) {
	326	return false;
	327	}
	328
	329	@Override
	330	protected boolean isHtml() {
	331	return false;
	332	}
	333
	334	@Override
	335	protected MetaData getMeta(URL source, InputStream in)
	336	throws IOException {
	337	return null;
	338	}
	339
	340	@Override
	341	protected String getDesc(URL source, InputStream in) throws IOException {
	342	return null;
	343	}
	344
	345	@Override
	346	protected List<Entry<String, URL>> getChapters(URL source,
	347	InputStream in) throws IOException {
	348	return null;
	349	}
	350
	351	@Override
	352	protected String getChapterContent(URL source, InputStream in,
	353	int number) throws IOException {
	354	return null;
	355	}
	356
	357	@Override
	358	// and make it public!
	359	public List<Paragraph> makeParagraphs(URL source, String content)
	360	throws IOException {
	361	return super.makeParagraphs(source, content);
	362	}
	363
	364	@Override
	365	// and make it public!
	366	public void fixBlanksBreaks(List<Paragraph> paras) {
	367	super.fixBlanksBreaks(paras);
	368	}
22848428 NR	369
	370	@Override
	371	// and make it public!
	372	public Paragraph processPara(String line) {
	373	return super.processPara(line);
	374	}
68e370a4 NR	375	}
68e370a4 NR	376	}