source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.metadata.repository;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import org.apache.archiva.metadata.model.ArtifactMetadata;
  23 import org.apache.archiva.metadata.model.CiManagement;
  24 import org.apache.archiva.metadata.model.Dependency;
  25 import org.apache.archiva.metadata.model.IssueManagement;
  26 import org.apache.archiva.metadata.model.License;
  27 import org.apache.archiva.metadata.model.MailingList;
  28 import org.apache.archiva.metadata.model.MetadataFacet;
  29 import org.apache.archiva.metadata.model.MetadataFacetFactory;
  30 import org.apache.archiva.metadata.model.Organization;
  31 import org.apache.archiva.metadata.model.ProjectMetadata;
  32 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  33 import org.apache.archiva.metadata.model.ProjectVersionReference;
  34 import org.apache.archiva.metadata.model.Scm;
  35 import org.codehaus.plexus.spring.PlexusInSpringTestCase;
  36
  37 import java.util.ArrayList;
  38 import java.util.Arrays;
  39 import java.util.Collection;
  40 import java.util.Collections;
  41 import java.util.Comparator;
  42 import java.util.Date;
  43 import java.util.HashMap;
  44 import java.util.List;
  45 import java.util.Map;
  46
  47 public abstract class AbstractMetadataRepositoryTest
  48     extends PlexusInSpringTestCase
  49 {
  50     protected MetadataRepository repository;
  51
  52     protected static final String TEST_REPO_ID = "test";
  53
  54     private static final String TEST_PROJECT = "projectId";
  55
  56     private static final String TEST_NAMESPACE = "namespace";
  57
  58     private static final String TEST_PROJECT_VERSION = "1.0";
  59
  60     private static final String TEST_FACET_ID = "test-facet-id";
  61
  62     private static final String TEST_NAME = "test/name";
  63
  64     private static final String TEST_VALUE = "test-value";
  65
  66     private static final String UNKNOWN = "unknown";
  67
  68     private static final String TEST_MD5 = "bd4a9b642562547754086de2dab26b7d";
  69
  70     private static final String TEST_SHA1 = "2e5daf0201ddeb068a62d5e08da18657ab2c6be9";
  71
  72     private static final String TEST_METADATA_VALUE = "test-metadata";
  73
  74     protected static Map<String, MetadataFacetFactory> createTestMetadataFacetFactories()
  75     {
  76         Map<String, MetadataFacetFactory> factories = new HashMap<String, MetadataFacetFactory>();
  77         factories.put( TEST_FACET_ID, new MetadataFacetFactory()
  78         {
  79             public MetadataFacet createMetadataFacet()
  80             {
  81                 return new TestMetadataFacet( TEST_METADATA_VALUE );
  82             }
  83
  84             public MetadataFacet createMetadataFacet( String repositoryId, String name )
  85             {
  86                 return new TestMetadataFacet( TEST_METADATA_VALUE );
  87             }
  88         } );
  89
  90         // add to ensure we don't accidentally create an empty facet ID.
  91         factories.put( "", new MetadataFacetFactory()
  92         {
  93             public MetadataFacet createMetadataFacet()
  94             {
  95                 return new TestMetadataFacet( "", TEST_VALUE );
  96             }
  97
  98             public MetadataFacet createMetadataFacet( String repositoryId, String name )
  99             {
 100                 return new TestMetadataFacet( "", TEST_VALUE );
 101             }
 102         } );
 103         return factories;
 104     }
 105
 106     public void testRootNamespaceWithNoMetadataRepository()
 107     {
 108         Collection<String> namespaces = repository.getRootNamespaces( TEST_REPO_ID );
 109         assertEquals( Collections.<String>emptyList(), namespaces );
 110     }
 111
 112     public void testGetNamespaceOnly()
 113     {
 114         assertEquals( Collections.emptyList(), repository.getRootNamespaces( TEST_REPO_ID ) );
 115
 116         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 117
 118         assertEquals( Collections.singletonList( TEST_NAMESPACE ), repository.getRootNamespaces( TEST_REPO_ID ) );
 119     }
 120
 121     public void testGetProjectOnly()
 122     {
 123         assertNull( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
 124         assertEquals( Collections.emptyList(), repository.getRootNamespaces( TEST_REPO_ID ) );
 125
 126         ProjectMetadata project = new ProjectMetadata();
 127         project.setId( TEST_PROJECT );
 128         project.setNamespace( TEST_NAMESPACE );
 129
 130         repository.updateProject( TEST_REPO_ID, project );
 131
 132         project = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 133         assertEquals( TEST_PROJECT, project.getId() );
 134         assertEquals( TEST_NAMESPACE, project.getNamespace() );
 135
 136         // test that namespace is also constructed
 137         assertEquals( Collections.singletonList( TEST_NAMESPACE ), repository.getRootNamespaces( TEST_REPO_ID ) );
 138     }
 139
 140     public void testGetProjectVersionOnly()
 141         throws MetadataResolutionException
 142     {
 143         assertNull( repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) );
 144         assertNull( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
 145         assertEquals( Collections.<String>emptyList(), repository.getRootNamespaces( TEST_REPO_ID ) );
 146
 147         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 148         metadata.setId( TEST_PROJECT_VERSION );
 149
 150         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 151
 152         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 153         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 154
 155         // test that namespace and project is also constructed
 156         assertEquals( Collections.singletonList( TEST_NAMESPACE ), repository.getRootNamespaces( TEST_REPO_ID ) );
 157         ProjectMetadata projectMetadata = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 158         assertEquals( TEST_PROJECT, projectMetadata.getId() );
 159         assertEquals( TEST_NAMESPACE, projectMetadata.getNamespace() );
 160     }
 161
 162     public void testGetArtifactOnly()
 163         throws MetadataResolutionException
 164     {
 165         assertEquals( Collections.<ArtifactMetadata>emptyList(),
 166                       new ArrayList<ArtifactMetadata>(
 167                           repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
 168         assertNull( repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) );
 169         assertNull( repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
 170         assertEquals( Collections.<String>emptyList(), repository.getRootNamespaces( TEST_REPO_ID ) );
 171
 172         ArtifactMetadata metadata = createArtifact();
 173
 174         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 175
 176         Collection<ArtifactMetadata> artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 177                                                                           TEST_PROJECT_VERSION );
 178         assertEquals( Collections.singletonList( metadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 179
 180         // test that namespace, project and project version is also constructed
 181         assertEquals( Collections.singletonList( TEST_NAMESPACE ), repository.getRootNamespaces( TEST_REPO_ID ) );
 182
 183         ProjectMetadata projectMetadata = repository.getProject( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 184         assertEquals( TEST_PROJECT, projectMetadata.getId() );
 185         assertEquals( TEST_NAMESPACE, projectMetadata.getNamespace() );
 186
 187         ProjectVersionMetadata projectVersionMetadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 188         assertEquals( TEST_PROJECT_VERSION, projectVersionMetadata.getId() );
 189     }
 190
 191     public void testUpdateProjectVersionMetadataWithNoOtherArchives()
 192         throws MetadataResolutionException
 193     {
 194         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 195         metadata.setId( TEST_PROJECT_VERSION );
 196         MailingList mailingList = new MailingList();
 197         mailingList.setName( "Foo List" );
 198         mailingList.setOtherArchives( Collections.<String>emptyList() );
 199         metadata.setMailingLists( Collections.singletonList( mailingList ) );
 200         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 201
 202         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 203         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 204         assertEquals( 1, metadata.getMailingLists().size() );
 205         mailingList = metadata.getMailingLists().get( 0 );
 206         assertEquals( "Foo List", mailingList.getName() );
 207         assertEquals( Collections.<String>emptyList(), mailingList.getOtherArchives() );
 208     }
 209
 210     public void testUpdateProjectVersionMetadataWithAllElements()
 211         throws MetadataResolutionException
 212     {
 213         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 214         metadata.setId( TEST_PROJECT_VERSION );
 215
 216         metadata.setName( "project name" );
 217         metadata.setDescription( "project description" );
 218
 219         MailingList mailingList = new MailingList();
 220         mailingList.setName( "Foo List" );
 221         mailingList.setOtherArchives( Collections.singletonList( "other archive" ) );
 222         metadata.setMailingLists( Collections.singletonList( mailingList ) );
 223
 224         Scm scm = new Scm();
 225         scm.setConnection( "connection" );
 226         scm.setDeveloperConnection( "dev conn" );
 227         scm.setUrl( "url" );
 228         metadata.setScm( scm );
 229
 230         CiManagement ci = new CiManagement();
 231         ci.setSystem( "system" );
 232         ci.setUrl( "ci url" );
 233         metadata.setCiManagement( ci );
 234
 235         IssueManagement tracker = new IssueManagement();
 236         tracker.setSystem( "system" );
 237         tracker.setUrl( "issue tracker url" );
 238         metadata.setIssueManagement( tracker );
 239
 240         Organization org = new Organization();
 241         org.setName( "org name" );
 242         org.setUrl( "url" );
 243         metadata.setOrganization( org );
 244
 245         License l = new License();
 246         l.setName( "license name" );
 247         l.setUrl( "license url" );
 248         metadata.addLicense( l );
 249
 250         Dependency d = new Dependency();
 251         d.setArtifactId( "artifactId" );
 252         d.setClassifier( "classifier" );
 253         d.setGroupId( "groupId" );
 254         d.setScope( "scope" );
 255         d.setSystemPath( "system path" );
 256         d.setType( "type" );
 257         d.setVersion( "version" );
 258         metadata.addDependency( d );
 259
 260         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 261
 262         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 263         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 264         assertEquals( TEST_PROJECT_VERSION, metadata.getVersion() );
 265         assertEquals( "project name", metadata.getName() );
 266         assertEquals( "project description", metadata.getDescription() );
 267
 268         assertEquals( 1, metadata.getMailingLists().size() );
 269         mailingList = metadata.getMailingLists().get( 0 );
 270         assertEquals( "Foo List", mailingList.getName() );
 271         assertEquals( Collections.singletonList( "other archive" ), mailingList.getOtherArchives() );
 272
 273         assertEquals( "connection", metadata.getScm().getConnection() );
 274         assertEquals( "dev conn", metadata.getScm().getDeveloperConnection() );
 275         assertEquals( "url", metadata.getScm().getUrl() );
 276
 277         assertEquals( "system", metadata.getCiManagement().getSystem() );
 278         assertEquals( "ci url", metadata.getCiManagement().getUrl() );
 279
 280         assertEquals( "system", metadata.getIssueManagement().getSystem() );
 281         assertEquals( "issue tracker url", metadata.getIssueManagement().getUrl() );
 282
 283         assertEquals( "org name", metadata.getOrganization().getName() );
 284         assertEquals( "url", metadata.getOrganization().getUrl() );
 285
 286         assertEquals( 1, metadata.getLicenses().size() );
 287         l = metadata.getLicenses().get( 0 );
 288         assertEquals( "license name", l.getName() );
 289         assertEquals( "license url", l.getUrl() );
 290
 291         assertEquals( 1, metadata.getDependencies().size() );
 292         d = metadata.getDependencies().get( 0 );
 293         assertEquals( "artifactId", d.getArtifactId() );
 294         assertEquals( "classifier", d.getClassifier() );
 295         assertEquals( "groupId", d.getGroupId() );
 296         assertEquals( "scope", d.getScope() );
 297         assertEquals( "system path", d.getSystemPath() );
 298         assertEquals( "type", d.getType() );
 299         assertEquals( "version", d.getVersion() );
 300     }
 301
 302     public void testUpdateProjectReference()
 303     {
 304         ProjectVersionReference reference = new ProjectVersionReference();
 305         reference.setNamespace( "another.namespace" );
 306         reference.setProjectId( "another-project-id" );
 307         reference.setProjectVersion( "1.1" );
 308         reference.setReferenceType( ProjectVersionReference.ReferenceType.DEPENDENCY );
 309
 310         repository.updateProjectReference( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, reference );
 311
 312         Collection<ProjectVersionReference> references = repository.getProjectReferences( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 313         assertEquals( 1, references.size() );
 314         reference = references.iterator().next();
 315         assertEquals( "another.namespace", reference.getNamespace() );
 316         assertEquals( "another-project-id", reference.getProjectId() );
 317         assertEquals( "1.1", reference.getProjectVersion() );
 318         assertEquals( ProjectVersionReference.ReferenceType.DEPENDENCY, reference.getReferenceType() );
 319     }
 320
 321     public void testGetRepositories()
 322     {
 323         // currently set up this way so the behaviour of both the test and the mock config return the same repository
 324         // set as the File implementation just uses the config rather than the content
 325         repository.updateNamespace( TEST_REPO_ID, "namespace" );
 326         repository.updateNamespace( "other-repo", "namespace" );
 327
 328         assertEquals( Arrays.asList( TEST_REPO_ID, "other-repo" ), new ArrayList<String>( repository.getRepositories() ) );
 329     }
 330
 331     public void testUpdateProjectVersionMetadataIncomplete()
 332         throws MetadataResolutionException
 333     {
 334         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 335         metadata.setId( TEST_PROJECT_VERSION );
 336         metadata.setIncomplete( true );
 337         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 338
 339         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 340         assertEquals( true, metadata.isIncomplete() );
 341         assertNull( metadata.getCiManagement() );
 342         assertNull( metadata.getScm() );
 343         assertNull( metadata.getIssueManagement() );
 344         assertNull( metadata.getOrganization() );
 345         assertNull( metadata.getDescription() );
 346         assertNull( metadata.getName() );
 347         assertEquals( TEST_PROJECT_VERSION, metadata.getId() );
 348         assertEquals( TEST_PROJECT_VERSION, metadata.getVersion() );
 349         assertTrue( metadata.getMailingLists().isEmpty() );
 350         assertTrue( metadata.getLicenses().isEmpty() );
 351         assertTrue( metadata.getDependencies().isEmpty() );
 352     }
 353
 354     public void testUpdateProjectVersionMetadataWithExistingFacets()
 355         throws MetadataResolutionException
 356     {
 357         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 358         metadata.setId( TEST_PROJECT_VERSION );
 359         MetadataFacet facet = new TestMetadataFacet( "baz" );
 360         metadata.addFacet( facet );
 361         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 362
 363         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 364         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 365
 366         metadata = new ProjectVersionMetadata();
 367         metadata.setId( TEST_PROJECT_VERSION );
 368         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 369
 370         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 371         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 372         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 373         assertEquals( "baz", testFacet.getValue() );
 374     }
 375
 376     public void testUpdateProjectVersionMetadataWithNoExistingFacets()
 377         throws MetadataResolutionException
 378     {
 379         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 380         metadata.setId( TEST_PROJECT_VERSION );
 381         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 382
 383         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 384         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 385
 386         metadata = new ProjectVersionMetadata();
 387         metadata.setId( TEST_PROJECT_VERSION );
 388         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 389
 390         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 391         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 392     }
 393
 394     public void testUpdateProjectVersionMetadataWithExistingFacetsFacetPropertyWasRemoved()
 395         throws MetadataResolutionException
 396     {
 397         ProjectVersionMetadata metadata = new ProjectVersionMetadata();
 398         metadata.setId( TEST_PROJECT_VERSION );
 399
 400         Map<String, String> additionalProps = new HashMap<String, String>();
 401         additionalProps.put( "deleteKey", "deleteValue" );
 402
 403         MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
 404         metadata.addFacet( facet );
 405         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 406
 407         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 408         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 409
 410         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 411         Map<String, String> facetProperties = testFacet.toProperties();
 412
 413         assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
 414
 415         facetProperties.remove( "deleteKey" );
 416
 417         TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue(), facetProperties );
 418         metadata.addFacet( newTestFacet );
 419
 420         repository.updateProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 421
 422         metadata = repository.getProjectVersion( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 423         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 424         testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 425         assertFalse( testFacet.toProperties().containsKey( "deleteKey" ) );
 426     }
 427
 428     public void testUpdateArtifactMetadataWithExistingFacets()
 429     {
 430         ArtifactMetadata metadata = createArtifact();
 431         MetadataFacet facet = new TestMetadataFacet( "baz" );
 432         metadata.addFacet( facet );
 433         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 434
 435         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 436                                             TEST_PROJECT_VERSION ).iterator().next();
 437         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 438
 439         metadata = createArtifact();
 440         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 441
 442         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 443                                             TEST_PROJECT_VERSION ).iterator().next();
 444         assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds() );
 445         TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 446         assertEquals( "baz", testFacet.getValue() );
 447     }
 448
 449     public void testUpdateArtifactMetadataWithNoExistingFacets()
 450     {
 451         ArtifactMetadata metadata = createArtifact();
 452         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 453
 454         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 455                                             TEST_PROJECT_VERSION ).iterator().next();
 456         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 457
 458         metadata = createArtifact();
 459         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 460
 461         metadata = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 462                                             TEST_PROJECT_VERSION ).iterator().next();
 463         assertEquals( Collections.<String>emptyList(), new ArrayList<String>( metadata.getFacetIds() ) );
 464     }
 465
 466     public void testGetMetadataFacet()
 467     {
 468         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 469
 470         assertEquals( new TestMetadataFacet( TEST_VALUE ), repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID,
 471                                                                                         TEST_NAME ) );
 472     }
 473
 474     public void testGetMetadataFacetWhenEmpty()
 475     {
 476         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 477     }
 478
 479     public void testGetMetadataFacetWhenUnknownName()
 480     {
 481         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 482
 483         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, UNKNOWN ) );
 484     }
 485
 486     public void testGetMetadataFacetWhenDefaultValue()
 487     {
 488         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( null ) );
 489
 490         assertEquals( new TestMetadataFacet( TEST_METADATA_VALUE ), repository.getMetadataFacet( TEST_REPO_ID,
 491                                                                                                  TEST_FACET_ID,
 492                                                                                                  TEST_NAME ) );
 493     }
 494
 495     public void testGetMetadataFacetWhenUnknownFacetId()
 496     {
 497         assertNull( repository.getMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME ) );
 498     }
 499
 500     public void testGetMetadataFacets()
 501     {
 502         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 503
 504         assertEquals( Collections.singletonList( TEST_NAME ), repository.getMetadataFacets( TEST_REPO_ID,
 505                                                                                             TEST_FACET_ID ) );
 506     }
 507
 508     public void testGetMetadataFacetsWhenEmpty()
 509     {
 510         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 511         assertTrue( facets.isEmpty() );
 512     }
 513
 514     public void testRemoveFacets()
 515     {
 516         repository.addMetadataFacet( TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 517
 518         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 519         assertFalse( facets.isEmpty() );
 520
 521         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 522
 523         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 524         assertTrue( facets.isEmpty() );
 525     }
 526
 527     public void testRemoveFacetsWhenEmpty()
 528     {
 529         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 530         assertTrue( facets.isEmpty() );
 531
 532         repository.removeMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 533
 534         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 535         assertTrue( facets.isEmpty() );
 536     }
 537
 538     public void testRemoveFacetsWhenUnknown()
 539     {
 540         // testing no exception
 541         repository.removeMetadataFacets( TEST_REPO_ID, UNKNOWN );
 542     }
 543
 544     public void testRemoveFacetWhenUnknown()
 545     {
 546         // testing no exception
 547         repository.removeMetadataFacet( TEST_REPO_ID, UNKNOWN, TEST_NAME );
 548     }
 549
 550     public void testRemoveFacet()
 551     {
 552         TestMetadataFacet metadataFacet = new TestMetadataFacet( TEST_VALUE );
 553         repository.addMetadataFacet( TEST_REPO_ID, metadataFacet );
 554
 555         assertEquals( metadataFacet, repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 556         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 557         assertFalse( facets.isEmpty() );
 558
 559         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 560
 561         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 562         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 563         assertTrue( facets.isEmpty() );
 564     }
 565
 566     public void testRemoveFacetWhenEmpty()
 567     {
 568         List<String> facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 569         assertTrue( facets.isEmpty() );
 570         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 571
 572         repository.removeMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 573
 574         facets = repository.getMetadataFacets( TEST_REPO_ID, TEST_FACET_ID );
 575         assertTrue( facets.isEmpty() );
 576         assertNull( repository.getMetadataFacet( TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
 577     }
 578
 579     public void testGetArtifacts()
 580     {
 581         ArtifactMetadata artifact1 = createArtifact();
 582         ArtifactMetadata artifact2 = createArtifact( "pom" );
 583         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 584         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 585
 586         Collection<ArtifactMetadata> artifacts = repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 587                                                                           TEST_PROJECT_VERSION );
 588         ArrayList<ArtifactMetadata> actual = new ArrayList<ArtifactMetadata>( artifacts );
 589         Collections.sort( actual, new Comparator<ArtifactMetadata>()
 590         {
 591             public int compare( ArtifactMetadata o1, ArtifactMetadata o2 )
 592             {
 593                 return o1.getId().compareTo( o2.getId() );
 594             }
 595         } );
 596         assertEquals( Arrays.asList( artifact1, artifact2 ), actual );
 597     }
 598
 599     public void testGetArtifactVersions()
 600     {
 601         ArtifactMetadata artifact1 = createArtifact();
 602         String version1 = "1.0-20091212.012345-1";
 603         artifact1.setId( artifact1.getProject() + "-" + version1 + ".jar" );
 604         artifact1.setVersion( version1 );
 605         ArtifactMetadata artifact2 = createArtifact();
 606         String version2 = "1.0-20091212.123456-2";
 607         artifact2.setId( artifact2.getProject() + "-" + version2 + ".jar" );
 608         artifact2.setVersion( version2 );
 609         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 610         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 611
 612         List<String> versions = new ArrayList<String>( repository.getArtifactVersions( TEST_REPO_ID, TEST_NAMESPACE,
 613                                                                                        TEST_PROJECT,
 614                                                                                        TEST_PROJECT_VERSION ) );
 615         Collections.sort( versions );
 616         assertEquals( Arrays.asList( version1, version2 ), versions );
 617     }
 618
 619     public void testGetArtifactVersionsMultipleArtifactsSingleVersion()
 620     {
 621         ArtifactMetadata artifact1 = createArtifact();
 622         artifact1.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
 623         ArtifactMetadata artifact2 = createArtifact();
 624         artifact2.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "-sources.jar" );
 625         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 626         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 627
 628         assertEquals( Collections.singleton( TEST_PROJECT_VERSION ), repository.getArtifactVersions( TEST_REPO_ID,
 629                                                                                                      TEST_NAMESPACE,
 630                                                                                                      TEST_PROJECT,
 631                                                                                                      TEST_PROJECT_VERSION ) );
 632     }
 633
 634     public void testGetArtifactsByDateRangeOpen()
 635     {
 636         ArtifactMetadata artifact = createArtifact();
 637         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 638
 639         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 640                                                                                                  null ) );
 641     }
 642
 643     public void testGetArtifactsByDateRangeSparseNamespace()
 644     {
 645         String namespace = "org.apache.archiva";
 646         ArtifactMetadata artifact = createArtifact();
 647         artifact.setNamespace( namespace );
 648         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 649
 650         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 651                                                                                                  null ) );
 652     }
 653
 654     public void testGetArtifactsByDateRangeLowerBound()
 655     {
 656         ArtifactMetadata artifact = createArtifact();
 657         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 658
 659         Date date = new Date( artifact.getWhenGathered().getTime() - 10000 );
 660         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, date,
 661                                                                                                  null ) );
 662     }
 663
 664     public void testGetArtifactsByDateRangeLowerBoundOutOfRange()
 665     {
 666         ArtifactMetadata artifact = createArtifact();
 667         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 668
 669         Date date = new Date( artifact.getWhenGathered().getTime() + 10000 );
 670         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, date, null ).isEmpty() );
 671     }
 672
 673     public void testGetArtifactsByDateRangeLowerAndUpperBound()
 674     {
 675         ArtifactMetadata artifact = createArtifact();
 676         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 677
 678         Date lower = new Date( artifact.getWhenGathered().getTime() - 10000 );
 679         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 680         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, lower,
 681                                                                                                  upper ) );
 682     }
 683
 684     public void testGetArtifactsByDateRangeUpperBound()
 685     {
 686         ArtifactMetadata artifact = createArtifact();
 687         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 688
 689         Date upper = new Date( artifact.getWhenGathered().getTime() + 10000 );
 690         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByDateRange( TEST_REPO_ID, null,
 691                                                                                                  upper ) );
 692     }
 693
 694     public void testGetArtifactsByDateRangeUpperBoundOutOfRange()
 695     {
 696         ArtifactMetadata artifact = createArtifact();
 697         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 698
 699         Date upper = new Date( artifact.getWhenGathered().getTime() - 10000 );
 700         assertTrue( repository.getArtifactsByDateRange( TEST_REPO_ID, null, upper ).isEmpty() );
 701     }
 702
 703      public void testGetArtifactsByRepoId()
 704     {
 705         ArtifactMetadata artifact = createArtifact();
 706         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 707         assertEquals( Collections.singletonList( artifact ), repository.getArtifacts( TEST_REPO_ID ) );
 708     }
 709
 710     public void testGetNamespacesWithSparseDepth()
 711     {
 712         repository.updateNamespace( TEST_REPO_ID, "org.apache.maven.shared" );
 713
 714         assertEquals( Arrays.asList( "org" ), repository.getRootNamespaces( TEST_REPO_ID ) );
 715         assertEquals( Arrays.asList( "apache" ), repository.getNamespaces( TEST_REPO_ID, "org" ) );
 716         assertEquals( Arrays.asList( "maven" ), repository.getNamespaces( TEST_REPO_ID, "org.apache" ) );
 717         assertEquals( Arrays.asList( "shared" ), repository.getNamespaces( TEST_REPO_ID, "org.apache.maven" ) );
 718     }
 719
 720     public void testGetArtifactsByChecksumSingleResultMd5()
 721     {
 722         ArtifactMetadata artifact = createArtifact();
 723         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 724
 725         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByChecksum( TEST_REPO_ID,
 726                                                                                                 TEST_MD5 ) );
 727     }
 728
 729     public void testGetArtifactsByChecksumSingleResultSha1()
 730     {
 731         ArtifactMetadata artifact = createArtifact();
 732         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 733
 734         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByChecksum( TEST_REPO_ID,
 735                                                                                                 TEST_SHA1 ) );
 736     }
 737
 738     public void testGetArtifactsByChecksumDeepNamespace()
 739     {
 740         ArtifactMetadata artifact = createArtifact();
 741         String namespace = "multi.level.ns";
 742         artifact.setNamespace( namespace );
 743         repository.updateArtifact( TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 744
 745         assertEquals( Collections.singletonList( artifact ), repository.getArtifactsByChecksum( TEST_REPO_ID,
 746                                                                                                 TEST_SHA1 ) );
 747     }
 748
 749     public void testGetArtifactsByChecksumMultipleResult()
 750     {
 751         ArtifactMetadata artifact1 = createArtifact();
 752         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 753
 754         String newProjectId = "another-project";
 755         ArtifactMetadata artifact2 = createArtifact();
 756         artifact2.setProject( newProjectId );
 757         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, newProjectId, TEST_PROJECT_VERSION, artifact2 );
 758
 759         List<ArtifactMetadata> artifacts = new ArrayList<ArtifactMetadata>( repository.getArtifactsByChecksum(
 760             TEST_REPO_ID, TEST_SHA1 ) );
 761         Collections.sort( artifacts, new ArtifactMetadataComparator() );
 762         assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
 763     }
 764
 765     public void testGetArtifactsByChecksumNoResult()
 766     {
 767         ArtifactMetadata artifact = createArtifact();
 768         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 769
 770         assertEquals( Collections.<ArtifactMetadata>emptyList(), repository.getArtifactsByChecksum( TEST_REPO_ID, "not a checksum" ) );
 771     }
 772
 773     public void testDeleteArtifact()
 774     {
 775         ArtifactMetadata artifact = createArtifact();
 776         artifact.addFacet( new TestMetadataFacet( "value" ) );
 777
 778         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
 779
 780         assertEquals( Collections.singletonList( artifact ), new ArrayList<ArtifactMetadata>( repository.getArtifacts(
 781             TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ) );
 782
 783         repository.deleteArtifact( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId() );
 784
 785         assertTrue( repository.getArtifacts( TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT,
 786                                              TEST_PROJECT_VERSION ).isEmpty() );
 787     }
 788
 789     public void testDeleteRepository()
 790     {
 791         repository.updateNamespace( TEST_REPO_ID, TEST_NAMESPACE );
 792
 793         ProjectMetadata project1 = new ProjectMetadata();
 794         project1.setNamespace( TEST_NAMESPACE );
 795         project1.setId( "project1" );
 796         repository.updateProject( TEST_REPO_ID, project1 );
 797         ProjectMetadata project2 = new ProjectMetadata();
 798         project2.setNamespace( TEST_NAMESPACE );
 799         project2.setId( "project2" );
 800         repository.updateProject( TEST_REPO_ID, project2 );
 801
 802         ArtifactMetadata artifact1 = createArtifact();
 803         artifact1.setProject( "project1" );
 804         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project1", TEST_PROJECT_VERSION, artifact1 );
 805         ArtifactMetadata artifact2 = createArtifact();
 806         artifact2.setProject( "project2" );
 807         repository.updateArtifact( TEST_REPO_ID, TEST_NAMESPACE, "project2", TEST_PROJECT_VERSION, artifact2 );
 808
 809         List<ArtifactMetadata> expected = Arrays.asList( artifact1, artifact2 );
 810         Collections.sort( expected, new ArtifactMetadataComparator() );
 811
 812         List<ArtifactMetadata> actual = new ArrayList<ArtifactMetadata>( repository.getArtifactsByDateRange(
 813             TEST_REPO_ID, null, null ) );
 814         Collections.sort( actual, new ArtifactMetadataComparator() );
 815
 816         assertEquals( expected, actual );
 817
 818         repository.deleteRepository( TEST_REPO_ID );
 819
 820         assertTrue( repository.getArtifacts( TEST_REPO_ID ).isEmpty() );
 821         assertTrue( repository.getRootNamespaces( TEST_REPO_ID ).isEmpty() );
 822     }
 823
 824     private static ProjectMetadata createProject()
 825     {
 826         return createProject( TEST_NAMESPACE );
 827     }
 828
 829     private static ProjectMetadata createProject( String ns )
 830     {
 831         ProjectMetadata project = new ProjectMetadata();
 832         project.setId( TEST_PROJECT );
 833         project.setNamespace( ns );
 834         return project;
 835     }
 836
 837     private static ArtifactMetadata createArtifact()
 838     {
 839         return createArtifact( "jar" );
 840     }
 841
 842     private static ArtifactMetadata createArtifact( String type )
 843     {
 844         ArtifactMetadata artifact = new ArtifactMetadata();
 845         artifact.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "." + type );
 846         artifact.setWhenGathered( new Date() );
 847         artifact.setNamespace( TEST_NAMESPACE );
 848         artifact.setProject( TEST_PROJECT );
 849         artifact.setRepositoryId( TEST_REPO_ID );
 850         artifact.setFileLastModified( System.currentTimeMillis() );
 851         artifact.setVersion( TEST_PROJECT_VERSION );
 852         artifact.setProjectVersion( TEST_PROJECT_VERSION );
 853         artifact.setMd5( TEST_MD5 );
 854         artifact.setSha1( TEST_SHA1 );
 855         return artifact;
 856     }
 857
 858     private static class ArtifactMetadataComparator
 859         implements Comparator<ArtifactMetadata>
 860     {
 861         public final int compare( ArtifactMetadata a, ArtifactMetadata b )
 862         {
 863             return a.getProject().compareTo( b.getProject() );
 864         }
 865     }
 866
 867     private static class TestMetadataFacet
 868         implements MetadataFacet
 869     {
 870         private String testFacetId;
 871
 872         private Map<String, String> additionalProps;
 873
 874         private String value;
 875
 876         private TestMetadataFacet( String value )
 877         {
 878             this.value = value;
 879             testFacetId = TEST_FACET_ID;
 880         }
 881
 882         private TestMetadataFacet( String facetId, String value )
 883         {
 884             this.value = value;
 885             testFacetId = facetId;
 886         }
 887
 888         private TestMetadataFacet( String facetId, String value, Map<String, String> additionalProps )
 889         {
 890             this( facetId, value );
 891             this.additionalProps = additionalProps;
 892         }
 893
 894         public String getFacetId()
 895         {
 896             return testFacetId;
 897         }
 898
 899         public String getName()
 900         {
 901             return TEST_NAME;
 902         }
 903
 904         public Map<String, String> toProperties()
 905         {
 906             if ( value != null )
 907             {
 908                 if( additionalProps == null )
 909                 {
 910                     return Collections.singletonMap( "foo", value );
 911                 }
 912                 else
 913                 {
 914                     Map<String, String> props = new HashMap<String, String>();
 915                     props.put( "foo", value );
 916
 917                     for( String key : additionalProps.keySet() )
 918                     {
 919                         props.put( key, additionalProps.get( key ) );
 920                     }
 921                     return props;
 922                 }
 923             }
 924             else
 925             {
 926                 return Collections.emptyMap();
 927             }
 928         }
 929
 930         public void fromProperties( Map<String, String> properties )
 931         {
 932             String value = properties.get( "foo" );
 933             if ( value != null )
 934             {
 935                 this.value = value;
 936             }
 937
 938             properties.remove( "foo" );
 939
 940             if( additionalProps == null )
 941             {
 942                 additionalProps = new HashMap<String, String>();
 943             }
 944
 945             for( String key: properties.keySet() )
 946             {
 947                 additionalProps.put( key, properties.get( key ) );
 948             }
 949         }
 950
 951         public String getValue()
 952         {
 953             return value;
 954         }
 955
 956         @Override
 957         public String toString()
 958         {
 959             return "TestMetadataFacet{" + "value='" + value + '\'' + '}';
 960         }
 961
 962         @Override
 963         public boolean equals( Object o )
 964         {
 965             if ( this == o )
 966             {
 967                 return true;
 968             }
 969             if ( o == null || getClass() != o.getClass() )
 970             {
 971                 return false;
 972             }
 973
 974             TestMetadataFacet that = (TestMetadataFacet) o;
 975
 976             if ( value != null ? !value.equals( that.value ) : that.value != null )
 977             {
 978                 return false;
 979             }
 980
 981             return true;
 982         }
 983
 984         @Override
 985         public int hashCode()
 986         {
 987             return value != null ? value.hashCode() : 0;
 988         }
 989     }
 990 }