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