yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/builder/impl/RefineUtilsTest.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
   3  * This program and the accompanying materials are made available under the
   4  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   5  * and is available at http://www.eclipse.org/legal/epl-v10.html
   6  */
   7 package org.opendaylight.yangtools.yang.parser.builder.impl;
   8
   9 import static org.junit.Assert.assertEquals;
  10 import static org.junit.Assert.assertFalse;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertNull;
  13 import static org.junit.Assert.assertTrue;
  14 import org.junit.Test;
  15 import org.opendaylight.yangtools.yang.common.QName;
  16 import org.opendaylight.yangtools.yang.model.api.MustDefinition;
  17 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  18 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
  19 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
  20 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  21
  22 /**
  23  * Test suite for increasing of test coverage of RefineUtils implementation.
  24  *
  25  * @see org.opendaylight.yangtools.yang.parser.builder.impl.RefineUtils
  26  *
  27  * @author Lukas Sedlak <lsedlak@cisco.com>
  28  */
  29 public class RefineUtilsTest extends AbstractBuilderTest {
  30
  31     @Test
  32     public void testRefineLeafWithEmptyDefaultString() {
  33         final String leafLocalName = "leaf-to-refine";
  34         final QName leafName = QName.create(module.getNamespace(), module.getRevision(), leafLocalName);
  35         final SchemaPath leafPath = SchemaPath.create(true, leafName);
  36         final LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(module.getModuleName(), 22, leafName, leafPath);
  37
  38         final RefineHolderImpl refineBuilder = new RefineHolderImpl(module.getModuleName(), 23, "/"+leafLocalName);
  39         refineBuilder.setDefaultStr("");
  40
  41         RefineUtils.performRefine(leafBuilder, refineBuilder);
  42         assertNull(leafBuilder.getDefaultStr());
  43     }
  44
  45     @Test
  46     public void testRefineContainer() {
  47         final String containerLocalName = "container-to-refine";
  48         final QName containerName = QName.create(module.getNamespace(), module.getRevision(), containerLocalName);
  49         final SchemaPath containerPath = SchemaPath.create(true, containerName);
  50         final ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(module.getModuleName(),
  51             10, containerName, containerPath);
  52
  53         final RefineHolderImpl refineBuilder = new RefineHolderImpl(module.getModuleName(), 23, "/"+containerLocalName);
  54         refineBuilder.setPresence(null);
  55
  56         final MustDefinition must = provideMustDefinition();
  57         refineBuilder.setMust(must);
  58
  59         final UnknownSchemaNodeBuilder unknownNodeBuilder = provideUnknownNodeBuilder();
  60         refineBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
  61
  62         RefineUtils.performRefine(containerBuilder, refineBuilder);
  63
  64         assertFalse(containerBuilder.getConstraints().getMustDefinitions().isEmpty());
  65         assertEquals(containerBuilder.getConstraints().getMustDefinitions().size(), 1);
  66         assertFalse(containerBuilder.getUnknownNodes().isEmpty());
  67         assertEquals(containerBuilder.getUnknownNodes().get(0), unknownNodeBuilder);
  68     }
  69
  70
  71
  72     @Test
  73     public void testRefineList() {
  74         final String listLocalName = "list-to-refine";
  75         final QName listQName = QName.create(module.getNamespace(), module.getRevision(), listLocalName);
  76         final SchemaPath listPath = SchemaPath.create(true, listQName);
  77         final ListSchemaNodeBuilder listBuilder = new ListSchemaNodeBuilder(module.getModuleName(),
  78             10, listQName, listPath);
  79
  80         final RefineHolderImpl refineBuilder = new RefineHolderImpl(module.getModuleName(), 23, "/"+listLocalName);
  81
  82         final MustDefinition must = provideMustDefinition();
  83         refineBuilder.setMust(must);
  84
  85         final UnknownSchemaNodeBuilder unknownNodeBuilder = provideUnknownNodeBuilder();
  86         refineBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
  87
  88         refineBuilder.setMinElements(null);
  89         refineBuilder.setMaxElements(null);
  90
  91         RefineUtils.performRefine(listBuilder, refineBuilder);
  92         assertFalse(listBuilder.getConstraints().getMustDefinitions().isEmpty());
  93         assertEquals(listBuilder.getConstraints().getMustDefinitions().size(), 1);
  94         assertNull(listBuilder.getConstraints().getMinElements());
  95         assertNull(listBuilder.getConstraints().getMaxElements());
  96         assertFalse(listBuilder.getUnknownNodes().isEmpty());
  97         assertEquals(listBuilder.getUnknownNodes().get(0), unknownNodeBuilder);
  98     }
  99
 100     @Test
 101     public void testRefineLeafList() {
 102         final String leafListLocalName = "list-to-refine";
 103         final QName leafListQName = QName.create(module.getNamespace(), module.getRevision(), leafListLocalName);
 104         final SchemaPath leafListPath = SchemaPath.create(true, leafListQName);
 105         final LeafListSchemaNodeBuilder leafListBuilder = new LeafListSchemaNodeBuilder(module.getModuleName(),
 106             10, leafListQName, leafListPath);
 107
 108         final RefineHolderImpl refineBuilder = new RefineHolderImpl(module.getModuleName(), 23, "/"+leafListLocalName);
 109
 110         final MustDefinition must = provideMustDefinition();
 111         refineBuilder.setMust(null);
 112
 113         final UnknownSchemaNodeBuilder unknownNodeBuilder = provideUnknownNodeBuilder();
 114         refineBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 115
 116         refineBuilder.setMinElements(null);
 117         refineBuilder.setMaxElements(null);
 118
 119         RefineUtils.performRefine(leafListBuilder, refineBuilder);
 120         assertTrue(leafListBuilder.getConstraints().getMustDefinitions().isEmpty());
 121         assertNull(leafListBuilder.getConstraints().getMinElements());
 122         assertNull(leafListBuilder.getConstraints().getMaxElements());
 123         assertFalse(leafListBuilder.getUnknownNodes().isEmpty());
 124         assertEquals(leafListBuilder.getUnknownNodes().get(0), unknownNodeBuilder);
 125
 126         refineBuilder.setMinElements(Integer.MIN_VALUE);
 127         refineBuilder.setMaxElements(Integer.MAX_VALUE);
 128         refineBuilder.setMust(must);
 129
 130         RefineUtils.performRefine(leafListBuilder, refineBuilder);
 131         assertFalse(leafListBuilder.getConstraints().getMustDefinitions().isEmpty());
 132         assertEquals(leafListBuilder.getConstraints().getMustDefinitions().size(), 1);
 133
 134         assertNotNull(leafListBuilder.getConstraints().getMinElements());
 135         assertNotNull(leafListBuilder.getConstraints().getMaxElements());
 136     }
 137
 138     @Test
 139     public void testRefineChoice() {
 140         final String choiceLocalName = "choice-to-refine";
 141         final ChoiceBuilder choiceBuilder = provideChoiceBuilder(choiceLocalName);
 142
 143         final RefineHolderImpl refineBuilder = new RefineHolderImpl(module.getModuleName(), 23, "/"+choiceLocalName);
 144         refineBuilder.setDefaultStr(null);
 145         refineBuilder.setMandatory(null);
 146
 147         RefineUtils.performRefine(choiceBuilder, refineBuilder);
 148         assertNull(choiceBuilder.getDefaultCase());
 149         assertFalse(choiceBuilder.getConstraints().isMandatory());
 150
 151         final String defaultValue = "choice-default-case";
 152         refineBuilder.setDefaultStr(defaultValue);
 153         refineBuilder.setMandatory(true);
 154         final UnknownSchemaNodeBuilder unknownNodeBuilder = provideUnknownNodeBuilder();
 155         refineBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 156
 157         RefineUtils.performRefine(choiceBuilder, refineBuilder);
 158         assertNotNull(choiceBuilder.getDefaultCase());
 159         assertNotNull(choiceBuilder.getConstraints().isMandatory());
 160         assertFalse(choiceBuilder.getUnknownNodes().isEmpty());
 161         assertEquals(choiceBuilder.getUnknownNodes().get(0), unknownNodeBuilder);
 162     }
 163
 164     @Test
 165     public void testRefineAnyxml() {
 166         final String anyxmlLocalName = "anyxml-to-refine";
 167         final QName anyxmlName = QName.create(module.getNamespace(), module.getRevision(), anyxmlLocalName);
 168         final SchemaPath anyxmlPath = SchemaPath.create(true, anyxmlName);
 169         final AnyXmlBuilder anyXmlBuilder = new AnyXmlBuilder(module.getModuleName(), 22, anyxmlName, anyxmlPath);
 170
 171         final RefineHolderImpl refineBuilder = new RefineHolderImpl(module.getModuleName(), 23, "/"+anyxmlLocalName);
 172         refineBuilder.setMandatory(null);
 173         refineBuilder.setMust(null);
 174
 175         RefineUtils.performRefine(anyXmlBuilder, refineBuilder);
 176         assertNull(refineBuilder.isMandatory());
 177         assertNull(refineBuilder.getMust());
 178
 179         final MustDefinition must = provideMustDefinition();
 180
 181         refineBuilder.setMandatory(true);
 182         refineBuilder.setMust(must);
 183
 184         final UnknownSchemaNodeBuilder unknownNodeBuilder = provideUnknownNodeBuilder();
 185         refineBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 186
 187         RefineUtils.performRefine(anyXmlBuilder, refineBuilder);
 188         assertFalse(anyXmlBuilder.getConstraints().getMustDefinitions().isEmpty());
 189         assertEquals(anyXmlBuilder.getConstraints().getMustDefinitions().size(), 1);
 190         assertFalse(anyXmlBuilder.getUnknownNodes().isEmpty());
 191         assertEquals(anyXmlBuilder.getUnknownNodes().get(0), unknownNodeBuilder);
 192         assertTrue(anyXmlBuilder.getConstraints().isMandatory());
 193     }
 194
 195     @Test(expected = YangParseException.class)
 196     public void testCheckRefineDefault() {
 197         final String groupLocalName = "test-group";
 198         final QName testGroup = QName.create(module.getNamespace(), module.getRevision(), groupLocalName);
 199         final SchemaPath groupPath = SchemaPath.create(true, testGroup);
 200         final GroupingBuilder grouping = module.addGrouping(12, testGroup, groupPath);
 201
 202         final RefineHolderImpl refineBuilder = new RefineHolderImpl(module.getModuleName(), 23, "/"+groupLocalName);
 203         refineBuilder.setDefaultStr("invalid-default-value");
 204
 205         RefineUtils.performRefine(grouping, refineBuilder);
 206     }
 207
 208     @Test(expected = YangParseException.class)
 209     public void testCheckRefineMandatory() {
 210         final TypeDefinitionBuilderImpl typedef = initTypedef();
 211         final RefineHolderImpl refineBuilder = new RefineHolderImpl(module.getModuleName(), 23, "/"+typedef.getQName().getLocalName());
 212         refineBuilder.setMandatory(true);
 213         RefineUtils.performRefine(typedef, refineBuilder);
 214     }
 215
 216     private TypeDefinitionBuilderImpl initTypedef() {
 217         final String typedefLocalName = "test-type-definition";
 218         final QName testTypedef = QName.create(module.getNamespace(), module.getRevision(), typedefLocalName);
 219         SchemaPath testTypedefPath = SchemaPath.create(true, testTypedef);
 220
 221         return module.addTypedef(23, testTypedef, testTypedefPath);
 222     }
 223
 224     @Test(expected = YangParseException.class)
 225     public void testCheckRefineMust() {
 226         final TypeDefinitionBuilderImpl typedef = initTypedef();
 227         final RefineHolderImpl refineBuilder = new RefineHolderImpl(module.getModuleName(), 23, "/"+typedef.getQName().getLocalName());
 228
 229         final MustDefinition must = provideMustDefinition();
 230         refineBuilder.setMust(must);
 231         RefineUtils.performRefine(typedef, refineBuilder);
 232     }
 233
 234     @Test(expected = YangParseException.class)
 235     public void testCheckRefineMin() {
 236         final TypeDefinitionBuilderImpl typedef = initTypedef();
 237         final RefineHolderImpl refineBuilder = new RefineHolderImpl(module.getModuleName(), 23, "/"+typedef.getQName().getLocalName());
 238
 239         refineBuilder.setMinElements(Integer.MIN_VALUE);
 240         RefineUtils.performRefine(typedef, refineBuilder);
 241     }
 242
 243     @Test(expected = YangParseException.class)
 244     public void testCheckRefineMax() {
 245         final TypeDefinitionBuilderImpl typedef = initTypedef();
 246         final RefineHolderImpl refineBuilder = new RefineHolderImpl(module.getModuleName(), 23, "/"+typedef.getQName().getLocalName());
 247
 248         refineBuilder.setMaxElements(Integer.MAX_VALUE);
 249         RefineUtils.performRefine(typedef, refineBuilder);
 250     }
 251 }