| 1 | /******************************************************************************* |
| 2 | * Copyright (c) 2013 Ericsson |
| 3 | * All rights reserved. This program and the accompanying materials |
| 4 | * are made available under the terms of the Eclipse Public License v1.0 |
| 5 | * which accompanies this distribution, and is available at |
| 6 | * http://www.eclipse.org/legal/epl-v10.html |
| 7 | * |
| 8 | * Contributors: |
| 9 | * Matthew Khouzam - Initial API and implementation |
| 10 | *******************************************************************************/ |
| 11 | |
| 12 | package org.eclipse.linuxtools.ctf.core.tests.types; |
| 13 | |
| 14 | import static org.junit.Assert.assertEquals; |
| 15 | import static org.junit.Assert.assertNotNull; |
| 16 | import static org.junit.Assert.assertNull; |
| 17 | |
| 18 | import java.nio.ByteBuffer; |
| 19 | |
| 20 | import org.eclipse.jdt.annotation.NonNull; |
| 21 | import org.eclipse.linuxtools.ctf.core.event.io.BitBuffer; |
| 22 | import org.eclipse.linuxtools.ctf.core.event.types.AbstractArrayDefinition; |
| 23 | import org.eclipse.linuxtools.ctf.core.event.types.EnumDeclaration; |
| 24 | import org.eclipse.linuxtools.ctf.core.event.types.EnumDefinition; |
| 25 | import org.eclipse.linuxtools.ctf.core.event.types.IDefinition; |
| 26 | import org.eclipse.linuxtools.ctf.core.event.types.IntegerDeclaration; |
| 27 | import org.eclipse.linuxtools.ctf.core.event.types.IntegerDefinition; |
| 28 | import org.eclipse.linuxtools.ctf.core.event.types.StringDeclaration; |
| 29 | import org.eclipse.linuxtools.ctf.core.event.types.StringDefinition; |
| 30 | import org.eclipse.linuxtools.ctf.core.event.types.StructDeclaration; |
| 31 | import org.eclipse.linuxtools.ctf.core.event.types.StructDefinition; |
| 32 | import org.eclipse.linuxtools.ctf.core.event.types.VariantDeclaration; |
| 33 | import org.eclipse.linuxtools.ctf.core.event.types.VariantDefinition; |
| 34 | import org.eclipse.linuxtools.ctf.core.tests.io.Util; |
| 35 | import org.eclipse.linuxtools.ctf.core.trace.CTFReaderException; |
| 36 | import org.eclipse.linuxtools.internal.ctf.core.event.types.SequenceDeclaration; |
| 37 | import org.junit.Before; |
| 38 | import org.junit.Test; |
| 39 | |
| 40 | /** |
| 41 | * The class <code>StructDefinitionTest</code> contains tests for the class |
| 42 | * <code>{@link StructDefinition}</code>. |
| 43 | * |
| 44 | * @author ematkho |
| 45 | * @version $Revision: 1.0 $ |
| 46 | */ |
| 47 | public class StructDefinitionTest { |
| 48 | |
| 49 | private static final @NonNull String TEST_STRUCT_ID = "testStruct"; |
| 50 | private static final @NonNull String ENUM_2 = "y"; |
| 51 | private static final @NonNull String ENUM_1 = "x"; |
| 52 | private static final @NonNull String TAG_ID = "Tag"; |
| 53 | private static final @NonNull String INT_ID = "_id"; |
| 54 | private static final @NonNull String STRING_ID = "_args"; |
| 55 | private static final @NonNull String ENUM_ID = "_enumArgs"; |
| 56 | private static final @NonNull String SEQUENCE_ID = "_seq"; |
| 57 | private static final @NonNull String LENGTH_SEQ = "_len"; |
| 58 | private static final @NonNull String VAR_FIELD_NAME = "SomeVariant"; |
| 59 | |
| 60 | private StructDefinition fixture; |
| 61 | private StructDefinition emptyStruct; |
| 62 | private StructDefinition simpleStruct; |
| 63 | |
| 64 | /** |
| 65 | * Perform pre-test initialization. |
| 66 | * |
| 67 | * @throws CTFReaderException |
| 68 | * won't happen |
| 69 | */ |
| 70 | @Before |
| 71 | public void setUp() throws CTFReaderException { |
| 72 | StructDeclaration sDec = new StructDeclaration(12); |
| 73 | IntegerDeclaration id = IntegerDeclaration.INT_32B_DECL; |
| 74 | IntegerDeclaration lenDec = IntegerDeclaration.UINT_8_DECL; |
| 75 | StringDeclaration sd = new StringDeclaration(); |
| 76 | EnumDeclaration ed = new EnumDeclaration(id); |
| 77 | SequenceDeclaration seqDec = new SequenceDeclaration(LENGTH_SEQ, id); |
| 78 | VariantDeclaration varDec = new VariantDeclaration(); |
| 79 | EnumDeclaration tagDec = new EnumDeclaration(id); |
| 80 | tagDec.add(0, 1, ENUM_1); |
| 81 | tagDec.add(2, 3, ENUM_2); |
| 82 | varDec.addField(ENUM_2, id); |
| 83 | varDec.addField(ENUM_1, sd); |
| 84 | varDec.setTag(TAG_ID); |
| 85 | sDec.addField(INT_ID, id); |
| 86 | sDec.addField(STRING_ID, sd); |
| 87 | sDec.addField(ENUM_ID, ed); |
| 88 | sDec.addField(TAG_ID, tagDec); |
| 89 | sDec.addField(LENGTH_SEQ, lenDec); |
| 90 | sDec.addField(SEQUENCE_ID, seqDec); |
| 91 | sDec.addField(VAR_FIELD_NAME, varDec); |
| 92 | byte bytes[] = new byte[100]; |
| 93 | bytes[4] = 1; |
| 94 | bytes[8] = 2; |
| 95 | bytes[13] = 3; |
| 96 | BitBuffer bb = new BitBuffer(Util.testMemory(ByteBuffer.wrap(bytes))); |
| 97 | fixture = sDec.createDefinition(null, TEST_STRUCT_ID, bb); |
| 98 | EnumDefinition eDef = tagDec.createDefinition(fixture, TAG_ID, bb); |
| 99 | assertNotNull(eDef); |
| 100 | VariantDefinition vd = varDec.createDefinition(fixture, VAR_FIELD_NAME, bb); |
| 101 | assertNotNull(vd); |
| 102 | // Create an empty struct |
| 103 | StructDeclaration esDec = new StructDeclaration(32); |
| 104 | emptyStruct = esDec.createDefinition(null, TEST_STRUCT_ID, bb); |
| 105 | |
| 106 | // Create a simple struct with two items |
| 107 | StructDeclaration ssDec = new StructDeclaration(32); |
| 108 | ssDec.addField(INT_ID, id); |
| 109 | ssDec.addField(STRING_ID, sd); |
| 110 | simpleStruct = ssDec.createDefinition(null, TEST_STRUCT_ID, bb); |
| 111 | } |
| 112 | |
| 113 | /** |
| 114 | * Run the StructDeclaration getDeclaration() method test. |
| 115 | */ |
| 116 | @Test |
| 117 | public void testGetDeclaration() { |
| 118 | StructDeclaration result = fixture.getDeclaration(); |
| 119 | assertNotNull(result); |
| 120 | } |
| 121 | |
| 122 | /** |
| 123 | * Run the HashMap<String, Definition> getDefinitions() method test. |
| 124 | */ |
| 125 | @Test |
| 126 | public void testGetDefinitions_1() { |
| 127 | IDefinition result = fixture.getDefinition("_id"); |
| 128 | assertNotNull(result); |
| 129 | } |
| 130 | |
| 131 | /** |
| 132 | * Run the ArrayDefinition lookupArray(String) method test. |
| 133 | */ |
| 134 | @Test |
| 135 | public void testLookupArray() { |
| 136 | String name = INT_ID; |
| 137 | AbstractArrayDefinition result = fixture.lookupArrayDefinition(name); |
| 138 | assertNull(result); |
| 139 | } |
| 140 | |
| 141 | /** |
| 142 | * Run the Definition lookupDefinition(String) method test. |
| 143 | */ |
| 144 | @Test |
| 145 | public void testLookupDefinition() { |
| 146 | String lookupPath = "args"; |
| 147 | IDefinition result = fixture.lookupDefinition(lookupPath); |
| 148 | |
| 149 | assertNotNull(result); |
| 150 | } |
| 151 | |
| 152 | /** |
| 153 | * Run the EnumDefinition lookupEnum(String) method test. |
| 154 | */ |
| 155 | @Test |
| 156 | public void testLookupEnum() { |
| 157 | String name = ENUM_ID; |
| 158 | EnumDefinition result = fixture.lookupEnum(name); |
| 159 | assertNotNull(result); |
| 160 | } |
| 161 | |
| 162 | /** |
| 163 | * Run the IntegerDefinition lookupInteger(String) method test. |
| 164 | */ |
| 165 | @Test |
| 166 | public void testLookupInteger_1() { |
| 167 | String name = "_id"; |
| 168 | IntegerDefinition result = fixture.lookupInteger(name); |
| 169 | assertNotNull(result); |
| 170 | } |
| 171 | |
| 172 | /** |
| 173 | * Run the IntegerDefinition lookupInteger(String) method test. |
| 174 | */ |
| 175 | @Test |
| 176 | public void testLookupInteger_2() { |
| 177 | String name = VAR_FIELD_NAME; |
| 178 | IntegerDefinition result = fixture.lookupInteger(name); |
| 179 | assertNull(result); |
| 180 | } |
| 181 | |
| 182 | /** |
| 183 | * Run the SequenceDefinition lookupSequence(String) method test. |
| 184 | */ |
| 185 | @Test |
| 186 | public void testLookupFixedStringDefinition() { |
| 187 | String name = SEQUENCE_ID; |
| 188 | AbstractArrayDefinition result = fixture.lookupArrayDefinition(name); |
| 189 | assertNotNull(result); |
| 190 | } |
| 191 | |
| 192 | /** |
| 193 | * Run the StringDefinition lookupString(String) method test. |
| 194 | */ |
| 195 | @Test |
| 196 | public void testLookupString() { |
| 197 | String name = VAR_FIELD_NAME; |
| 198 | StringDefinition result = fixture.lookupString(name); |
| 199 | |
| 200 | assertNull(result); |
| 201 | } |
| 202 | |
| 203 | /** |
| 204 | * Run the StructDefinition lookupStruct(String) method test. |
| 205 | */ |
| 206 | @Test |
| 207 | public void testLookupStruct() { |
| 208 | String name = VAR_FIELD_NAME; |
| 209 | StructDefinition result = fixture.lookupStruct(name); |
| 210 | |
| 211 | assertNull(result); |
| 212 | } |
| 213 | |
| 214 | /** |
| 215 | * Run the VariantDefinition lookupVariant(String) method test. |
| 216 | */ |
| 217 | @Test |
| 218 | public void testLookupVariant() { |
| 219 | String name = VAR_FIELD_NAME; |
| 220 | VariantDefinition result = fixture.lookupVariant(name); |
| 221 | |
| 222 | assertNotNull(result); |
| 223 | } |
| 224 | |
| 225 | /** |
| 226 | * Run the String toString() method test. |
| 227 | */ |
| 228 | @Test |
| 229 | public void testToString() { |
| 230 | String result = fixture.toString(); |
| 231 | assertNotNull(result); |
| 232 | |
| 233 | result = emptyStruct.toString(); |
| 234 | assertEquals("{ }", result); |
| 235 | |
| 236 | result = simpleStruct.toString(); |
| 237 | assertEquals("{ _id = 0, _args = \"\" }", result); |
| 238 | } |
| 239 | } |