[67] | 1 | package org.expeditee.io;
|
---|
| 2 |
|
---|
| 3 | import java.awt.Font;
|
---|
[72] | 4 | import java.awt.Point;
|
---|
[80] | 5 | import java.lang.reflect.Method;
|
---|
[72] | 6 | import java.util.ArrayList;
|
---|
| 7 | import java.util.List;
|
---|
[67] | 8 |
|
---|
| 9 | import junit.framework.TestCase;
|
---|
| 10 |
|
---|
[1102] | 11 | import org.expeditee.core.Colour;
|
---|
[67] | 12 | import org.expeditee.items.Item;
|
---|
[96] | 13 | import org.expeditee.items.Justification;
|
---|
[72] | 14 | import org.expeditee.items.Text;
|
---|
[67] | 15 |
|
---|
| 16 | public class ConversionTest extends TestCase {
|
---|
| 17 |
|
---|
| 18 | public final void testGetColor() {
|
---|
[1102] | 19 | assertEquals(null, Conversion.getColor("TrAnSpArEnT", Colour.WHITE));
|
---|
| 20 | assertEquals(null, Conversion.getColor("Clear", Colour.WHITE));
|
---|
| 21 | assertEquals(null, Conversion.getColor("Auto", Colour.WHITE));
|
---|
| 22 | assertEquals(null, Conversion.getColor("Default", Colour.WHITE));
|
---|
| 23 | assertEquals(null, Conversion.getColor("adf", Colour.RED));
|
---|
| 24 | assertEquals(null, Conversion.getColor("none", Colour.RED));
|
---|
| 25 | assertEquals(null, Conversion.getColor("null", Colour.RED));
|
---|
| 26 | assertEquals(null, Conversion.getColor(null, Colour.RED));
|
---|
| 27 | assertEquals(null, Conversion.getColor("a0a0a0", Colour.WHITE));
|
---|
[80] | 28 |
|
---|
[1102] | 29 | assertEquals(Colour.RED, Conversion.getColor("100 0 0", Colour.WHITE));
|
---|
| 30 | assertEquals(Colour.GREEN, Conversion.getColor("0 100 0", Colour.WHITE));
|
---|
| 31 | assertEquals(Colour.BLUE, Conversion.getColor("0 0 100", Colour.WHITE));
|
---|
| 32 | assertEquals(Colour.WHITE, Conversion.getColor("100 100 100",
|
---|
| 33 | Colour.WHITE));
|
---|
| 34 | assertEquals(Colour.GREY, Conversion.getColor("50 50 50", Colour.WHITE));
|
---|
| 35 | assertEquals(Colour.GREEN, Conversion.getColor("-100 +0 -100",
|
---|
| 36 | Colour.WHITE));
|
---|
| 37 | assertEquals(Colour.GREEN, Conversion.getColor("-10 +100 +0",
|
---|
| 38 | Colour.BLACK));
|
---|
| 39 | assertEquals(Colour.GREEN, Conversion.getColor("+0 +110 +0", null));
|
---|
[86] | 40 |
|
---|
[1102] | 41 | assertEquals(Conversion.getColor("red9", Colour.WHITE), new Colour(0.9F,
|
---|
[72] | 42 | 0.0F, 0.0F));
|
---|
[1102] | 43 | assertEquals(Conversion.getColor("BlUe15", Colour.WHITE), new Colour(
|
---|
[72] | 44 | 0.0F, 0.0F, 1.0F));
|
---|
[1102] | 45 | assertEquals(Conversion.getColor("GREEN0", Colour.WHITE), new Colour(
|
---|
[72] | 46 | 0.0F, 0.0F, 0.0F));
|
---|
[1102] | 47 | assertEquals(Conversion.getColor("GREEN3", Colour.WHITE), new Colour(
|
---|
[80] | 48 | 0.0F, 0.3F, 0.0F));
|
---|
[1102] | 49 | assertEquals(Conversion.getColor("Blue1", Colour.WHITE), new Colour(0.0F,
|
---|
[86] | 50 | 0.0F, 0.1F));
|
---|
[67] | 51 | }
|
---|
| 52 |
|
---|
[80] | 53 | public final void testGetExpediteeColorCode() {
|
---|
[1102] | 54 | assertTrue(Conversion.getExpediteeColorCode(Colour.RED)
|
---|
[80] | 55 | .equals("100 0 0"));
|
---|
[1102] | 56 | assertTrue(Conversion.getExpediteeColorCode(Colour.GREEN).equals(
|
---|
[80] | 57 | "0 100 0"));
|
---|
[1102] | 58 | assertTrue(Conversion.getExpediteeColorCode(Colour.BLUE).equals(
|
---|
[80] | 59 | "0 0 100"));
|
---|
[67] | 60 | }
|
---|
| 61 |
|
---|
[80] | 62 | public final void testGetExpediteeFontCode() {
|
---|
[72] | 63 | Font testFont = new Font(Text.FONT_WHEEL[1], Font.BOLD, 18);
|
---|
| 64 | Font testFont2 = new Font(Text.FONT_WHEEL[4], Font.ITALIC, 20);
|
---|
[80] | 65 | Font testFont3 = new Font("xxx123", Font.ITALIC | Font.BOLD, 10);
|
---|
[72] | 66 | Font testFont4 = new Font(Text.FONT_WHEEL[0], Font.PLAIN, 2);
|
---|
[67] | 67 |
|
---|
[72] | 68 | String result = Text.FONT_CHARS[1] + "b18";
|
---|
[80] | 69 | assertEquals(result, Conversion.getExpediteeFontCode(testFont));
|
---|
| 70 |
|
---|
[72] | 71 | result = Text.FONT_CHARS[4] + "i20";
|
---|
[80] | 72 | assertEquals(result, Conversion.getExpediteeFontCode(testFont2));
|
---|
| 73 |
|
---|
[72] | 74 | result = "dp10";
|
---|
[80] | 75 | assertEquals(result, Conversion.getExpediteeFontCode(testFont3));
|
---|
| 76 |
|
---|
[72] | 77 | result = Text.FONT_CHARS[0] + "r2";
|
---|
[80] | 78 | assertEquals(result, Conversion.getExpediteeFontCode(testFont4));
|
---|
[67] | 79 | }
|
---|
| 80 |
|
---|
[72] | 81 | public final void testGetFont() {
|
---|
| 82 | Font testFont = new Font(Text.FONT_WHEEL[1], Font.BOLD, 18);
|
---|
| 83 | Font testFont2 = new Font(Text.FONT_WHEEL[4], Font.ITALIC, 20);
|
---|
| 84 | Font testFont3 = new Font(Text.FONT_WHEEL[3], Font.ITALIC | Font.BOLD,
|
---|
| 85 | 10);
|
---|
| 86 | Font testFont4 = new Font(Text.FONT_WHEEL[0], Font.PLAIN, 2);
|
---|
[67] | 87 |
|
---|
[72] | 88 | String code = Text.FONT_CHARS[1] + "b18";
|
---|
| 89 | assertEquals(testFont, Conversion.getFont(code));
|
---|
[80] | 90 |
|
---|
[72] | 91 | code = Text.FONT_CHARS[4] + "i20";
|
---|
| 92 | assertEquals(testFont2, Conversion.getFont(code));
|
---|
[80] | 93 |
|
---|
[72] | 94 | code = Text.FONT_CHARS[3] + "p10";
|
---|
| 95 | assertEquals(testFont3, Conversion.getFont(code));
|
---|
[80] | 96 |
|
---|
[72] | 97 | code = Text.FONT_CHARS[0] + "r2";
|
---|
| 98 | assertEquals(testFont4, Conversion.getFont(code));
|
---|
[67] | 99 | }
|
---|
| 100 |
|
---|
| 101 | public final void testGetFrameNumber() {
|
---|
| 102 | assertEquals(1, Conversion.getFrameNumber("a1"));
|
---|
| 103 | assertEquals(91, Conversion.getFrameNumber("a91"));
|
---|
| 104 | assertEquals(1, Conversion.getFrameNumber("a1C1"));
|
---|
| 105 | }
|
---|
| 106 |
|
---|
| 107 | public final void testGetFrameset() {
|
---|
[96] | 108 | assertTrue(Conversion.getFramesetName("a1").equals("a"));
|
---|
| 109 | assertTrue(Conversion.getFramesetName("a91").equals("a"));
|
---|
| 110 | assertTrue(Conversion.getFramesetName("Aa1C1").equals("aa1c"));
|
---|
| 111 | assertTrue(Conversion.getFramesetName("Aa1C1", false).equals("Aa1C"));
|
---|
| 112 | assertTrue(Conversion.getFramesetName("Abc1C1", true).equals(
|
---|
| 113 | Conversion.getFramesetName("Abc1C1")));
|
---|
[67] | 114 | }
|
---|
| 115 |
|
---|
| 116 | public final void testConvertClassString() {
|
---|
[80] | 117 | assertEquals(null, Conversion.Convert(Class.class, null));
|
---|
| 118 |
|
---|
[86] | 119 | assertEquals(" Test ", Conversion.Convert(String.class, " Test "));
|
---|
[67] | 120 | assertEquals(null, Conversion.Convert(String.class, ""));
|
---|
[80] | 121 |
|
---|
| 122 | // Test fonts
|
---|
| 123 | assertEquals(Conversion.getFont("tR16"), Conversion.Convert(Font.class,
|
---|
| 124 | "Tr16"));
|
---|
| 125 | assertEquals(Conversion.getFont("tR16"), Conversion.Convert(Font.class,
|
---|
| 126 | "Tr16"));
|
---|
| 127 |
|
---|
[72] | 128 | // Test Color Conversion
|
---|
[1102] | 129 | assertEquals(Colour.DARK_GREY, Conversion.Convert(Colour.class,
|
---|
[72] | 130 | "dark_gray"));
|
---|
[1102] | 131 | assertEquals(Colour.DARK_GREY, Conversion
|
---|
| 132 | .Convert(Colour.class, "DARKGRAY"));
|
---|
| 133 | assertEquals(Colour.RED, Conversion.Convert(Colour.class, "red"));
|
---|
| 134 | assertEquals(Colour.RED, Conversion.Convert(Colour.class, "Red"));
|
---|
| 135 | assertEquals(Colour.RED, Conversion.Convert(Colour.class, "RED"));
|
---|
| 136 | assertEquals(Colour.RED, Conversion.Convert(Colour.class, " 100 "));
|
---|
| 137 | assertEquals(Colour.GREEN, Conversion.Convert(Colour.class, "0 100"));
|
---|
| 138 | assertEquals(Colour.BLUE, Conversion.Convert(Colour.class, "0 0 100"));
|
---|
[72] | 139 | // Test Boolean Conversion
|
---|
[80] | 140 | assertEquals(true, Conversion.Convert(boolean.class, ""));
|
---|
[72] | 141 | assertEquals(true, Conversion.Convert(boolean.class, "tRuE"));
|
---|
| 142 | assertEquals(true, Conversion.Convert(boolean.class, "T"));
|
---|
| 143 | assertEquals(true, Conversion.Convert(boolean.class, "yes"));
|
---|
| 144 | assertEquals(true, Conversion.Convert(boolean.class, "Y"));
|
---|
| 145 | assertEquals(false, Conversion.Convert(boolean.class, "FALSE"));
|
---|
| 146 | assertEquals(false, Conversion.Convert(boolean.class, "no"));
|
---|
| 147 | assertEquals(false, Conversion.Convert(boolean.class, "n"));
|
---|
| 148 | assertEquals(false, Conversion.Convert(boolean.class, "f"));
|
---|
[80] | 149 | assertEquals(false, Conversion.Convert(boolean.class, "XXX"));
|
---|
[67] | 150 | }
|
---|
| 151 |
|
---|
| 152 | public final void testConvertClassStringObject() {
|
---|
[1102] | 153 | assertEquals(Colour.FromRGB255(255, 0, 255), Conversion.Convert(Colour.class,
|
---|
[86] | 154 | "+100 +0 +100", null));
|
---|
[1102] | 155 | assertEquals(Colour.RED, Conversion.Convert(Colour.class, "+100 +0 -100",
|
---|
| 156 | Colour.BLUE));
|
---|
| 157 | assertEquals(Colour.BLACK, Conversion.Convert(Colour.class, "-0 +0 -100",
|
---|
| 158 | Colour.BLUE));
|
---|
[72] | 159 | // Float test
|
---|
| 160 | assertEquals(2.0F, Conversion.Convert(float.class, "2.0", null));
|
---|
| 161 | assertEquals(-8.0F, Conversion.Convert(float.class, "+2.0", -10.0F));
|
---|
| 162 | assertEquals(8.0F, Conversion.Convert(float.class, "-2.0", 10.0F));
|
---|
[151] | 163 | // Float test
|
---|
| 164 | assertEquals(2.0F, Conversion.Convert(Float.class, "2.0", null));
|
---|
| 165 | assertEquals(-8.0F, Conversion.Convert(Float.class, "+2.0", -10.0F));
|
---|
| 166 | assertEquals(8.0F, Conversion.Convert(Float.class, "-2.0", 10.0F));
|
---|
| 167 | assertEquals(null, Conversion.Convert(Float.class, "", 10.0F));
|
---|
| 168 | assertEquals(null, Conversion.Convert(Float.class, "null", 10.0F));
|
---|
[72] | 169 | // Double test
|
---|
| 170 | assertEquals(2.0, Conversion.Convert(double.class, "2.0", null));
|
---|
| 171 | assertEquals(-8.0, Conversion.Convert(double.class, "+2.0", -10.0));
|
---|
| 172 | assertEquals(8.0, Conversion.Convert(double.class, "-2.0", 10.0));
|
---|
| 173 | // Integer test
|
---|
[114] | 174 | assertEquals(255, Conversion.Convert(int.class, "0xFF", null));
|
---|
| 175 | assertEquals(5, Conversion.Convert(int.class, "+0xF", -10));
|
---|
[72] | 176 | assertEquals(2, Conversion.Convert(int.class, "2", null));
|
---|
| 177 | assertEquals(-8, Conversion.Convert(int.class, "+2", -10));
|
---|
| 178 | assertEquals(8, Conversion.Convert(int.class, "-2", 10));
|
---|
[80] | 179 | assertEquals(-1, Conversion.Convert(int.class, "null", 10));
|
---|
[67] | 180 |
|
---|
[80] | 181 | // Integer Array test
|
---|
[86] | 182 | int[] expectedResult = { 2, 10, 4, 5 };
|
---|
| 183 | int[] actualResult = (int[]) Conversion.Convert(int[].class,
|
---|
| 184 | "2 10 4 5", null);
|
---|
| 185 | for (int i = 0; i < expectedResult.length; i++)
|
---|
[80] | 186 | assertEquals(expectedResult[i], actualResult[i]);
|
---|
| 187 |
|
---|
| 188 | // Point test
|
---|
| 189 | assertEquals(new Point(-2, 20), Conversion.Convert(Point.class,
|
---|
| 190 | " -2 20 ", null));
|
---|
| 191 | assertEquals(new Point(-12, 20), Conversion.Convert(Point.class,
|
---|
| 192 | "-2 20", new Point(-10, -20)));
|
---|
| 193 | assertEquals(new Point(-8, -30), Conversion.Convert(Point.class,
|
---|
| 194 | "+2 -10", new Point(-10, -20)));
|
---|
[67] | 195 | }
|
---|
| 196 |
|
---|
| 197 | public final void testConvertMethodStringObject() {
|
---|
[80] | 198 | try {
|
---|
[86] | 199 | Method appendLine = Text.class.getMethod("appendLine",
|
---|
| 200 | new Class[] { String.class });
|
---|
[80] | 201 | Method setPosition = Item.class.getMethod("setPosition",
|
---|
| 202 | new Class[] { Point.class });
|
---|
| 203 | Method setJustification = Text.class.getMethod("setJustification",
|
---|
[96] | 204 | new Class[] { Justification.class });
|
---|
[80] | 205 | Method setArrow = Text.class.getMethod("setArrow", new Class[] {
|
---|
[110] | 206 | float.class, double.class });
|
---|
[80] | 207 | Method setActions = Text.class.getMethod("setActions",
|
---|
| 208 | new Class[] { List.class });
|
---|
| 209 |
|
---|
| 210 | // Test that the two methods return the same value
|
---|
| 211 | assertEquals(Conversion.Convert(setPosition, " 10 20 ")[0],
|
---|
| 212 | Conversion.Convert(setPosition, " 10 20", null)[0]);
|
---|
| 213 | Object[] result = Conversion.Convert(setPosition, " 10 20", null);
|
---|
| 214 | assertEquals(1, result.length);
|
---|
| 215 | assertEquals(new Point(10, 20), result[0]);
|
---|
[86] | 216 |
|
---|
[80] | 217 | result = Conversion.Convert(setPosition, "-10 20", null);
|
---|
| 218 | assertEquals(1, result.length);
|
---|
| 219 | assertEquals(new Point(-10, 20), result[0]);
|
---|
| 220 |
|
---|
| 221 | // Test justification method
|
---|
| 222 | String justificationCode = " f ";
|
---|
| 223 | result = Conversion.Convert(setJustification, justificationCode,
|
---|
| 224 | null);
|
---|
| 225 | assertEquals(1, result.length);
|
---|
[428] | 226 | assertEquals(Justification.convertString(justificationCode),
|
---|
[80] | 227 | result[0]);
|
---|
[86] | 228 |
|
---|
[80] | 229 | justificationCode = "f";
|
---|
[86] | 230 | result = Conversion
|
---|
| 231 | .Convert(setJustification, justificationCode, "");
|
---|
[80] | 232 | assertEquals(1, result.length);
|
---|
[428] | 233 | assertEquals(Justification.convertString(justificationCode),
|
---|
[80] | 234 | result[0]);
|
---|
| 235 |
|
---|
| 236 | // Test the setting of Arrows
|
---|
| 237 | result = Conversion.Convert(setArrow, " 20 10.5 ", null);
|
---|
| 238 | assertEquals(2, result.length);
|
---|
[110] | 239 | assertEquals(20.0F, result[0]);
|
---|
[80] | 240 | assertEquals(10.5, result[1]);
|
---|
| 241 |
|
---|
| 242 | result = Conversion.Convert(setArrow, "+20 9.5", "10 10.5");
|
---|
[110] | 243 | assertEquals(30.0F, result[0]);
|
---|
[80] | 244 | assertEquals(9.5, result[1]);
|
---|
| 245 |
|
---|
| 246 | result = Conversion.Convert(setArrow, " 20 +2.5 ", "10 10.5");
|
---|
[110] | 247 | assertEquals(20.0F, result[0]);
|
---|
[80] | 248 | assertEquals(13.0, result[1]);
|
---|
[86] | 249 |
|
---|
[80] | 250 | assertEquals(null, Conversion.Convert(setArrow, " 23423 "));
|
---|
| 251 |
|
---|
| 252 | // Test a setMethod with list parameter
|
---|
| 253 | String actionsString = "action1\naction2\naction3";
|
---|
| 254 | result = Conversion.Convert(setActions, actionsString, null);
|
---|
| 255 | assertTrue(result[0] instanceof List);
|
---|
| 256 | List resultList = (List) result[0];
|
---|
| 257 | assertEquals(3, resultList.size());
|
---|
| 258 | assertEquals("action1", resultList.get(0));
|
---|
| 259 | assertEquals("action2", resultList.get(1));
|
---|
| 260 | assertEquals("action3", resultList.get(2));
|
---|
| 261 |
|
---|
[86] | 262 | // Test the setting of text
|
---|
| 263 | String text = " + BulletTest ";
|
---|
| 264 | result = Conversion.Convert(appendLine, text, null);
|
---|
| 265 | assertEquals(1, result.length);
|
---|
| 266 | assertEquals(text, result[0]);
|
---|
| 267 |
|
---|
[80] | 268 | } catch (Exception e) {
|
---|
| 269 | fail();
|
---|
| 270 | e.printStackTrace();
|
---|
| 271 | }
|
---|
[67] | 272 | }
|
---|
| 273 |
|
---|
[80] | 274 | public final void testConvertToExpeditee() {
|
---|
[72] | 275 | try {
|
---|
| 276 | java.lang.reflect.Method getPosition = Item.class.getMethod(
|
---|
| 277 | "getPosition", new Class[] {});
|
---|
| 278 | java.lang.reflect.Method getJustification = Text.class.getMethod(
|
---|
| 279 | "getJustification", new Class[] {});
|
---|
| 280 |
|
---|
[96] | 281 | assertEquals('C', Conversion.ConvertToExpeditee(getJustification,
|
---|
| 282 | Justification.center));
|
---|
[72] | 283 |
|
---|
[80] | 284 | assertEquals("Test", Conversion.ConvertToExpeditee(getPosition,
|
---|
[72] | 285 | (Object) "Test"));
|
---|
[80] | 286 | assertEquals("0", Conversion.ConvertToExpeditee(getPosition,
|
---|
| 287 | (Object) 0));
|
---|
| 288 | assertEquals("0.0", Conversion.ConvertToExpeditee(getPosition,
|
---|
[72] | 289 | (Object) 0.0F));
|
---|
[80] | 290 | assertEquals(null, Conversion.ConvertToExpeditee(getPosition,
|
---|
[72] | 291 | (new Integer(-1))));
|
---|
[80] | 292 | assertEquals(null, Conversion.ConvertToExpeditee(getPosition,
|
---|
| 293 | (new Float(-0.1F))));
|
---|
| 294 | assertEquals(null, Conversion.ConvertToExpeditee(getPosition,
|
---|
[72] | 295 | (new Boolean(true))));
|
---|
[80] | 296 | assertEquals("F", Conversion.ConvertToExpeditee(getPosition,
|
---|
[72] | 297 | (new Boolean(false))));
|
---|
[80] | 298 | assertEquals(null, Conversion.ConvertToExpeditee(getPosition,
|
---|
[72] | 299 | (new int[] {})));
|
---|
[80] | 300 | assertEquals("1 22 333", Conversion.ConvertToExpeditee(getPosition,
|
---|
[72] | 301 | (new int[] { 1, 22, 333 })));
|
---|
| 302 |
|
---|
[80] | 303 | assertEquals("22 44", Conversion.ConvertToExpeditee(getPosition,
|
---|
[72] | 304 | (new Point(22, 44))));
|
---|
| 305 |
|
---|
[80] | 306 | assertEquals("100 0 0", Conversion.ConvertToExpeditee(getPosition,
|
---|
[1102] | 307 | Colour.RED));
|
---|
[72] | 308 |
|
---|
[80] | 309 | assertEquals(null, Conversion.ConvertToExpeditee(getPosition, null));
|
---|
[72] | 310 | List<String> testList = new ArrayList<String>();
|
---|
| 311 | testList.add("test");
|
---|
| 312 |
|
---|
[80] | 313 | assertEquals(testList, Conversion.ConvertToExpeditee(getPosition,
|
---|
[72] | 314 | testList));
|
---|
| 315 |
|
---|
| 316 | Font testFont = new Font(Text.FONT_WHEEL[1], Font.BOLD, 18);
|
---|
| 317 | String result = Text.FONT_CHARS[1] + "b18";
|
---|
[80] | 318 | assertEquals(result, Conversion.ConvertToExpeditee(getPosition,
|
---|
| 319 | testFont));
|
---|
[72] | 320 | } catch (Exception e) {
|
---|
| 321 | e.printStackTrace();
|
---|
| 322 | fail();
|
---|
| 323 | }
|
---|
[67] | 324 | }
|
---|
| 325 |
|
---|
[288] | 326 | public final void testGetCssColor() {
|
---|
[1102] | 327 | assertEquals("rgb(255,0,0)", Conversion.getCssColor(Colour.RED));
|
---|
| 328 | assertEquals("rgb(255,0,255)", Conversion.getCssColor(Colour.MAGENTA));
|
---|
| 329 | assertEquals("rgb(128,128,128)", Conversion.getCssColor(Colour.GREY));
|
---|
[288] | 330 | }
|
---|
[67] | 331 | }
|
---|