yang/yang-parser-impl/src/test/java/org/opendaylight/yangtools/yang/parser/builder/impl/BuilderUtilsTest.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.mockito.Mockito.mock;
  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.*;
  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.*;
  21 import org.opendaylight.yangtools.yang.model.util.Uint16;
  22 import org.opendaylight.yangtools.yang.parser.builder.api.*;
  23 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  24
  25 /**
  26  * Test suite for increasing of test coverage of BuilderUtils implementation.
  27  *
  28  * @see org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils
  29  *
  30  * @author Lukas Sedlak <lsedlak@cisco.com>
  31  */
  32 public class BuilderUtilsTest {
  33
  34     private final static String MASTER_MODULE_NAMESPACE = "urn:opendaylight.master-model";
  35     private final static String MODULES_REVISION = "2014-10-06";
  36     private final static String MASTER_MODULE = "master-module";
  37     private final static String DEPENDENT_MODULE_NAMESPACE = "urn:opendaylight.secondary-model";
  38     private final static String DEPENDENT_MODULE = "depend-module";
  39     private final static String MASTER_MODULE_PATH = "test/module/path/master-module@" + MODULES_REVISION + ".yang";
  40     private final static String DEPENDENT_MODULE_PATH = "test/module/path/depend-module@" + MODULES_REVISION + ".yang";
  41     private final static String DEPENDENT_MODULE_PREFIX = "dep";
  42
  43     private final static DateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-mm-dd");
  44
  45     private ModuleBuilder masterModule;
  46     private ModuleBuilder dependentModule;
  47
  48     @Before
  49     public void setUp() throws Exception {
  50         masterModule = new ModuleBuilder(MASTER_MODULE, MASTER_MODULE_PATH);
  51         dependentModule = new ModuleBuilder(DEPENDENT_MODULE, DEPENDENT_MODULE_PATH);
  52
  53         final Date moduleRevision = SIMPLE_DATE_FORMAT.parse(MODULES_REVISION);
  54         masterModule.setRevision(moduleRevision);
  55         dependentModule.setRevision(moduleRevision);
  56
  57         masterModule.setNamespace(URI.create(MASTER_MODULE_NAMESPACE));
  58         dependentModule.setNamespace(URI.create(DEPENDENT_MODULE_NAMESPACE));
  59
  60         masterModule.setNamespace(URI.create(MASTER_MODULE_NAMESPACE));
  61         dependentModule.setNamespace(URI.create(DEPENDENT_MODULE_NAMESPACE));
  62
  63         masterModule.setPrefix("mod");
  64         dependentModule.setPrefix("mod");
  65         masterModule.addModuleImport(dependentModule.getModuleName(), dependentModule.getRevision(), DEPENDENT_MODULE_PREFIX);
  66     }
  67
  68     @Test
  69     public void testFindModuleFromBuildersWithNullPrefix() throws Exception {
  70         final Map<String, TreeMap<Date, ModuleBuilder>> testModules = initModuleBuildersForTest();
  71
  72         ModuleBuilder result = BuilderUtils.findModuleFromBuilders(testModules, masterModule, null, 12);
  73         assertEquals(masterModule, result);
  74
  75         result = BuilderUtils.findModuleFromBuilders(testModules, masterModule, masterModule.getPrefix(), 12);
  76         assertEquals(masterModule, result);
  77
  78         result = BuilderUtils.findModuleFromBuilders(testModules, masterModule, DEPENDENT_MODULE_PREFIX, 12);
  79         assertEquals(dependentModule, result);
  80     }
  81
  82     private Map<String, TreeMap<Date, ModuleBuilder>> initModuleBuildersForTest() throws Exception {
  83         final Map<String, TreeMap<Date, ModuleBuilder>> modules = new HashMap<>();
  84         final String module3Name = "Module3";
  85
  86         ModuleBuilder module3 = new ModuleBuilder(module3Name, "test/module/path/module3.yang");
  87         final Date moduleRevision = SIMPLE_DATE_FORMAT.parse(MODULES_REVISION);
  88
  89         module3.setRevision(moduleRevision);
  90         module3.setNamespace(URI.create("urn:opendaylight.ternary-model"));
  91         module3.setPrefix("mod");
  92
  93         dependentModule.addModuleImport(module3.getModuleName(), module3.getRevision(), "ter");
  94
  95         final TreeMap<Date, ModuleBuilder> module1Map = new TreeMap<>();
  96         module1Map.put(masterModule.getRevision(), masterModule);
  97
  98         final TreeMap<Date, ModuleBuilder> module2Map = new TreeMap<>();
  99         module2Map.put(dependentModule.getRevision(), dependentModule);
 100
 101         final TreeMap<Date, ModuleBuilder> module3Map = new TreeMap<>();
 102         module3Map.put(module3.getRevision(), module3);
 103
 104         modules.put(masterModule.getName(), module1Map);
 105         modules.put(dependentModule.getName(), module2Map);
 106         modules.put(module3Name, module3Map);
 107
 108         return modules;
 109     }
 110
 111     @Test(expected = YangParseException.class)
 112     public void testFindModuleFromBuildersWithNoImportedModule() throws Exception {
 113         final Map<String, TreeMap<Date, ModuleBuilder>> testModules = initModuleBuildersForTest();
 114
 115         BuilderUtils.findModuleFromBuilders(testModules, masterModule, "eth", 12);
 116     }
 117
 118     @Test(expected = YangParseException.class)
 119     public void testFindModuleFromContextWithDependentModuleImportEqualsToNull() {
 120         final SchemaContext mockContext = mock(SchemaContext.class);
 121
 122         BuilderUtils.findModuleFromContext(mockContext, masterModule, "inalid-prefix", 14);
 123     }
 124
 125     @Test(expected = YangParseException.class)
 126     public void testFindModuleFromContextWhereModuleIsNotPresent() {
 127         final SchemaContext mockContext = mock(SchemaContext.class);
 128
 129         BuilderUtils.findModuleFromContext(mockContext, masterModule, DEPENDENT_MODULE_PREFIX, 14);
 130     }
 131
 132     @Test(expected = YangParseException.class)
 133     public void testFillAugmentTargetForInvalidTarget() {
 134         AugmentationSchemaBuilder augBuilder = mock(AugmentationSchemaBuilder.class);
 135         Builder invalidTarget = mock(Builder.class);
 136         BuilderUtils.fillAugmentTarget(augBuilder, invalidTarget);
 137     }
 138
 139     @Test(expected = YangParseException.class)
 140     public void testFillAugmentTargetWithChoiceBuilderContainingInvalidUsesNodeBuilder() {
 141         final QName usesQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "test-grouping");
 142         final UsesNodeBuilder usesNodeBuilder = new UsesNodeBuilderImpl(masterModule.getModuleName(), 10, SchemaPath.create(true, usesQName));
 143
 144         final QName augTargetQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "target");
 145         final AugmentationSchemaBuilder augBuilder = new AugmentationSchemaBuilderImpl(masterModule.getModuleName(), 12,
 146             "/target", SchemaPath.create(true, augTargetQName), 1);
 147
 148         augBuilder.setParent(usesNodeBuilder);
 149
 150         final QName choiceQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "test-choice");
 151         final ChoiceBuilder choiceBuilder = new ChoiceBuilder(masterModule.getModuleName(), 14, choiceQName,
 152             SchemaPath.create(true, choiceQName));
 153
 154         augBuilder.addUsesNode(usesNodeBuilder);
 155         BuilderUtils.fillAugmentTarget(augBuilder, choiceBuilder);
 156     }
 157
 158     @Test
 159     public void testFillAugmentTargetSetNodeAddedByUses() {
 160         final QName augTargetQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "target");
 161         final AugmentationSchemaBuilder augBuilder = new AugmentationSchemaBuilderImpl(masterModule.getModuleName(), 12,
 162             "/target", SchemaPath.create(true, augTargetQName), 1);
 163
 164         final String containerLocalName = "top-level-container";
 165         final QName containerQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), containerLocalName);
 166         SchemaPath containerPath = SchemaPath.create(true, containerQName);
 167         augBuilder.addChildNode(
 168             new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 10, containerQName, containerPath));
 169
 170         final QName choiceQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "test-choice");
 171         final ChoiceBuilder choiceBuilder = new ChoiceBuilder(masterModule.getModuleName(), 14, choiceQName,
 172             SchemaPath.create(true, choiceQName));
 173
 174         BuilderUtils.fillAugmentTarget(augBuilder, choiceBuilder);
 175
 176         ChoiceCaseBuilder result = choiceBuilder.getCaseNodeByName(containerLocalName);
 177         assertNotNull(result);
 178     }
 179
 180     @Test
 181     public void testFindUnknownNodeInDataNodeContainer() {
 182         final String parentLocalName = "parent";
 183         final QName containerQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), parentLocalName);
 184         SchemaPath containerPath = SchemaPath.create(true, containerQName);
 185
 186         final ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 10,
 187             containerQName, containerPath);
 188
 189         final String unknownLocalName = "unknown-ext-use";
 190         final QName unknownNode = QName.create(masterModule.getNamespace(), masterModule.getRevision(), unknownLocalName);
 191         SchemaPath unknownNodePath = SchemaPath.create(true, containerQName, unknownNode);
 192         UnknownSchemaNodeBuilderImpl unknownNodeBuilder = new UnknownSchemaNodeBuilderImpl(masterModule.getModuleName(),
 193             22, unknownNode, unknownNodePath);
 194         containerBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 195
 196         List<QName> path = new ArrayList<>(2);
 197         path.add(unknownNode);
 198
 199         SchemaNodeBuilder result = BuilderUtils.findSchemaNode(path, containerBuilder);
 200         assertNotNull(result);
 201         assertEquals(unknownNodeBuilder, result);
 202
 203         path.add(QName.create(masterModule.getNamespace(), masterModule.getRevision(), "foo"));
 204         assertNull(BuilderUtils.findSchemaNode(path, containerBuilder));
 205
 206         final QName choiceQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "select");
 207         SchemaPath choicePath = SchemaPath.create(true, choiceQName);
 208
 209         final ChoiceBuilder choiceBuilder = new ChoiceBuilder(masterModule.getModuleName(), 33, choiceQName, choicePath);
 210
 211         final QName caseQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "simple-case");
 212         SchemaPath casePath = SchemaPath.create(true, choiceQName, caseQName);
 213
 214         ChoiceCaseBuilder caseBuilder = new ChoiceCaseBuilder(masterModule.getModuleName(), 35, caseQName, casePath);
 215         choiceBuilder.addCase(caseBuilder);
 216
 217         choiceBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 218
 219         path.clear();
 220         path.add(caseQName);
 221         result = BuilderUtils.findSchemaNode(path, choiceBuilder);
 222         assertNotNull(result);
 223         assertTrue(result instanceof ChoiceCaseBuilder);
 224         assertEquals(caseBuilder, result);
 225
 226         path.clear();
 227         path.add(unknownNode);
 228         result = BuilderUtils.findSchemaNode(path, choiceBuilder);
 229         assertNotNull(result);
 230         assertEquals(unknownNodeBuilder, result);
 231
 232         path.add(QName.create(masterModule.getNamespace(), masterModule.getRevision(), "foo"));
 233         result = BuilderUtils.findSchemaNode(path, choiceBuilder);
 234         assertNull(result);
 235
 236         final QName rpcQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), parentLocalName);
 237         SchemaPath rpcPath = SchemaPath.create(true, rpcQName);
 238         final RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(masterModule.getModuleName(), 45, rpcQName, rpcPath);
 239
 240         final QName inputQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "input");
 241         final SchemaPath inputPath = SchemaPath.create(true, rpcQName, inputQName);
 242
 243         final QName outputQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "output");
 244         final SchemaPath outputPath = SchemaPath.create(true, rpcQName, outputQName);
 245
 246         final ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 46,
 247             inputQName, inputPath);
 248         final ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 76,
 249             outputQName, outputPath);
 250
 251         rpcBuilder.setInput(inputBuilder);
 252         rpcBuilder.setOutput(outputBuilder);
 253         rpcBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 254
 255         path.clear();
 256         path.add(inputQName);
 257         result = BuilderUtils.findSchemaNode(path, rpcBuilder);
 258         assertNotNull(result);
 259         assertEquals(inputBuilder, result);
 260
 261         path.clear();
 262         path.add(outputQName);
 263         result = BuilderUtils.findSchemaNode(path, rpcBuilder);
 264         assertNotNull(result);
 265         assertEquals(outputBuilder, result);
 266
 267         path.clear();
 268         path.add(unknownNode);
 269         result = BuilderUtils.findSchemaNode(path, rpcBuilder);
 270         assertNotNull(result);
 271         assertEquals(unknownNodeBuilder, result);
 272
 273         final QName leafQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "simple-leaf");
 274         SchemaPath leafPath = SchemaPath.create(true, leafQName);
 275
 276         final LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(masterModule.getModuleName(), 10, leafQName, leafPath);
 277         leafBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 278
 279         path.clear();
 280         path.add(unknownNode);
 281         result = BuilderUtils.findSchemaNode(path, leafBuilder);
 282         assertNotNull(result);
 283         assertEquals(unknownNodeBuilder, result);
 284     }
 285
 286     @Test
 287     public void testFindUnknownSchemaNodeInModule() {
 288         final String parentLocalName = "parent";
 289         final QName containerQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), parentLocalName);
 290         SchemaPath containerPath = SchemaPath.create(true, containerQName);
 291
 292         final ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 10,
 293             containerQName, containerPath);
 294
 295         final String unknownLocalName = "unknown-ext-use";
 296         final QName unknownNode = QName.create(masterModule.getNamespace(), masterModule.getRevision(), unknownLocalName);
 297         final SchemaPath unknownNodePath = SchemaPath.create(true, containerQName, unknownNode);
 298         UnknownSchemaNodeBuilderImpl unknownNodeBuilder = new UnknownSchemaNodeBuilderImpl(masterModule.getModuleName(),
 299             22, unknownNode, unknownNodePath);
 300         containerBuilder.addUnknownNodeBuilder(unknownNodeBuilder);
 301
 302         masterModule.addChildNode(containerBuilder);
 303
 304         Optional<SchemaNodeBuilder> result = BuilderUtils.findSchemaNodeInModule(unknownNodePath, masterModule);
 305
 306         assertTrue(result.isPresent());
 307         assertEquals(result.get(), unknownNodeBuilder);
 308
 309         final QName invalidUnknownNode = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "invalid-ext-use");
 310         final SchemaPath invalidPath = SchemaPath.create(true, containerQName, invalidUnknownNode);
 311
 312         result = BuilderUtils.findSchemaNodeInModule(invalidPath, masterModule);
 313         assertFalse(result.isPresent());
 314     }
 315
 316     @Test
 317     public void testFindContainerInRPC() {
 318
 319         final QName rpcQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "send-message");
 320         SchemaPath rpcPath = SchemaPath.create(true, rpcQName);
 321         final RpcDefinitionBuilder rpcBuilder = masterModule.addRpc(45, rpcQName, rpcPath);
 322
 323         final QName inputQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "input");
 324         final SchemaPath inputPath = SchemaPath.create(true, rpcQName, inputQName);
 325
 326         final QName outputQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "output");
 327         final SchemaPath outputPath = SchemaPath.create(true, rpcQName, outputQName);
 328
 329         Optional<SchemaNodeBuilder> requestResult = BuilderUtils.findSchemaNodeInModule(inputPath, masterModule);
 330         assertTrue(requestResult.isPresent());
 331
 332         Optional<SchemaNodeBuilder> responseResult = BuilderUtils.findSchemaNodeInModule(outputPath, masterModule);
 333         assertTrue(responseResult.isPresent());
 334
 335         final ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 46,
 336             inputQName, inputPath);
 337         final ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 76,
 338             outputQName, outputPath);
 339
 340         final QName request = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "request");
 341         final SchemaPath requestPath = SchemaPath.create(true, rpcQName, inputQName, request);
 342
 343         final QName response = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "response");
 344         final SchemaPath responsePath = SchemaPath.create(true, rpcQName, outputQName, response);
 345
 346         final ContainerSchemaNodeBuilder requestBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 50,
 347             request, requestPath);
 348         final ContainerSchemaNodeBuilder responseBuilder = new ContainerSchemaNodeBuilder(masterModule.getModuleName(), 80,
 349             response, responsePath);
 350
 351         inputBuilder.addChildNode(requestBuilder);
 352         outputBuilder.addChildNode(responseBuilder);
 353
 354         rpcBuilder.setInput(inputBuilder);
 355         rpcBuilder.setOutput(outputBuilder);
 356
 357         requestResult = BuilderUtils.findSchemaNodeInModule(requestPath, masterModule);
 358         assertTrue(requestResult.isPresent());
 359
 360         responseResult = BuilderUtils.findSchemaNodeInModule(responsePath, masterModule);
 361         assertTrue(responseResult.isPresent());
 362
 363         final SchemaPath invalidPath = SchemaPath.create(true, rpcQName, response);
 364         Optional<SchemaNodeBuilder> invalidResult = BuilderUtils.findSchemaNodeInModule(invalidPath, masterModule);
 365         assertFalse(invalidResult.isPresent());
 366     }
 367
 368     @Test
 369     public void testFindIdentity() {
 370         assertNull(BuilderUtils.findIdentity(Collections.<IdentitySchemaNodeBuilder>emptySet(), "test-identity"));
 371     }
 372
 373     @Test
 374     public void testGetModuleByPrefix() {
 375         assertEquals(BuilderUtils.getModuleByPrefix(masterModule, null), masterModule);
 376         assertEquals(BuilderUtils.getModuleByPrefix(masterModule, ""), masterModule);
 377         assertEquals(BuilderUtils.getModuleByPrefix(masterModule, masterModule.getPrefix()), masterModule);
 378     }
 379
 380     @Test
 381     public void testFindModule() {
 382         final Map<URI, TreeMap<Date, ModuleBuilder>> modules = new HashMap<>(1);
 383         final TreeMap<Date, ModuleBuilder> masterModuleMap = new TreeMap<>();
 384         masterModuleMap.put(masterModule.getRevision(), masterModule);
 385         modules.put(masterModule.getNamespace(), masterModuleMap);
 386
 387         assertNull(BuilderUtils.findModule(QName.create("test-urn:namespace", "2014-10-08", "impossible-module"), modules));
 388
 389         assertEquals(BuilderUtils.findModule(QName.create(masterModule.getNamespace(), null, masterModule.getName()), modules),
 390             masterModule);
 391     }
 392
 393     @Test
 394     public void testFindBaseIdentity() {
 395         assertNull(BuilderUtils.findBaseIdentity(masterModule, "prefix:ident", 27));
 396
 397         final QName identity = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "ident");
 398         masterModule.addIdentity(identity, 22, SchemaPath.create(true, identity));
 399
 400         final IdentitySchemaNodeBuilder result = BuilderUtils
 401             .findBaseIdentity(masterModule, masterModule.getPrefix() + ":ident", 22);
 402         assertNotNull(result);
 403         assertEquals(result.getQName(), identity);
 404     }
 405
 406     @Test
 407     public void testWrapChildNode() {
 408         final QName leafQName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "parent-leaf");
 409         final SchemaPath leafPath = SchemaPath.create(true, leafQName);
 410         final LeafListSchemaNodeBuilder leafListBuilder = new LeafListSchemaNodeBuilder(masterModule.getModuleName(),
 411             27, leafQName, leafPath);
 412         leafListBuilder.setType(Uint16.getInstance());
 413
 414         final LeafListSchemaNode leafList = leafListBuilder.build();
 415
 416         DataSchemaNodeBuilder wrapedLeafList = BuilderUtils
 417             .wrapChildNode(masterModule.getModuleName(), 72, leafList, leafPath, leafQName);
 418
 419         assertNotNull(wrapedLeafList);
 420         assertEquals(wrapedLeafList.getQName(), leafList.getQName());
 421     }
 422
 423     @Test(expected = YangParseException.class)
 424     public void wrapChildNodeForUnknownNode() {
 425         final QName qName = QName.create(masterModule.getNamespace(), masterModule.getRevision(), "name");
 426         final SchemaPath path = SchemaPath.create(true, qName);
 427
 428         BuilderUtils
 429             .wrapChildNode(masterModule.getModuleName(), 72, new NotExistingDataSchemaNodeImpl(), path, qName);
 430     }
 431
 432     private static class NotExistingDataSchemaNodeImpl implements DataSchemaNode {
 433
 434         @Override public boolean isAugmenting() {
 435             return false;
 436         }
 437
 438         @Override public boolean isAddedByUses() {
 439             return false;
 440         }
 441
 442         @Override public boolean isConfiguration() {
 443             return false;
 444         }
 445
 446         @Override public ConstraintDefinition getConstraints() {
 447             return null;
 448         }
 449
 450         @Override public QName getQName() {
 451             return null;
 452         }
 453
 454         @Override public SchemaPath getPath() {
 455             return null;
 456         }
 457
 458         @Override public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 459             return null;
 460         }
 461
 462         @Override public String getDescription() {
 463             return null;
 464         }
 465
 466         @Override public String getReference() {
 467             return null;
 468         }
 469
 470         @Override public Status getStatus() {
 471             return null;
 472         }
 473     }
 474 }