← Back to branch summary

~ubuntu-branches/ubuntu/saucy/libv8/saucy

« back to all changes in this revision

Viewing changes to test/mjsunit/math-pow.js

  • Committer: Package Import Robot
  • Author(s): Jérémy Lal
  • Date: 2012-04-07 16:26:13 UTC
  • mfrom: (15.1.27 sid)
  • Revision ID: package-import@ubuntu.com-20120407162613-dqo1m6w9r3fh8tst
Tags: 3.8.9.16-3
* mipsel build fixes :
  + v8_use_mips_abi_hardfloat=false, this lowers EABI requirements.
  + v8_can_use_fpu_instructions=false, detect if FPU is present.
  + set -Wno-unused-but-set-variable only on mipsel.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/mjsunit/math-pow.js
25
25
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26
26
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
27
 
 
28
// Flags: --allow-natives-syntax
28
29
// Tests the special cases specified by ES 15.8.2.13
29
30
 
30
 
// Simple sanity check
31
 
assertEquals(4, Math.pow(2, 2));
32
 
assertEquals(2147483648, Math.pow(2, 31));
33
 
assertEquals(0.25, Math.pow(2, -2));
34
 
assertEquals(0.0625, Math.pow(2, -4));
35
 
assertEquals(1, Math.pow(1, 100));
36
 
assertEquals(0, Math.pow(0, 1000));
37
 
 
38
 
// Spec tests
39
 
assertEquals(NaN, Math.pow(2, NaN));
40
 
assertEquals(NaN, Math.pow(+0, NaN));
41
 
assertEquals(NaN, Math.pow(-0, NaN));
42
 
assertEquals(NaN, Math.pow(Infinity, NaN));
43
 
assertEquals(NaN, Math.pow(-Infinity, NaN));
44
 
 
45
 
assertEquals(1, Math.pow(NaN, +0));
46
 
assertEquals(1, Math.pow(NaN, -0));
47
 
 
48
 
assertEquals(NaN, Math.pow(NaN, NaN));
49
 
assertEquals(NaN, Math.pow(NaN, 2.2));
50
 
assertEquals(NaN, Math.pow(NaN, 1));
51
 
assertEquals(NaN, Math.pow(NaN, -1));
52
 
assertEquals(NaN, Math.pow(NaN, -2.2));
53
 
assertEquals(NaN, Math.pow(NaN, Infinity));
54
 
assertEquals(NaN, Math.pow(NaN, -Infinity));
55
 
 
56
 
assertEquals(Infinity, Math.pow(1.1, Infinity));
57
 
assertEquals(Infinity, Math.pow(-1.1, Infinity));
58
 
assertEquals(Infinity, Math.pow(2, Infinity));
59
 
assertEquals(Infinity, Math.pow(-2, Infinity));
60
 
 
61
 
// Because +0 == -0, we need to compare 1/{+,-}0 to {+,-}Infinity
62
 
assertEquals(+Infinity, 1/Math.pow(1.1, -Infinity));
63
 
assertEquals(+Infinity, 1/Math.pow(-1.1, -Infinity));
64
 
assertEquals(+Infinity, 1/Math.pow(2, -Infinity));
65
 
assertEquals(+Infinity, 1/Math.pow(-2, -Infinity));
66
 
 
67
 
assertEquals(NaN, Math.pow(1, Infinity));
68
 
assertEquals(NaN, Math.pow(1, -Infinity));
69
 
assertEquals(NaN, Math.pow(-1, Infinity));
70
 
assertEquals(NaN, Math.pow(-1, -Infinity));
71
 
 
72
 
assertEquals(+0, Math.pow(0.1, Infinity));
73
 
assertEquals(+0, Math.pow(-0.1, Infinity));
74
 
assertEquals(+0, Math.pow(0.999, Infinity));
75
 
assertEquals(+0, Math.pow(-0.999, Infinity));
76
 
 
77
 
assertEquals(Infinity, Math.pow(0.1, -Infinity));
78
 
assertEquals(Infinity, Math.pow(-0.1, -Infinity));
79
 
assertEquals(Infinity, Math.pow(0.999, -Infinity));
80
 
assertEquals(Infinity, Math.pow(-0.999, -Infinity));
81
 
 
82
 
assertEquals(Infinity, Math.pow(Infinity, 0.1));
83
 
assertEquals(Infinity, Math.pow(Infinity, 2));
84
 
 
85
 
assertEquals(+Infinity, 1/Math.pow(Infinity, -0.1));
86
 
assertEquals(+Infinity, 1/Math.pow(Infinity, -2));
87
 
 
88
 
assertEquals(-Infinity, Math.pow(-Infinity, 3));
89
 
assertEquals(-Infinity, Math.pow(-Infinity, 13));
90
 
 
91
 
assertEquals(Infinity, Math.pow(-Infinity, 3.1));
92
 
assertEquals(Infinity, Math.pow(-Infinity, 2));
93
 
 
94
 
assertEquals(-Infinity, 1/Math.pow(-Infinity, -3));
95
 
assertEquals(-Infinity, 1/Math.pow(-Infinity, -13));
96
 
 
97
 
assertEquals(+Infinity, 1/Math.pow(-Infinity, -3.1));
98
 
assertEquals(+Infinity, 1/Math.pow(-Infinity, -2));
99
 
 
100
 
assertEquals(+Infinity, 1/Math.pow(+0, 1.1));
101
 
assertEquals(+Infinity, 1/Math.pow(+0, 2));
102
 
 
103
 
assertEquals(Infinity, Math.pow(+0, -1.1));
104
 
assertEquals(Infinity, Math.pow(+0, -2));
105
 
 
106
 
assertEquals(-Infinity, 1/Math.pow(-0, 3));
107
 
assertEquals(-Infinity, 1/Math.pow(-0, 13));
108
 
 
109
 
assertEquals(+Infinity, 1/Math.pow(-0, 3.1));
110
 
assertEquals(+Infinity, 1/Math.pow(-0, 2));
111
 
 
112
 
assertEquals(-Infinity, Math.pow(-0, -3));
113
 
assertEquals(-Infinity, Math.pow(-0, -13));
114
 
 
115
 
assertEquals(Infinity, Math.pow(-0, -3.1));
116
 
assertEquals(Infinity, Math.pow(-0, -2));
117
 
 
118
 
assertEquals(NaN, Math.pow(-0.00001, 1.1));
119
 
assertEquals(NaN, Math.pow(-0.00001, -1.1));
120
 
assertEquals(NaN, Math.pow(-1.1, 1.1));
121
 
assertEquals(NaN, Math.pow(-1.1, -1.1));
122
 
assertEquals(NaN, Math.pow(-2, 1.1));
123
 
assertEquals(NaN, Math.pow(-2, -1.1));
124
 
assertEquals(NaN, Math.pow(-1000, 1.1));
125
 
assertEquals(NaN, Math.pow(-1000, -1.1));
126
 
 
127
 
assertEquals(+Infinity, 1/Math.pow(-0, 0.5));
128
 
assertEquals(+Infinity, 1/Math.pow(-0, 0.6));
129
 
assertEquals(-Infinity, 1/Math.pow(-0, 1));
130
 
assertEquals(-Infinity, 1/Math.pow(-0, 10000000001));
131
 
 
132
 
assertEquals(+Infinity, Math.pow(-0, -0.5));
133
 
assertEquals(+Infinity, Math.pow(-0, -0.6));
134
 
assertEquals(-Infinity, Math.pow(-0, -1));
135
 
assertEquals(-Infinity, Math.pow(-0, -10000000001));
136
 
 
137
 
 
138
 
 
139
 
// Tests from Sputnik S8.5_A13_T1.
140
 
assertTrue((1*((Math.pow(2,53))-1)*(Math.pow(2,-1074))) === 4.4501477170144023e-308);
141
 
assertTrue((1*(Math.pow(2,52))*(Math.pow(2,-1074))) === 2.2250738585072014e-308);
142
 
assertTrue((-1*(Math.pow(2,52))*(Math.pow(2,-1074))) === -2.2250738585072014e-308);
 
31
function test() {
 
32
  // Simple sanity check
 
33
  assertEquals(4, Math.pow(2, 2));
 
34
  assertEquals(2147483648, Math.pow(2, 31));
 
35
  assertEquals(0.25, Math.pow(2, -2));
 
36
  assertEquals(0.0625, Math.pow(2, -4));
 
37
  assertEquals(1, Math.pow(1, 100));
 
38
  assertEquals(0, Math.pow(0, 1000));
 
39
 
 
40
  // Spec tests
 
41
  assertEquals(NaN, Math.pow(2, NaN));
 
42
  assertEquals(NaN, Math.pow(+0, NaN));
 
43
  assertEquals(NaN, Math.pow(-0, NaN));
 
44
  assertEquals(NaN, Math.pow(Infinity, NaN));
 
45
  assertEquals(NaN, Math.pow(-Infinity, NaN));
 
46
 
 
47
  assertEquals(1, Math.pow(NaN, +0));
 
48
  assertEquals(1, Math.pow(NaN, -0));
 
49
 
 
50
  assertEquals(NaN, Math.pow(NaN, NaN));
 
51
  assertEquals(NaN, Math.pow(NaN, 2.2));
 
52
  assertEquals(NaN, Math.pow(NaN, 1));
 
53
  assertEquals(NaN, Math.pow(NaN, -1));
 
54
  assertEquals(NaN, Math.pow(NaN, -2.2));
 
55
  assertEquals(NaN, Math.pow(NaN, Infinity));
 
56
  assertEquals(NaN, Math.pow(NaN, -Infinity));
 
57
 
 
58
  assertEquals(Infinity, Math.pow(1.1, Infinity));
 
59
  assertEquals(Infinity, Math.pow(-1.1, Infinity));
 
60
  assertEquals(Infinity, Math.pow(2, Infinity));
 
61
  assertEquals(Infinity, Math.pow(-2, Infinity));
 
62
 
 
63
  // Because +0 == -0, we need to compare 1/{+,-}0 to {+,-}Infinity
 
64
  assertEquals(+Infinity, 1/Math.pow(1.1, -Infinity));
 
65
  assertEquals(+Infinity, 1/Math.pow(-1.1, -Infinity));
 
66
  assertEquals(+Infinity, 1/Math.pow(2, -Infinity));
 
67
  assertEquals(+Infinity, 1/Math.pow(-2, -Infinity));
 
68
 
 
69
  assertEquals(NaN, Math.pow(1, Infinity));
 
70
  assertEquals(NaN, Math.pow(1, -Infinity));
 
71
  assertEquals(NaN, Math.pow(-1, Infinity));
 
72
  assertEquals(NaN, Math.pow(-1, -Infinity));
 
73
 
 
74
  assertEquals(+0, Math.pow(0.1, Infinity));
 
75
  assertEquals(+0, Math.pow(-0.1, Infinity));
 
76
  assertEquals(+0, Math.pow(0.999, Infinity));
 
77
  assertEquals(+0, Math.pow(-0.999, Infinity));
 
78
 
 
79
  assertEquals(Infinity, Math.pow(0.1, -Infinity));
 
80
  assertEquals(Infinity, Math.pow(-0.1, -Infinity));
 
81
  assertEquals(Infinity, Math.pow(0.999, -Infinity));
 
82
  assertEquals(Infinity, Math.pow(-0.999, -Infinity));
 
83
 
 
84
  assertEquals(Infinity, Math.pow(Infinity, 0.1));
 
85
  assertEquals(Infinity, Math.pow(Infinity, 2));
 
86
 
 
87
  assertEquals(+Infinity, 1/Math.pow(Infinity, -0.1));
 
88
  assertEquals(+Infinity, 1/Math.pow(Infinity, -2));
 
89
 
 
90
  assertEquals(-Infinity, Math.pow(-Infinity, 3));
 
91
  assertEquals(-Infinity, Math.pow(-Infinity, 13));
 
92
 
 
93
  assertEquals(Infinity, Math.pow(-Infinity, 3.1));
 
94
  assertEquals(Infinity, Math.pow(-Infinity, 2));
 
95
 
 
96
  assertEquals(-Infinity, 1/Math.pow(-Infinity, -3));
 
97
  assertEquals(-Infinity, 1/Math.pow(-Infinity, -13));
 
98
 
 
99
  assertEquals(+Infinity, 1/Math.pow(-Infinity, -3.1));
 
100
  assertEquals(+Infinity, 1/Math.pow(-Infinity, -2));
 
101
 
 
102
  assertEquals(+Infinity, 1/Math.pow(+0, 1.1));
 
103
  assertEquals(+Infinity, 1/Math.pow(+0, 2));
 
104
 
 
105
  assertEquals(Infinity, Math.pow(+0, -1.1));
 
106
  assertEquals(Infinity, Math.pow(+0, -2));
 
107
 
 
108
  assertEquals(-Infinity, 1/Math.pow(-0, 3));
 
109
  assertEquals(-Infinity, 1/Math.pow(-0, 13));
 
110
 
 
111
  assertEquals(+Infinity, 1/Math.pow(-0, 3.1));
 
112
  assertEquals(+Infinity, 1/Math.pow(-0, 2));
 
113
 
 
114
  assertEquals(-Infinity, Math.pow(-0, -3));
 
115
  assertEquals(-Infinity, Math.pow(-0, -13));
 
116
 
 
117
  assertEquals(Infinity, Math.pow(-0, -3.1));
 
118
  assertEquals(Infinity, Math.pow(-0, -2));
 
119
 
 
120
  assertEquals(NaN, Math.pow(-0.00001, 1.1));
 
121
  assertEquals(NaN, Math.pow(-0.00001, -1.1));
 
122
  assertEquals(NaN, Math.pow(-1.1, 1.1));
 
123
  assertEquals(NaN, Math.pow(-1.1, -1.1));
 
124
  assertEquals(NaN, Math.pow(-2, 1.1));
 
125
  assertEquals(NaN, Math.pow(-2, -1.1));
 
126
  assertEquals(NaN, Math.pow(-1000, 1.1));
 
127
  assertEquals(NaN, Math.pow(-1000, -1.1));
 
128
 
 
129
  assertEquals(+Infinity, 1/Math.pow(-0, 0.5));
 
130
  assertEquals(+Infinity, 1/Math.pow(-0, 0.6));
 
131
  assertEquals(-Infinity, 1/Math.pow(-0, 1));
 
132
  assertEquals(-Infinity, 1/Math.pow(-0, 10000000001));
 
133
 
 
134
  assertEquals(+Infinity, Math.pow(-0, -0.5));
 
135
  assertEquals(+Infinity, Math.pow(-0, -0.6));
 
136
  assertEquals(-Infinity, Math.pow(-0, -1));
 
137
  assertEquals(-Infinity, Math.pow(-0, -10000000001));
 
138
 
 
139
  assertEquals(4, Math.pow(16, 0.5));
 
140
  assertEquals(NaN, Math.pow(-16, 0.5));
 
141
  assertEquals(0.25, Math.pow(16, -0.5));
 
142
  assertEquals(NaN, Math.pow(-16, -0.5));
 
143
 
 
144
  // Test detecting and converting integer value as double.
 
145
  assertEquals(8, Math.pow(2, Math.sqrt(9)));
 
146
 
 
147
  // Tests from Mozilla 15.8.2.13.
 
148
  assertEquals(2, Math.pow.length);
 
149
  assertEquals(NaN, Math.pow());
 
150
  assertEquals(1, Math.pow(null, null));
 
151
  assertEquals(NaN, Math.pow(void 0, void 0));
 
152
  assertEquals(1, Math.pow(true, false));
 
153
  assertEquals(0, Math.pow(false, true));
 
154
  assertEquals(Infinity, Math.pow(-Infinity, Infinity));
 
155
  assertEquals(0, Math.pow(-Infinity, -Infinity));
 
156
  assertEquals(1, Math.pow(0, 0));
 
157
  assertEquals(0, Math.pow(0, Infinity));
 
158
  assertEquals(NaN, Math.pow(NaN, 0.5));
 
159
  assertEquals(NaN, Math.pow(NaN, -0.5));
 
160
 
 
161
  // Tests from Sputnik S8.5_A13_T1.
 
162
  assertTrue(
 
163
      (1*((Math.pow(2,53))-1)*(Math.pow(2,-1074))) === 4.4501477170144023e-308);
 
164
  assertTrue(
 
165
      (1*(Math.pow(2,52))*(Math.pow(2,-1074))) === 2.2250738585072014e-308);
 
166
  assertTrue(
 
167
      (-1*(Math.pow(2,52))*(Math.pow(2,-1074))) === -2.2250738585072014e-308);
 
168
}
 
169
 
 
170
test();
 
171
test();
 
172
%OptimizeFunctionOnNextCall(test);
 
173
test();
 
 
b'\\ No newline at end of file'