class KeyHasherTest extends Specification {
    def "can reuse to hash more than one key"() {
        def hasher = new KeyHasher(BaseSerializerFactory.LONG_SERIALIZER)

        expect:
        hasher.getHashCode(12L) != hasher.getHashCode(11L)
        hasher.getHashCode(12L) == hasher.getHashCode(12L)
        hasher.getHashCode(12L) == new KeyHasher(BaseSerializerFactory.LONG_SERIALIZER).getHashCode(12L)
    }

  }

  private Hasher fromHashers(Hasher[] hashers) {
    return new Hasher() {
      @Override
      public Hasher putByte(byte b) {
        for (Hasher hasher : hashers) {
          hasher.putByte(b);
        }
        return this;
      }

      @Override
      public Hasher putBytes(byte[] bytes) {
        for (Hasher hasher : hashers) {
          hasher.putBytes(bytes);
        }

        this.attributeResourceFilter = attributeResourceFilter;
    }

    @Override
    public void appendConfigurationToHasher(Hasher hasher) {
        super.appendConfigurationToHasher(hasher);
        hasher.putString(getClass().getName());
        attributeResourceFilter.appendConfigurationToHasher(hasher);
    }

    @Override
    boolean filter(RegularFileSnapshotContext context) {

    hasher.putShort((short) 0x0201);
    hasher.assertBytes(new byte[] {1, 2});
  }

  public void testInt() {
    TestHasher hasher = new TestHasher();
    hasher.putInt(0x04030201);
    hasher.assertBytes(new byte[] {1, 2, 3, 4});
  }

  public void testLong() {
    TestHasher hasher = new TestHasher();
    hasher.putLong(0x0807060504030201L);
    hasher.assertBytes(new byte[] {1, 2, 3, 4, 5, 6, 7, 8});

            hasher.putInt(bytes.length);
            hasher.putBytes(bytes);
        }

        @Override
        public void putBytes(byte[] bytes, int off, int len) {
            hasher.putInt(len);
            hasher.putBytes(bytes, off, len);
        }

        @Override
        public void putHash(HashCode hashCode) {
            hasher.putInt(hashCode.length());
            hasher.putHash(hashCode);

        this.resourceSnapshotterCacheService = resourceSnapshotterCacheService;
        Hasher hasher = Hashing.newHasher();
        appendConfigurationToHasher(hasher);
        this.delegateConfigurationHash = hasher.hash();
    }

    @Override
    public void appendConfigurationToHasher(Hasher hasher) {
        delegate.appendConfigurationToHasher(hasher);
    }

    @Nullable
    @Override

        Hasher hasher = Hashing.newHasher();
        addToHash(hasher, spec.getClassNames());
        addToHash(hasher, spec.getPackageNames());
        addToHash(hasher, spec.getPackagePrefixes());
        addToHash(hasher, spec.getResourcePrefixes());
        addToHash(hasher, spec.getResourceNames());
        addToHash(hasher, spec.getDisallowedClassNames());

        this.delegate = delegate;
        this.resourceSnapshotterCacheService = resourceSnapshotterCacheService;
        Hasher hasher = Hashing.newHasher();
        delegate.appendConfigurationToHasher(hasher);
        this.delegateConfigurationHash = hasher.hash();
    }

    @Nullable
    @Override
    public HashCode hash(RegularFileSnapshotContext fileSnapshotContext) throws IOException {

        if (ascii.exists()) {
            ascii.delete();
        }
        boolean hasKey = false;
        for (PGPPublicKeyRing keyRing : allKeyRings) {
            // First let's write some human readable info about the keyring being serialized
            try (OutputStream out = new FileOutputStream(ascii, true)) {
                if (hasKey) {
                    out.write('\n');
                }

            appendCollectionToHasherKeepingOrder(hasher, sortedFingerprints);
        }
    },
    KEEP_ORDER {
        @Override
        public void appendToHasher(Hasher hasher, Collection<FileSystemLocationFingerprint> fingerprints) {
            appendCollectionToHasherKeepingOrder(hasher, fingerprints);
        }
    };

    public abstract void appendToHasher(Hasher hasher, Collection<FileSystemLocationFingerprint> fingerprints);