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