private static void fillRequirementsMap(
     Map<String, Requirement> map,
     List<RequirementDefinition> elements,
     Collection<CSARDependency> dependencies,
     Map<String, Requirement> mapToMerge,
     IToscaElementFinder toscaElementFinder) {
   if (elements == null) {
     return;
   }
   for (RequirementDefinition requirement : elements) {
     Requirement toAddRequirement = MapUtils.getObject(mapToMerge, requirement.getId());
     if (toAddRequirement == null) {
       toAddRequirement = new Requirement();
       toAddRequirement.setType(requirement.getType());
       IndexedCapabilityType indexedReq =
           toscaElementFinder.getElementInDependencies(
               IndexedCapabilityType.class, requirement.getType(), dependencies);
       if (indexedReq != null && indexedReq.getProperties() != null) {
         toAddRequirement.setProperties(
             PropertyUtil.getDefaultPropertyValuesFromPropertyDefinitions(
                 indexedReq.getProperties()));
       }
     }
     map.put(requirement.getId(), toAddRequirement);
   }
 }
  @SuppressWarnings("unchecked")
  @Test
  public void testNodeType() throws FileNotFoundException, ParsingException {
    Mockito.reset(repositorySearchService);
    IndexedNodeType mockedResult = Mockito.mock(IndexedNodeType.class);
    Mockito.when(
            repositorySearchService.getElementInDependencies(
                Mockito.eq(IndexedNodeType.class),
                Mockito.eq("tosca.nodes.SoftwareComponent"),
                Mockito.any(List.class)))
        .thenReturn(mockedResult);
    Mockito.when(mockedResult.getDerivedFrom()).thenReturn(Lists.newArrayList("tosca.nodes.Root"));
    Mockito.when(
            repositorySearchService.getElementInDependencies(
                Mockito.eq(IndexedNodeType.class),
                Mockito.eq("tosca.nodes.Root"),
                Mockito.any(List.class)))
        .thenReturn(mockedResult);

    Mockito.when(
            repositorySearchService.getElementInDependencies(
                Mockito.eq(IndexedNodeType.class),
                Mockito.eq("tosca.nodes.Compute"),
                Mockito.any(List.class)))
        .thenReturn(mockedResult);
    IndexedCapabilityType mockedCapabilityResult = Mockito.mock(IndexedCapabilityType.class);
    Mockito.when(
            repositorySearchService.getElementInDependencies(
                Mockito.eq(IndexedCapabilityType.class),
                Mockito.eq("mytypes.mycapabilities.MyCapabilityTypeName"),
                Mockito.any(List.class)))
        .thenReturn(mockedCapabilityResult);
    Mockito.when(
            repositorySearchService.getElementInDependencies(
                Mockito.eq(IndexedCapabilityType.class),
                Mockito.eq("mytypes.mycapabilities.MyCapabilityTypeName"),
                Mockito.any(List.class)))
        .thenReturn(mockedCapabilityResult);

    Mockito.when(
            repositorySearchService.getElementInDependencies(
                Mockito.eq(IndexedCapabilityType.class),
                Mockito.eq("tosca.capabilities.Endpoint"),
                Mockito.any(List.class)))
        .thenReturn(mockedCapabilityResult);
    IndexedRelationshipType hostedOn = new IndexedRelationshipType();
    Mockito.when(
            repositorySearchService.getElementInDependencies(
                Mockito.eq(IndexedRelationshipType.class),
                Mockito.eq("tosca.relationships.HostedOn"),
                Mockito.any(List.class)))
        .thenReturn(hostedOn);

    ParsingResult<ArchiveRoot> parsingResult =
        parser.parseFile(Paths.get(getRootDirectory(), "tosca-node-type.yml"));

    assertNoBlocker(parsingResult);
    ArchiveRoot archiveRoot = parsingResult.getResult();
    Assert.assertNotNull(archiveRoot.getArchive());
    Assert.assertEquals(getToscaVersion(), archiveRoot.getArchive().getToscaDefinitionsVersion());
    Assert.assertEquals(1, archiveRoot.getNodeTypes().size());
    // check node type.
    Entry<String, IndexedNodeType> entry = archiveRoot.getNodeTypes().entrySet().iterator().next();

    Assert.assertEquals("my_company.my_types.MyAppNodeType", entry.getKey());
    IndexedNodeType nodeType = entry.getValue();

    Assert.assertEquals(
        Lists.newArrayList("tosca.nodes.SoftwareComponent", "tosca.nodes.Root"),
        nodeType.getDerivedFrom());
    Assert.assertEquals("My company’s custom applicaton", nodeType.getDescription());

    // validate properties parsing
    Assert.assertEquals(4, nodeType.getProperties().size());

    PropertyDefinition def1 = new PropertyDefinition();
    def1.setType("string");
    def1.setDefault(new ScalarPropertyValue("default"));
    def1.setDescription("application password");
    List<PropertyConstraint> constraints = Lists.newArrayList();
    constraints.add(new MinLengthConstraint(6));
    constraints.add(new MaxLengthConstraint(10));
    def1.setConstraints(constraints);

    PropertyDefinition def2 = new PropertyDefinition();
    def2.setType("integer");
    def2.setDescription("application port number");

    PropertyDefinition def3 = new PropertyDefinition();
    def3.setType("scalar-unit.size");
    def3.setDefault(new ScalarPropertyValue("1 GB"));
    LessThanConstraint ltConstraint = new LessThanConstraint();
    ltConstraint.setLessThan("1 TB");
    constraints = Lists.<PropertyConstraint>newArrayList(ltConstraint);
    def3.setConstraints(constraints);

    PropertyDefinition def4 = new PropertyDefinition();
    def4.setType("scalar-unit.time");
    def4.setDefault(new ScalarPropertyValue("1 d"));
    GreaterThanConstraint gtConstraint = new GreaterThanConstraint();
    gtConstraint.setGreaterThan("1 h");
    constraints = Lists.<PropertyConstraint>newArrayList(gtConstraint);
    def4.setConstraints(constraints);

    Assert.assertEquals(
        MapUtil.newHashMap(
            new String[] {"my_app_password", "my_app_duration", "my_app_size", "my_app_port"},
            new PropertyDefinition[] {def1, def4, def3, def2}),
        nodeType.getProperties());

    // check requirements
    Assert.assertEquals(2, nodeType.getRequirements().size());
    RequirementDefinition rd0 = nodeType.getRequirements().get(0);
    Assert.assertEquals("host", rd0.getId());
    Assert.assertEquals(1, rd0.getLowerBound());
    Assert.assertEquals(1, rd0.getUpperBound());

    RequirementDefinition rd1 = nodeType.getRequirements().get(1);
    Assert.assertEquals("other", rd1.getId());
    Assert.assertEquals(0, rd1.getLowerBound());
    Assert.assertEquals(Integer.MAX_VALUE, rd1.getUpperBound());

    // validate attributes parsing

    // nodeType.getAttributes()
    // nodeType.getInterfaces()
    // nodeType.getCapabilities()
    // nodeType.get
  }