001package beginner;
002
003import com.sandwich.koan.Koan;
004
005import static com.sandwich.koan.constant.KoanConstants.__;
006import static com.sandwich.util.Assert.assertEquals;
007
008public class AboutPrimitives {
009
010    @Koan
011    public void wholeNumbersAreOfTypeInt() {
012        assertEquals(getType(1), __); // hint: int.class
013    }
014
015    @Koan
016    public void primitivesOfTypeIntHaveAnObjectTypeInteger() {
017        Object number = 1;
018        assertEquals(getType(number), __);
019
020        // Primitives can be automatically changed into their object type via a process called auto-boxing
021        // We will explore this in more detail in intermediate.AboutAutoboxing
022    }
023
024    @Koan
025    public void integersHaveAFairlyLargeRange() {
026        assertEquals(Integer.MIN_VALUE, __);
027        assertEquals(Integer.MAX_VALUE, __);
028    }
029
030    @Koan
031    public void integerSize() {
032        assertEquals(Integer.SIZE, __);  // This is the amount of bits used to store an int
033    }
034
035    @Koan
036    public void wholeNumbersCanAlsoBeOfTypeLong() {
037        assertEquals(getType(1L), __);
038    }
039
040    @Koan
041    public void primitivesOfTypeLongHaveAnObjectTypeLong() {
042        Object number = 1L;
043        assertEquals(getType(number), __);
044    }
045
046    @Koan
047    public void longsHaveALargerRangeThanInts() {
048        assertEquals(Long.MIN_VALUE, __);
049        assertEquals(Long.MAX_VALUE, __);
050    }
051
052    @Koan
053    public void longSize() {
054        assertEquals(Long.SIZE, __);
055    }
056
057    @Koan
058    public void wholeNumbersCanAlsoBeOfTypeShort() {
059        assertEquals(getType((short) 1), __); // The '(short)' is called an explicit cast - to type 'short'
060    }
061
062    @Koan
063    public void primitivesOfTypeShortHaveAnObjectTypeShort() {
064        Object number = (short) 1;
065        assertEquals(getType(number), __);
066    }
067
068    @Koan
069    public void shortsHaveASmallerRangeThanInts() {
070        assertEquals(Short.MIN_VALUE, __);  // hint: You'll need an explicit cast
071        assertEquals(Short.MAX_VALUE, __);
072    }
073
074    @Koan
075    public void shortSize() {
076        assertEquals(Short.SIZE, __);
077    }
078
079    @Koan
080    public void wholeNumbersCanAlsoBeOfTypeByte() {
081        assertEquals(getType((byte) 1), __);
082    }
083
084    @Koan
085    public void primitivesOfTypeByteHaveAnObjectTypeByte() {
086        Object number = (byte) 1;
087        assertEquals(getType(number), __);
088    }
089
090    @Koan
091    public void bytesHaveASmallerRangeThanShorts() {
092        assertEquals(Byte.MIN_VALUE, __);
093        assertEquals(Byte.MAX_VALUE, __);
094
095        // Why would you use short or byte considering that you need to do explicit casts?
096    }
097
098    @Koan
099    public void byteSize() {
100        assertEquals(Byte.SIZE, __);
101    }
102
103    @Koan
104    public void wholeNumbersCanAlsoBeOfTypeChar() {
105        assertEquals(getType((char) 1), __);
106    }
107
108    @Koan
109    public void singleCharactersAreOfTypeChar() {
110        assertEquals(getType('a'), __);
111    }
112
113    @Koan
114    public void primitivesOfTypeCharHaveAnObjectTypeCharacter() {
115        Object number = (char) 1;
116        assertEquals(getType(number), __);
117    }
118
119    @Koan
120    public void charsCanOnlyBePositive() {
121        assertEquals((int) Character.MIN_VALUE, __);
122        assertEquals((int) Character.MAX_VALUE, __);
123
124        // Why did we cast MIN_VALUE and MAX_VALUE to int? Try it without the cast.
125    }
126
127    @Koan
128    public void charSize() {
129        assertEquals(Character.SIZE, __);
130    }
131
132    @Koan
133    public void decimalNumbersAreOfTypeDouble() {
134        assertEquals(getType(1.0), __);
135    }
136
137    @Koan
138    public void primitivesOfTypeDoubleCanBeDeclaredWithoutTheDecimalPoint() {
139        assertEquals(getType(1d), __);
140    }
141
142    @Koan
143    public void primitivesOfTypeDoubleCanBeDeclaredWithExponents() {
144        assertEquals(getType(1e3), __);
145        assertEquals(1.0e3, __);
146        assertEquals(1E3, __);
147    }
148
149    @Koan
150    public void primitivesOfTypeDoubleHaveAnObjectTypeDouble() {
151        Object number = 1.0;
152        assertEquals(getType(number), __);
153    }
154
155    @Koan
156    public void doublesHaveALargeRange() {
157        assertEquals(Double.MIN_VALUE, __);
158        assertEquals(Double.MAX_VALUE, __);
159    }
160
161    @Koan
162    public void doubleSize() {
163        assertEquals(Double.SIZE, __);
164    }
165
166    @Koan
167    public void decimalNumbersCanAlsoBeOfTypeFloat() {
168        assertEquals(getType(1f), __);
169    }
170
171    @Koan
172    public void primitivesOfTypeFloatCanBeDeclaredWithExponents() {
173        assertEquals(getType(1e3f), __);
174        assertEquals(1.0e3f, __);
175        assertEquals(1E3f, __);
176    }
177
178    @Koan
179    public void primitivesOfTypeFloatHaveAnObjectTypeFloat() {
180        Object number = 1f;
181        assertEquals(getType(number), __);
182    }
183
184    @Koan
185    public void floatsHaveASmallerRangeThanDoubles() {
186        assertEquals(Float.MIN_VALUE, __);
187        assertEquals(Float.MAX_VALUE, __);
188    }
189
190    @Koan
191    public void floatSize() {
192        assertEquals(Float.SIZE, __);
193    }
194
195    private Class<?> getType(int value) {
196        return int.class;
197    }
198
199    private Class<?> getType(long value) {
200        return long.class;
201    }
202
203    private Class<?> getType(float value) {
204        return float.class;
205    }
206
207    private Class<?> getType(double value) {
208        return double.class;
209    }
210
211    private Class<?> getType(byte value) {
212        return byte.class;
213    }
214
215    private Class<?> getType(char value) {
216        return char.class;
217    }
218
219    private Class<?> getType(short value) {
220        return short.class;
221    }
222
223    private Class<?> getType(Object value) {
224        return value.getClass();
225    }
226
227}