1/*
2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16function And(a: double, b: double): long {
17    return a & b
18}
19
20function Or(a: double, b: double): long {
21    return a | b
22}
23
24function Xor(a: double, b: double): long {
25    return a ^ b
26}
27
28function LeftShift(a: double, b: double): long {
29    return a << b
30}
31
32function RightShift(a: double, b: double): long {
33    return a >> b
34}
35
36function UnsignedRightShift(a: double, b: double): long {
37    return a >>> b
38}
39 
40function Inversion(a: double): long {
41    return ~a;
42}
43
44function main(): void {
45    /* ---- Compile time tests ---- */
46
47    // Testing "and" operator:
48    assert (542.910991 & -1903.2040221) == 16
49    assert (-542.910991 & 1903.2040221) == 1378
50    assert (-542.910991 & -1903.2040221) == -1920
51    assert (9E120 & 56.75) == 56
52    assert (0.0 & 0.0) == 0
53    assert (NaN & 42.131330352) == 0
54    assert (-NaN & -23432.34110144432) == 0
55    assert (Infinity & -94.24445985981884) == 9223372036854775714
56    assert (-Infinity & 94.24445985981884) == 0
57
58    // Testing "or" operator: 
59    assert (542.910991 | 1903.2040221) == 1919
60    assert (542.910991 | -1903.2040221) == -1377
61    assert (-542.910991 | 1903.2040221) == -17
62    assert (-542.910991 | -1903.2040221) == -525
63    assert (9E120 | 0) == 9223372036854775807
64    assert (824E3 | 21.018763) == 824021
65    assert (1.0 | 0.1) == 1
66    assert (NaN | 0.2) == 0
67    assert (-NaN | 0.3) == 0
68    assert (Infinity | 0.4) == 9223372036854775807
69    assert (-Infinity | 0.5) == -9223372036854775808
70
71    // Testing "xor" operator: 
72    assert (542.910991 ^ 1903.2040221) == 1393
73    assert (542.910991 ^ -1903.2040221) == -1393
74    assert (-542.910991 ^ 1903.2040221) == -1395
75    assert (-542.910991 ^ -1903.2040221) == 1395
76    assert (49509.2348100001 ^ 49509.2348100001) == 0
77    assert (9E120 ^ 1.2) == 9223372036854775806
78    assert (824E3 ^ 21.018763) == 824021
79    assert (NaN ^ 99854258.24) == 99854258
80    assert (-NaN ^ 30483040.293244) == 30483040
81    assert (Infinity ^ 1.2) == 9223372036854775806
82    assert (-Infinity ^ 10049329.80001) == -9223372036844726479
83
84    // Testing "left shift" operator:
85    assert (1E-100 << 0.0) == 0
86    assert (0.00003 << 12.13) == 0
87    assert (42.109 << 0.0120939) == 42
88    assert (1.409240940 << 17.3) == 131072
89    assert (4342435.309421 << 3.1) == 34739480
90    assert (9010034745.3449093132 << 7.000000000001) == 1153284447360
91    assert (-423.14981 << 20.32) == -443547648
92    assert (500.13 << 128.3440) == 500
93    assert (500.45 << 121.10000002) == -1729382256910270464
94    assert (NaN << 330.3911) == 0
95    assert (-NaN << 12.91213) == 0
96    assert (Infinity << 1.0092) == -2
97    assert (-Infinity << 1.0092) == 0
98    assert (-52242.2301 << -8.7) == -1297036692682702848
99    assert (52242.2301 << -8.7) == 1297036692682702848
100
101    // Testing "right shift" operator:
102    assert (1E-100 >> 0.0) == 0
103    assert (0.00003 >> 12.13) == 0
104    assert (42.109 >> 0.0120939) == 42
105    assert (1.409240940 >> 17.3) == 0
106    assert (4342435.309421 >> 3.1) == 542804
107    assert (9010034.3449093132 >> 3.000000000001) == 1126254
108    assert (-4599090490.24 >> 11) == -2245650
109    assert (500.13 >> 128.3440) == 500
110    assert (500.45 >> 121.10000002) == 0
111    assert (NaN >> 11.000003) == 0
112    assert (-NaN >> 7.912130001) == 0
113    assert (Infinity >> 61) == 3
114    assert (-Infinity >> 61) == -4
115    assert (132090941883.34343 >> -32.2) == 30
116    assert (-132090941883.34343 >> -32.2) == -31
117
118    // Testing "unsigned right shift" operator:
119    assert (1E-100 >>> 0.0) == 0
120    assert (0.00003 >>> 12.13) == 0
121    assert (42.109 >>> 0.0120939) == 42
122    assert (1.409240940 >>> 17.3) == 0
123    assert (4342435.309421 >>> 3.1) == 542804
124    assert (9010034.3449093132 >>> 3.000000000001) == 1126254
125    assert (-4599090490.24 >>> 11) == 9007199252495342
126    assert (500.13 >>> 128.3440) == 500
127    assert (500.45 >>> 121.10000002) == 0
128    assert (NaN >>> 11.000003) == 0
129    assert (-NaN >>> 7.912130001) == 0
130    assert (Infinity >>> 61.8) == 3
131    assert (-Infinity >>> 61.8) == 4
132    assert (132090941883.34343 >>> -32.2) == 30
133    assert (-132090941883.34343 >>> -32.2) == 4294967265
134
135    // Testing "bitwise complement" operator
136    assert ~0 == -1
137    assert ~0.000034 == -1
138    assert ~39530.93 == -39531
139    assert ~93718001.5424230894 == -93718002
140    assert ~Infinity == -9223372036854775808
141    assert ~-Infinity == 9223372036854775807
142    assert ~NaN == -1   
143    assert ~-NaN == -1
144    assert ~1E210 == -9223372036854775808
145    assert ~-1E210 ==  9223372036854775807
146    assert ~56E5 == -5600001
147    assert ~-56E5 == 5599999
148
149    /* ---- Run time tests ---- */
150
151    // Testing "and" operator:
152    assert And(542.910991, -1903.2040221) == 16
153    assert And(-542.910991, 1903.2040221) == 1378
154    assert And(-542.910991, -1903.2040221) == -1920
155    assert And(9E120, 56.75) == 56
156    assert And(0.0, 0.0) == 0
157    assert And(NaN, 42.131330352) == 0
158    assert And(-NaN, -23432.34110144432) == 0
159    assert And(Infinity, -94.24445985981884) == 9223372036854775714
160    assert And(-Infinity, 94.24445985981884) == 0
161
162    // Testing "or" operator: 
163    assert Or(542.910991, 1903.2040221) == 1919
164    assert Or(542.910991, -1903.2040221) == -1377
165    assert Or(-542.910991, 1903.2040221) == -17
166    assert Or(-542.910991, -1903.2040221) == -525
167    assert Or(9E120, 0) == 9223372036854775807
168    assert Or(824E3, 21.018763) == 824021
169    assert Or(1.0, 0.1) == 1
170    assert Or(NaN, 0.2) == 0
171    assert Or(-NaN, 0.3) == 0
172    assert Or(Infinity, 0.4) == 9223372036854775807
173    assert Or(-Infinity, 0.5) == -9223372036854775808
174
175    // Testing "xor" operator: 
176    assert Xor(542.910991, 1903.2040221) == 1393
177    assert Xor(542.910991, -1903.2040221) == -1393
178    assert Xor(-542.910991, 1903.2040221) == -1395
179    assert Xor(-542.910991, -1903.2040221) == 1395
180    assert Xor(49509.2348100001, 49509.2348100001) == 0
181    assert Xor(9E120, 1.2) == 9223372036854775806
182    assert Xor(824E3, 21.018763) == 824021
183    assert Xor(NaN, 99854258.24) == 99854258
184    assert Xor(-NaN, 30483040.293244) == 30483040
185    assert Xor(Infinity, 1.2) == 9223372036854775806
186    assert Xor(-Infinity, 10049329.80001) == -9223372036844726479
187
188    // Testing "left shift" operator:
189    assert LeftShift(1E-100, 0.0) == 0
190    assert LeftShift(0.00003, 12.13) == 0
191    assert LeftShift(42.109, 0.0120939) == 42
192    assert LeftShift(1.409240940, 17.3) == 131072
193    assert LeftShift(4342435.309421, 3.1) == 34739480
194    assert LeftShift(9010034745.3449093132, 7.000000000001) == 1153284447360
195    assert LeftShift(-423.14981, 20.32) == -443547648
196    assert LeftShift(500.13, 128.3440) == 500
197    assert LeftShift(500.45, 121.10000002) == -1729382256910270464
198    assert LeftShift(NaN, 330.3911) == 0
199    assert LeftShift(-NaN, 12.91213) == 0
200    assert LeftShift(Infinity, 1.0092) == -2
201    assert LeftShift(-Infinity, 1.0092) == 0
202    assert LeftShift(-52242.2301, -8.7) == -1297036692682702848
203    assert LeftShift(52242.2301,-8.7) == 1297036692682702848
204
205    // Testing "right shift" operator:
206    assert RightShift(1E-100, 0.0) == 0
207    assert RightShift(0.00003, 12.13) == 0
208    assert RightShift(42.109, 0.0120939) == 42
209    assert RightShift(1.409240940, 17.3) == 0
210    assert RightShift(4342435.309421, 3.1) == 542804
211    assert RightShift(9010034.3449093132, 3.000000000001) == 1126254
212    assert RightShift(-4599090490.24, 11) == -2245650
213    assert RightShift(500.13, 128.3440) == 500
214    assert RightShift(500.45, 121.10000002) == 0
215    assert RightShift(NaN, 11.000003) == 0
216    assert RightShift(-NaN, 7.912130001) == 0
217    assert RightShift(Infinity, 61) == 3
218    assert RightShift(-Infinity, 61) == -4
219    assert RightShift(132090941883.34343, -32.2) == 30
220    assert RightShift(-132090941883.34343, -32.2) == -31
221
222    // Testing "unsigned right shift" operator:
223    assert UnsignedRightShift(1E-100, 0.0) == 0
224    assert UnsignedRightShift(0.00003,12.13) == 0
225    assert UnsignedRightShift(42.109, 0.0120939) == 42
226    assert UnsignedRightShift(1.409240940, 17.3) == 0
227    assert UnsignedRightShift(4342435.309421, 3.1) == 542804
228    assert UnsignedRightShift(9010034.3449093132, 3.000000000001) == 1126254
229    assert UnsignedRightShift(-4599090490.24, 11) == 9007199252495342
230    assert UnsignedRightShift(500.13, 128.3440) == 500
231    assert UnsignedRightShift(500.45, 121.10000002) == 0
232    assert UnsignedRightShift(NaN, 11.000003) == 0
233    assert UnsignedRightShift(-NaN, 7.912130001) == 0
234    assert UnsignedRightShift(Infinity, 61.8) == 3
235    assert UnsignedRightShift(-Infinity, 61.8) == 4
236    assert UnsignedRightShift(132090941883.34343, -32.2) == 30
237    assert UnsignedRightShift(-132090941883.34343, -32.2) == 4294967265
238 
239    // Testing "bitwise complement" operator
240    assert Inversion(0) == -1
241    assert Inversion(0.000034) == -1
242    assert Inversion(39530.93) == -39531
243    assert Inversion(93718001.5424230894) == -93718002
244    assert Inversion(Infinity) == -9223372036854775808
245    assert Inversion(-Infinity) == 9223372036854775807
246    assert Inversion(NaN) == -1   
247    assert Inversion(-NaN) == -1
248    assert Inversion(1E210) == -9223372036854775808
249    assert Inversion(-1E210) ==  9223372036854775807
250    assert Inversion(56E5) == -5600001
251    assert Inversion(-56E5) == 5599999
252}
253