org.eclipse.linuxtools.tmf.ui.tests/src/org/eclipse/linuxtools/tmf/ui/tests/views/uml2sd/dialogs/CriteriaTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2011-2013 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Bernd Hufmann - Initial API and implementation
  11  *   Alexandre Montplaisir - Port to JUnit4
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.ui.tests.views.uml2sd.dialogs;
  15
  16 import static org.junit.Assert.assertEquals;
  17 import static org.junit.Assert.assertFalse;
  18 import static org.junit.Assert.assertNotNull;
  19 import static org.junit.Assert.assertNull;
  20 import static org.junit.Assert.assertTrue;
  21
  22 import java.util.List;
  23 import java.util.regex.Pattern;
  24
  25 import org.eclipse.jface.dialogs.DialogSettings;
  26 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.dialogs.Criteria;
  27 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.dialogs.FilterCriteria;
  28 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDFilterProvider;
  29 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.handlers.provider.ISDGraphNodeSupporter;
  30 import org.junit.Test;
  31
  32 /**
  33  *  Test cases to test Criteria class.
  34  */
  35 public class CriteriaTest {
  36
  37     /**
  38      * Test default constructor.
  39      */
  40     @Test
  41     public void testCriteria() {
  42         Criteria criteria = new Criteria();
  43         assertFalse("testCriteria", criteria.isAsyncMessageReturnSelected());
  44         assertFalse("testCriteria", criteria.isAsyncMessageSelected());
  45         assertFalse("testCriteria", criteria.isCaseSenstiveSelected());
  46         assertFalse("testCriteria", criteria.isLifeLineSelected());
  47         assertFalse("testCriteria", criteria.isStopSelected());
  48         assertFalse("testCriteria", criteria.isSyncMessageReturnSelected());
  49         assertFalse("testCriteria", criteria.isSyncMessageSelected());
  50         assertNull("testCriteria",  criteria.getExpression());
  51         assertNull("testCriteria",  criteria.getPattern());
  52     }
  53
  54     /**
  55      * Test copy constructor.
  56      */
  57     @Test
  58     public void testCriteriaCriteria() {
  59         Criteria criteria = new Criteria();
  60         criteria.setExpression("test");
  61         criteria.setLifeLineSelected(true);
  62         criteria.setSyncMessageSelected(true);
  63
  64         Criteria copy = new Criteria(criteria);
  65
  66         assertEquals("testCriteriaCriteria", criteria.isAsyncMessageReturnSelected(), copy.isAsyncMessageReturnSelected());
  67         assertEquals("testCriteriaCriteria", criteria.isAsyncMessageSelected(), copy.isAsyncMessageSelected());
  68         assertEquals("testCriteriaCriteria", criteria.isCaseSenstiveSelected(), copy.isCaseSenstiveSelected());
  69         assertEquals("testCriteriaCriteria", criteria.isLifeLineSelected(), copy.isLifeLineSelected());
  70         assertEquals("testCriteriaCriteria", criteria.isStopSelected(), copy.isStopSelected());
  71         assertEquals("testCriteriaCriteria", criteria.isSyncMessageReturnSelected(), copy.isSyncMessageReturnSelected());
  72         assertEquals("testCriteriaCriteria", criteria.isSyncMessageSelected(), copy.isSyncMessageSelected());
  73         assertEquals("testCriteriaCriteria", criteria.getExpression(), copy.getExpression());
  74         assertEquals("testCriteriaCriteria", criteria.getPattern().pattern(), copy.getPattern().pattern());
  75     }
  76
  77     /**
  78      * Test accessor methods.
  79      */
  80     @Test
  81     public void testAccessors() {
  82         Criteria criteria = new Criteria();
  83         criteria.setAsyncMessageReturnSelected(true);
  84         criteria.setAsyncMessageSelected(true);
  85         criteria.setCaseSenstiveSelected(true);
  86         criteria.setLifeLineSelected(true);
  87         criteria.setStopSelected(true);
  88         criteria.setSyncMessageReturnSelected(true);
  89         criteria.setSyncMessageSelected(true);
  90         criteria.setExpression("test.*");
  91
  92         // set true to all flags
  93         assertTrue("testAccessors", criteria.isAsyncMessageReturnSelected());
  94         assertTrue("testAccessors", criteria.isAsyncMessageSelected());
  95         assertTrue("testAccessors", criteria.isCaseSenstiveSelected());
  96         assertTrue("testAccessors", criteria.isLifeLineSelected());
  97         assertTrue("testAccessors", criteria.isStopSelected());
  98         assertTrue("testAccessors", criteria.isSyncMessageReturnSelected());
  99         assertTrue("testAccessors", criteria.isSyncMessageSelected());
 100         assertEquals("testAccessors",  "test.*", criteria.getExpression());
 101         assertNotNull("testAccessors",  criteria.getPattern());
 102         assertEquals("testAccessors", "test.*", criteria.getPattern().pattern());
 103         assertEquals("testAccessors", 0, criteria.getPattern().flags() & Pattern.CASE_INSENSITIVE);
 104
 105         // set false to all flags
 106         criteria.setAsyncMessageReturnSelected(false);
 107         criteria.setAsyncMessageSelected(false);
 108         criteria.setCaseSenstiveSelected(false);
 109         criteria.setLifeLineSelected(false);
 110         criteria.setStopSelected(false);
 111         criteria.setSyncMessageReturnSelected(false);
 112         criteria.setSyncMessageSelected(false);
 113
 114         assertFalse("testAccessors", criteria.isAsyncMessageReturnSelected());
 115         assertFalse("testAccessors", criteria.isAsyncMessageSelected());
 116         assertFalse("testAccessors", criteria.isCaseSenstiveSelected());
 117         assertFalse("testAccessors", criteria.isLifeLineSelected());
 118         assertFalse("testAccessors", criteria.isStopSelected());
 119         assertFalse("testAccessors", criteria.isSyncMessageReturnSelected());
 120         assertFalse("testAccessors", criteria.isSyncMessageSelected());
 121         assertEquals("testAccessors",  "test.*", criteria.getExpression());
 122         assertNotNull("testAccessors",  criteria.getPattern());
 123         assertEquals("testAccessors", "test.*", criteria.getPattern().pattern());
 124         assertEquals("testAccessors", Pattern.CASE_INSENSITIVE, criteria.getPattern().flags() & Pattern.CASE_INSENSITIVE);
 125     }
 126
 127     /**
 128      * Test compartTo method.
 129      */
 130     @Test
 131     public void testCompareTo() {
 132         Criteria criteria = new Criteria();
 133         criteria.setExpression("test");
 134         criteria.setLifeLineSelected(true);
 135         criteria.setSyncMessageSelected(true);
 136
 137         Criteria copy = new Criteria(criteria);
 138         assertTrue("testCompareTo", criteria.compareTo(copy));
 139         assertTrue("testCompareTo", copy.compareTo(criteria));
 140         assertTrue("testCompareTo", criteria.compareTo(criteria));
 141
 142         copy.setExpression(null);
 143         assertFalse("testCompareTo", criteria.compareTo(copy));
 144         assertFalse("testCompareTo", copy.compareTo(criteria));
 145
 146         criteria.setExpression(null);
 147         assertTrue("testCompareTo", criteria.compareTo(copy));
 148         assertTrue("testCompareTo", copy.compareTo(criteria));
 149
 150         criteria.setExpression("test");
 151         copy.setExpression("test.*[12345]");
 152         assertFalse("testCompareTo", criteria.compareTo(copy));
 153         assertFalse("testCompareTo", copy.compareTo(criteria));
 154
 155         copy.setExpression("test");
 156         copy.setAsyncMessageReturnSelected(true);
 157         assertFalse("testCompareTo", criteria.compareTo(copy));
 158         assertFalse("testCompareTo", copy.compareTo(criteria));
 159     }
 160
 161     /**
 162      * Test save to disk.
 163      */
 164     @Test
 165     public void testSave() {
 166         DialogSettings settings = new DialogSettings("mysettings");
 167
 168         Criteria criteria = new Criteria();
 169         criteria.setExpression("test");
 170         criteria.setLifeLineSelected(true);
 171         criteria.setSyncMessageSelected(true);
 172
 173         // Save the criteria to the dialog settings
 174         criteria.save(settings);
 175
 176         // Check if all values are saved as expected
 177         assertEquals("testSave", "test", settings.get("expression"));
 178         assertEquals("testSave", "false", settings.get("isCaseSenstiveSelected"));
 179         assertEquals("testSave", "false", settings.get("isAsyncMessageReturnSelected"));
 180         assertEquals("testSave", "false", settings.get("isAsyncMessageSelected"));
 181         assertEquals("testSave", "true", settings.get("isLifeLineSelected"));
 182         assertEquals("testSave", "false", settings.get("isStopSelected"));
 183         assertEquals("testSave", "false", settings.get("isSyncMessageReturnSelected"));
 184         assertEquals("testSave", "true", settings.get("isSyncMessageSelected"));
 185     }
 186
 187     /**
 188      * Test restore from disk.
 189      */
 190     @Test
 191     public void testLoad() {
 192         DialogSettings settings = new DialogSettings("mysettings");
 193
 194         Criteria criteria = new Criteria();
 195         criteria.setExpression("test");
 196         criteria.setLifeLineSelected(true);
 197         criteria.setSyncMessageSelected(true);
 198
 199         // Save the criteria to the dialog settings
 200         criteria.save(settings);
 201
 202         // Load the criteria from the dialog settings
 203         Criteria copy = new Criteria();
 204         copy.load(settings);
 205
 206         assertTrue("testCompareTo", criteria.compareTo(copy));
 207         assertTrue("testCompareTo", copy.compareTo(criteria));
 208     }
 209
 210     /**
 211      * Test graph node summary usage.
 212      */
 213     @Test
 214     public void testGetGraphNodeSummary() {
 215
 216         // Create a dummy provider
 217         ISDFilterProvider provider = new ISDFilterProvider() {
 218
 219             @Override
 220             public boolean isNodeSupported(int nodeType) {
 221                 return true;
 222             }
 223
 224             @Override
 225             public String getNodeName(int nodeType, String loaderClassName) {
 226                 // not clear about purpose loaderClassName
 227                 switch (nodeType) {
 228                 case ISDGraphNodeSupporter.LIFELINE:
 229                     return "MyLifeline";
 230                 case ISDGraphNodeSupporter.SYNCMESSAGE:
 231                     return "MySyncMessage";
 232                 case ISDGraphNodeSupporter.SYNCMESSAGERETURN:
 233                     return "MySyncMessageReturn";
 234                 case ISDGraphNodeSupporter.ASYNCMESSAGE:
 235                     return "MyAsyncMessage";
 236                 case ISDGraphNodeSupporter.ASYNCMESSAGERETURN:
 237                     return "MyAsyncMessageReturn";
 238                 case ISDGraphNodeSupporter.STOP:
 239                     return "MyStop";
 240                 default:
 241                     return "";
 242                 }
 243             }
 244
 245             @Override
 246             public boolean filter(List<FilterCriteria> filters) {
 247                 return false;
 248             }
 249         };
 250
 251         Criteria criteria = new Criteria();
 252         criteria.setExpression("BALL_.*");
 253         criteria.setAsyncMessageReturnSelected(true);
 254         criteria.setAsyncMessageSelected(true);
 255         criteria.setLifeLineSelected(true);
 256         criteria.setStopSelected(true);
 257         criteria.setSyncMessageReturnSelected(true);
 258         criteria.setSyncMessageSelected(true);
 259
 260         // Test summary when provider is available
 261         String summary = criteria.getGraphNodeSummary(provider, null);
 262         assertEquals("testGetGraphNodeSummary", "[MyLifeline or MySyncMessage or MySyncMessageReturn or MyAsyncMessage or MyAsyncMessageReturn or MyStop]", summary);
 263
 264         // Test default summary when no provider is provided
 265         summary = criteria.getGraphNodeSummary(null, null);
 266         assertEquals("testGetGraphNodeSummary", "[Lifeline or Synchronous message or Synchronous message return or Asynchronous message or Asynchronous message return or Stop]", summary);
 267
 268     }
 269
 270     /**
 271      * Test matches algorithm.
 272      */
 273     @Test
 274     public void testMatches() {
 275         Criteria criteria = new Criteria();
 276         criteria.setExpression("BALL_.*");
 277
 278         /*
 279          *  Note that method matches uses the Pattern class. Test
 280          *  only case sensitive/case insensitive case. All other regular
 281          *  expression cases are covered by Pattern class.
 282          */
 283
 284         // case insensitive
 285         assertTrue("testMatches", criteria.matches("BALL_REQUEST"));
 286         assertTrue("testMatches", criteria.matches("BALL_REPLY"));
 287         assertTrue("testMatches", criteria.matches("BALL_R"));
 288         assertTrue("testMatches", criteria.matches("ball_request"));
 289         assertTrue("testMatches", criteria.matches("ball_request"));
 290         assertFalse("testMatches", criteria.matches("NOBALL_REQUEST"));
 291         assertFalse("testMatches", criteria.matches("BLABLA"));
 292
 293         // case sensitive
 294         criteria.setCaseSenstiveSelected(true);
 295         assertTrue("testMatches", criteria.matches("BALL_REQUEST"));
 296         assertTrue("testMatches", criteria.matches("BALL_REPLY"));
 297         assertTrue("testMatches", criteria.matches("BALL_R"));
 298         assertFalse("testMatches", criteria.matches("ball_request"));
 299         assertFalse("testMatches", criteria.matches("ball_request"));
 300         assertFalse("testMatches", criteria.matches("NOBALL_REQUEST"));
 301         assertFalse("testMatches", criteria.matches("BLABLA"));
 302     }
 303
 304 }