src/test/java/org/lwes/db/ArrayTest.java

   1 /*======================================================================*
   2  * Copyright (c) 2010, Frank Maritato All rights reserved.              *
   3  *                                                                      *
   4  * Licensed under the New BSD License (the "License"); you may not use  *
   5  * this file except in compliance with the License.  Unless required    *
   6  * by applicable law or agreed to in writing, software distributed      *
   7  * under the License is distributed on an "AS IS" BASIS, WITHOUT        *
   8  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.     *
   9  * See the License for the specific language governing permissions and  *
  10  * limitations under the License. See accompanying LICENSE file.        *
  11  *======================================================================*/
  12
  13 package org.lwes.db;
  14
  15 import org.apache.commons.logging.Log;
  16 import org.apache.commons.logging.LogFactory;
  17 import org.junit.Before;
  18 import org.junit.Test;
  19 import org.lwes.Event;
  20 import org.lwes.EventAttributeSizeException;
  21 import org.lwes.EventSystemException;
  22
  23 import java.io.File;
  24 import java.net.InetAddress;
  25 import java.net.UnknownHostException;
  26 import java.util.ArrayList;
  27 import java.util.Arrays;
  28 import java.util.Enumeration;
  29 import java.util.List;
  30
  31 import static org.junit.Assert.assertEquals;
  32 import static org.junit.Assert.assertNotNull;
  33 import static org.junit.Assert.assertTrue;
  34
  35
  36 /**
  37  * @author fmaritato
  38  */
  39
  40 public class ArrayTest {
  41
  42     private static transient Log log = LogFactory.getLog(ArrayTest.class);
  43
  44     private static final String ESF = "src/test/java/org/lwes/db/ArrayTest.esf";
  45     private static final String TEST_EVENT = "TestEvent";
  46
  47     private EventTemplateDB template = null;
  48
  49     @Before
  50     public void setUp() {
  51         template = new EventTemplateDB();
  52         template.setESFFile(new File(ESF));
  53         template.initialize();
  54     }
  55
  56     @Test
  57     public void testArrayParse() {
  58
  59         EventTemplateDB template = new EventTemplateDB();
  60         template.setESFFile(new File(ESF));
  61         assertTrue("Template did not initialize", template.initialize());
  62
  63         Enumeration<String> eventNames = template.getEventNames();
  64         assertNotNull("Event names enum was null", eventNames);
  65
  66         assertTrue("TestEvent was not known to the template",
  67                    template.checkForEvent(TEST_EVENT));
  68
  69         assertTrue("field1 attribute not known to the template",
  70                    template.checkForAttribute(TEST_EVENT, "field1"));
  71
  72     }
  73
  74     @Test
  75     public void testStringArray() throws EventSystemException {
  76
  77         // First try to set a valid string array
  78         Event evt = new Event("TestEvent", true, template);
  79         List<String> data = new ArrayList<String>(Arrays.asList("1", "2", "3"));
  80         evt.setStringArray("field1", data);
  81         List<String> ar = evt.getStringArray("field1");
  82         assertNotNull("string array was null", ar);
  83         assertEquals("length was incorrect", 3, ar.size());
  84
  85         // Make sure we can serialize/deserialize it
  86         byte[] serializedEvent = evt.serialize();
  87         Event evt2 = new Event(serializedEvent, true, template);
  88         assertNotNull(evt2);
  89         List a2 = evt2.getStringArray("field1");
  90         assertNotNull(a2);
  91         assertEquals("deserialized array length was incorrect", 3, a2.size());
  92
  93         // Now try to set an invalid string array and make
  94         // sure an exception is thrown.
  95         boolean exceptionThrown = false;
  96         try {
  97             evt.setStringArray("field1",
  98                                new ArrayList(Arrays.asList("1", "2", "3",
  99                                                            "4", "5", "6",
 100                                                            "7", "8", "9",
 101                                                            "10", "11", "12")));
 102         }
 103         catch (EventAttributeSizeException e) {
 104             if (log.isDebugEnabled()) {
 105                 log.debug(e.getMessage());
 106             }
 107             exceptionThrown = true;
 108         }
 109         assertTrue("No exception was thrown for array length", exceptionThrown);
 110     }
 111
 112     @Test
 113     public void testInt16() throws EventSystemException {
 114         // First try to set a valid string array
 115         Event evt = new Event("TestEvent", true, template);
 116         evt.setInt16Array("field2", new ArrayList(Arrays.asList((short) 1, (short) 2, (short) 3)));
 117         List<Short> ar = evt.getInt16Array("field2");
 118         assertNotNull("string array was null", ar);
 119         assertEquals("length was incorrect", 3, ar.size());
 120
 121         // Make sure we can serialize/deserialize it
 122         byte[] serializedEvent = evt.serialize();
 123         Event evt2 = new Event(serializedEvent, true, template);
 124         assertNotNull(evt2);
 125         List<Short> a2 = evt2.getInt16Array("field2");
 126         assertNotNull(a2);
 127         assertEquals("deserialized array length was incorrect", 3, a2.size());
 128
 129         // Now try to set an invalid string array and make
 130         // sure an exception is thrown.
 131         boolean exceptionThrown = false;
 132         try {
 133             evt.setInt16Array("field2", new ArrayList(Arrays.asList(1, 2, 3,
 134                                                                     4, 5, 6,
 135                                                                     7, 8, 9,
 136                                                                     10, 11, 12)));
 137         }
 138         catch (EventAttributeSizeException e) {
 139             if (log.isDebugEnabled()) {
 140                 log.debug(e.getMessage());
 141             }
 142             exceptionThrown = true;
 143         }
 144         assertTrue("No exception was thrown for array length", exceptionThrown);
 145     }
 146
 147     @Test
 148     public void testInt32() throws EventSystemException {
 149         // First try to set a valid string array
 150         Event evt = new Event("TestEvent", true, template);
 151         evt.setInt32Array("field3", new ArrayList(Arrays.asList(1234567890, 234567890, 345678901)));
 152         List<Integer> ar = evt.getInt32Array("field3");
 153         assertNotNull("string array was null", ar);
 154         assertEquals("length was incorrect", 3, ar.size());
 155
 156         // Make sure we can serialize/deserialize it
 157         byte[] serializedEvent = evt.serialize();
 158         Event evt2 = new Event(serializedEvent, true, template);
 159         assertNotNull(evt2);
 160         List<Integer> a2 = evt2.getInt32Array("field3");
 161         assertNotNull(a2);
 162         assertEquals("deserialized array length was incorrect", 3, a2.size());
 163         assertEquals("a2[0]", (int) a2.get(0), 1234567890);
 164         assertEquals("a2[1]", (int) a2.get(1), 234567890);
 165         assertEquals("a2[2]", (int) a2.get(2), 345678901);
 166
 167         // Now try to set an invalid string array and make
 168         // sure an exception is thrown.
 169         boolean exceptionThrown = false;
 170         try {
 171             evt.setInt32Array("field3", new ArrayList(Arrays.asList(1, 2, 3,
 172                                                                     4, 5, 6,
 173                                                                     7, 8, 9,
 174                                                                     10, 11, 12)));
 175         }
 176         catch (EventAttributeSizeException e) {
 177             if (log.isDebugEnabled()) {
 178                 log.debug(e.getMessage());
 179             }
 180             exceptionThrown = true;
 181         }
 182         assertTrue("No exception was thrown for array length", exceptionThrown);
 183     }
 184
 185     @Test
 186     public void testInt64() throws EventSystemException {
 187         // First try to set a valid string array
 188         Event evt = new Event("TestEvent", true, template);
 189         evt.setInt64Array("field4", new ArrayList(Arrays.asList(123456789012l, 234567890123l)));
 190         List<Long> ar = evt.getInt64Array("field4");
 191         assertNotNull("string array was null", ar);
 192         assertEquals("length was incorrect", 2, ar.size());
 193
 194         // Make sure we can serialize/deserialize it
 195         byte[] serializedEvent = evt.serialize();
 196         Event evt2 = new Event(serializedEvent, true, template);
 197         assertNotNull(evt2);
 198         List<Long> a2 = evt2.getInt64Array("field4");
 199         assertNotNull(a2);
 200         assertEquals("deserialized array length was incorrect", 2, a2.size());
 201         assertEquals("a2[0]", (long) a2.get(0), 123456789012l);
 202         assertEquals("a2[1]", (long) a2.get(1), 234567890123l);
 203
 204         // Now try to set an invalid string array and make
 205         // sure an exception is thrown.
 206         boolean exceptionThrown = false;
 207         try {
 208             evt.setInt64Array("field4", new ArrayList(Arrays.asList(1, 2, 3,
 209                                                                     4, 5, 6,
 210                                                                     7, 8, 9,
 211                                                                     10, 11, 12)));
 212         }
 213         catch (EventAttributeSizeException e) {
 214             if (log.isDebugEnabled()) {
 215                 log.debug(e.getMessage());
 216             }
 217             exceptionThrown = true;
 218         }
 219         assertTrue("No exception was thrown for array length", exceptionThrown);
 220     }
 221
 222     @Test
 223     public void testUInt16() throws EventSystemException {
 224         // First try to set a valid string array
 225         Event evt = new Event("TestEvent", true, template);
 226         evt.setUInt16Array("field5", new ArrayList(Arrays.asList(1, 2, 3)));
 227         List<Integer> ar = evt.getUInt16Array("field5");
 228         assertNotNull("string array was null", ar);
 229         assertEquals("length was incorrect", 3, ar.size());
 230
 231         // Make sure we can serialize/deserialize it
 232         byte[] serializedEvent = evt.serialize();
 233         Event evt2 = new Event(serializedEvent, true, template);
 234         assertNotNull(evt2);
 235         List<Integer> a2 = evt2.getUInt16Array("field5");
 236         assertNotNull(a2);
 237         assertEquals("deserialized array length was incorrect", 3, a2.size());
 238
 239         // Now try to set an invalid string array and make
 240         // sure an exception is thrown.
 241         boolean exceptionThrown = false;
 242         try {
 243             evt.setUInt16Array("field5", new ArrayList(Arrays.asList(1, 2, 3,
 244                                                                      4, 5, 6,
 245                                                                      7, 8, 9,
 246                                                                      10, 11, 12)));
 247         }
 248         catch (EventAttributeSizeException e) {
 249             if (log.isDebugEnabled()) {
 250                 log.debug(e.getMessage());
 251             }
 252             exceptionThrown = true;
 253         }
 254         assertTrue("No exception was thrown for array length", exceptionThrown);
 255     }
 256
 257     @Test
 258     public void testUInt32() throws EventSystemException {
 259         // First try to set a valid string array
 260         Event evt = new Event("TestEvent", true, template);
 261         evt.setUInt32Array("field6", new ArrayList(Arrays.asList(1234567890l, 234567890l, 345678901l)));
 262         List<Long> ar = evt.getUInt32Array("field6");
 263         assertNotNull("string array was null", ar);
 264         assertEquals("length was incorrect", 3, ar.size());
 265
 266         // Make sure we can serialize/deserialize it
 267         byte[] serializedEvent = evt.serialize();
 268         Event evt2 = new Event(serializedEvent, true, template);
 269         assertNotNull(evt2);
 270         List<Long> a2 = evt2.getUInt32Array("field6");
 271         assertNotNull(a2);
 272         assertEquals("deserialized array length was incorrect", 3, a2.size());
 273         assertEquals("a2[0]", (long) a2.get(0), 1234567890);
 274         assertEquals("a2[1]", (long) a2.get(1), 234567890);
 275         assertEquals("a2[2]", (long) a2.get(2), 345678901);
 276
 277         // Now try to set an invalid string array and make
 278         // sure an exception is thrown.
 279         boolean exceptionThrown = false;
 280         try {
 281             evt.setUInt32Array("field6", new ArrayList(Arrays.asList(1, 2, 3,
 282                                                                      4, 5, 6,
 283                                                                      7, 8, 9,
 284                                                                      10, 11, 12)));
 285         }
 286         catch (EventAttributeSizeException e) {
 287             if (log.isDebugEnabled()) {
 288                 log.debug(e.getMessage());
 289             }
 290             exceptionThrown = true;
 291         }
 292         assertTrue("No exception was thrown for array length", exceptionThrown);
 293     }
 294
 295     @Test
 296     public void testUInt64() throws EventSystemException {
 297         // First try to set a valid string array
 298         Event evt = new Event("TestEvent", true, template);
 299         evt.setUInt64Array("field7", new ArrayList(Arrays.asList(123456789012l, 234567890123l)));
 300         List ar = evt.getUInt64Array("field7");
 301         assertNotNull("string array was null", ar);
 302         assertEquals("length was incorrect", 2, ar.size());
 303
 304         // Make sure we can serialize/deserialize it
 305         byte[] serializedEvent = evt.serialize();
 306         Event evt2 = new Event(serializedEvent, true, template);
 307         assertNotNull(evt2);
 308         List a2 = evt2.getUInt64Array("field7");
 309         assertNotNull(a2);
 310         assertEquals("deserialized array length was incorrect", 2, a2.size());
 311         assertEquals("a2.get(0)", a2.get(0), 123456789012l);
 312         assertEquals("a2.get(1)", a2.get(1), 234567890123l);
 313
 314         // Now try to set an invalid string array and make
 315         // sure an exception is thrown.
 316         boolean exceptionThrown = false;
 317         try {
 318             evt.setUInt64Array("field7", new ArrayList(Arrays.asList(1, 2, 3,
 319                                                                      4, 5, 6,
 320                                                                      7, 8, 9,
 321                                                                      10, 11, 12)));
 322         }
 323         catch (EventAttributeSizeException e) {
 324             if (log.isDebugEnabled()) {
 325                 log.debug(e.getMessage());
 326             }
 327             exceptionThrown = true;
 328         }
 329         assertTrue("No exception was thrown for array length", exceptionThrown);
 330     }
 331
 332     @Test
 333     public void testBooleanArray() throws EventSystemException {
 334         Event evt = new Event("TestEvent", true, template);
 335         evt.setBooleanArray("field8", new ArrayList(Arrays.asList(true, false)));
 336         List ar = evt.getBooleanArray("field8");
 337         assertNotNull("boolean array was null", ar);
 338         assertEquals("length was incorrect", 2, ar.size());
 339
 340         // Make sure we can serialize/deserialize it
 341         byte[] serializedEvent = evt.serialize();
 342         Event evt2 = new Event(serializedEvent, true, template);
 343         assertNotNull(evt2);
 344         List a2 = evt2.getBooleanArray("field8");
 345         assertNotNull(a2);
 346         assertEquals("deserialized array length was incorrect", 2, a2.size());
 347         assertEquals("a2.get(0)", a2.get(0), true);
 348         assertEquals("a2.get(1)", a2.get(1), false);
 349     }
 350
 351     @Test
 352     public void testByteArray() throws EventSystemException {
 353         Event evt = new Event("TestEvent", true, template);
 354         evt.setByteArray("field9", new ArrayList(Arrays.asList((byte) 0x1, (byte) 0x2)));
 355         List ar = evt.getByteArray("field9");
 356         assertNotNull("boolean array was null", ar);
 357         assertEquals("length was incorrect", 2, ar.size());
 358
 359         // Make sure we can serialize/deserialize it
 360         byte[] serializedEvent = evt.serialize();
 361         Event evt2 = new Event(serializedEvent, true, template);
 362         assertNotNull(evt2);
 363         List a2 = evt2.getByteArray("field9");
 364         assertNotNull(a2);
 365         assertEquals("deserialized array length was incorrect", 2, a2.size());
 366         assertEquals("a2.get(0)", a2.get(0), (byte) 0x1);
 367         assertEquals("a2.get(1)", a2.get(1), (byte) 0x2);
 368     }
 369
 370     @Test
 371     public void testDoubleArray() throws EventSystemException {
 372
 373         Event evt = new Event("TestEvent", true, template);
 374         evt.setDoubleArray("field10", new ArrayList(Arrays.asList(3.14159, 5.99999)));
 375         List ar = evt.getDoubleArray("field10");
 376         assertNotNull("double array was null", ar);
 377         assertEquals("number of fields is wrong", 2, ar.size());
 378         log.debug("EVENT: " + evt.toOneLineString());
 379         // Make sure we can serialize/deserialize it
 380         byte[] serializedEvent = evt.serialize();
 381         Event evt2 = new Event(serializedEvent, true, template);
 382         assertNotNull(evt2);
 383         List<Double> a2 = evt2.getDoubleArray("field10");
 384         assertNotNull(a2);
 385         assertEquals("deserialized array length was incorrect", 2, a2.size());
 386         log.debug(a2);
 387         assertEquals("a2.get(0)", 3.14159, a2.get(0), .00001);
 388         assertEquals("a2.get(1)", 5.99999, a2.get(1), .00001);
 389     }
 390
 391     @Test
 392     public void testFloatArray() throws EventSystemException {
 393         Event evt = new Event("TestEvent", true, template);
 394         evt.setFloatArray("field11", new ArrayList(Arrays.asList(new Float(1.11), new Float(2.22))));
 395         List ar = evt.getFloatArray("field11");
 396         assertNotNull("Float array was null", ar);
 397         assertEquals("number of fields is wrong ", 2, ar.size());
 398
 399         byte[] serializedEvent = evt.serialize();
 400         Event evt2 = new Event(serializedEvent, true, template);
 401         assertNotNull(evt2);
 402         List<Float> a2 = evt2.getFloatArray("field11");
 403         assertNotNull(a2);
 404         assertEquals("deserialized array length was incorrect", 2, a2.size());
 405         assertEquals("a2.get(0)", (float) 1.11, a2.get(0), .01);
 406         assertEquals("a2.get(1)", (float) 2.22, a2.get(1), .01);
 407     }
 408
 409     @Test
 410     public void testIPV4Array() throws EventSystemException, UnknownHostException {
 411         Event evt = new Event("TestEvent", true, template);
 412         evt.setIPV4AddressArray("field12", new ArrayList
 413                 (Arrays.asList(InetAddress.getByName("yp.com"),
 414                                InetAddress.getByName("yahoo.com"))));
 415         List ar = evt.getIPV4Array("field12");
 416         assertNotNull("IPV4 array was null", ar);
 417         assertEquals("number of fields is wrong ", 2, ar.size());
 418
 419         byte[] serializedEvent = evt.serialize();
 420         Event evt2 = new Event(serializedEvent, true, template);
 421         assertNotNull(evt2);
 422         List<InetAddress> a2 = evt2.getFloatArray("field12");
 423         assertNotNull(a2);
 424         assertEquals("deserialized array length was incorrect", 2, a2.size());
 425         assertTrue("a2.get(0)", a2.get(0).getHostName().endsWith(".yp.atti.com"));
 426         assertTrue("a2.get(1)", a2.get(1).getHostName().endsWith(".yahoo.com"));
 427     }
 428 }