/src/test/java/com/tr/rp/rpl/TestRPLExamples.java

https://github.com/tjitze/RankPL · Java · 284 lines · 256 code · 23 blank · 5 comment · 19 complexity · 6f6b51fb7a4f4a57df4207752efa6211 MD5 · raw file 

    

  1. package com.tr.rp.rpl;
    2. 

  2. 

  3. import java.util.Arrays;
    4. 

  4. import java.util.HashMap;
    5. 

  5. import java.util.HashSet;
    6. 

  6. import java.util.LinkedHashMap;
    7. 

  7. import java.util.Map;
    8. 

  8. import java.util.Map.Entry;
    9. 

  9. import java.util.Set;
    10. 

  10. 

  11. import com.tr.rp.RankPL;
    12. 

  12. import com.tr.rp.ast.statements.Program;
    13. 

  13. import com.tr.rp.base.Rank;
    14. 

  14. import com.tr.rp.executors.Guard;
    15. 

  15. 

  16. import junit.framework.TestCase;
    17. 

  17. 

  18. public class TestRPLExamples extends TestCase {
    19. 

  19. 

  20. 	public TestRPLExamples() {
    21. 

  21. 		Guard.setEnabled(true);
    22. 

  22. 	}
    23. 

  23. 

  24. 	public void testBoolCircuitExample() {
    25. 

  25. 		
    26. 

  26. 		Map<Integer, Set<String>> expectedResultMap = new HashMap<Integer, Set<String>>();
    27. 

  27. 		expectedResultMap.put(0, new HashSet<String>(Arrays.asList(
    28. 

  28. 				"X1 broken: true, X2 broken: false, A1 broken: false, a2 broken: false, O1 broken: false"
    29. 

  29. 		)));
    30. 

  30. 		expectedResultMap.put(1, new HashSet<String>(Arrays.asList(
    31. 

  31. 				"X1 broken: false, X2 broken: true, A1 broken: false, a2 broken: true, O1 broken: false",
    32. 

  32. 				"X1 broken: false, X2 broken: true, A1 broken: false, a2 broken: false, O1 broken: true",
    33. 

  33. 				"X1 broken: true, X2 broken: true, A1 broken: false, a2 broken: false, O1 broken: false",
    34. 

  34. 				"X1 broken: false, X2 broken: true, A1 broken: true, a2 broken: false, O1 broken: false",
    35. 

  35. 				"X1 broken: true, X2 broken: false, A1 broken: true, a2 broken: false, O1 broken: false",
    36. 

  36. 				"X1 broken: true, X2 broken: false, A1 broken: false, a2 broken: false, O1 broken: true",
    37. 

  37. 				"X1 broken: true, X2 broken: false, A1 broken: false, a2 broken: true, O1 broken: false"
    38. 

  38. 		)));
    39. 

  39. 		expectedResultMap.put(2, new HashSet<String>(Arrays.asList(
    40. 

  40. 				"X1 broken: true, X2 broken: true, A1 broken: true, a2 broken: false, O1 broken: false",
    41. 

  41. 				"X1 broken: true, X2 broken: false, A1 broken: true, a2 broken: true, O1 broken: false",
    42. 

  42. 				"X1 broken: false, X2 broken: true, A1 broken: true, a2 broken: true, O1 broken: false",
    43. 

  43. 				"X1 broken: true, X2 broken: true, A1 broken: false, a2 broken: true, O1 broken: false",
    44. 

  44. 				"X1 broken: true, X2 broken: false, A1 broken: false, a2 broken: true, O1 broken: true",
    45. 

  45. 				"X1 broken: false, X2 broken: true, A1 broken: false, a2 broken: true, O1 broken: true",
    46. 

  46. 				"X1 broken: false, X2 broken: true, A1 broken: true, a2 broken: false, O1 broken: true",
    47. 

  47. 				"X1 broken: true, X2 broken: true, A1 broken: false, a2 broken: false, O1 broken: true",
    48. 

  48. 				"X1 broken: true, X2 broken: false, A1 broken: true, a2 broken: false, O1 broken: true"
    49. 

  49. 		)));
    50. 

  50. 		expectedResultMap.put(3, new HashSet<String>(Arrays.asList(
    51. 

  51. 				"X1 broken: true, X2 broken: true, A1 broken: true, a2 broken: true, O1 broken: false",
    52. 

  52. 				"X1 broken: true, X2 broken: true, A1 broken: true, a2 broken: false, O1 broken: true",
    53. 

  53. 				"X1 broken: true, X2 broken: false, A1 broken: true, a2 broken: true, O1 broken: true",
    54. 

  54. 				"X1 broken: true, X2 broken: true, A1 broken: false, a2 broken: true, O1 broken: true",
    55. 

  55. 				"X1 broken: false, X2 broken: true, A1 broken: true, a2 broken: true, O1 broken: true"
    56. 

  56. 		)));
    57. 

  57. 		expectedResultMap.put(4, new HashSet<String>(Arrays.asList(
    58. 

  58. 				"X1 broken: true, X2 broken: true, A1 broken: true, a2 broken: true, O1 broken: true"
    59. 

  59. 		)));
    60. 

  60. 		
    61. 

  61. 		String file = "./examples/boolcircuit.rpl";
    62. 

  62. 		try { 
    63. 

  63. 			System.out.print("Running test " + file + "... ");
    64. 

  64. 			String source = RankPL.getFileContent(file);
    65. 

  65. 			Program program = RankPL.parse(source);
    66. 

  66. 			if (program == null) {
    67. 

  67. 				fail("Parse error");
    68. 

  68. 			}
    69. 

  69. 			Map<Integer, Set<String>> resultMap = RankPL.execute(program, Rank.MAX, Rank.MAX, false, false);
    70. 

  70. 			assertEquals(expectedResultMap, resultMap);
    71. 

  71. 		} catch (Exception e) {
    72. 

  72. 			e.printStackTrace();
    73. 

  73. 			fail("Failure: " + e.toString());
    74. 

  74. 		}
    75. 

  75. 	}
    76. 

  76. 	
    77. 

  77. 	public void testRankingNetworkExample() {
    78. 

  78. 		
    79. 

  79. 		Map<Integer, Set<String>> expectedResultMap = new HashMap<Integer, Set<String>>();
    80. 

  80. 		expectedResultMap.put(0, new HashSet<String>(Arrays.asList(
    81. 

  81. 				"rain: false	sprinkler: true	grass_wet: true"
    82. 

  82. 		)));
    83. 

  83. 		expectedResultMap.put(2, new HashSet<String>(Arrays.asList(
    84. 

  84. 				"rain: true	sprinkler: true	grass_wet: true",
    85. 

  85. 				"rain: false	sprinkler: true	grass_wet: false"
    86. 

  86. 		)));
    87. 

  87. 		expectedResultMap.put(7, new HashSet<String>(Arrays.asList(
    88. 

  88. 				"rain: true	sprinkler: true	grass_wet: false"
    89. 

  89. 		)));
    90. 

  90. 		
    91. 

  91. 		String file = "./examples/rankingnetwork.rpl";
    92. 

  92. 		try { 
    93. 

  93. 			System.out.print("Running test " + file + "... ");
    94. 

  94. 			String source = RankPL.getFileContent(file);
    95. 

  95. 			Program program = RankPL.parse(source);
    96. 

  96. 			if (program == null) {
    97. 

  97. 				fail("Parse error");
    98. 

  98. 			}
    99. 

  99. 			Map<Integer, Set<String>> resultMap = RankPL.execute(program, Rank.MAX, Rank.MAX, false, false);
    100. 

  100. 			assertEquals(expectedResultMap, resultMap);
    101. 

  101. 		} catch (Exception e) {
    102. 

  102. 			e.printStackTrace();
    103. 

  103. 			fail("Failure: " + e.toString());
    104. 

  104. 		}
    105. 

  105. 	}
    106. 

  106. 

  107. 	public void testSpellingCorrectorExample() {
    108. 

  108. 		Map<Integer, Set<String>> expectedResultMap = new HashMap<Integer, Set<String>>();
    109. 

  109. 		expectedResultMap.put(0, new HashSet<String>(Arrays.asList(
    110. 

  110. 				"twelve", "eleven"
    111. 

  111. 		)));
    112. 

  112. 		expectedResultMap.put(2, new HashSet<String>(Arrays.asList(
    113. 

  113. 				"seven"
    114. 

  114. 		)));
    115. 

  115. 		expectedResultMap.put(3, new HashSet<String>(Arrays.asList(
    116. 

  116. 				"thirteen", "fifteen", "sixteen", "ten", "twenty", "three", "nineteen"
    117. 

  117. 		)));
    118. 

  118. 		expectedResultMap.put(4, new HashSet<String>(Arrays.asList(
    119. 

  119. 				"eighteen", "fourteen", "two", "five", "seventeen"
    120. 

  120. 		)));
    121. 

  121. 		expectedResultMap.put(5, new HashSet<String>(Arrays.asList(
    122. 

  122. 				"eight", "one", "nine"
    123. 

  123. 		)));
    124. 

  124. 		expectedResultMap.put(6, new HashSet<String>(Arrays.asList(
    125. 

  125. 				"four", "six"
    126. 

  126. 		)));
    127. 

  127. 		
    128. 

  128. 		String file = "./examples/spellingcorrector.rpl";
    129. 

  129. 		try { 
    130. 

  130. 			System.out.print("Running test " + file + "... ");
    131. 

  131. 			String source = RankPL.getFileContent(file);
    132. 

  132. 			Program program = RankPL.parse(source);
    133. 

  133. 			if (program == null) {
    134. 

  134. 				fail("Parse error");
    135. 

  135. 			}
    136. 

  136. 			Map<Integer, Set<String>> resultMap = RankPL.execute(program, Rank.MAX, Rank.MAX, false, false);
    137. 

  137. 			assertEquals(expectedResultMap, resultMap);
    138. 

  138. 		} catch (Exception e) {
    139. 

  139. 			e.printStackTrace();
    140. 

  140. 			fail("Failure: " + e.toString());
    141. 

  141. 		}
    142. 

  142. 	}
    143. 

  143. 

  144. 	public void testSpellingCorrectorExample10K() {
    145. 

  145. 		
    146. 

  146. 		// We test a couple of different inputs and compare the first match
    147. 

  147. 		String actualExample = "inkorrect";
    148. 

  148. 		Map<String, String> expectedResults = new LinkedHashMap<String, String>();
    149. 

  149. 		expectedResults.put("inkorrect", "incorrect");
    150. 

  150. 		expectedResults.put("switzerland", "switzerland");
    151. 

  151. 		expectedResults.put("swizerland", "switzerland");
    152. 

  152. 		expectedResults.put("switxzerland", "switzerland");
    153. 

  153. 		expectedResults.put("svitzerland", "switzerland");
    154. 

  154. 		expectedResults.put("svvitzerland", "switzerland");
    155. 

  155. 		expectedResults.put("serbia", "serbia");
    156. 

  156. 		expectedResults.put("srbia", "serbia");
    157. 

  157. 		expectedResults.put("serrbia", "serbia");
    158. 

  158. 		expectedResults.put("serbja", "serbia");
    159. 

  159. 		
    160. 

  160. 		for (Entry<String, String> entry: expectedResults.entrySet()) {
    161. 

  161. 			String file = "./examples/spellingcorrector-10K-words.rpl";
    162. 

  162. 			try {
    163. 

  163. 				System.out.println("Running test " + file + " with input " + entry.getKey());
    164. 

  164. 				String source = RankPL.getFileContent(file);
    165. 

  165. 				source = source.replaceFirst(actualExample, entry.getKey());
    166. 

  166. 				Program program = RankPL.parse(source);
    167. 

  167. 				if (program == null) {
    168. 

  168. 					fail("Parse error");
    169. 

  169. 				}
    170. 

  170. 				Map<Integer, Set<String>> resultMap = RankPL.execute(program, Rank.MAX, Rank.MAX, false, true);
    171. 

  171. 				assertTrue(resultMap.size() == 1);
    172. 

  172. 				assertTrue(resultMap.get(0).size() == 1);
    173. 

  173. 				assertEquals(entry.getValue(), resultMap.get(0).iterator().next());
    174. 

  174. 			} catch (Exception e) {
    175. 

  175. 				e.printStackTrace();
    176. 

  176. 				fail("Failure: " + e.toString());
    177. 

  177. 			}
    178. 

  178. 		}
    179. 

  179. 	}
    180. 

  180. 	
    181. 

  181. 	public void testLocalizerExample() {
    182. 

  182. 		
    183. 

  183. 		Map<Integer, Set<String>> expectedResultMapK1 = new HashMap<Integer, Set<String>>();
    184. 

  184. 		expectedResultMapK1.put(0, new HashSet<String>(Arrays.asList(
    185. 

  185. 				"Inferred location (1, 5)",
    186. 

  186. 				"Inferred location (2, 5)",
    187. 

  187. 				"Inferred location (3, 5)",
    188. 

  188. 				"Inferred location (5, 4)"
    189. 

  189. 		)));
    190. 

  190. 		expectedResultMapK1.put(1, new HashSet<String>(Arrays.asList(
    191. 

  191. 				"Inferred location (10, 4)",
    192. 

  192. 				"Inferred location (9, 4)",
    193. 

  193. 				"Inferred location (8, 4)",
    194. 

  194. 				"Inferred location (7, 4)",
    195. 

  195. 				"Inferred location (6, 4)",
    196. 

  196. 				"Inferred location (4, 4)",
    197. 

  197. 				"Inferred location (10, 5)",
    198. 

  198. 				"Inferred location (9, 5)",
    199. 

  199. 				"Inferred location (8, 5)",
    200. 

  200. 				"Inferred location (7, 5)",
    201. 

  201. 				"Inferred location (6, 5)",
    202. 

  202. 				"Inferred location (4, 5)"
    203. 

  203. 		)));
    204. 

  204. 		
    205. 

  205. 		Map<Integer, Set<String>> expectedResultMapK2 = new HashMap<Integer, Set<String>>();
    206. 

  206. 		expectedResultMapK2.put(0, new HashSet<String>(Arrays.asList(
    207. 

  207. 				"Inferred location (6, 4)"
    208. 

  208. 		)));
    209. 

  209. 		expectedResultMapK2.put(1, new HashSet<String>(Arrays.asList(
    210. 

  210. 				"Inferred location (2, 5)",
    211. 

  211. 				"Inferred location (4, 5)",
    212. 

  212. 				"Inferred location (3, 5)",
    213. 

  213. 				"Inferred location (7, 4)",
    214. 

  214. 				"Inferred location (8, 4)",
    215. 

  215. 				"Inferred location (9, 4)",
    216. 

  216. 				"Inferred location (10, 4)"
    217. 

  217. 		)));
    218. 

  218. 

  219. 		Map<Integer, Set<String>> expectedResultMapK3 = new HashMap<Integer, Set<String>>();
    220. 

  220. 		expectedResultMapK3.put(0, new HashSet<String>(Arrays.asList(
    221. 

  221. 				"Inferred location (7, 4)",
    222. 

  222. 				"Inferred location (3, 5)"
    223. 

  223. 		)));
    224. 

  224. 		expectedResultMapK3.put(1, new HashSet<String>(Arrays.asList(
    225. 

  225. 				"Inferred location (8, 4)",
    226. 

  226. 				"Inferred location (9, 4)",
    227. 

  227. 				"Inferred location (10, 4)",
    228. 

  228. 				"Inferred location (4, 5)"
    229. 

  229. 		)));
    230. 

  230. 

  231. 		Map<Integer, Set<String>> expectedResultMapK4 = new HashMap<Integer, Set<String>>();
    232. 

  232. 		expectedResultMapK4.put(0, new HashSet<String>(Arrays.asList(
    233. 

  233. 				"Inferred location (4, 5)"
    234. 

  234. 		)));
    235. 

  235. 		expectedResultMapK4.put(1, new HashSet<String>(Arrays.asList(
    236. 

  236. 				"Inferred location (8, 4)"
    237. 

  237. 		)));
    238. 

  238. 

  239. 		String file = "./examples/localizer.rpl";
    240. 

  240. 		try { 
    241. 

  241. 			System.out.print("Running test " + file + "... ");
    242. 

  242. 			// K1
    243. 

  243. 			String source = RankPL.getFileContent(file);
    244. 

  244. 			source = source.replaceFirst("k := 1", "k := 1");
    245. 

  245. 			Program program = RankPL.parse(source);
    246. 

  246. 			if (program == null) {
    247. 

  247. 				fail("Parse error");
    248. 

  248. 			}
    249. 

  249. 			Map<Integer, Set<String>> resultMap = RankPL.execute(program, Rank.MAX, 1, false, false);
    250. 

  250. 			assertEquals(expectedResultMapK1, resultMap);
    251. 

  251. 			// K2
    252. 

  252. 			source = RankPL.getFileContent(file);
    253. 

  253. 			source = source.replaceFirst("k := 1", "k := 2");
    254. 

  254. 			program = RankPL.parse(source);
    255. 

  255. 			if (program == null) {
    256. 

  256. 				fail("Parse error");
    257. 

  257. 			}
    258. 

  258. 			resultMap = RankPL.execute(program, Rank.MAX, 1, false, false);
    259. 

  259. 			assertEquals(expectedResultMapK2, resultMap);
    260. 

  260. 			// K3
    261. 

  261. 			source = RankPL.getFileContent(file);
    262. 

  262. 			source = source.replaceFirst("k := 1", "k := 3");
    263. 

  263. 			program = RankPL.parse(source);
    264. 

  264. 			if (program == null) {
    265. 

  265. 				fail("Parse error");
    266. 

  266. 			}
    267. 

  267. 			resultMap = RankPL.execute(program, Rank.MAX, 1, false, false);
    268. 

  268. 			assertEquals(expectedResultMapK3, resultMap);
    269. 

  269. 			// K4
    270. 

  270. 			source = RankPL.getFileContent(file);
    271. 

  271. 			source = source.replaceFirst("k := 1", "k := 4");
    272. 

  272. 			program = RankPL.parse(source);
    273. 

  273. 			if (program == null) {
    274. 

  274. 				fail("Parse error");
    275. 

  275. 			}
    276. 

  276. 			resultMap = RankPL.execute(program, Rank.MAX, 1, false, false);
    277. 

  277. 			assertEquals(expectedResultMapK4, resultMap);
    278. 

  278. 

  279. 		} catch (Exception e) {
    280. 

  280. 			e.printStackTrace();
    281. 

  281. 			fail("Failure: " + e.toString());
    282. 

  282. 		}
    283. 

  283. 	}
    284. 

  284. }
    285.