001package de.cuioss.test.generator.impl;
002
003import static de.cuioss.tools.base.Preconditions.checkArgument;
004import static java.util.Objects.requireNonNull;
005
006import de.cuioss.test.generator.Generators;
007import de.cuioss.test.generator.TypedGenerator;
008
009/**
010 * Generates arrays of primitive types.
011 *
012 * @author Oliver Wolff
013 */
014public enum PrimitiveArrayGenerators {
015
016    /** Provides booleans */
017    BOOLEAN {
018
019        @Override
020        public Object next() {
021            final int size = sizeGenerator.next();
022            final var generator = Generators.booleans();
023            final var array = new boolean[size];
024            for (var index = 0; index < size; index++) {
025                array[index] = generator.next();
026            }
027            return array;
028        }
029
030        @Override
031        public Class<?> getType() {
032            return boolean.class;
033        }
034    },
035    /** Provides bytes */
036    BYTE {
037
038        @Override
039        public Object next() {
040            final int size = sizeGenerator.next();
041            final var generator = Generators.bytes();
042            final var array = new byte[size];
043            for (var index = 0; index < size; index++) {
044                array[index] = generator.next();
045            }
046            return array;
047        }
048
049        @Override
050        public Class<?> getType() {
051            return byte.class;
052        }
053    },
054    /** Provides chars */
055    CHAR {
056
057        @Override
058        public Object next() {
059            final int size = sizeGenerator.next();
060            final var generator = Generators.characters();
061            final var array = new char[size];
062            for (var index = 0; index < size; index++) {
063                array[index] = generator.next();
064            }
065            return array;
066        }
067
068        @Override
069        public Class<?> getType() {
070            return char.class;
071        }
072    },
073    /** Provides shorts */
074    SHORT {
075
076        @Override
077        public Object next() {
078            final int size = sizeGenerator.next();
079            final TypedGenerator<Short> generator = new ShortObjectGenerator();
080            final var array = new short[size];
081            for (var index = 0; index < size; index++) {
082                array[index] = generator.next();
083            }
084            return array;
085        }
086
087        @Override
088        public Class<?> getType() {
089            return short.class;
090        }
091    },
092    /** Provides integers */
093    INTEGER {
094
095        @Override
096        public Object next() {
097            final int size = sizeGenerator.next();
098            final var generator = Generators.integers();
099            final var array = new int[size];
100            for (var index = 0; index < size; index++) {
101                array[index] = generator.next();
102            }
103            return array;
104        }
105
106        @Override
107        public Class<?> getType() {
108            return int.class;
109        }
110    },
111    /** Provides longs */
112    LONG {
113
114        @Override
115        public Object next() {
116            final int size = sizeGenerator.next();
117            final var generator = Generators.longs();
118            final var array = new long[size];
119            for (var index = 0; index < size; index++) {
120                array[index] = generator.next();
121            }
122            return array;
123        }
124
125        @Override
126        public Class<?> getType() {
127            return long.class;
128        }
129    },
130    /** Provides floats */
131    FLOAT {
132
133        @Override
134        public Object next() {
135            final int size = sizeGenerator.next();
136            final TypedGenerator<Float> generator = new FloatObjectGenerator();
137            final var array = new float[size];
138            for (var index = 0; index < size; index++) {
139                array[index] = generator.next();
140            }
141            return array;
142        }
143
144        @Override
145        public Class<?> getType() {
146            return float.class;
147        }
148    },
149    /** Provides doubles */
150    DOUBLE {
151
152        @Override
153        public Object next() {
154            final int size = sizeGenerator.next();
155            final var generator = Generators.doubles();
156            final var array = new double[size];
157            for (var index = 0; index < size; index++) {
158                array[index] = generator.next();
159            }
160            return array;
161        }
162
163        @Override
164        public Class<?> getType() {
165            return double.class;
166        }
167    };
168
169    private static final TypedGenerator<Integer> sizeGenerator = Generators.integers(0, 128);
170
171    /**
172     * @return an primitive array of the configured type, with the sizes 1-128
173     */
174    public abstract Object next();
175
176    /**
177     * @return the type of the primitive
178     */
179    public abstract Class<?> getType();
180
181    /**
182     * Returns a {@link PrimitiveArrayGenerators} for the given primitive type.
183     *
184     * @param primitiveType must not be null and a primitive type.
185     * @return the found {@link PrimitiveArrayGenerators} or throws an {@link IllegalStateException}
186     *         if none could be found
187     */
188    public static PrimitiveArrayGenerators resolveForType(final Class<?> primitiveType) {
189        requireNonNull(primitiveType);
190        checkArgument(primitiveType.isPrimitive(), "You must provide a primitive type, given: " + primitiveType);
191        for (final PrimitiveArrayGenerators generator : PrimitiveArrayGenerators.values()) {
192            if (primitiveType.equals(generator.getType())) {
193                return generator;
194            }
195        }
196        throw new IllegalStateException("No generator registered for type " + primitiveType);
197    }
198
199}