nemo-impl/src/test/java/org/opendaylight/nemo/user/vnspacemanager/languagestyle/updateintentlang/UpdateTemplateDefinitionLangTest.java

   1 /*\r
   2  * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.\r
   3  *\r
   4  * This program and the accompanying materials are made available under the\r
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
   7  */\r
   8 package org.opendaylight.nemo.user.vnspacemanager.languagestyle.updateintentlang;\r
   9 \r
  10 import junit.framework.TestCase;\r
  11 import org.junit.Assert;\r
  12 import org.junit.Before;\r
  13 import org.junit.Test;\r
  14 import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
  15 import org.opendaylight.nemo.user.tenantmanager.TenantManage;\r
  16 import org.opendaylight.nemo.user.vnspacemanager.languagestyle.NEMOConstants;\r
  17 import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.GetDefinitions;\r
  18 import org.opendaylight.nemo.user.vnspacemanager.structurestyle.updateintent.UpdateTemplateDefinition;\r
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.hosts.PhysicalHost;\r
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.*;\r
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.PhysicalHostId;\r
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.PhysicalHostName;\r
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinition;\r
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinitionBuilder;\r
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.intent.rev151010.user.intent.template.definitions.TemplateDefinitionKey;\r
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.EndNode;\r
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.EndNodeBuilder;\r
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.connection.instance.EndNodeKey;\r
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItem;\r
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItemBuilder;\r
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.flow.instance.MatchItemKey;\r
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.match.item.instance.MatchItemValueBuilder;\r
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.node.instance.*;\r
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.PropertyValuesBuilder;\r
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010.property.instance.property.values.*;\r
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action.instance.ParameterValuesBuilder;\r
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.ConditionSegment;\r
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.ConditionSegmentBuilder;\r
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.ConditionSegmentKey;\r
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.condition.instance.condition.segment.ConditionParameterTargetValueBuilder;\r
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.Action;\r
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.ActionBuilder;\r
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.operation.instance.ActionKey;\r
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.AbstractIntentsBuilder;\r
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.TemplateParameter;\r
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.TemplateParameterBuilder;\r
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping.TemplateParameterKey;\r
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents.AbstractObjectsBuilder;\r
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents.AbstractOperationsBuilder;\r
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.objects.*;\r
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.operations.AbstractOperation;\r
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.operations.AbstractOperationBuilder;\r
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.template.rev151201.template.definition.grouping._abstract.intents._abstract.operations.AbstractOperationKey;\r
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.NodeId;\r
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.ConnectionId;\r
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.FlowId;\r
  57 import java.lang.reflect.Field;\r
  58 import java.util.*;\r
  59 import static org.junit.Assert.*;\r
  60 import static org.mockito.Mockito.*;\r
  61 /**\r
  62  * Created by zhangmeng on 2015/12/29.\r
  63  */\r
  64 public class UpdateTemplateDefinitionLangTest extends TestCase {\r
  65     private DataBroker dataBroker;\r
  66     private TenantManage tenantManage;\r
  67     private UpdateTemplateDefinitionLang updateTemplateDefinitionLang;\r
  68     private Class<UpdateTemplateDefinitionLang> class1;\r
  69     private Field field_definition;\r
  70     private Field field_abstractNodes ;\r
  71     private Field field_abstractConnections;\r
  72     private Field field_abstractFlows;\r
  73     private Field field_abstractOperations;\r
  74     private Field field;\r
  75 \r
  76     @Before\r
  77     public void setUp() throws Exception {\r
  78         class1 = UpdateTemplateDefinitionLang.class;\r
  79         field_definition = class1.getDeclaredField("definition");\r
  80         field_abstractNodes = class1.getDeclaredField("abstractNodes");\r
  81         field_abstractConnections = class1.getDeclaredField("abstractConnections");\r
  82         field_abstractFlows = class1.getDeclaredField("abstractFlows");\r
  83         field_abstractOperations = class1.getDeclaredField("abstractOperations");\r
  84         field = class1.getDeclaredField("getDefinitions");\r
  85         field_definition.setAccessible(true);\r
  86         field_abstractNodes.setAccessible(true);\r
  87         field_abstractConnections.setAccessible(true);\r
  88         field_abstractFlows.setAccessible(true);\r
  89         field_abstractOperations.setAccessible(true);\r
  90         field.setAccessible(true);\r
  91 \r
  92         dataBroker = mock(DataBroker.class);\r
  93         tenantManage = mock(TenantManage.class);\r
  94 \r
  95         updateTemplateDefinitionLang = new UpdateTemplateDefinitionLang(dataBroker,tenantManage);\r
  96     }\r
  97 \r
  98     @Test\r
  99     public void testTemplateDefinitionLang() throws Exception {\r
 100 \r
 101         UserId userId = mock(UserId.class);\r
 102         NodeName nodeName = mock(NodeName.class);\r
 103         AbstractNode abstractNode = mock(AbstractNode.class);\r
 104         ConnectionName connectionName = mock(ConnectionName.class);\r
 105         AbstractConnection abstractConnection = mock(AbstractConnection.class);\r
 106         FlowName flowName = mock(FlowName.class);\r
 107         AbstractFlow abstractFlow = mock(AbstractFlow.class);\r
 108         OperationName operationName = mock(OperationName.class);\r
 109         AbstractOperation abstractOperation = mock(AbstractOperation.class);\r
 110         UpdateTemplateDefinition updateTemplateDefinition = mock(UpdateTemplateDefinition.class);\r
 111         String templateName = new String("test");\r
 112         String value = new String("string");\r
 113         LinkedHashMap<String, String> parameters = new LinkedHashMap<String, String>();\r
 114         Map<NodeName, AbstractNode> abstractNodes = new HashMap<NodeName, AbstractNode>();\r
 115         Map<ConnectionName, AbstractConnection> abstractConnections = new HashMap<ConnectionName, AbstractConnection>();\r
 116         Map<FlowName, AbstractFlow> abstractFlows = new HashMap<FlowName, AbstractFlow>();\r
 117         Map<OperationName, AbstractOperation> abstractOperations = new HashMap<OperationName, AbstractOperation>();\r
 118 \r
 119         parameters.put(value, NEMOConstants.string);\r
 120         abstractConnections.put(connectionName,abstractConnection);\r
 121         abstractNodes.put(nodeName, abstractNode);\r
 122         abstractFlows.put(flowName,abstractFlow);\r
 123         abstractOperations.put(operationName,abstractOperation);\r
 124         field_definition.set(updateTemplateDefinitionLang, updateTemplateDefinition);\r
 125 \r
 126         when(updateTemplateDefinition.checkTemplateDefinition(any(UserId.class),any(TemplateDefinition.class)))\r
 127                 .thenReturn("1")\r
 128                 .thenReturn("2")\r
 129                 .thenReturn("3");\r
 130         Assert.assertTrue(updateTemplateDefinitionLang.templateDefinitionLang(userId, templateName, parameters).equals("1"));\r
 131         parameters.clear();\r
 132         parameters.put(value, NEMOConstants.integer);\r
 133         field_abstractNodes.set(updateTemplateDefinitionLang, abstractNodes);\r
 134         field_abstractConnections.set(updateTemplateDefinitionLang, abstractConnections);\r
 135         field_abstractFlows.set(updateTemplateDefinitionLang,abstractFlows);\r
 136         field_abstractOperations.set(updateTemplateDefinitionLang,abstractOperations);\r
 137         Assert.assertTrue(updateTemplateDefinitionLang.templateDefinitionLang(userId, templateName, parameters).equals("2"));\r
 138         parameters.clear();\r
 139         parameters.put(value, NEMOConstants.range);\r
 140         Assert.assertTrue(updateTemplateDefinitionLang.templateDefinitionLang(userId, templateName, parameters).equals("3"));\r
 141         verify(updateTemplateDefinition,times(3)).checkTemplateDefinition(any(UserId.class),any(TemplateDefinition.class));\r
 142     }\r
 143 \r
 144     @Test\r
 145     public void testCreateAbstractNode() throws Exception {\r
 146         String name = new String("name");\r
 147         String type = NEMOConstants.host;\r
 148         List<String> subnodes = new ArrayList<String>();\r
 149         LinkedHashMap<String, LinkedHashMap<String,String>> propertyList = new LinkedHashMap<String, LinkedHashMap<String, String>>();\r
 150         GetDefinitions getDefinitions = mock(GetDefinitions.class);\r
 151         String nodeName1 = new String("nodeName");\r
 152         String propertyName = new String("propertyName");\r
 153         String ValueName = new String("valuename");\r
 154         String Value = NEMOConstants.string;\r
 155         NodeName nodeName = new NodeName(nodeName1);\r
 156         AbstractNode abstractNode = mock(AbstractNode.class);\r
 157         PhysicalHostId physicalHostId = mock(PhysicalHostId.class);\r
 158         PhysicalHost physicalHost = mock(PhysicalHost.class);\r
 159         LinkedHashMap<String, String> values = new LinkedHashMap<String, String>();\r
 160         Map<PhysicalHostName, PhysicalHost> physicalHostMap = mock(Map.class);\r
 161         Map<NodeName, AbstractNode> abstractNodes = new HashMap<NodeName, AbstractNode>();\r
 162 \r
 163         field.set(updateTemplateDefinitionLang, getDefinitions);\r
 164         subnodes.add(nodeName1);\r
 165 \r
 166         when(getDefinitions.getPhysicalHost()).thenReturn(physicalHostMap);\r
 167         when(physicalHostMap.containsKey(any(PhysicalHostName.class)))\r
 168                 .thenReturn(false)\r
 169                 .thenReturn(true);\r
 170         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList).equals("The host " + name + " is not exist in physical network."));\r
 171         when(physicalHostMap.get(any(PhysicalHostName.class))).thenReturn(physicalHost);\r
 172         when(physicalHost.getHostId()).thenReturn(physicalHostId);\r
 173         when(physicalHostId.getValue()).thenReturn("00001111-0000-0000-0000-000011112222");\r
 174         //test nodes empty\r
 175         field_abstractNodes.set(updateTemplateDefinitionLang, abstractNodes);\r
 176         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList).equals("There are no nodes."));\r
 177         //nodes not empty propertyList empty\r
 178         abstractNodes.put(nodeName, abstractNode);\r
 179         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList) == null);\r
 180         //propertyList not empty\r
 181         propertyList.put(propertyName,values);\r
 182         values.put(ValueName,Value);\r
 183         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList) == null);\r
 184         values.clear();\r
 185         values.put("11", NEMOConstants.integer);\r
 186         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList) == null);\r
 187         values.clear();\r
 188         values.put("1,1", NEMOConstants.range);\r
 189         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList) == null);\r
 190         type = NEMOConstants.SubNodes;\r
 191         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractNode(name, type, subnodes, propertyList) == null);\r
 192 \r
 193     }\r
 194 \r
 195     @Test\r
 196     public void testCreateAbstractConnection() throws Exception {\r
 197         String name = new String("name");\r
 198         String type = NEMOConstants.host;\r
 199         String endNode = new String("endNode");\r
 200         String propertyName = new String("propertyName");\r
 201         String ValueName = new String("valuename");\r
 202         String Value = NEMOConstants.string;\r
 203         List<String> endnodes = new ArrayList<String>();\r
 204         NodeName nodeName = mock(NodeName.class);\r
 205         NodeId nodeId = mock(NodeId.class);\r
 206         AbstractNode abstractNode = mock(AbstractNode.class);\r
 207         LinkedHashMap<String, String> values = new LinkedHashMap<String, String>();\r
 208         LinkedHashMap<String, LinkedHashMap<String,String>> propertyList = new LinkedHashMap<String, LinkedHashMap<String, String>>();\r
 209         Map<NodeName, AbstractNode> abstractNodes = new HashMap<NodeName, AbstractNode>();\r
 210 \r
 211         abstractNodes.put(nodeName, abstractNode);\r
 212         endnodes.add(endNode);\r
 213 \r
 214         //test abstractNodes empty\r
 215         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList).equals("There are nodes exist."));\r
 216         //abstractNodes not empty\r
 217         field_abstractNodes.set(updateTemplateDefinitionLang, abstractNodes);\r
 218         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList).equals("The endnode " + endNode + " is not exit."));\r
 219         abstractNodes.clear();\r
 220         abstractNodes.put(new NodeName(endNode), abstractNode);\r
 221         when(abstractNode.getNodeId()).thenReturn(nodeId);\r
 222         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList) == null);\r
 223         //test propertyList not null\r
 224         propertyList.put(propertyName, values);\r
 225         // string\r
 226         values.put(ValueName,Value);\r
 227         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList) == null);\r
 228         values.clear();\r
 229         values.put("11", NEMOConstants.integer);\r
 230         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList) == null);\r
 231         values.clear();\r
 232         values.put("1,1", NEMOConstants.range);\r
 233         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractConnection(name, type, endnodes, propertyList) == null);\r
 234 \r
 235     }\r
 236 \r
 237     @Test\r
 238     public void testCreateAbstractFlow() throws Exception {\r
 239         String name = new String("name");\r
 240         String value = new String("value");\r
 241         String Value = NEMOConstants.string;\r
 242         String matchName = new String("matchName");\r
 243         LinkedHashMap<String,String> values = new LinkedHashMap<String, String>();\r
 244         LinkedHashMap<String,LinkedHashMap<String,String>> matches =  new LinkedHashMap<String, LinkedHashMap<String, String>>();\r
 245         LinkedHashMap<String,LinkedHashMap<String,String>> propertyList = new LinkedHashMap<String, LinkedHashMap<String, String>>();\r
 246 \r
 247         matches.put(matchName,values);\r
 248 \r
 249         //string\r
 250         values.put(value,Value);\r
 251         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractFlow(name, matches, propertyList) == null);\r
 252         values.clear();\r
 253         values.put("11", NEMOConstants.integer);\r
 254         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractFlow(name, matches, propertyList) == null);\r
 255         values.clear();\r
 256         values.put("1,1", NEMOConstants.range);\r
 257         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractFlow(name, matches, propertyList) == null);\r
 258 \r
 259     }\r
 260 \r
 261     @Test\r
 262     public void testCreateAbstractOperation() throws Exception {\r
 263         String name = new String("name");\r
 264         String target = new String("target");\r
 265         String priority = new String("1");\r
 266         LinkedHashMap<String,LinkedHashMap<String,String>> conditions = new LinkedHashMap<String, LinkedHashMap<String, String>>();\r
 267         LinkedHashMap<String,LinkedHashMap<String,String>>actions = new LinkedHashMap<String, LinkedHashMap<String, String>>();\r
 268 \r
 269         String conditionName = new String("!,name,==");\r
 270         String value = new String("value");\r
 271         String actionName = new String("actionName");\r
 272         AbstractNode abstractNode = mock(AbstractNode.class);\r
 273         AbstractFlow abstractFlow = mock(AbstractFlow.class);\r
 274         AbstractConnection abstractConnection = mock(AbstractConnection.class);\r
 275         LinkedHashMap<String,String> parameters = new LinkedHashMap<String, String>();\r
 276         LinkedHashMap<String, String> targetValue = new LinkedHashMap<String, String>();\r
 277         Map<NodeName, AbstractNode> abstractNodes = mock(Map.class);\r
 278         Map<ConnectionName, AbstractConnection> abstractConnections = mock(Map.class);\r
 279         Map<FlowName, AbstractFlow> abstractFlows = mock(Map.class);\r
 280 \r
 281         field_abstractNodes.set(updateTemplateDefinitionLang, abstractNodes);\r
 282         field_abstractConnections.set(updateTemplateDefinitionLang, abstractConnections);\r
 283         field_abstractFlows.set(updateTemplateDefinitionLang, abstractFlows);\r
 284 \r
 285         when(abstractNodes.containsKey(any(NodeName.class))).thenReturn(true);\r
 286         when(abstractNodes.get(new NodeName(target))).thenReturn(abstractNode);\r
 287         when(abstractNode.getNodeId()).thenReturn(mock(NodeId.class));\r
 288         when(abstractConnections.containsKey(any(ConnectionName.class))).thenReturn(true);\r
 289         when(abstractConnections.get(new ConnectionName(target))).thenReturn(abstractConnection);\r
 290         when(abstractConnection.getConnectionId()).thenReturn(mock(ConnectionId.class));\r
 291         when(abstractFlows.containsKey(any(FlowName.class))).thenReturn(true);\r
 292         when(abstractFlows.get(new FlowName(target))).thenReturn(abstractFlow);\r
 293         when(abstractFlow.getFlowId()).thenReturn(mock(FlowId.class));\r
 294         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null);\r
 295         //test conditions not empty\r
 296         targetValue.put(value,NEMOConstants.string); //string\r
 297         conditions.put(conditionName, targetValue);// not equal\r
 298 //        System.out.println(",1,2".split(NEMOConstants.comma)[1] == null);\r
 299 //        System.out.println("split" + conditionName.split(NEMOConstants.comma)[0] + "+" + conditionName.split(NEMOConstants.comma)[2]);\r
 300         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null);\r
 301         targetValue.clear();\r
 302         conditions.clear();\r
 303         targetValue.put("11", NEMOConstants.integer); // int\r
 304         conditions.put("&&,name,!=", targetValue);// and notEqual\r
 305         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null);\r
 306         targetValue.clear();\r
 307         conditions.clear();\r
 308         targetValue.put("1,1", NEMOConstants.range); // range\r
 309         conditions.put("||,name,>", targetValue);// and greater_than\r
 310         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null);\r
 311         targetValue.clear();\r
 312         conditions.clear();\r
 313         targetValue.put("1,1", NEMOConstants.range); // range\r
 314         conditions.put(",name,<", targetValue);// null less_than\r
 315         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null);\r
 316         targetValue.clear();\r
 317         conditions.clear();\r
 318         targetValue.put("1,1", NEMOConstants.range); // range\r
 319         conditions.put(",name,>=", targetValue);// null not_less_than\r
 320         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null);\r
 321         targetValue.clear();\r
 322         conditions.clear();\r
 323         targetValue.put("1,1", NEMOConstants.range); // range\r
 324         conditions.put(",name,<=", targetValue);// null not_greater_than\r
 325         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null);\r
 326         targetValue.clear();\r
 327         conditions.clear();\r
 328         targetValue.put("1,1", NEMOConstants.range); // range\r
 329         conditions.put(",name,*", targetValue);// null between\r
 330         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null);\r
 331         targetValue.clear();\r
 332         conditions.clear();\r
 333         targetValue.put("1,1", NEMOConstants.range); // range\r
 334         conditions.put(",name,==", targetValue);// null equal\r
 335         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null);\r
 336 \r
 337         //test actions not empty\r
 338         parameters.put("string", NEMOConstants.string);\r
 339         actions.put(actionName, parameters);\r
 340         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null);\r
 341         actions.clear();\r
 342         parameters.clear();\r
 343         parameters.put("11", NEMOConstants.integer);\r
 344         actions.put(actionName, parameters);\r
 345         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions) == null);\r
 346         actions.clear();\r
 347         parameters.clear();\r
 348         parameters.put("1,1", NEMOConstants.range);\r
 349         actions.put(actionName,parameters);\r
 350         Assert.assertTrue(updateTemplateDefinitionLang.createAbstractOperation(name, target, priority, conditions, actions).equals("The action values are not consistent."));\r
 351 \r
 352 \r
 353     }\r
 354 }