@Test
  public void testSetAmount2() throws Exception {
    System.out.println("setAmount2");

    /* Set up a new loan */
    Loan target = new Loan();

    /* get the setAmount method details */
    Method method = Loan.class.getDeclaredMethod("setAmount", double.class);

    /* make the field assessible */
    method.setAccessible(true);

    /* invoke the method setAmount with the value 3000.0 */
    method.invoke(target, 3000.0);

    /*access the field loanAmount and check its value is set the 3000.0*/
    Class secretClass = target.getClass();
    Field f = secretClass.getDeclaredField("loanAmount");
    f.setAccessible(true);

    double result = f.getDouble(target);

    assertEquals("The amounts should be equal", 3000.00, result, 0.0);
  }
 protected void invokeKey(String name) throws Exception {
   if (!needsKey) return;
   BehaviorSkinBase skin = (BehaviorSkinBase) getView().getSkin();
   BehaviorBase behavior = skin.getBehavior();
   Class<? extends BehaviorBase> behaviorClass = behavior.getClass();
   Field field = behaviorClass.getDeclaredField(name);
   field.setAccessible(true);
   field.set(behavior, true);
 }
  @Test
  public void testCheckFlowTemplate() throws Exception {
    method =
        class1.getDeclaredMethod("checkFlowTemplate", new Class[] {AbstractFlow.class, Map.class});
    method.setAccessible(true);
    field = class1.getDeclaredField("getDefinitions");
    field.setAccessible(true);

    GetDefinitions getDefinitions = mock(GetDefinitions.class);
    AbstractFlow flow = mock(AbstractFlow.class);
    MatchItem matchItem = mock(MatchItem.class);
    List<MatchItem> matchItemList = new ArrayList<MatchItem>();
    MatchItemValue matchItemValue = mock(MatchItemValue.class);
    MatchItemName matchItemName = mock(MatchItemName.class);
    MatchItemDefinition matchItemDefinition = mock(MatchItemDefinition.class);
    MatchItemDefinition.MatchItemValueType type = MatchItemDefinition.MatchItemValueType.String;
    TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
    Map<MatchItemName, MatchItemDefinition> matchItemDefinitionMap =
        new HashMap<MatchItemName, MatchItemDefinition>();
    Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap =
        new HashMap<ParameterName, TemplateParameter.ParameterValueType>();

    field.set(updateTemplateDefinition, getDefinitions);
    parameterValueTypeMap.put(new ParameterName("ParameterName"), valueType);

    when(getDefinitions.getMatchItemDefinition()).thenReturn(matchItemDefinitionMap);
    when(flow.getMatchItem()).thenReturn(matchItemList);
    Assert.assertTrue(method.invoke(updateTemplateDefinition, flow, parameterValueTypeMap) == null);
    matchItemList.add(matchItem);
    when(matchItem.getMatchItemName()).thenReturn(matchItemName);
    when(matchItemName.getValue()).thenReturn("test");
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, flow, parameterValueTypeMap)
            .equals(
                "The match item " + matchItem.getMatchItemName().getValue() + " is not defined."));
    // test add matchItem
    matchItemDefinitionMap.put(matchItemName, matchItemDefinition);
    Assert.assertTrue(matchItemDefinitionMap.containsKey(matchItemName));
    when(matchItemDefinition.getMatchItemValueType())
        .thenReturn(MatchItemDefinition.MatchItemValueType.Int)
        .thenReturn(type);
    Assert.assertTrue(method.invoke(updateTemplateDefinition, flow, parameterValueTypeMap) == null);
    when(matchItem.getMatchItemValue()).thenReturn(matchItemValue);
    when(matchItemValue.getStringValue()).thenReturn("ParameterName");
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, flow, parameterValueTypeMap)
            .equals("The match item " + "ParameterName" + " type is not right."));
  }
Example #4
0
  private Object getValueOfField(String fieldname, Class<?> sourceClass, Object source) {
    String sourceClassName = sourceClass.getName();

    Field field = null;
    try {
      field = sourceClass.getDeclaredField(fieldname);
      field.setAccessible(true);
    } catch (SecurityException e) {
      fail(
          "Unable to retrieve "
              + fieldname
              + " field from "
              + sourceClassName
              + ": "
              + e.getCause());
    } catch (NoSuchFieldException e) {
      fail(
          "Unable to retrieve "
              + fieldname
              + " field from "
              + sourceClassName
              + ": "
              + e.getCause());
    }

    assertNotNull("." + fieldname + " field is null!?!", field);
    Object fieldValue = null;
    try {
      fieldValue = field.get(source);
    } catch (IllegalArgumentException e) {
      fail(
          "Unable to retrieve value of "
              + fieldname
              + " from "
              + sourceClassName
              + ": "
              + e.getCause());
    } catch (IllegalAccessException e) {
      fail(
          "Unable to retrieve value of "
              + fieldname
              + " from "
              + sourceClassName
              + ": "
              + e.getCause());
    }
    return fieldValue;
  }
  @Test
  public void testSetPeriod() throws Exception {
    System.out.println("test setPeriod()");

    Loan target = new Loan();

    Method method = Loan.class.getDeclaredMethod("setPeriod", int.class);

    method.setAccessible(true);

    method.invoke(target, 2);

    Class secretClass = target.getClass();
    Field f = secretClass.getDeclaredField("numberOfPayments");
    f.setAccessible(true);

    int result = f.getInt(target);

    assertEquals("The number of payments should be equal", 24, result);
  }
  /** Accessing a private field Test of loanamount, of class Loan. */
  @Test
  public void testSetAmount1() throws Exception {
    System.out.println("setAmount1");
    Loan target = new Loan(4000.0, 10.0, 5);

    /*creat secret class */
    Class secretClass = target.getClass();

    /* The the private field */
    Field f = secretClass.getDeclaredField("loanAmount");

    /*Set tha field to accessible */
    f.setAccessible(true);
    System.out.println("The value in f is " + f.get(target));

    /*get the value of the field */
    double result = f.getDouble(target);

    /*Assert the value is correct */
    assertEquals("The amounts should be equal", 4000.00, result, 0.0);
  }
Example #7
0
  @Test
  public void bindingTest() throws Exception {

    // String nativesPath = testOutput + "/build/natives";
    // System.load(nativesPath + "/librofl.so");
    System.loadLibrary("rofl");

    Class<?> clazz = Class.forName("test.BindingTest");

    assertEquals((long) 0xFFFFFFFF, clazz.getDeclaredField("GL_INVALID_INDEX").get(null));
    assertEquals(-0.5f, clazz.getDeclaredField("AL_FLANGER_DEFAULT_FEEDBACK").get(null));

    // TODO fix Exception: ...Caused by: java.lang.UnsatisfiedLinkError:
    // test.BindingTest.arrayTest0(JLjava/lang/Object;I)I
    /*
    // test values
    ByteBuffer dbb = Buffers.newDirectByteBuffer(32);
    ByteBuffer bb  = ByteBuffer.allocate(32).order(ByteOrder.nativeOrder());

    PointerBuffer dpb = PointerBuffer.allocateDirect(32);
    PointerBuffer pb  = PointerBuffer.allocate(32);

    long[] array = new long[] {1,2,3,4,5,6,7,8,9};
    int offset = 0;
    long id = 42;


    // invoke everything public
    Object bindingTest = clazz.newInstance();
    Method[] methods = clazz.getDeclaredMethods();

    for (Method method : methods) {

        // prepare method parameters
        Class<?>[] paramTypes = method.getParameterTypes();
        Object[] paramInstances = new Object[paramTypes.length];

        for (int i = 0; i < paramTypes.length; i++) {
            Class<?> paramType = paramTypes[i];
            if(paramType.isInstance(dbb)) {
                paramInstances[i] = dbb;
            }else if(paramType.isInstance(bb)) {
                paramInstances[i] = bb;
            }else if(paramType.isInstance(dpb)) {
                paramInstances[i] = dpb;
            }else if(paramType.isInstance(pb)) {
                paramInstances[i] = pb;
            }else if(paramType.isPrimitive()) { // TODO primitive types
                paramInstances[i] = offset;
            }else if(paramType.isArray()) {     // TODO array types
                paramInstances[i] = array;
            }
        }

        out.println("invoking: "+method);
        out.println("with params: ");
        for (Object param : paramInstances)
            out.print(param+", ");
        out.println();

        Object result = method.invoke(bindingTest, paramInstances);
        out.println("result: "+result);
        out.println("success");
    }
    */
  }
 private Object getField(String fieldName, Class<?> clazz, Object obj) throws Exception {
   Field field = clazz.getDeclaredField(fieldName);
   field.setAccessible(true);
   return field.get(obj);
 }
  @Test
  public void testCheckTemplateDefinition() throws Exception {
    field = class1.getDeclaredField("getDefinitions");
    field.setAccessible(true);

    GetDefinitions getDefinitions = mock(GetDefinitions.class);
    UserId userId = mock(UserId.class);
    NodeId nodeId = mock(NodeId.class);
    SubNode subNode = mock(SubNode.class);
    EndNode endNode = mock(EndNode.class);
    TemplateDefinition templateDefinition = mock(TemplateDefinition.class);
    TemplateName templateName = mock(TemplateName.class);
    ParameterName parameterName = mock(ParameterName.class);
    AbstractIntents abstractIntents = mock(AbstractIntents.class);
    TemplateParameter.ParameterValueType parameterValueType =
        TemplateParameter.ParameterValueType.Int;
    TemplateParameter templateParameter = mock(TemplateParameter.class);
    AbstractObjects abstractObjects = mock(AbstractObjects.class);
    AbstractNode node = mock(AbstractNode.class);
    AbstractNode node1 = mock(AbstractNode.class);
    NodeType nodeType = mock(NodeType.class);
    NodeDefinition nodeDefinition = mock(NodeDefinition.class);
    AbstractConnection connection = mock(AbstractConnection.class);
    List<PropertyDefinition> propertyDefinitions = new ArrayList<PropertyDefinition>();
    List<TemplateParameter> list = new ArrayList<TemplateParameter>();
    List<AbstractNode> nodeList = new ArrayList<AbstractNode>();
    List<SubNode> subNodeList = new ArrayList<SubNode>();
    List<EndNode> endNodeList = new ArrayList<EndNode>();
    List<AbstractNode> nodeList1 = new ArrayList<AbstractNode>();
    List<AbstractConnection> connectionList = new ArrayList<AbstractConnection>();
    Map<TemplateName, TemplateDefinition> map = mock(Map.class);
    Map<NodeType, NodeDefinition> nodeDefinitions = mock(Map.class);
    Map<ConnectionType, ConnectionDefinition> connDefinitions = mock(Map.class);
    field.set(updateTemplateDefinition, getDefinitions);
    //        nodeDefinitions.put(nodeType, nodeDefinition);
    list.add(templateParameter);
    endNodeList.add(endNode);
    nodeList.add(node);
    nodeList1.add(node1);
    subNodeList.add(subNode);
    connectionList.add(connection);

    when(getDefinitions.getNodeDefinition()).thenReturn(nodeDefinitions);
    when(tenantManage.getTempalteDefinition(userId))
        .thenReturn(map)
        .thenReturn(map)
        .thenReturn(null);
    when(templateDefinition.getTemplateName()).thenReturn(templateName);
    when(templateName.getValue()).thenReturn("test");
    when(map.containsKey(templateDefinition.getTemplateName())).thenReturn(true);
    Assert.assertTrue(
        updateTemplateDefinition
            .checkTemplateDefinition(userId, templateDefinition)
            .equals(
                "The template "
                    + templateDefinition.getTemplateName().getValue()
                    + " has been defined."));
    verify(tenantManage, times(2)).getTempalteDefinition(userId);
    when(templateDefinition.getTemplateParameter()).thenReturn(list);
    when(templateParameter.getParameterName()).thenReturn(parameterName);
    when(templateParameter.getParameterValueType()).thenReturn(parameterValueType);
    when(templateDefinition.getAbstractIntents()).thenReturn(abstractIntents);
    when(abstractIntents.getAbstractObjects()).thenReturn(abstractObjects);
    when(abstractObjects.getAbstractNode()).thenReturn(nodeList);
    when(node.getNodeId()).thenReturn(nodeId);
    when(node.getSubNode()).thenReturn(subNodeList);
    when(subNode.getNodeId()).thenReturn(mock(NodeId.class)).thenReturn(nodeId);
    Assert.assertTrue(
        updateTemplateDefinition
            .checkTemplateDefinition(userId, templateDefinition)
            .equals("The sub node is not defined."));
    // get into method "checkNodeTemplate" args(node,map) map(parameterName,parameterValueType)
    when(node.getNodeType()).thenReturn(nodeType);
    when(nodeDefinitions.containsKey(node.getNodeType())).thenReturn(true);
    when(nodeDefinitions.get(node.getNodeType())).thenReturn(nodeDefinition);
    when(nodeDefinition.getPropertyDefinition()).thenReturn(null);
    when(node.getProperty()).thenReturn(null);
    // return

  }
  @Test
  public void testCheckOperationTemplate() throws Exception {
    method =
        class1.getDeclaredMethod(
            "checkOperationTemplate", new Class[] {AbstractOperation.class, Map.class});
    method.setAccessible(true);
    field = class1.getDeclaredField("getDefinitions");
    field.setAccessible(true);

    GetDefinitions getDefinitions = mock(GetDefinitions.class);
    Action action = mock(Action.class);
    ActionName actionName = mock(ActionName.class);
    ActionDefinition actionDefinition = mock(ActionDefinition.class);
    AbstractOperation operation = mock(AbstractOperation.class);
    ConditionSegment conditionSegment = mock(ConditionSegment.class);
    ParameterName parameterName = mock(ParameterName.class);
    ParameterValues parameterValues = mock(ParameterValues.class);
    ConditionParameterName conditionParameterName = mock(ConditionParameterName.class);
    ConditionParameterDefinition definition = mock(ConditionParameterDefinition.class);
    ConditionParameterDefinition conditionParameterDefinition =
        mock(ConditionParameterDefinition.class);
    ConditionParameterTargetValue conditionParameterTargetValue =
        mock(ConditionParameterTargetValue.class);
    ConditionParameterDefinition.ParameterValueType type =
        ConditionParameterDefinition.ParameterValueType.String;
    TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
    ActionDefinition.ParameterValueType type1 = ActionDefinition.ParameterValueType.String;
    org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation.rev151010.action
            .instance.parameter.values.StringValue
        stringValue =
            mock(
                org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation
                    .rev151010.action.instance.parameter.values.StringValue.class);
    List<Action> actionList = new ArrayList<Action>();
    List<
            org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation
                .rev151010.action.instance.parameter.values.StringValue>
        stringValues =
            new ArrayList<
                org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.operation
                    .rev151010.action.instance.parameter.values.StringValue>();
    List<ConditionSegment> conditionSegmentList = new ArrayList<ConditionSegment>();
    Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap =
        new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
    Map<ActionName, ActionDefinition> actionDefinitionMap =
        new HashMap<ActionName, ActionDefinition>();
    Map<ParameterName, ConditionParameterDefinition> conditionParameterDefinitionMap =
        mock(Map.class);

    field.set(updateTemplateDefinition, getDefinitions);
    conditionSegmentList.add(conditionSegment);
    parameterValueTypeMap.put(new ParameterName("ParameterName"), valueType);
    conditionParameterDefinitionMap.put(parameterName, conditionParameterDefinition);

    when(getDefinitions.getActionDefinition()).thenReturn(actionDefinitionMap);
    when(getDefinitions.getConditionParameterDefinition())
        .thenReturn(conditionParameterDefinitionMap);
    when(operation.getConditionSegment()).thenReturn(null).thenReturn(conditionSegmentList);
    when(operation.getAction()).thenReturn(null).thenReturn(actionList);
    Assert.assertTrue(
        method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
    // test condition
    when(conditionSegment.getConditionParameterName()).thenReturn(conditionParameterName);
    when(conditionParameterDefinitionMap.containsKey(conditionSegment.getConditionParameterName()))
        .thenReturn(false)
        .thenReturn(true);
    when(parameterName.getValue()).thenReturn("test");
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, operation, parameterValueTypeMap)
            .equals(
                "The Condition "
                    + conditionSegment.getConditionParameterName().getValue()
                    + " is not defined."));
    when(conditionSegment.getConditionParameterTargetValue())
        .thenReturn(null)
        .thenReturn(conditionParameterTargetValue);
    Assert.assertTrue(
        method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
    when(conditionParameterDefinitionMap.get(conditionSegment.getConditionParameterName()))
        .thenReturn(definition);
    when(definition.getParameterValueType())
        .thenReturn(ConditionParameterDefinition.ParameterValueType.Int)
        .thenReturn(type);
    Assert.assertTrue(
        method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
    when(conditionParameterTargetValue.getStringValue()).thenReturn("ParameterName");
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, operation, parameterValueTypeMap)
            .equals(
                "The condition "
                    + conditionSegment.getConditionParameterName().getValue()
                    + " type is not right."));

    // test action
    conditionSegmentList.clear();
    actionList.add(action);
    stringValues.add(stringValue);

    when(action.getActionName()).thenReturn(actionName);
    when(actionName.getValue()).thenReturn("test");
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, operation, parameterValueTypeMap)
            .equals("The action " + action.getActionName().getValue() + " is not defined."));
    actionDefinitionMap.put(actionName, actionDefinition);
    when(action.getParameterValues()).thenReturn(null).thenReturn(parameterValues);
    Assert.assertTrue(
        method.invoke(updateTemplateDefinition, operation, parameterValueTypeMap) == null);
    when(actionDefinition.getParameterValueType()).thenReturn(type1);
    when(parameterValues.getStringValue()).thenReturn(stringValues);
    when(stringValue.getValue()).thenReturn("ParameterName");
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, operation, parameterValueTypeMap)
            .equals("The action " + action.getActionName().getValue() + " type is not right."));
  }
  @Test
  public void testCheckConnectionTemplate() throws Exception {
    method =
        class1.getDeclaredMethod(
            "checkConnectionTemplate", new Class[] {AbstractConnection.class, Map.class});
    method.setAccessible(true);
    field = class1.getDeclaredField("getDefinitions");
    field.setAccessible(true);

    GetDefinitions getDefinitions = mock(GetDefinitions.class);
    AbstractConnection connection = mock(AbstractConnection.class);
    ConnectionDefinition connectionDefinition = mock(ConnectionDefinition.class);
    ConnectionType connectionType = mock(ConnectionType.class);
    PropertyDefinition propertyDefinition = mock(PropertyDefinition.class);
    PropertyName propertyName = mock(PropertyName.class);
    PropertyValues propertyValues = mock(PropertyValues.class);
    StringValue stringValue = mock(StringValue.class);
    PropertyDefinition.PropertyValueType type = PropertyDefinition.PropertyValueType.String;
    TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
    org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010
            .connection.instance.Property
        property =
            mock(
                org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object
                    .rev151010.connection.instance.Property.class);
    List<
            org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010
                .connection.instance.Property>
        properties =
            new ArrayList<
                org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object
                    .rev151010.connection.instance.Property>();
    List<PropertyDefinition> propertyDefinitions = new ArrayList<PropertyDefinition>();
    List<StringValue> stringValues = new ArrayList<StringValue>();
    Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap =
        new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
    Map<ConnectionType, ConnectionDefinition> connDefinitions =
        new HashMap<ConnectionType, ConnectionDefinition>();

    field.set(updateTemplateDefinition, getDefinitions);
    propertyDefinitions.add(propertyDefinition);
    properties.add(property);
    stringValues.add(stringValue);
    parameterValueTypeMap.put(new ParameterName("ParameterName"), valueType);

    when(getDefinitions.getConnectionDefinition()).thenReturn(connDefinitions);
    when(connection.getConnectionType()).thenReturn(connectionType);
    when(connectionType.getValue()).thenReturn("test");
    // test null
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, connection, parameterValueTypeMap)
            .equals(
                "The connection type "
                    + connection.getConnectionType().getValue()
                    + " is not defined."));
    // test not null
    connDefinitions.put(connectionType, connectionDefinition);
    when(connectionDefinition.getPropertyDefinition()).thenReturn(propertyDefinitions);
    when(propertyDefinition.getPropertyName()).thenReturn(propertyName);
    when(connection.getProperty()).thenReturn(null).thenReturn(properties);
    Assert.assertTrue(
        method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap) == null);
    when(property.getPropertyName()).thenReturn(mock(PropertyName.class)).thenReturn(propertyName);
    when(propertyName.getValue()).thenReturn("test");
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, connection, parameterValueTypeMap)
            .equals(
                "The property name " + property.getPropertyName().getValue() + " is not defined."));
    Assert.assertTrue(type.getIntValue() == 0);
    when(propertyDefinition.getPropertyValueType())
        .thenReturn(PropertyDefinition.PropertyValueType.Int)
        .thenReturn(type);
    Assert.assertTrue(
        method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap) == null);
    verify(propertyDefinition).getPropertyValueType();
    when(property.getPropertyValues()).thenReturn(propertyValues);
    when(propertyValues.getStringValue()).thenReturn(stringValues);
    when(stringValue.getValue()).thenReturn(new String("ParameterName"));
    Assert.assertTrue(parameterValueTypeMap.get(new ParameterName("ParameterName")) == valueType);
    //        System.out.println((String) method.invoke(updateTemplateDefinition, connection,
    // parameterValueTypeMap));
    //        System.out.println("valuetype" + valueType.getIntValue());
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, connection, parameterValueTypeMap)
            .equals(
                "The property " + property.getPropertyName().getValue() + " type is not right."));
    verify(stringValue).getValue();
  }
  @Test
  public void testCheckNodeTemplate() throws Exception {
    method =
        class1.getDeclaredMethod("checkNodeTemplate", new Class[] {AbstractNode.class, Map.class});
    method.setAccessible(true);
    field = class1.getDeclaredField("getDefinitions");
    field.setAccessible(true);

    GetDefinitions getDefinitions = mock(GetDefinitions.class);
    AbstractNode node = mock(AbstractNode.class);
    NodeType nodeType = mock(NodeType.class);
    NodeDefinition nodeDefinition = mock(NodeDefinition.class);
    PropertyName propertyName = mock(PropertyName.class);
    Property property = mock(Property.class);
    StringValue stringValue = mock(StringValue.class);
    PropertyValues propertyValues = mock(PropertyValues.class);
    PropertyDefinition.PropertyValueType type = PropertyDefinition.PropertyValueType.String;
    PropertyDefinition propertyDefinition = mock(PropertyDefinition.class);
    TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
    List<Property> properties = new ArrayList<Property>();
    List<StringValue> stringValues = new ArrayList<StringValue>();
    List<PropertyDefinition> propertyDefinitions = new ArrayList<PropertyDefinition>();
    Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap =
        new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
    Map<NodeType, NodeDefinition> nodeDefinitions = new HashMap<NodeType, NodeDefinition>();

    parameterValueTypeMap.put(new ParameterName("ParameterName"), valueType);

    field.set(updateTemplateDefinition, getDefinitions);
    when(getDefinitions.getNodeDefinition()).thenReturn(nodeDefinitions);
    when(node.getNodeType()).thenReturn(nodeType);
    when(nodeType.getValue()).thenReturn("test");
    // test null
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, node, parameterValueTypeMap)
            .equals("The node type " + node.getNodeType().getValue() + " is not defined."));
    verify(node, times(3)).getNodeType();
    // test not null
    nodeDefinitions.put(nodeType, nodeDefinition);
    propertyDefinitions.add(propertyDefinition);
    properties.add(property);
    stringValues.add(stringValue);
    Assert.assertTrue(nodeDefinitions.get(nodeType) == nodeDefinition);
    when(nodeDefinition.getPropertyDefinition()).thenReturn(propertyDefinitions);
    when(propertyDefinition.getPropertyName()).thenReturn(propertyName);
    when(propertyName.getValue()).thenReturn("test");
    when(node.getProperty()).thenReturn(null).thenReturn(properties);
    Assert.assertTrue(method.invoke(updateTemplateDefinition, node, parameterValueTypeMap) == null);
    when(property.getPropertyName()).thenReturn(mock(PropertyName.class)).thenReturn(propertyName);
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, node, parameterValueTypeMap)
            .equals(
                "The property name " + property.getPropertyName().getValue() + " is not defined."));
    when(propertyDefinition.getPropertyValueType())
        .thenReturn(PropertyDefinition.PropertyValueType.Int)
        .thenReturn(type);
    //        System.out.println("type" + type.getIntValue());
    Assert.assertTrue(method.invoke(updateTemplateDefinition, node, parameterValueTypeMap) == null);
    when(property.getPropertyValues()).thenReturn(propertyValues);
    when(propertyValues.getStringValue()).thenReturn(stringValues);
    when(stringValue.getValue()).thenReturn(new String("ParameterName"));
    Assert.assertTrue(
        method
            .invoke(updateTemplateDefinition, node, parameterValueTypeMap)
            .equals(
                "The property " + property.getPropertyName().getValue() + " type is not right."));
  }