* limitations under the License.
 */

package org.gradle.internal.snapshot.impl;

import org.gradle.internal.hash.Hasher;

public class LongValueSnapshot extends AbstractIsolatableScalarValue<Long> {
    public LongValueSnapshot(Long value) {
        super(value);
    }

    @Override
    public void appendToHasher(Hasher hasher) {
        hasher.putLong(getValue());
    }

        integer(Integer.MAX_VALUE)              | _
        integer(Integer.MIN_VALUE)              | _
        new LongValueSnapshot(123L)             | _
        new LongValueSnapshot(0L)               | _
        new LongValueSnapshot(Long.MAX_VALUE)   | _
        new LongValueSnapshot(Long.MIN_VALUE)   | _
        new ShortValueSnapshot(123 as short)    | _
        new ShortValueSnapshot(0 as short)      | _

        @Override
        protected void serialize(Encoder encoder, LongValueSnapshot value) throws Exception {
            encoder.writeLong(value.getValue());
        }

        @Override
        protected LongValueSnapshot deserialize(Decoder decoder) throws Exception {
            return new LongValueSnapshot(decoder.readLong());
        }

            encoder.writeSmallInt(INTEGER_SNAPSHOT);
            encoder.writeInt(integerSnapshot.getValue());
        } else if (snapshot instanceof LongValueSnapshot) {
            LongValueSnapshot longSnapshot = (LongValueSnapshot) snapshot;
            encoder.writeSmallInt(LONG_SNAPSHOT);
            encoder.writeLong(longSnapshot.getValue());
        } else if (snapshot instanceof ShortValueSnapshot) {

        public ValueSnapshot integerValue(Integer value) {
            return new IntegerValueSnapshot(value);
        }

        @Override
        public ValueSnapshot longValue(Long value) {
            return new LongValueSnapshot(value);
        }

        @Override
        public ValueSnapshot shortValue(Short value) {
            return new ShortValueSnapshot(value);
        }

        @Override

        public Isolatable<?> integerValue(Integer value) {
            return new IntegerValueSnapshot(value);
        }

        @Override
        public Isolatable<?> longValue(Long value) {
            return new LongValueSnapshot(value);
        }

        @Override
        public Isolatable<?> shortValue(Short value) {
            return new ShortValueSnapshot(value);
        }

        @Override

    }

    def "creates isolated long"() {
        expect:
        def original = 123L
        def isolated = isolatableFactory.isolate(original)
        isolated instanceof LongValueSnapshot
        isolated.isolate().is(original)
    }

    def "can coerce long value"() {
        expect:
        def original = 123L
        def isolated = isolatableFactory.isolate(original)

        snapshotter.snapshot(456) != snapshotter.snapshot(isolated)
    }

    def "creates snapshot for long"() {
        expect:
        def snapshot = snapshotter.snapshot(123L)
        snapshot instanceof LongValueSnapshot
        snapshot == snapshotter.snapshot(123L)
        snapshot != snapshotter.snapshot(-1L)
        snapshot != snapshotter.snapshot(123)
        snapshot != snapshotter.snapshot(123 as short)