[nikiroo-utils.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.Progress;
import be.nikiroo.utils.test.TestCase;
import be.nikiroo.utils.test.TestLauncher;

public class BasicSupportTest extends TestLauncher {
	// quote chars
	private char openQuote = Instance.getTrans().getCharacter(
			StringId.OPEN_SINGLE_QUOTE);
	private char closeQuote = Instance.getTrans().getCharacter(
			StringId.CLOSE_SINGLE_QUOTE);
	private char openDoubleQuote = Instance.getTrans().getCharacter(
			StringId.OPEN_DOUBLE_QUOTE);
	private char closeDoubleQuote = Instance.getTrans().getCharacter(
			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
							public 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, "", 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>", null);
						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>", null);
						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>",
										null);
						assertEquals(5, paras.size());

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

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

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

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

						paras = support.makeParagraphs(null,
								"1<p><br/><br>* * *<br/><p><br><p>2", null);
						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());
					}
				});

				addTest(new TestCase("BasicSupport.processPara() words count") {
					@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(3, para.getWords());

						para = support.processPara("One, twee, trois.");
						assertEquals(3, para.getWords());
					}
				});

				addTest(new TestCase("BasicSupport.requotify() words count") {
					@Override
					public void test() throws Exception {
						BasicSupportEmpty support = new BasicSupportEmpty();

						char openDoubleQuote = Instance.getTrans()
								.getCharacter(StringId.OPEN_DOUBLE_QUOTE);
						char closeDoubleQuote = Instance.getTrans()
								.getCharacter(StringId.CLOSE_DOUBLE_QUOTE);

						String content = null;
						Paragraph para = null;
						List<Paragraph> paras = null;
						long words = 0;

						content = "One, twee, trois.";
						para = new Paragraph(ParagraphType.NORMAL, content,
								content.split(" ").length);
						paras = support.requotify(para);
						words = 0;
						for (Paragraph p : paras) {
							words += p.getWords();
						}
						assertEquals("Bad words count in a single paragraph",
								para.getWords(), words);

						content = "Such WoW! So Web2.0! With Colours!";
						para = new Paragraph(ParagraphType.NORMAL, content,
								content.split(" ").length);
						paras = support.requotify(para);
						words = 0;
						for (Paragraph p : paras) {
							words += p.getWords();
						}
						assertEquals("Bad words count in a single paragraph",
								para.getWords(), words);

						content = openDoubleQuote + "Such a good idea!"
								+ closeDoubleQuote
								+ ", she said. This ought to be a new para.";
						para = new Paragraph(ParagraphType.QUOTE, content,
								content.split(" ").length);
						paras = support.requotify(para);
						words = 0;
						for (Paragraph p : paras) {
							words += p.getWords();
						}
						assertEquals(
								"Bad words count in a requotified paragraph",
								para.getWords(), words);
					}
				});
			}
		});

		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, Progress pg) throws IOException {
			return null;
		}

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

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

		@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);
		}

		@Override
		// and make it public!
		public List<Paragraph> requotify(Paragraph para) {
			return super.requotify(para);
		}
	}
}
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;
ed08c171	20	import be.nikiroo.utils.Progress;
68e370a4 NR	21	import be.nikiroo.utils.test.TestCase;
	22	import be.nikiroo.utils.test.TestLauncher;
	23
	24	public class BasicSupportTest extends TestLauncher {
22848428	25	// quote chars
e8eeea0a	26	private char openQuote = Instance.getTrans().getCharacter(
22848428	27	StringId.OPEN_SINGLE_QUOTE);
e8eeea0a	28	private char closeQuote = Instance.getTrans().getCharacter(
22848428	29	StringId.CLOSE_SINGLE_QUOTE);
e8eeea0a	30	private char openDoubleQuote = Instance.getTrans().getCharacter(
22848428	31	StringId.OPEN_DOUBLE_QUOTE);
e8eeea0a	32	private char closeDoubleQuote = Instance.getTrans().getCharacter(
22848428	33	StringId.CLOSE_DOUBLE_QUOTE);
68e370a4 NR	34
	35	public BasicSupportTest(String[] args) {
	36	super("BasicSupport", args);
	37
	38	addSeries(new TestLauncher("General", args) {
	39	{
	40	addTest(new TestCase("BasicSupport.makeParagraphs()") {
	41	@Override
	42	public void test() throws Exception {
	43	BasicSupportEmpty support = new BasicSupportEmpty() {
	44	@Override
	45	protected boolean isHtml() {
	46	return true;
	47	}
	48
	49	@Override
	50	public void fixBlanksBreaks(List<Paragraph> paras) {
	51	}
	52
	53	@Override
793f1071	54	public List<Paragraph> requotify(Paragraph para) {
68e370a4 NR	55	List<Paragraph> paras = new ArrayList<Paragraph>(
	56	1);
	57	paras.add(para);
	58	return paras;
	59	}
	60	};
	61
	62	List<Paragraph> paras = null;
	63
ed08c171	64	paras = support.makeParagraphs(null, "", null);
68e370a4 NR	65	assertEquals(
	66	"An empty content should not generate paragraphs",
	67	0, paras.size());
	68
	69	paras = support.makeParagraphs(null,
ed08c171	70	"Line 1</p><p>Line 2</p><p>Line 3</p>", null);
68e370a4 NR	71	assertEquals(5, paras.size());
	72	assertEquals("Line 1", paras.get(0).getContent());
	73	assertEquals(ParagraphType.BLANK, paras.get(1)
	74	.getType());
	75	assertEquals("Line 2", paras.get(2).getContent());
	76	assertEquals(ParagraphType.BLANK, paras.get(3)
	77	.getType());
	78	assertEquals("Line 3", paras.get(4).getContent());
	79
	80	paras = support.makeParagraphs(null,
ed08c171	81	"<p>Line1</p><p>Line2</p><p>Line3</p>", null);
68e370a4 NR	82	assertEquals(6, paras.size());
	83	}
	84	});
	85
	86	addTest(new TestCase("BasicSupport.removeDoubleBlanks()") {
	87	@Override
	88	public void test() throws Exception {
	89	BasicSupportEmpty support = new BasicSupportEmpty() {
	90	@Override
	91	protected boolean isHtml() {
	92	return true;
	93	}
	94	};
	95
	96	List<Paragraph> paras = null;
	97
	98	paras = support
ed08c171 NR	99	.makeParagraphs(
	100	null,
	101	"<p>Line1</p><p>Line2</p><p>Line3<br/><br><p></p>",
	102	null);
68e370a4 NR	103	assertEquals(5, paras.size());
	104
	105	paras = support
ed08c171 NR	106	.makeParagraphs(
	107	null,
	108	"<p>Line1</p><p>Line2</p><p>Line3<br/><br><p></p>* * *",
	109	null);
68e370a4 NR	110	assertEquals(5, paras.size());
68e370a4 NR	111
ed08c171 NR	112	paras = support.makeParagraphs(null, "1<p>* * *<p>2",
ed08c171 NR	113	null);
68e370a4 NR	114	assertEquals(3, paras.size());
	115	assertEquals(ParagraphType.BREAK, paras.get(1)
	116	.getType());
	117
	118	paras = support.makeParagraphs(null,
ed08c171	119	"1<p><br/><p>* * *<p>2", null);
68e370a4 NR	120	assertEquals(3, paras.size());
	121	assertEquals(ParagraphType.BREAK, paras.get(1)
	122	.getType());
	123
	124	paras = support.makeParagraphs(null,
ed08c171	125	"1<p>* * *<br/><p><br><p>2", null);
68e370a4 NR	126	assertEquals(3, paras.size());
	127	assertEquals(ParagraphType.BREAK, paras.get(1)
	128	.getType());
	129
	130	paras = support.makeParagraphs(null,
ed08c171	131	"1<p><br/><br>* * *<br/><p><br><p>2", null);
68e370a4 NR	132	assertEquals(3, paras.size());
	133	assertEquals(ParagraphType.BREAK, paras.get(1)
	134	.getType());
	135	}
	136	});
22848428 NR	137
	138	addTest(new TestCase("BasicSupport.processPara() quotes") {
	139	@Override
	140	public void test() throws Exception {
	141	BasicSupportEmpty support = new BasicSupportEmpty() {
	142	@Override
	143	protected boolean isHtml() {
	144	return true;
	145	}
	146	};
	147
	148	Paragraph para;
	149
	150	// sanity check
	151	para = support.processPara("");
	152	assertEquals(ParagraphType.BLANK, para.getType());
	153	//
	154
	155	para = support.processPara("\"Yes, my Lord!\"");
	156	assertEquals(ParagraphType.QUOTE, para.getType());
	157	assertEquals(openDoubleQuote + "Yes, my Lord!"
	158	+ closeDoubleQuote, para.getContent());
	159
	160	para = support.processPara("«Yes, my Lord!»");
	161	assertEquals(ParagraphType.QUOTE, para.getType());
	162	assertEquals(openDoubleQuote + "Yes, my Lord!"
	163	+ closeDoubleQuote, para.getContent());
	164
	165	para = support.processPara("'Yes, my Lord!'");
	166	assertEquals(ParagraphType.QUOTE, para.getType());
	167	assertEquals(openQuote + "Yes, my Lord!" + closeQuote,
	168	para.getContent());
	169
	170	para = support.processPara("‹Yes, my Lord!›");
	171	assertEquals(ParagraphType.QUOTE, para.getType());
	172	assertEquals(openQuote + "Yes, my Lord!" + closeQuote,
	173	para.getContent());
	174	}
	175	});
	176
	177	addTest(new TestCase(
	178	"BasicSupport.processPara() double-simple quotes") {
	179	@Override
	180	public void setUp() throws Exception {
	181	super.setUp();
	182
211f7ddb	183	}
22848428 NR	184
	185	@Override
	186	public void tearDown() throws Exception {
	187
	188	super.tearDown();
	189	}
	190
	191	@Override
	192	public void test() throws Exception {
	193	BasicSupportEmpty support = new BasicSupportEmpty() {
	194	@Override
	195	protected boolean isHtml() {
	196	return true;
	197	}
	198	};
	199
	200	Paragraph para;
	201
	202	para = support.processPara("''Yes, my Lord!''");
	203	assertEquals(ParagraphType.QUOTE, para.getType());
	204	assertEquals(openDoubleQuote + "Yes, my Lord!"
	205	+ closeDoubleQuote, para.getContent());
	206
	207	para = support.processPara("‹‹Yes, my Lord!››");
	208	assertEquals(ParagraphType.QUOTE, para.getType());
	209	assertEquals(openDoubleQuote + "Yes, my Lord!"
	210	+ closeDoubleQuote, para.getContent());
	211	}
	212	});
	213
	214	addTest(new TestCase("BasicSupport.processPara() apostrophe") {
	215	@Override
	216	public void test() throws Exception {
	217	BasicSupportEmpty support = new BasicSupportEmpty() {
	218	@Override
	219	protected boolean isHtml() {
	220	return true;
	221	}
	222	};
	223
	224	Paragraph para;
	225
	226	String text = "Nous étions en été, mais cela aurait être l'hiver quand nous n'étions encore qu'à Aubeuge";
	227	para = support.processPara(text);
	228	assertEquals(ParagraphType.NORMAL, para.getType());
	229	assertEquals(text, para.getContent());
	230	}
	231	});
793f1071 NR	232
	233	addTest(new TestCase("BasicSupport.processPara() words count") {
	234	@Override
	235	public void test() throws Exception {
	236	BasicSupportEmpty support = new BasicSupportEmpty() {
	237	@Override
	238	protected boolean isHtml() {
	239	return true;
	240	}
	241	};
	242
	243	Paragraph para;
	244
	245	para = support.processPara("«Yes, my Lord!»");
	246	assertEquals(3, para.getWords());
	247
	248	para = support.processPara("One, twee, trois.");
	249	assertEquals(3, para.getWords());
	250	}
	251	});
	252
	253	addTest(new TestCase("BasicSupport.requotify() words count") {
	254	@Override
	255	public void test() throws Exception {
	256	BasicSupportEmpty support = new BasicSupportEmpty();
	257
e8eeea0a NR	258	char openDoubleQuote = Instance.getTrans()
	259	.getCharacter(StringId.OPEN_DOUBLE_QUOTE);
	260	char closeDoubleQuote = Instance.getTrans()
	261	.getCharacter(StringId.CLOSE_DOUBLE_QUOTE);
793f1071 NR	262
	263	String content = null;
	264	Paragraph para = null;
	265	List<Paragraph> paras = null;
	266	long words = 0;
	267
	268	content = "One, twee, trois.";
	269	para = new Paragraph(ParagraphType.NORMAL, content,
	270	content.split(" ").length);
	271	paras = support.requotify(para);
	272	words = 0;
	273	for (Paragraph p : paras) {
	274	words += p.getWords();
	275	}
	276	assertEquals("Bad words count in a single paragraph",
	277	para.getWords(), words);
	278
	279	content = "Such WoW! So Web2.0! With Colours!";
	280	para = new Paragraph(ParagraphType.NORMAL, content,
	281	content.split(" ").length);
	282	paras = support.requotify(para);
	283	words = 0;
	284	for (Paragraph p : paras) {
	285	words += p.getWords();
	286	}
	287	assertEquals("Bad words count in a single paragraph",
	288	para.getWords(), words);
	289
	290	content = openDoubleQuote + "Such a good idea!"
	291	+ closeDoubleQuote
	292	+ ", she said. This ought to be a new para.";
	293	para = new Paragraph(ParagraphType.QUOTE, content,
	294	content.split(" ").length);
	295	paras = support.requotify(para);
	296	words = 0;
	297	for (Paragraph p : paras) {
	298	words += p.getWords();
	299	}
	300	assertEquals(
	301	"Bad words count in a requotified paragraph",
	302	para.getWords(), words);
	303	}
	304	});
22848428 NR	305	}
	306	});
	307
	308	addSeries(new TestLauncher("Text", args) {
	309	{
	310	addTest(new TestCase("Chapter detection simple") {
	311	private File tmp;
	312
	313	@Override
	314	public void setUp() throws Exception {
	315	tmp = File.createTempFile("fanfix-text-file_", ".test");
	316	IOUtils.writeSmallFile(tmp.getParentFile(),
	317	tmp.getName(), "TITLE"
	318	+ "\n"//
	319	+ "By nona"
	320	+ "\n" //
	321	+ "\n" //
	322	+ "Chapter 0: Resumé" + "\n" + "\n"
	323	+ "'sume." + "\n" + "\n"
	324	+ "Chapter 1: chap1" + "\n" + "\n"
	325	+ "Fanfan." + "\n" + "\n"
	326	+ "Chapter 2: Chap2" + "\n" + "\n" //
	327	+ "Tulipe." + "\n");
211f7ddb	328	}
22848428 NR	329
	330	@Override
	331	public void tearDown() throws Exception {
	332	tmp.delete();
211f7ddb	333	}
22848428 NR	334
	335	@Override
	336	public void test() throws Exception {
	337	BasicSupport support = BasicSupport
	338	.getSupport(SupportType.TEXT);
	339
	340	Story story = support
	341	.process(tmp.toURI().toURL(), null);
	342
	343	assertEquals(2, story.getChapters().size());
	344	assertEquals(1, story.getChapters().get(1)
	345	.getParagraphs().size());
	346	assertEquals("Tulipe.", story.getChapters().get(1)
	347	.getParagraphs().get(0).getContent());
	348	}
	349	});
	350
	351	addTest(new TestCase("Chapter detection with String 'Chapter'") {
	352	private File tmp;
	353
	354	@Override
	355	public void setUp() throws Exception {
	356	tmp = File.createTempFile("fanfix-text-file_", ".test");
	357	IOUtils.writeSmallFile(tmp.getParentFile(),
	358	tmp.getName(), "TITLE"
	359	+ "\n"//
	360	+ "By nona"
	361	+ "\n" //
	362	+ "\n" //
	363	+ "Chapter 0: Resumé" + "\n" + "\n"
	364	+ "'sume." + "\n" + "\n"
	365	+ "Chapter 1: chap1" + "\n" + "\n"
	366	+ "Chapter fout-la-merde" + "\n"
	367	+ "\n"//
	368	+ "Fanfan." + "\n" + "\n"
	369	+ "Chapter 2: Chap2" + "\n" + "\n" //
	370	+ "Tulipe." + "\n");
211f7ddb	371	}
22848428 NR	372
	373	@Override
	374	public void tearDown() throws Exception {
	375	tmp.delete();
211f7ddb	376	}
22848428 NR	377
	378	@Override
	379	public void test() throws Exception {
	380	BasicSupport support = BasicSupport
	381	.getSupport(SupportType.TEXT);
	382
	383	Story story = support
	384	.process(tmp.toURI().toURL(), null);
	385
	386	assertEquals(2, story.getChapters().size());
	387	assertEquals(1, story.getChapters().get(1)
	388	.getParagraphs().size());
	389	assertEquals("Tulipe.", story.getChapters().get(1)
	390	.getParagraphs().get(0).getContent());
	391	}
	392	});
68e370a4 NR	393	}
	394	});
	395	}
	396
	397	private class BasicSupportEmpty extends BasicSupport {
	398	@Override
	399	protected String getSourceName() {
	400	return null;
	401	}
	402
	403	@Override
	404	protected boolean supports(URL url) {
	405	return false;
	406	}
	407
	408	@Override
	409	protected boolean isHtml() {
	410	return false;
	411	}
	412
	413	@Override
	414	protected MetaData getMeta(URL source, InputStream in)
	415	throws IOException {
	416	return null;
	417	}
	418
	419	@Override
	420	protected String getDesc(URL source, InputStream in) throws IOException {
	421	return null;
	422	}
	423
	424	@Override
	425	protected List<Entry<String, URL>> getChapters(URL source,
ed08c171	426	InputStream in, Progress pg) throws IOException {
68e370a4 NR	427	return null;
	428	}
	429
	430	@Override
	431	protected String getChapterContent(URL source, InputStream in,
ed08c171	432	int number, Progress pg) throws IOException {
68e370a4 NR	433	return null;
	434	}
	435
	436	@Override
	437	// and make it public!
ed08c171 NR	438	public List<Paragraph> makeParagraphs(URL source, String content,
	439	Progress pg) throws IOException {
	440	return super.makeParagraphs(source, content, pg);
68e370a4 NR	441	}
	442
	443	@Override
	444	// and make it public!
	445	public void fixBlanksBreaks(List<Paragraph> paras) {
	446	super.fixBlanksBreaks(paras);
	447	}
22848428 NR	448
	449	@Override
	450	// and make it public!
	451	public Paragraph processPara(String line) {
	452	return super.processPara(line);
	453	}
793f1071 NR	454
	455	@Override
	456	// and make it public!
	457	public List<Paragraph> requotify(Paragraph para) {
	458	return super.requotify(para);
	459	}
68e370a4 NR	460	}
68e370a4 NR	461	}