/*******************************************************************************
- * Copyright (c) 2012 Ericsson
+ * Copyright (c) 2012, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
package org.eclipse.linuxtools.tmf.core.tests.ctfadaptor;
+import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import java.io.UnsupportedEncodingException;
+import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.eclipse.linuxtools.ctf.core.event.io.BitBuffer;
import org.eclipse.linuxtools.ctf.core.event.types.ArrayDeclaration;
import org.eclipse.linuxtools.ctf.core.event.types.Definition;
import org.eclipse.linuxtools.ctf.core.event.types.Encoding;
+import org.eclipse.linuxtools.ctf.core.event.types.EnumDeclaration;
import org.eclipse.linuxtools.ctf.core.event.types.FloatDeclaration;
import org.eclipse.linuxtools.ctf.core.event.types.FloatDefinition;
import org.eclipse.linuxtools.ctf.core.event.types.IntegerDeclaration;
import org.eclipse.linuxtools.ctf.core.event.types.StringDeclaration;
import org.eclipse.linuxtools.ctf.core.event.types.StructDeclaration;
import org.eclipse.linuxtools.ctf.core.event.types.StructDefinition;
+import org.eclipse.linuxtools.ctf.core.event.types.VariantDeclaration;
+import org.eclipse.linuxtools.ctf.core.trace.CTFReaderException;
import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfTmfEventField;
-import org.junit.After;
import org.junit.Before;
import org.junit.Test;
*/
public class CtfTmfEventFieldTest {
- private static final String ROOT = "root"; //$NON-NLS-1$
- private static final String SEQ = "seq"; //$NON-NLS-1$
- private static final String ARRAY = "array"; //$NON-NLS-1$
- private static final String STR = "str"; //$NON-NLS-1$
- private static final String FLOAT = "float"; //$NON-NLS-1$
- private static final String LEN = "len"; //$NON-NLS-1$
- private static final String INT = "int"; //$NON-NLS-1$
- private static final String NAME = "test"; //$NON-NLS-1$
+ private static final String ROOT = "root";
+ private static final String SEQ = "seq";
+ private static final String ARRAY_STR = "array_str";
+ private static final String ARRAY_FLOAT = "array_float";
+ private static final String ARRAY_INT = "array_int";
+ private static final String ARRAY_STRUCT = "array_struct";
+ private static final String ARRAY_VARIANT = "array_variant";
+ private static final String ARRAY_ENUM = "array_enum";
+ private static final String STR = "str";
+ private static final String FLOAT = "float";
+ private static final String LEN = "len";
+ private static final String INT = "int";
+ private static final String NAME = "test";
+ private static final String STRUCT = "struct";
+ private static final String VARIANT = "variant";
+ private static final String ENUM = "enum";
- private StructDefinition fixture;
+ private static final byte TEST_NUMBER = 2;
+ private static final String TEST_STRING = "two";
- /**
- * Launch the test.
- *
- * @param args
- * the command line arguments
- */
- public static void main(String[] args) {
- new org.junit.runner.JUnitCore().run(CtfTmfEventFieldTest.class);
- }
+ private static final int ARRAY_SIZE = 2;
+
+ private StructDefinition fixture;
/**
* Perform pre-test initialization.
+ *
+ * @throws UnsupportedEncodingException
+ * Thrown when UTF-8 encoding is not available.
+ * @throws CTFReaderException
+ * error
*/
@Before
- public void setUp() {
+ public void setUp() throws UnsupportedEncodingException, CTFReaderException {
+ final byte[] testStringBytes = TEST_STRING.getBytes("UTF-8");
+
+ int capacity = 2048;
+ ByteBuffer bb = ByteBuffer.allocateDirect(capacity);
+
StructDeclaration sDec = new StructDeclaration(1l);
StringDeclaration strDec = new StringDeclaration();
IntegerDeclaration intDec = new IntegerDeclaration(8, false, 8,
ByteOrder.BIG_ENDIAN, Encoding.NONE, null, 8);
FloatDeclaration flDec = new FloatDeclaration(8, 24,
ByteOrder.BIG_ENDIAN, 8);
- ArrayDeclaration arrDec = new ArrayDeclaration(2, intDec);
SequenceDeclaration seqDec = new SequenceDeclaration(LEN, intDec);
+ StructDeclaration structDec = new StructDeclaration(8);
+ EnumDeclaration enumDec = new EnumDeclaration(intDec);
+ VariantDeclaration varDec = new VariantDeclaration();
+ ArrayDeclaration arrStrDec = new ArrayDeclaration(ARRAY_SIZE, strDec);
+ ArrayDeclaration arrFloatDec = new ArrayDeclaration(ARRAY_SIZE, flDec);
+ ArrayDeclaration arrIntDec = new ArrayDeclaration(ARRAY_SIZE, intDec);
+ ArrayDeclaration arrStructDec = new ArrayDeclaration(ARRAY_SIZE, structDec);
+ ArrayDeclaration arrVariantDec = new ArrayDeclaration(ARRAY_SIZE, varDec);
+ ArrayDeclaration arrEnumDec = new ArrayDeclaration(ARRAY_SIZE, enumDec);
+
sDec.addField(INT, intDec);
+ bb.put(TEST_NUMBER);
+
+ sDec.addField(ARRAY_INT, arrIntDec);
+ for (int i = 0; i < ARRAY_SIZE; ++i) {
+ bb.put(TEST_NUMBER);
+ }
+
sDec.addField(LEN, intDec);
+ bb.put(TEST_NUMBER);
+
sDec.addField(FLOAT, flDec);
+ bb.putFloat(TEST_NUMBER);
+
+ sDec.addField(ARRAY_FLOAT, arrFloatDec);
+ for (int i = 0; i < ARRAY_SIZE; ++i) {
+ bb.putFloat(TEST_NUMBER);
+ }
+
sDec.addField(STR, strDec);
- sDec.addField(ARRAY, arrDec);
- sDec.addField(SEQ, seqDec);
- fixture = sDec.createDefinition(fixture, ROOT);
- int capacity = 1024;
- java.nio.ByteBuffer bb = java.nio.ByteBuffer.allocateDirect(capacity);
- for (int i = 0; i < capacity; i++) {
- bb.put((byte) 2);
+ bb.put(testStringBytes);
+ bb.put((byte) 0);
+
+ sDec.addField(ARRAY_STR, arrStrDec);
+ for (int i = 0; i < ARRAY_SIZE; ++i) {
+ bb.put(testStringBytes);
+ bb.put((byte) 0);
}
- bb.position(20);
+
+ sDec.addField(SEQ, seqDec);
+ bb.put(TEST_NUMBER);
+ bb.put(TEST_NUMBER);
+
+ structDec.addField(STR, strDec);
+ structDec.addField(INT, intDec);
+ sDec.addField(STRUCT, structDec);
+ bb.put(testStringBytes);
bb.put((byte) 0);
+ bb.put(TEST_NUMBER);
+
+ sDec.addField(ARRAY_STRUCT, arrStructDec);
+ for (int i = 0; i < ARRAY_SIZE; ++i) {
+ bb.put(testStringBytes);
+ bb.put((byte) 0);
+ bb.put(TEST_NUMBER);
+ }
+
+ enumDec.add(0, 1, LEN);
+ enumDec.add(2, 3, FLOAT);
+ sDec.addField(ENUM, enumDec);
+ bb.put(TEST_NUMBER);
+
+ sDec.addField(ARRAY_ENUM, arrEnumDec);
+ for (int i = 0; i < ARRAY_SIZE; ++i) {
+ bb.put(TEST_NUMBER);
+ }
+
+ varDec.addField(LEN, intDec);
+ varDec.addField(FLOAT, flDec);
+ varDec.setTag(ENUM);
+ sDec.addField(VARIANT, varDec);
+ bb.putFloat(TEST_NUMBER);
+
+ sDec.addField(ARRAY_VARIANT, arrVariantDec);
+ for (int i = 0; i < ARRAY_SIZE; ++i) {
+ bb.putFloat(TEST_NUMBER);
+ }
+
+ fixture = sDec.createDefinition(fixture, ROOT);
+
bb.position(0);
fixture.read(new BitBuffer(bb));
}
- /**
- * Perform post-test clean-up.
- */
- @After
- public void tearDown() {
- // Add additional tear down code here
- }
-
/**
* Run the CtfTmfEventField parseField(Definition,String) method test.
*/
@Test
public void testParseField_float() {
- FloatDefinition fieldDef;
- fieldDef = (FloatDefinition) fixture.lookupDefinition(FLOAT);
- CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, "_"+NAME); //$NON-NLS-1$
- String result2 = CtfTmfEventField.copyFrom(result).toString();
- assertEquals( result2, "test=9.551467814359616E-38"); //$NON-NLS-1$
+ FloatDefinition fieldDef = (FloatDefinition) fixture.lookupDefinition(FLOAT);
+ CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, "_" + NAME);
+ assertEquals("test=2.0", result.toString());
}
/**
- * Run the CtfTmfEventField parseField(Definition,String) method test.
+ * Run the CtfTmfEventField parseField(Definition,String) method test for an
+ * array of floats field.
*/
@Test
- public void testParseField_array() {
- CtfTmfEventField result;
- result = CtfTmfEventField.parseField(fixture.lookupArray(ARRAY), NAME);
- String result2 = CtfTmfEventField.copyFrom(result).toString();
- assertEquals( result2, "test={ 2, 2}"); //$NON-NLS-1$
+ public void testParseField_array_float() {
+ Definition fieldDef = fixture.lookupArray(ARRAY_FLOAT);
+ CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
+ assertEquals("test=[2.0, 2.0]", result.toString());
}
/**
public void testParseField_int() {
Definition fieldDef = fixture.lookupDefinition(INT);
CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
- String result2 =CtfTmfEventField.copyFrom(result).toString();
- assertEquals( result2, "test=02"); //$NON-NLS-1$
+ assertEquals("test=02", result.toString());
+ }
+
+ /**
+ * Run the CtfTmfEventField parseField(Definition,String) method test for an
+ * array of integers field.
+ */
+ @Test
+ public void testParseField_array_int() {
+ Definition fieldDef = fixture.lookupArray(ARRAY_INT);
+ CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
+ assertEquals("test=[02, 02]", result.toString());
}
/**
public void testParseField_sequence() {
Definition fieldDef = fixture.lookupDefinition(SEQ);
CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
- String result2 =CtfTmfEventField.copyFrom(result).toString();
- assertEquals( result2, "test={ 2, 2}"); //$NON-NLS-1$
+ assertEquals("test=[02, 02]", result.toString());
+ }
+
+ /**
+ * Run the CtfTmfEventField parseField(Definition,String) method test.
+ */
+ @Test
+ public void testParseField_sequence_value() {
+ Definition fieldDef = fixture.lookupDefinition(SEQ);
+ CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
+ long[] values = (long[]) result.getValue();
+ long[] expected = new long[] { 2, 2 };
+ assertArrayEquals(expected, values);
}
/**
public void testParseField_string() {
Definition fieldDef = fixture.lookupDefinition(STR);
CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
- String result2 =CtfTmfEventField.copyFrom(result).toString();
- assertEquals( result2, "test=\ 2\ 2\ 2\ 2\ 2\ 2\ 2\ 2\ 2\ 2\ 2\ 2\ 2\ 2"); //$NON-NLS-1$
+ assertEquals("test=two", result.toString());
}
/**
- * Test the clone() method.
+ * Run the CtfTmfEventField parseField(Definition,String) method test for an
+ * array of strings field.
*/
@Test
- public void testClone() {
- Definition fieldDef = fixture.lookupDefinition(STR);
+ public void testParseField_array_string() {
+ Definition fieldDef = fixture.lookupArray(ARRAY_STR);
+ CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
+ assertEquals("test=[two, two]", result.toString());
+ }
+
+ /**
+ * Run the CtfTmfEventField parseField(Definition,String) method test.
+ */
+ @Test
+ public void testParseField_struct() {
+ Definition fieldDef = fixture.lookupDefinition(STRUCT);
+ CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
+ assertEquals("test=[str=two, int=02]", result.toString());
+ }
+
+ /**
+ * Run the CtfTmfEventField parseField(Definition,String) method test for an
+ * array of structs field.
+ */
+ @Test
+ public void testParseField_array_struct() {
+ Definition fieldDef = fixture.lookupArray(ARRAY_STRUCT);
+ CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
+ assertEquals("test=[[str=two, int=02], [str=two, int=02]]", result.toString());
+ }
+
+ /**
+ * Run the CtfTmfEventField parseField(Definition,String) method test.
+ */
+ @Test
+ public void testParseField_enum() {
+ Definition fieldDef = fixture.lookupDefinition(ENUM);
+ CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
+ assertEquals("test=float", result.toString());
+ }
+
+ /**
+ * Run the CtfTmfEventField parseField(Definition,String) method test for an
+ * array of enums field.
+ */
+ @Test
+ public void testParseField_array_enum() {
+ Definition fieldDef = fixture.lookupArray(ARRAY_ENUM);
+ CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
+ assertEquals("test=[float, float]", result.toString());
+ }
+
+ /**
+ * Run the CtfTmfEventField parseField(Definition,String) method test.
+ */
+ @Test
+ public void testParseField_variant() {
+ Definition fieldDef = fixture.lookupDefinition(VARIANT);
+ CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
+ assertEquals("test=float=2.0", result.toString());
+ }
+
+ /**
+ * Run the CtfTmfEventField parseField(Definition,String) method test for an
+ * array of variants field.
+ */
+ @Test
+ public void testParseField_array_variant() {
+ Definition fieldDef = fixture.lookupArray(ARRAY_VARIANT);
CtfTmfEventField result = CtfTmfEventField.parseField(fieldDef, NAME);
- assertNotNull(result.clone());
+ assertEquals("test=[float=2.0, float=2.0]", result.toString());
}
}
projects / deliverable / tracecompass.git / blobdiff