return (char) decoder.readInt();
        }

        @Override
        public void write(Encoder encoder, Character value) throws Exception {
            encoder.writeInt(value);
        }
    }

    private static class IntegerSerializer extends AbstractSerializer<Integer> {
        @Override
        public Integer read(Decoder decoder) throws Exception {

		ix.sa.int32 = make([]int32, len(data))
		text_32(data, ix.sa.int32)
	} else {
		ix.sa.int64 = make([]int64, len(data))
		text_64(data, ix.sa.int64)
	}
	return ix
}

// writeInt writes an int x to w using buf to buffer the write.
func writeInt(w io.Writer, buf []byte, x int) error {
	binary.PutVarint(buf, int64(x))
	_, err := w.Write(buf[0:binary.MaxVarintLen64])
	return err
}

                encoder.writeBoolean((Boolean) container.getAttribute(attribute));
            } else if (type == Integer.class) {
                encoder.writeByte(INTEGER_ATTRIBUTE);
                encoder.writeInt((Integer) container.getAttribute(attribute));
            } else {
                assert type == String.class : "Unexpected attribute type " + type + " : should be " + String.class.getSimpleName();

	// write "pool"
	err = en.Append(0xa4, 0x70, 0x6f, 0x6f, 0x6c)
	if err != nil {
		return
	}
	err = en.WriteInt(z.pool)
	if err != nil {
		err = msgp.WrapError(err, "pool")
		return
	}
	// write "set"
	err = en.Append(0xa3, 0x73, 0x65, 0x74)
	if err != nil {
		return
	}
	err = en.WriteInt(z.set)
	if err != nil {
		err = msgp.WrapError(err, "set")
		return
	}
	return
}

            try {
                indexOutput.writeInt(index.size(), true);

                for (Map.Entry<Long, Map<Long, TestCaseRegion>> classEntry : index.entrySet()) {
                    Long classId = classEntry.getKey();
                    Map<Long, TestCaseRegion> regions = classEntry.getValue();

                    indexOutput.writeLong(classId, true);
                    indexOutput.writeInt(regions.size(), true);

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

        }

        then:
        thrown(EOFException)
    }

    def "can encode and decode int #value"() {
        expect:
        def bytes = encode { Encoder encoder ->
            encoder.writeInt(value as int)
        }
        decode(bytes) { Decoder decoder ->
            assert decoder.readInt() == value
        }

        where:
        value             | _
        0                 | _

    void writeSmallLong(long value) throws IOException;

    /**
     * Writes a signed 32 bit int value. The implementation may encode the value as a variable number of bytes, not necessarily as 4 bytes.
     */
    void writeInt(int value) throws IOException;

    /**
     * Writes a signed 32 bit int value whose value is likely to be small and positive but may not be. The implementation may encode the value in a way that

			err = msgp.WrapError(err)
			return
		}
		(*z) = rebalSaveOpts(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z rebalSaveOpts) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteUint8(uint8(z))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z rebalSaveOpts) MarshalMsg(b []byte) (o []byte, err error) {

	}
	// write "ra"
	err = en.Append(0xa2, 0x72, 0x61)
	if err != nil {
		return
	}
	err = en.WriteInt(z.RetryAttempts)
	if err != nil {
		err = msgp.WrapError(err, "RetryAttempts")
		return
	}
	// write "at"
	err = en.Append(0xa2, 0x61, 0x74)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Attempts)
	if err != nil {
		err = msgp.WrapError(err, "Attempts")
		return
	}
	// write "cmp"