1/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17// Note that $opt$ is a marker for the optimizing compiler to test
18// it does compile the method.
19public class Main {
20
21  public static void expectEquals(int expected, int result) {
22    if (expected != result) {
23      throw new Error("Expected: " + expected + ", found: " + result);
24    }
25  }
26
27  public static void expectEquals(long expected, long result) {
28    if (expected != result) {
29      throw new Error("Expected: " + expected + ", found: " + result);
30    }
31  }
32
33  public static void expectEquals(float expected, float result) {
34    if (expected != result) {
35      throw new Error("Expected: " + expected + ", found: " + result);
36    }
37  }
38
39  public static void expectEquals(double expected, double result) {
40    if (expected != result) {
41      throw new Error("Expected: " + expected + ", found: " + result);
42    }
43  }
44
45  public static void expectApproxEquals(float a, float b) {
46    float maxDelta = 0.00001F;
47    boolean aproxEquals = (a > b) ? ((a - b) < maxDelta) : ((b - a) < maxDelta);
48    if (!aproxEquals) {
49      throw new Error("Expected: " + a + ", found: " + b
50          + ", with delta: " + maxDelta + " " + (a - b));
51    }
52  }
53
54  public static void expectApproxEquals(double a, double b) {
55    double maxDelta = 0.00001D;
56    boolean aproxEquals = (a > b) ? ((a - b) < maxDelta) : ((b - a) < maxDelta);
57    if (!aproxEquals) {
58      throw new Error("Expected: " + a + ", found: "
59          + b + ", with delta: " + maxDelta + " " + (a - b));
60    }
61  }
62
63  public static void expectNaN(float a) {
64    if (a == a) {
65      throw new Error("Expected NaN: " + a);
66    }
67  }
68
69  public static void expectNaN(double a) {
70    if (a == a) {
71      throw new Error("Expected NaN: " + a);
72    }
73  }
74
75  public static void expectDivisionByZero(int value) {
76    try {
77      $opt$Div(value, 0);
78      throw new Error("Expected RuntimeException when dividing by 0");
79    } catch (java.lang.RuntimeException e) {
80    }
81    try {
82      $opt$DivZero(value);
83      throw new Error("Expected RuntimeException when dividing by 0");
84    } catch (java.lang.RuntimeException e) {
85    }
86  }
87
88  public static void expectDivisionByZero(long value) {
89    try {
90      $opt$Div(value, 0L);
91      throw new Error("Expected RuntimeException when dividing by 0");
92    } catch (java.lang.RuntimeException e) {
93    }
94    try {
95      $opt$DivZero(value);
96      throw new Error("Expected RuntimeException when dividing by 0");
97    } catch (java.lang.RuntimeException e) {
98    }
99  }
100
101  public static void main(String[] args) {
102    div();
103  }
104
105  public static void div() {
106    divInt();
107    divLong();
108    divFloat();
109    divDouble();
110  }
111
112  private static void divInt() {
113    expectEquals(2, $opt$DivConst(6));
114    expectEquals(2, $opt$Div(6, 3));
115    expectEquals(6, $opt$Div(6, 1));
116    expectEquals(-2, $opt$Div(6, -3));
117    expectEquals(1, $opt$Div(4, 3));
118    expectEquals(-1, $opt$Div(4, -3));
119    expectEquals(5, $opt$Div(23, 4));
120    expectEquals(-5, $opt$Div(-23, 4));
121
122    expectEquals(-Integer.MAX_VALUE, $opt$Div(Integer.MAX_VALUE, -1));
123    expectEquals(Integer.MIN_VALUE, $opt$Div(Integer.MIN_VALUE, -1)); // overflow
124    expectEquals(-1073741824, $opt$Div(Integer.MIN_VALUE, 2));
125
126    expectEquals(0, $opt$Div(0, Integer.MAX_VALUE));
127    expectEquals(0, $opt$Div(0, Integer.MIN_VALUE));
128
129    expectDivisionByZero(0);
130    expectDivisionByZero(1);
131    expectDivisionByZero(Integer.MAX_VALUE);
132    expectDivisionByZero(Integer.MIN_VALUE);
133  }
134
135  private static void divLong() {
136    expectEquals(2L, $opt$DivConst(6L));
137    expectEquals(2L, $opt$Div(6L, 3L));
138    expectEquals(6L, $opt$Div(6L, 1L));
139    expectEquals(-2L, $opt$Div(6L, -3L));
140    expectEquals(1L, $opt$Div(4L, 3L));
141    expectEquals(-1L, $opt$Div(4L, -3L));
142    expectEquals(5L, $opt$Div(23L, 4L));
143    expectEquals(-5L, $opt$Div(-23L, 4L));
144
145    expectEquals(-Integer.MAX_VALUE, $opt$Div(Integer.MAX_VALUE, -1L));
146    expectEquals(2147483648L, $opt$Div(Integer.MIN_VALUE, -1L));
147    expectEquals(-1073741824L, $opt$Div(Integer.MIN_VALUE, 2L));
148
149    expectEquals(-Long.MAX_VALUE, $opt$Div(Long.MAX_VALUE, -1L));
150    expectEquals(Long.MIN_VALUE, $opt$Div(Long.MIN_VALUE, -1L)); // overflow
151
152    expectEquals(11111111111111L, $opt$Div(33333333333333L, 3L));
153    expectEquals(3L, $opt$Div(33333333333333L, 11111111111111L));
154
155    expectEquals(0L, $opt$Div(0L, Long.MAX_VALUE));
156    expectEquals(0L, $opt$Div(0L, Long.MIN_VALUE));
157
158    expectDivisionByZero(0L);
159    expectDivisionByZero(1L);
160    expectDivisionByZero(Long.MAX_VALUE);
161    expectDivisionByZero(Long.MIN_VALUE);
162  }
163
164  private static void divFloat() {
165    expectApproxEquals(1.6666666F, $opt$Div(5F, 3F));
166    expectApproxEquals(0F, $opt$Div(0F, 3F));
167    expectApproxEquals(-0.3333333F, $opt$Div(1F, -3F));
168    expectApproxEquals(4F, $opt$Div(-12F, -3F));
169    expectApproxEquals(0.5, $opt$Div(0.1F, 0.2F));
170    expectApproxEquals(-2.5F, $opt$Div(-0.5F, 0.2F));
171
172    expectEquals(0F, $opt$Div(0F, Float.POSITIVE_INFINITY));
173    expectEquals(0F, $opt$Div(11F, Float.POSITIVE_INFINITY));
174    expectEquals(0F, $opt$Div(0F, Float.NEGATIVE_INFINITY));
175    expectEquals(0F, $opt$Div(11F, Float.NEGATIVE_INFINITY));
176
177    expectNaN($opt$Div(0F, 0F));
178    expectNaN($opt$Div(Float.NaN, 11F));
179    expectNaN($opt$Div(-11F, Float.NaN));
180    expectNaN($opt$Div(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY));
181    expectNaN($opt$Div(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY));
182    expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY));
183    expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY));
184    expectNaN($opt$Div(Float.NaN, Float.NEGATIVE_INFINITY));
185    expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.NaN));
186
187    expectEquals(Float.POSITIVE_INFINITY, $opt$Div(3F, 0F));
188    expectEquals(Float.NEGATIVE_INFINITY, $opt$Div(-3F, 0F));
189    expectEquals(Float.POSITIVE_INFINITY, $opt$Div(Float.MAX_VALUE, Float.MIN_VALUE));
190    expectEquals(Float.NEGATIVE_INFINITY, $opt$Div(-Float.MAX_VALUE, Float.MIN_VALUE));
191  }
192
193  private static void divDouble() {
194    expectApproxEquals(1.6666666D, $opt$Div(5D, 3D));
195    expectApproxEquals(0D, $opt$Div(0D, 3D));
196    expectApproxEquals(-0.3333333D, $opt$Div(1D, -3D));
197    expectApproxEquals(4D, $opt$Div(-12D, -3D));
198    expectApproxEquals(0.5, $opt$Div(0.1D, 0.2D));
199    expectApproxEquals(-2.5D, $opt$Div(-0.5D, 0.2D));
200
201    expectEquals(0D, $opt$Div(0D, Float.POSITIVE_INFINITY));
202    expectEquals(0D, $opt$Div(11D, Float.POSITIVE_INFINITY));
203    expectEquals(0D, $opt$Div(0D, Float.NEGATIVE_INFINITY));
204    expectEquals(0D, $opt$Div(11D, Float.NEGATIVE_INFINITY));
205
206    expectNaN($opt$Div(0D, 0D));
207    expectNaN($opt$Div(Float.NaN, 11D));
208    expectNaN($opt$Div(-11D, Float.NaN));
209    expectNaN($opt$Div(Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY));
210    expectNaN($opt$Div(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY));
211    expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY));
212    expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY));
213    expectNaN($opt$Div(Float.NaN, Float.NEGATIVE_INFINITY));
214    expectNaN($opt$Div(Float.POSITIVE_INFINITY, Float.NaN));
215
216    expectEquals(Float.POSITIVE_INFINITY, $opt$Div(3D, 0D));
217    expectEquals(Float.NEGATIVE_INFINITY, $opt$Div(-3D, 0D));
218    expectEquals(Float.POSITIVE_INFINITY, $opt$Div(Float.MAX_VALUE, Float.MIN_VALUE));
219    expectEquals(Float.NEGATIVE_INFINITY, $opt$Div(-Float.MAX_VALUE, Float.MIN_VALUE));
220  }
221
222  static int $opt$Div(int a, int b) {
223    return a / b;
224  }
225
226  static int $opt$DivZero(int a) {
227    return a / 0;
228  }
229
230  // Division by literals != 0 should not generate checks.
231  static int $opt$DivConst(int a) {
232    return a / 3;
233  }
234
235  static long $opt$DivConst(long a) {
236    return a / 3L;
237  }
238
239  static long $opt$Div(long a, long b) {
240    return a / b;
241  }
242
243  static long $opt$DivZero(long a) {
244    return a / 0L;
245  }
246
247  static float $opt$Div(float a, float b) {
248    return a / b;
249  }
250
251  static double $opt$Div(double a, double b) {
252    return a / b;
253  }
254}
255