DoubleTest.java revision 8e06d7bdd50edba2b2af3ede7515c5145c2d49e2 
1/* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements.  See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License.  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
17package org.apache.harmony.tests.java.lang;
18
19import java.util.Locale;
20
21import junit.framework.TestCase;
22
23public class DoubleTest extends TestCase {
24    private static final long rawBitsFor3_4en324ToN1[] = { 0x1L, 0x7L, 0x45L, 0x2b0L, 0x1ae2L,
25            0x10cd1L, 0xa8028L, 0x69018dL, 0x41a0f7eL, 0x29049aedL, 0x19a2e0d44L,
26            0x1005cc84acL, 0xa039fd2ebdL, 0x64243e3d361L, 0x3e96a6e641c6L, 0x271e284fe91b8L,
27            0x1872d931f1b131L, 0x4e8f8f7e6e1d7dL, 0x8319b9af04d26eL, 0xb7e0281ac6070aL,
28            0xedd832217788ccL, 0x122a71f54eab580L, 0x15750e72a2562e0L, 0x18d2520f4aebb98L,
29            0x1c2373498ed353fL, 0x1f6c501bf28828eL, 0x22c76422ef2a332L, 0x261c9e95d57a5ffL,
30            0x2963c63b4ad8f7fL, 0x2cbcb7ca1d8f35fL, 0x3015f2de527981bL, 0x335b6f95e717e22L,
31            0x36b24b7b60dddabL, 0x3a0f6f2d1c8aa8bL, 0x3d534af863ad52dL, 0x40a81db67c98a79L,
32            0x440912920ddf68bL, 0x474b5736915742eL, 0x4a9e2d0435ad13aL, 0x4e02dc22a18c2c4L,
33            0x5143932b49ef375L, 0x549477f61c6b052L, 0x57f995f3a385c67L, 0x5b3bfdb846339c0L,
34            0x5e8afd2657c0830L, 0x61edbc6fedb0a3dL, 0x653495c5f48e666L, 0x6881bb3771b1fffL,
35            0x6be22a054e1e7ffL, 0x6f2d5a4350d30ffL, 0x7278b0d42507d3fL, 0x75d6dd092e49c8fL,
36            0x79264a25bcee1daL, 0x7c6fdcaf2c29a50L, 0x7fcbd3daf7340e4L, 0x831f6468da8088eL,
37            0x86673d831120ab2L, 0x89c10ce3d568d5fL, 0x8d18a80e656185bL, 0x905ed211feb9e72L,
38            0x93b686967e6860eL, 0x9712141e0f013c9L, 0x9a56992592c18bbL, 0x9dac3f6ef771eeaL,
39            0xa10ba7a55aa7352L, 0xa44e918eb151027L, 0xa7a235f25da5430L, 0xab0561b77a8749eL,
40            0xae46ba2559291c6L, 0xb19868aeaf73637L, 0xb4fe82da5b503c5L, 0xb83f11c8791225bL,
41            0xbb8ed63a9756af2L, 0xbef28bc93d2c5afL, 0xc237975dc63bb8dL, 0xc5857d3537caa70L,
42            0xc8e6dc8285bd50cL, 0xcc3049d19396528L, 0xcf7c5c45f87be72L, 0xd2db7357769ae0eL,
43            0xd6292816aa20cc9L, 0xd973721c54a8ffbL, 0xdcd04ea369d33faL, 0xe0223126222407cL,
44            0xe36abd6faaad09bL, 0xe6c56ccb95584c2L, 0xea1b63ff3d572f9L, 0xed623cff0cacfb8L,
45            0xf0bacc3ecfd83a5L, 0xf414bfa741e7247L, 0xf759ef911260ed9L, 0xfab06b7556f9290L,
46            0xfe0e4329565bb9aL, 0x10151d3f3abf2a80L, 0x104a648f096ef520L, 0x10807ed965e55934L,
47            0x10b49e8fbf5eaf81L, 0x10e9c633af365b61L, 0x11201be04d81f91dL, 0x115422d860e27764L,
48            0x11892b8e791b153dL, 0x11bf76721761da8cL, 0x11f3aa074e9d2898L, 0x12289489224472beL,
49            0x125eb9ab6ad58f6dL, 0x1293340b22c579a4L, 0x12c8010deb76d80dL, 0x12fe015166548e11L,
50            0x1332c0d2dff4d8caL, 0x1367710797f20efdL, 0x139d4d497dee92bcL, 0x13d2504deeb51bb6L,
51            0x1406e4616a6262a3L, 0x143c9d79c4fafb4cL, 0x1471e26c1b1cdd0fL, 0x14a65b0721e41453L,
52            0x14dbf1c8ea5d1968L, 0x1511771d927a2fe1L, 0x1545d4e4f718bbd9L, 0x157b4a1e34deead0L,
53            0x15b10e52e10b52c2L, 0x15e551e7994e2772L, 0x161aa6617fa1b14fL, 0x1650a7fcefc50ed1L,
54            0x1684d1fc2bb65286L, 0x16ba067b36a3e727L, 0x16f0440d02267078L, 0x1724551042b00c96L,
55            0x17596a54535c0fbcL, 0x178fc4e9683313abL, 0x17c3db11e11fec4bL, 0x17f8d1d65967e75eL,
56            0x182f064befc1e135L, 0x186363ef75d92cc1L, 0x18983ceb534f77f1L, 0x18ce4c26282355eeL,
57            0x1902ef97d91615b5L, 0x1937ab7dcf5b9b22L, 0x196d965d433281eaL, 0x19a27dfa49ff9132L,
58            0x19d71d78dc7f757fL, 0x1a0ce4d7139f52dfL, 0x1a420f066c4393cbL, 0x1a7692c8075478beL,
59            0x1aac377a092996edL, 0x1ae1a2ac45b9fe54L, 0x1b160b5757287de9L, 0x1b4b8e2d2cf29d64L,
60            0x1b8138dc3c17a25eL, 0x1bb587134b1d8af6L, 0x1beae8d81de4edb4L, 0x1c20d18712af1490L,
61            0x1c5505e8d75ad9b4L, 0x1c8a47630d319021L, 0x1cc06c9de83efa15L, 0x1cf487c5624eb89aL,
62            0x1d29a9b6bae266c1L, 0x1d600a1234cd8038L, 0x1d940c96c200e046L, 0x1dc90fbc72811858L,
63            0x1dff53ab8f215e6eL, 0x1e33944b3974db05L, 0x1e68795e07d211c6L, 0x1e9e97b589c69637L,
64            0x1ed31ed1761c1de3L, 0x1f07e685d3a3255bL, 0x1f3de027488beeb2L, 0x1f72ac188d57752fL,
65            0x1fa7571eb0ad527bL, 0x1fdd2ce65cd8a71aL, 0x20123c0ffa076870L, 0x2046cb13f889428cL,
66            0x207c7dd8f6ab932fL, 0x20b1cea79a2b3bfeL, 0x20e6425180b60afdL, 0x211bd2e5e0e38dbcL,
67            0x215163cfac8e3896L, 0x2185bcc397b1c6bbL, 0x21bb2bf47d9e386aL, 0x21f0fb78ce82e342L,
68            0x22253a5702239c13L, 0x225a88ecc2ac8317L, 0x22909593f9abd1efL, 0x22c4baf8f816c66aL,
69            0x22f9e9b7361c7805L, 0x2330321281d1cb03L, 0x23643e9722463dc4L, 0x23994e3cead7cd35L,
70            0x23cfa1cc258dc082L, 0x2403c51f97789851L, 0x2438b6677d56be65L, 0x246ee4015cac6dffL,
71            0x24a34e80d9ebc4bfL, 0x24d822211066b5efL, 0x250e2aa95480636bL, 0x2542daa9d4d03e23L,
72            0x257791544a044dabL, 0x25ad75a95c856116L, 0x25e26989d9d35caeL, 0x261703ec504833d9L,
73            0x264cc4e7645a40d0L, 0x2681fb109eb86882L, 0x26b679d4c66682a2L, 0x26ec1849f800234bL,
74            0x27218f2e3b00160fL, 0x2755f2f9c9c01b93L, 0x278b6fb83c302277L, 0x27c125d3259e158bL,
75            0x27f56f47ef059aedL, 0x282acb19eac701a8L, 0x2860bef032bc6109L, 0x2894eeac3f6b794cL,
76            0x28ca2a574f46579eL, 0x29005a76918bf6c3L, 0x2934711435eef474L, 0x29698d59436ab191L,
77            0x299ff0af94455df5L, 0x29d3f66dbcab5ab9L, 0x2a08f4092bd63167L, 0x2a3f310b76cbbdc1L,
78            0x2a737ea72a3f5699L, 0x2aa85e50f4cf2c3fL, 0x2ade75e53202f74fL, 0x2b1309af3f41da91L,
79            0x2b47cc1b0f125135L, 0x2b7dbf21d2d6e583L, 0x2bb2977523c64f72L, 0x2be73d526cb7e34eL,
80            0x2c1d0ca707e5dc22L, 0x2c5227e864efa995L, 0x2c86b1e27e2b93faL, 0x2cbc5e5b1db678f9L,
81            0x2cf1baf8f2920b9cL, 0x2d2629b72f368e83L, 0x2d5bb424fb043223L, 0x2d9150971ce29f56L,
82            0x2dc5a4bce41b472bL, 0x2dfb0dec1d2218f6L, 0x2e30e8b392354f9aL, 0x2e6522e076c2a380L,
83            0x2e9a6b9894734c61L, 0x2ed0833f5cc80fbcL, 0x2f04a40f33fa13abL, 0x2f39cd1300f89896L,
84            0x2f70202be09b5f5eL, 0x2fa42836d8c23735L, 0x2fd932448ef2c503L, 0x300f7ed5b2af7643L,
85            0x3043af458fada9eaL, 0x30789b16f3991465L, 0x30aec1dcb07f597eL, 0x30e33929ee4f97efL,
86            0x3118077469e37deaL, 0x314e0951845c5d65L, 0x3182c5d2f2b9ba5fL, 0x31b77747af6828f7L,
87            0x31ed55199b423335L, 0x3222553001096001L, 0x3256ea7c014bb801L, 0x328ca51b019ea601L,
88            0x32c1e730e10327c1L, 0x32f660fd1943f1b1L, 0x332bf93c5f94ee1dL, 0x33617bc5bbbd14d2L,
89            0x3395dab72aac5a07L, 0x33cb5164f5577089L, 0x340112df1956a655L, 0x34355796dfac4febL,
90            0x346aad7c979763e5L, 0x34a0ac6ddebe9e6fL, 0x34d4d789566e460bL, 0x350a0d6bac09d78eL,
91            0x354048634b8626b9L, 0x35745a7c1e67b067L, 0x35a9711b26019c81L, 0x35dfcd61ef8203a1L,
92            0x3613e05d35b14245L, 0x3648d874831d92d6L, 0x367f0e91a3e4f78bL, 0x36b3691b066f1ab7L,
93            0x36e84361c80ae165L, 0x371e543a3a0d99beL, 0x3752f4a464488017L, 0x3787b1cd7d5aa01cL,
94            0x37bd9e40dcb14823L, 0x37f282e889eecd16L, 0x382723a2ac6a805cL, 0x385cec8b57852073L,
95            0x389213d716b33448L, 0x38c698ccdc60015aL, 0x38fc3f00137801b0L, 0x3931a7600c2b010eL,
96            0x396611380f35c151L, 0x399b9586130331a6L, 0x39d13d73cbe1ff08L, 0x3a058cd0beda7ec9L,
97            0x3a3af004ee911e7cL, 0x3a70d603151ab30dL, 0x3aa50b83da615fd1L, 0x3ada4e64d0f9b7c5L,
98            0x3b1070ff029c12dbL, 0x3b448d3ec3431792L, 0x3b79b08e7413dd76L, 0x3bb00e59088c6a6aL,
99            0x3be411ef4aaf8504L, 0x3c19166b1d5b6646L, 0x3c4f5c05e4b23fd7L, 0x3c839983aeef67e6L,
100            0x3cb87fe49aab41e0L, 0x3cee9fddc1561258L, 0x3d2323ea98d5cb77L, 0x3d57ece53f0b3e55L,
101            0x3d8de81e8ece0deaL, 0x3dc2b1131940c8b2L, 0x3df75d57df90fadfL, 0x3e2d34add7753996L,
102            0x3e6240eca6a943feL, 0x3e96d127d05394fdL, 0x3ecc8571c4687a3dL, 0x3f01d3671ac14c66L,
103            0x3f364840e1719f80L, 0x3f6bda5119ce075fL, 0x3fa16872b020c49cL, 0x3fd5c28f5c28f5c3L,
104            0x400B333333333333L };
105
106    private static final long rawBitsFor1_2e0To309[] = { 0x3ff3333333333333L, 0x4028000000000000L,
107            0x405e000000000000L, 0x4092c00000000000L, 0x40c7700000000000L, 0x40fd4c0000000000L,
108            0x41324f8000000000L, 0x4166e36000000000L, 0x419c9c3800000000L, 0x41d1e1a300000000L,
109            0x42065a0bc0000000L, 0x423bf08eb0000000L, 0x427176592e000000L, 0x42a5d3ef79800000L,
110            0x42db48eb57e00000L, 0x43110d9316ec0000L, 0x434550f7dca70000L, 0x437aa535d3d0c000L,
111            0x43b0a741a4627800L, 0x43e4d1120d7b1600L, 0x441a055690d9db80L, 0x445043561a882930L,
112            0x4484542ba12a337cL, 0x44b969368974c05bL, 0x44efc3842bd1f072L, 0x4523da329b633647L,
113            0x4558d0bf423c03d9L, 0x458f04ef12cb04cfL, 0x45c363156bbee301L, 0x45f83bdac6ae9bc2L,
114            0x462e4ad1785a42b2L, 0x4662eec2eb3869afL, 0x4697aa73a606841bL, 0x46cd95108f882522L,
115            0x47027d2a59b51735L, 0x47371c74f0225d03L, 0x476ce3922c2af443L, 0x47a20e3b5b9ad8aaL,
116            0x47d691ca32818ed5L, 0x480c363cbf21f28aL, 0x4841a1e5f7753796L, 0x48760a5f7552857cL,
117            0x48ab8cf752a726daL, 0x48e1381a93a87849L, 0x491586213892965bL, 0x494ae7a986b73bf1L,
118            0x4980d0c9f4328577L, 0x49b504fc713f26d5L, 0x49ea463b8d8ef08aL, 0x4a206be538795656L,
119            0x4a5486de8697abecL, 0x4a89a896283d96e6L, 0x4ac0095dd9267e50L, 0x4af40bb54f701de4L,
120            0x4b290ea2a34c255dL, 0x4b5f524b4c1f2eb4L, 0x4b93936f0f937d31L, 0x4bc8784ad3785c7dL,
121            0x4bfe965d8856739cL, 0x4c331dfa75360842L, 0x4c67e57912838a52L, 0x4c9dded757246ce6L,
122            0x4cd2ab469676c410L, 0x4d0756183c147514L, 0x4d3d2b9e4b199259L, 0x4d723b42eeeffb78L,
123            0x4da6ca13aaabfa56L, 0x4ddc7c989556f8ebL, 0x4e11cddf5d565b93L, 0x4e46415734abf278L,
124            0x4e7bd1ad01d6ef15L, 0x4eb1630c2126556dL, 0x4ee5bbcf296feac9L, 0x4f1b2ac2f3cbe57bL,
125            0x4f50fab9d85f6f6dL, 0x4f8539684e774b48L, 0x4fba87c262151e1aL, 0x4ff094d97d4d32d0L,
126            0x5024ba0fdca07f84L, 0x5059e893d3c89f65L, 0x5090315c645d639fL, 0x50c43db37d74bc87L,
127            0x50f94d205cd1eba9L, 0x512fa06874066693L, 0x5163c4414884001cL, 0x5198b5519aa50023L,
128            0x51cee2a6014e402cL, 0x52034da7c0d0e81bL, 0x52382111b1052222L, 0x526e29561d466aabL,
129            0x52a2d9d5d24c02abL, 0x52d7904b46df0355L, 0x530d745e1896c42bL, 0x534268bacf5e3a9bL,
130            0x537702e98335c941L, 0x53acc3a3e4033b92L, 0x53e1fa466e82053bL, 0x541678d80a22868aL,
131            0x544c170e0cab282cL, 0x54818e68c7eaf91cL, 0x54b5f202f9e5b763L, 0x54eb6e83b85f253bL,
132            0x55212512533b7745L, 0x55556e56e80a5516L, 0x558ac9eca20cea5cL, 0x55c0be33e5481279L,
133            0x55f4edc0de9a1718L, 0x562a293116409cdeL, 0x566059beade8620bL, 0x5694702e59627a8dL,
134            0x56c98c39efbb1931L, 0x56ffef486ba9df7dL, 0x5733f58d434a2baeL, 0x5768f2f0941cb699L,
135            0x579f2facb923e440L, 0x57d37dcbf3b66ea8L, 0x58085d3ef0a40a52L, 0x583e748eaccd0ce6L,
136            0x587308d92c002810L, 0x58a7cb0f77003214L, 0x58ddbdd354c03e99L, 0x591296a414f82720L,
137            0x59473c4d1a3630e8L, 0x597d0b6060c3bd21L, 0x59b2271c3c7a5635L, 0x59e6b0e34b98ebc2L,
138            0x5a1c5d1c1e7f26b3L, 0x5a51ba31930f7830L, 0x5a8628bdf7d3563cL, 0x5abbb2ed75c82bcaL,
139            0x5af14fd4699d1b5fL, 0x5b25a3c984046236L, 0x5b5b0cbbe5057ac4L, 0x5b90e7f56f236cbaL,
140            0x5bc521f2caec47e9L, 0x5bfa6a6f7da759e3L, 0x5c308285ae88982eL, 0x5c64a3271a2abe39L,
141            0x5c99cbf0e0b56dc8L, 0x5cd01f768c71649dL, 0x5d0427542f8dbdc4L, 0x5d3931293b712d35L,
142            0x5d6f7d738a4d7882L, 0x5da3ae6836706b51L, 0x5dd89a02440c8626L, 0x5e0ec082d50fa7afL,
143            0x5e433851c529c8ceL, 0x5e78066636743b01L, 0x5eae07ffc41149c1L, 0x5ee2c4ffda8ace19L,
144            0x5f17763fd12d819fL, 0x5f4d53cfc578e207L, 0x5f825461db6b8d44L, 0x5fb6e97a52467095L,
145            0x5feca3d8e6d80cbbL, 0x6021e667904707f5L, 0x605660017458c9f2L, 0x608bf801d16efc6eL,
146            0x60c17b0122e55dc5L, 0x60f5d9c16b9eb536L, 0x612b5031c6866284L, 0x6161121f1c13fd92L,
147            0x619556a6e318fcf7L, 0x61caac509bdf3c34L, 0x6200abb2616b85a1L, 0x6234d69ef9c66709L,
148            0x626a0c46b83800cbL, 0x62a047ac3323007fL, 0x62d459973febc09fL, 0x63096ffd0fe6b0c6L,
149            0x633fcbfc53e05cf8L, 0x6373df7db46c3a1bL, 0x63a8d75d218748a2L, 0x63df0d3469e91acaL,
150            0x64136840c231b0beL, 0x64484250f2be1ceeL, 0x647e52e52f6da42aL, 0x64b2f3cf3da4869aL,
151            0x64e7b0c30d0da840L, 0x651d9cf3d0511251L, 0x655282186232ab72L, 0x6587229e7abf564fL,
152            0x65bceb46196f2be3L, 0x65f2130bcfe57b6eL, 0x662697cec3deda49L, 0x665c3dc274d690dbL,
153            0x6691a69989061a89L, 0x66c6103feb47a12bL, 0x66fb944fe6198976L, 0x67313cb1efcff5eaL,
154            0x67658bde6bc3f364L, 0x679aeed606b4f03dL, 0x67d0d545c4311626L, 0x68050a97353d5bb0L,
155            0x683a4d3d028cb29cL, 0x687070462197efa2L, 0x68a48c57a9fdeb8aL, 0x68d9af6d947d666cL,
156            0x69100da47cce6004L, 0x6944110d9c01f805L, 0x6979155103027606L, 0x69af5aa543c31387L,
157            0x69e398a74a59ec35L, 0x6a187ed11cf06742L, 0x6a4e9e85642c8112L, 0x6a8323135e9bd0abL,
158            0x6ab7ebd83642c4d6L, 0x6aede6ce43d3760cL, 0x6b22b040ea6429c7L, 0x6b575c5124fd3439L,
159            0x6b8d33656e3c8147L, 0x6bc2401f64e5d0cdL, 0x6bf6d0273e1f4500L, 0x6c2c84310da71640L,
160            0x6c61d29ea8886de8L, 0x6c96474652aa8962L, 0x6ccbd917e7552bbaL, 0x6d0167aef0953b54L,
161            0x6d35c19aacba8a29L, 0x6d6b320157e92cb4L, 0x6da0ff40d6f1bbf0L, 0x6dd53f110cae2aedL,
162            0x6e0a8ed54fd9b5a8L, 0x6e40994551e81189L, 0x6e74bf96a66215ebL, 0x6ea9ef7c4ffa9b66L,
163            0x6ee035adb1fca120L, 0x6f1443191e7bc967L, 0x6f4953df661abbc1L, 0x6f7fa8d73fa16ab2L,
164            0x6fb3c98687c4e2afL, 0x6fe8bbe829b61b5bL, 0x701eeae23423a232L, 0x705352cd6096455fL,
165            0x70882780b8bbd6b7L, 0x70be3160e6eacc64L, 0x70f2dedc9052bfbfL, 0x71279693b4676faeL,
166            0x715d7c38a1814b9aL, 0x71926da364f0cf40L, 0x71c7090c3e2d0310L, 0x71fccb4f4db843d4L,
167            0x7231ff1190932a65L, 0x72667ed5f4b7f4feL, 0x729c1e8b71e5f23dL, 0x72d19317272fb766L,
168            0x7305f7dcf0fba540L, 0x733b75d42d3a8e90L, 0x737129a49c44991aL, 0x73a5740dc355bf60L,
169            0x73dad111342b2f39L, 0x7410c2aac09afd83L, 0x7444f35570c1bce4L, 0x747a302accf22c1dL,
170            0x74b05e1ac0175b92L, 0x74e475a1701d3277L, 0x75199309cc247f15L, 0x754ff7cc3f2d9edaL,
171            0x7583fadfa77c8348L, 0x75b8f997915ba41aL, 0x75ef37fd75b28d21L, 0x762382fe698f9834L,
172            0x765863be03f37e41L, 0x768e7cad84f05dd2L, 0x76c30dec73163aa3L, 0x76f7d1678fdbc94cL,
173            0x772dc5c173d2bb9fL, 0x77629b98e863b543L, 0x7797427f227ca294L, 0x77cd131eeb1bcb39L,
174            0x78022bf352f15f04L, 0x7836b6f027adb6c5L, 0x786c64ac31992476L, 0x78a1beeb9effb6caL,
175            0x78d62ea686bfa47cL, 0x790bba50286f8d9bL, 0x794154721945b881L, 0x7975a98e9f9726a1L,
176            0x79ab13f2477cf049L, 0x79e0ec776cae162eL, 0x7a15279547d99bb9L, 0x7a4a717a99d002a8L,
177            0x7a8086eca02201a9L, 0x7ab4a8a7c82a8213L, 0x7ae9d2d1ba352298L, 0x7b2023c31461359fL,
178            0x7b542cb3d9798307L, 0x7b8937e0cfd7e3c8L, 0x7bbf85d903cddcbaL, 0x7bf3b3a7a260a9f4L,
179            0x7c28a0918af8d472L, 0x7c5ec8b5edb7098eL, 0x7c933d71b49265f9L, 0x7cc80cce21b6ff77L,
180            0x7cfe1001aa24bf55L, 0x7d32ca010a56f795L, 0x7d677c814cecb57aL, 0x7d9d5ba1a027e2d9L,
181            0x7dd259450418edc7L, 0x7e06ef96451f2939L, 0x7e3cab7bd666f388L, 0x7e71eb2d66005835L,
182            0x7ea665f8bf806e42L, 0x7edbff76ef6089d2L, 0x7f117faa559c5623L, 0x7f45df94eb036bacL,
183            0x7f7b577a25c44697L, 0x7fb116ac579aac1fL, 0x7fe55c576d815726L, 0x7ff0000000000000L };
184
185    private void doTestCompareRawBits(String originalDoubleString, long expectedRawBits,
186            String expectedString) {
187        double result;
188        long rawBits;
189        String convertedString;
190        result = Double.parseDouble(originalDoubleString);
191        rawBits = Double.doubleToLongBits(result);
192        convertedString = new Double(result).toString();
193        assertEquals(expectedRawBits, rawBits);
194        assertEquals(expectedString.toLowerCase(Locale.US), convertedString
195                .toLowerCase(Locale.US));
196    }
197
198    private void test_toString(double dd, String answer) {
199        assertEquals(answer, Double.toString(dd));
200        Double d = new Double(dd);
201        assertEquals(answer, Double.toString(d.doubleValue()));
202        assertEquals(answer, d.toString());
203    }
204
205    /**
206     * java.lang.Double#Double(double)
207     */
208    public void test_ConstructorD() {
209        Double d = new Double(39089.88888888888888888888888888888888);
210        assertEquals("Created incorrect double", 39089.88888888888888888888888888888888, d
211                .doubleValue(), 0D);
212    }
213
214    /**
215     * java.lang.Double#Double(java.lang.String)
216     */
217    public void test_ConstructorLjava_lang_String() {
218        Double d = new Double("39089.88888888888888888888888888888888");
219        assertEquals("Created incorrect double", 39089.88888888888888888888888888888888, d
220                .doubleValue(), 0D);
221
222        // Regression test for HARMONY-489
223        try {
224            d = new Double("1E+-20");
225            fail("new Double(\"1E+-20\") should throw exception");
226        } catch (NumberFormatException e) {
227            // expected
228        }
229
230        // Regression test for HARMONY-329
231        d = Double.parseDouble("-1.233999999999999965116738099630936817275852021384209929081813042837802886790127428328465579708849276001782791006814286802871737087810957327493372866733334925806221045495205250590286471187577636646208155890426896101636282423463443661040209738873506655844025580428394216030152374941053494694642722606658935546875E-112");
232        assertEquals("Failed to parse long string", -1.234E-112D, d.doubleValue(), 0D);
233    }
234
235    /**
236     * java.lang.Double#byteValue()
237     */
238    public void test_byteValue() {
239        Double d = new Double(1923311.47712);
240        assertEquals("Returned incorrect byte value", (byte) -17, d.byteValue());
241    }
242
243    /**
244     * java.lang.Double#compareTo(java.lang.Double)
245     * java.lang.Double#compare(double, double)
246     */
247    public void test_compare() {
248        double[] values = new double[] { Double.NEGATIVE_INFINITY, -Double.MAX_VALUE, -2d,
249                -Double.MIN_VALUE, -0d, 0d, Double.MIN_VALUE, 2d, Double.MAX_VALUE,
250                Double.POSITIVE_INFINITY, Double.NaN };
251        for (int i = 0; i < values.length; i++) {
252            double d1 = values[i];
253            assertTrue("compare() should be equal: " + d1, Double.compare(d1, d1) == 0);
254            Double D1 = new Double(d1);
255            assertTrue("compareTo() should be equal: " + d1, D1.compareTo(D1) == 0);
256            for (int j = i + 1; j < values.length; j++) {
257                double d2 = values[j];
258                assertTrue("compare() " + d1 + " should be less " + d2,
259                        Double.compare(d1, d2) == -1);
260                assertTrue("compare() " + d2 + " should be greater " + d1, Double.compare(d2,
261                        d1) == 1);
262                Double D2 = new Double(d2);
263                assertTrue("compareTo() " + d1 + " should be less " + d2,
264                        D1.compareTo(D2) == -1);
265                assertTrue("compareTo() " + d2 + " should be greater " + d1,
266                        D2.compareTo(D1) == 1);
267            }
268        }
269
270        try {
271            new Double(0.0D).compareTo(null);
272            fail("No NPE");
273        } catch (NullPointerException e) {
274        }
275    }
276
277    /**
278     * java.lang.Double#doubleToLongBits(double)
279     */
280    public void test_doubleToLongBitsD() {
281        // Test for method long java.lang.Double.doubleToLongBits(double)
282        Double d = new Double(Double.MAX_VALUE);
283        long lbits = Double.doubleToLongBits(d.doubleValue());
284        double r = Double.longBitsToDouble(lbits);
285
286        assertTrue("Bit conversion failed", d.doubleValue() == r);
287    }
288
289    /**
290     * java.lang.Double#doubleToRawLongBits(double)
291     */
292    public void test_doubleToRawLongBitsD() {
293        long l = 0x7ff80000000004d2L;
294        double d = Double.longBitsToDouble(l);
295        assertTrue("Wrong raw bits", Double.doubleToRawLongBits(d) == l);
296    }
297
298    /**
299     * java.lang.Double#doubleValue()
300     */
301    public void test_doubleValue() {
302        assertEquals("Incorrect double value returned", 999999999999999.9999999999999,
303                new Double(999999999999999.9999999999999).doubleValue(), 0D);
304    }
305
306    /**
307     * java.lang.Double#floatValue()
308     */
309    public void test_floatValue() {
310        // Test for method float java.lang.Double.floatValue()
311        assertTrue(
312                "Incorrect float value returned ",
313                Math
314                        .abs(new Double(999999999999999.9999999999999d).floatValue() - 999999999999999.9999999999999f) < 1);
315    }
316
317    /**
318     * java.lang.Double#hashCode()
319     */
320    public void test_hashCode() {
321        // Test for method int java.lang.Double.hashCode()
322        for (int i = -1000; i < 1000; i++) {
323            Double d = new Double(i);
324            Double dd = new Double(i);
325            assertTrue("Should not be identical ", d != dd);
326            assertTrue("Should be equals 1 ", d.equals(dd));
327            assertTrue("Should be equals 2 ", dd.equals(d));
328            assertTrue("Should have identical values ", dd.doubleValue() == d.doubleValue());
329            assertTrue("Invalid hash for equal but not identical doubles ", d.hashCode() == dd
330                    .hashCode());
331        }
332        assertEquals("Magic assumption hasCode (0.0) = 0 failed", 0, new Double(0.0).hashCode());
333    }
334
335    /**
336     * java.lang.Double#intValue()
337     */
338    public void test_intValue() {
339        // Test for method int java.lang.Double.intValue()
340        Double d = new Double(1923311.47712);
341        assertEquals("Returned incorrect int value", 1923311, d.intValue());
342    }
343
344    /**
345     * java.lang.Double#isInfinite()
346     */
347    public void test_isInfinite() {
348        // Test for method boolean java.lang.Double.isInfinite()
349        assertTrue("NEGATIVE_INFINITY returned false", new Double(Double.NEGATIVE_INFINITY)
350                .isInfinite());
351        assertTrue("POSITIVE_INFINITY returned false", new Double(Double.POSITIVE_INFINITY)
352                .isInfinite());
353        assertTrue("Non infinite number returned true", !(new Double(1000).isInfinite()));
354    }
355
356    /**
357     * java.lang.Double#isInfinite(double)
358     */
359    public void test_isInfiniteD() {
360        // Test for method boolean java.lang.Double.isInfinite(double)
361        assertTrue(Double.isInfinite(Double.NEGATIVE_INFINITY));
362        assertTrue(Double.isInfinite(Double.POSITIVE_INFINITY));
363        assertFalse(Double.isInfinite(Double.MAX_VALUE));
364        assertFalse(Double.isInfinite(Double.MIN_VALUE));
365        assertFalse(Double.isInfinite(Double.NaN));
366        assertFalse(Double.isInfinite(0.0));
367    }
368
369    /**
370     * java.lang.Double#isFinite(double)
371     */
372    public void test_isFiniteD() {
373        // Test for method boolean java.lang.Double.isFinite(double)
374        assertFalse(Double.isFinite(Double.NEGATIVE_INFINITY));
375        assertFalse(Double.isFinite(Double.POSITIVE_INFINITY));
376        assertTrue(Double.isFinite(Double.MAX_VALUE));
377        assertTrue(Double.isFinite(Double.MIN_VALUE));
378        assertFalse(Double.isFinite(Double.NaN));
379        assertTrue(Double.isFinite(0.0));
380    }
381
382    /**
383     * java.lang.Double#isNaN()
384     */
385    public void test_isNaN() {
386        // Test for method boolean java.lang.Double.isNaN()
387        Double d = new Double(0.0 / 0.0);
388        assertTrue("NAN returned false", d.isNaN());
389        d = new Double(0);
390        assertTrue("Non NAN returned true", !d.isNaN());
391    }
392
393    /**
394     * java.lang.Double#isNaN(double)
395     */
396    public void test_isNaND() {
397        // Test for method boolean java.lang.Double.isNaN(double)
398
399        Double d = new Double(0.0 / 0.0);
400        assertTrue("NAN check failed", Double.isNaN(d.doubleValue()));
401    }
402
403    /**
404     * java.lang.Double#longBitsToDouble(long)
405     */
406    public void test_longBitsToDoubleJ() {
407        // Test for method double java.lang.Double.longBitsToDouble(long)
408
409        Double d = new Double(Double.MAX_VALUE);
410        long lbits = Double.doubleToLongBits(d.doubleValue());
411        double r = Double.longBitsToDouble(lbits);
412
413        assertTrue("Bit conversion failed", d.doubleValue() == r);
414    }
415
416    /**
417     * java.lang.Double#longValue()
418     */
419    public void test_longValue() {
420        // Test for method long java.lang.Double.longValue()
421        Double d = new Double(1923311.47712);
422        assertEquals("Returned incorrect long value", 1923311, d.longValue());
423    }
424
425    /**
426     * java.lang.Double#parseDouble(java.lang.String)
427     */
428    public void test_parseDoubleLjava_lang_String() {
429        assertEquals("Incorrect double returned, expected zero.", 0.0, Double
430                .parseDouble("2.4703282292062327208828439643411e-324"), 0.0);
431        assertTrue("Incorrect double returned, expected minimum double.", Double
432                .parseDouble("2.4703282292062327208828439643412e-324") == Double.MIN_VALUE);
433
434        for (int i = 324; i > 0; i--) {
435            Double.parseDouble("3.4e-" + i);
436        }
437        for (int i = 0; i <= 309; i++) {
438            Double.parseDouble("1.2e" + i);
439        }
440
441        /*
442         * The first two cases and the last four cases have to placed outside
443         * the loop due to the difference in the expected output string.
444         */
445        doTestCompareRawBits("3.4e-324", rawBitsFor3_4en324ToN1[0], "4.9e-324");
446        doTestCompareRawBits("3.4e-323", rawBitsFor3_4en324ToN1[1], "3.5e-323");
447        for (int i = 322; i > 3; i--) {
448            String testString, expectedString;
449            testString = expectedString = "3.4e-" + i;
450            doTestCompareRawBits(testString, rawBitsFor3_4en324ToN1[324 - i], expectedString);
451        }
452        doTestCompareRawBits("3.4e-3", rawBitsFor3_4en324ToN1[321], "0.0034");
453        doTestCompareRawBits("3.4e-2", rawBitsFor3_4en324ToN1[322], "0.034");
454        doTestCompareRawBits("3.4e-1", rawBitsFor3_4en324ToN1[323], "0.34");
455        doTestCompareRawBits("3.4e-0", rawBitsFor3_4en324ToN1[324], "3.4");
456
457        doTestCompareRawBits("1.2e0", rawBitsFor1_2e0To309[0], "1.2");
458        doTestCompareRawBits("1.2e1", rawBitsFor1_2e0To309[1], "12.0");
459        doTestCompareRawBits("1.2e2", rawBitsFor1_2e0To309[2], "120.0");
460        doTestCompareRawBits("1.2e3", rawBitsFor1_2e0To309[3], "1200.0");
461        doTestCompareRawBits("1.2e4", rawBitsFor1_2e0To309[4], "12000.0");
462        doTestCompareRawBits("1.2e5", rawBitsFor1_2e0To309[5], "120000.0");
463        doTestCompareRawBits("1.2e6", rawBitsFor1_2e0To309[6], "1200000.0");
464        for (int i = 7; i <= 308; i++) {
465            String testString, expectedString;
466            testString = expectedString = "1.2e" + i;
467            doTestCompareRawBits(testString, rawBitsFor1_2e0To309[i], expectedString);
468        }
469        doTestCompareRawBits("1.2e309", rawBitsFor1_2e0To309[309], "Infinity");
470
471        doTestCompareRawBits(
472                "111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000.92233720368547758079223372036854775807",
473                0x7e054218c295e43fL, "1.1122233344455567E299");
474        doTestCompareRawBits(
475                "-111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000.92233720368547758079223372036854775807",
476                0xfe054218c295e43fL, "-1.1122233344455567E299");
477
478        doTestCompareRawBits("1.234123412431233E107", 0x562ae7a25fe706ebL,
479                "1.234123412431233E107");
480        doTestCompareRawBits("1.2341234124312331E107", 0x562ae7a25fe706ecL,
481                "1.2341234124312331E107");
482        doTestCompareRawBits("1.2341234124312332E107", 0x562ae7a25fe706ecL,
483                "1.2341234124312331E107");
484        doTestCompareRawBits("-1.234123412431233E107", 0xd62ae7a25fe706ebL,
485                "-1.234123412431233E107");
486        doTestCompareRawBits("-1.2341234124312331E107", 0xd62ae7a25fe706ecL,
487                "-1.2341234124312331E107");
488        doTestCompareRawBits("-1.2341234124312332E107", 0xd62ae7a25fe706ecL,
489                "-1.2341234124312331E107");
490
491        // Java spec requires Double.toString to have exponent corresponding to the
492        // binary value, in this case is 22, since the binary value is very slightly
493        // less than 10^23. Therefore the correct decimal representation is
494        // 9.999999999999999e22.
495        // See ag/831934
496        doTestCompareRawBits("1e23", 0x44b52d02c7e14af6L, "9.999999999999999e22");
497
498        doTestCompareRawBits("1e22", 0x4480F0CF064DD592L, "1.0e22");
499
500        /*
501         * These particular tests verify that the extreme boundary conditions
502         * are converted correctly.
503         */
504        doTestCompareRawBits("0.0e-309", 0L, "0.0");
505        doTestCompareRawBits("-0.0e-309", 0x8000000000000000L, "-0.0");
506        doTestCompareRawBits("0.0e309", 0L, "0.0");
507        doTestCompareRawBits("-0.0e309", 0x8000000000000000L, "-0.0");
508        doTestCompareRawBits("0.1e309", 0x7fe1ccf385ebc8a0L, "1.0e308");
509        doTestCompareRawBits("0.2e309", 0x7ff0000000000000L, "Infinity");
510        doTestCompareRawBits("65e-325", 1L, "4.9e-324");
511        doTestCompareRawBits("1000e-326", 2L, "1.0e-323");
512
513        doTestCompareRawBits("4.0e-306", 0x86789e3750f791L, "4.0e-306");
514        doTestCompareRawBits("2.22507e-308", 0xffffe2e8159d0L, "2.22507e-308");
515        doTestCompareRawBits(
516                "111222333444555666777888999000111228999000.92233720368547758079223372036854775807",
517                0x48746da623f1dd8bL, "1.1122233344455567E41");
518        doTestCompareRawBits(
519                "-111222333444555666777888999000111228999000.92233720368547758079223372036854775807",
520                0xc8746da623f1dd8bL, "-1.1122233344455567E41");
521        doTestCompareRawBits(
522                "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890.987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210",
523                0x54820fe0ba17f469L, "1.2345678901234567E99");
524        doTestCompareRawBits(
525                "-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890.987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210",
526                0xd4820fe0ba17f469L, "-1.2345678901234567E99");
527
528        doTestCompareRawBits(
529                "179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01",
530                0x7fefffffffffffffL, "1.7976931348623157E308");
531        doTestCompareRawBits(
532                "-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01",
533                0xffefffffffffffffL, "-1.7976931348623157E308");
534        doTestCompareRawBits(
535                "1112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001234567890",
536                0x7ff0000000000000L, "Infinity");
537        doTestCompareRawBits(
538                "-1112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001234567890",
539                0xfff0000000000000L, "-Infinity");
540        doTestCompareRawBits(
541                "179769313486231590000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01",
542                0x7ff0000000000000L, "Infinity");
543        doTestCompareRawBits(
544                "-179769313486231590000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01",
545                0xfff0000000000000L, "-Infinity");
546        doTestCompareRawBits(
547                "0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157",
548                0x2b392a32afcc661eL, "1.7976931348623157E-100");
549        doTestCompareRawBits(
550                "-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157",
551                0xab392a32afcc661eL, "-1.7976931348623157E-100");
552        doTestCompareRawBits(
553                "0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157",
554                0x1b3432f0cb68e61L, "1.7976931348623157E-300");
555        doTestCompareRawBits(
556                "-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157",
557                0x81b3432f0cb68e61L, "-1.7976931348623157E-300");
558        doTestCompareRawBits(
559                "0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157",
560                0x2117b590b942L, "1.79769313486234E-310");
561        doTestCompareRawBits(
562                "-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157",
563                0x80002117b590b942L, "-1.79769313486234E-310");
564        doTestCompareRawBits(
565                "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157",
566                0xe37L, "1.798E-320");
567        doTestCompareRawBits(
568                "-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157",
569                0x8000000000000e37L, "-1.798E-320");
570        doTestCompareRawBits(
571                "0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001",
572                0x2L, "1.0E-323");
573        doTestCompareRawBits(
574                "-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001",
575                0x8000000000000002L, "-1.0E-323");
576        doTestCompareRawBits(
577                "0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055595409854908458349204328908234982349050934129878452378432452458968024357823490509341298784523784324524589680243578234905093412987845237843245245896802435782349050934129878452378432452458968024357868024357823490509341298784523784324524589680243578234905093412987845237843245245896802435786802435782349050934129878452378432452458968024357823490509341298784523784324524589680243578",
578                0x1L, "4.9E-324");
579        doTestCompareRawBits(
580                "-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055595409854908458349204328908234982349050934129878452378432452458968024357823490509341298784523784324524589680243578234905093412987845237843245245896802435782349050934129878452378432452458968024357868024357823490509341298784523784324524589680243578234905093412987845237843245245896802435786802435782349050934129878452378432452458968024357823490509341298784523784324524589680243578",
581                0x8000000000000001L, "-4.9E-324");
582    }
583
584    /**
585     * java.lang.Double#parseDouble(java.lang.String)
586     */
587    public void test_parseDouble_LString_Illegal() {
588        try {
589            Double.parseDouble("0.0p0D");
590            fail("Should throw NumberFormatException.");
591        } catch (NumberFormatException e) {
592            // expected
593        }
594
595        try {
596            Double.parseDouble("+0x.p1d");
597            fail("Should throw NumberFormatException.");
598        } catch (NumberFormatException e) {
599            // expected
600        }
601
602        try {
603            Double.parseDouble("0Xg.gp1D");
604            fail("Should throw NumberFormatException.");
605        } catch (NumberFormatException e) {
606            // expected
607        }
608
609        try {
610            Double.parseDouble("-0x1.1p");
611            fail("Should throw NumberFormatException.");
612        } catch (NumberFormatException e) {
613            // expected
614        }
615
616        try {
617            Double.parseDouble("+0x 1.1 p2d");
618            fail("Should throw NumberFormatException.");
619        } catch (NumberFormatException e) {
620            // expected
621        }
622
623        try {
624            Double.parseDouble("x1.1p2d");
625            fail("Should throw NumberFormatException.");
626        } catch (NumberFormatException e) {
627            // expected
628        }
629
630        try {
631            Double.parseDouble(" 0x-2.1p2");
632            fail("Should throw NumberFormatException.");
633        } catch (NumberFormatException e) {
634            // expected
635        }
636
637        try {
638            Double.parseDouble(" 0x2.1pad");
639            fail("Should throw NumberFormatException.");
640        } catch (NumberFormatException e) {
641            // expected
642        }
643
644        try {
645            Double.parseDouble(" 0x111.222p 22d");
646            fail("Should throw NumberFormatException.");
647        } catch (NumberFormatException e) {
648            // expected
649        }
650    }
651
652    /**
653     * java.lang.Double#parseDouble(java.lang.String)
654     */
655    public void test_parseDouble_LString_FromHexString() {
656        double actual;
657        double expected;
658
659        actual = Double.parseDouble("0x0.0p0D");
660        assertEquals("Returned incorrect value", 0.0d, actual, 0.0D);
661
662        actual = Double.parseDouble("0xa.ap+9d");
663        assertEquals("Returned incorrect value", 5440.0d, actual, 0.0D);
664
665        actual = Double.parseDouble("+0Xb.10ap8");
666        assertEquals("Returned incorrect value", 2832.625d, actual, 0.0D);
667
668        actual = Double.parseDouble("-0X.a0P2D");
669        assertEquals("Returned incorrect value", -2.5d, actual, 0.0D);
670
671        actual = Double.parseDouble("\r 0x22.1p2d \t");
672        assertEquals("Returned incorrect value", 136.25d, actual, 0.0D);
673
674        actual = Double.parseDouble("0x1.0p-1");
675        assertEquals("Returned incorrect value", 0.5, actual, 0.0D);
676
677        actual = Double
678                .parseDouble("0x00000000000000000000000000000000001.0p-1");
679        assertEquals("Returned incorrect value", 0.5, actual, 0.0D);
680
681        actual = Double.parseDouble("0x1.0p-00000000000000000000000000001");
682        assertEquals("Returned incorrect value", 0.5, actual, 0.0D);
683
684        actual = Double.parseDouble("0x.100000000000000000000000000000000p1");
685        assertEquals("Returned incorrect value", 0.125, actual, 0.0D);
686
687        actual = Double.parseDouble("0x0.0p999999999999999999999999999999999999999999999999999999999999999");
688        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
689
690        actual = Double.parseDouble("0xf1.0p9999999999999999999999999999999999999999999999999999999999999999");
691        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D);
692
693        actual = Double.parseDouble("0xffffffffffffffffffffffffffffffffffff.ffffffffffffffffffffffffffffffffffffffffffffffp1");
694        expected = Double.longBitsToDouble(0x4900000000000000L);
695        assertEquals("Returned incorrect value", expected, actual, 0.0D);
696
697        actual = Double.parseDouble("0x0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001p1600");
698        expected = Double.longBitsToDouble(0x7f30000000000000L);
699        assertEquals("Returned incorrect value", expected, actual, 0.0D);
700
701        actual = Double.parseDouble("0x0.0p-999999999999999999999999999999999999999999999999999999");
702        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
703
704        actual = Double.parseDouble("0xf1.0p-9999999999999999999999999999999999999999999999999999999999999999");
705        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
706
707        actual = Double.parseDouble("0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000p-1600");
708        expected = Double.longBitsToDouble(0xf0000000000000L);
709        assertEquals("Returned incorrect value", expected, actual, 0.0D);
710
711        actual = Double.parseDouble("0x1.p9223372036854775807");
712        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D);
713
714        actual = Double.parseDouble("0x1.p9223372036854775808");
715        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D);
716
717        actual = Double.parseDouble("0x10.p9223372036854775808");
718        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D);
719
720        actual = Double.parseDouble("0xabcd.ffffffffp+2000");
721        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D);
722
723        actual = Double.parseDouble("0x1.p-9223372036854775808");
724        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
725
726        actual = Double.parseDouble("0x1.p-9223372036854775809");
727        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
728
729        actual = Double.parseDouble("0x.1p-9223372036854775809");
730        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
731
732        actual = Double.parseDouble("0xabcd.ffffffffffffffp-2000");
733        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
734    }
735
736    /**
737     * java.lang.Double#parseDouble(java.lang.String)
738     */
739    public void test_parseDouble_LString_NormalPositiveExponent() {
740        long[] expecteds = {
741                0x3f323456789abcdfL, 0x40e111012345678aL, 0x41a1110091a2b3c5L,
742                0x4259998091a2b3c5L, 0x4311110048d159e2L, 0x43c5554048d159e2L,
743                0x4479998048d159e2L, 0x452dddc048d159e2L, 0x45e111002468acf1L,
744                0x469333202468acf1L, 0x4751011001234568L, 0x4802112101234568L,
745                0x48b3213201234568L, 0x4964314301234568L, 0x4a15415401234568L,
746                0x4ac6516501234568L, 0x4b77617601234568L, 0x4c28718701234568L,
747                0x4cd9819801234568L, 0x4d9049048091a2b4L, 0x4e4101100091a2b4L,
748                0x4ef189188091a2b4L, 0x4fa211210091a2b4L, 0x505299298091a2b4L,
749                0x510321320091a2b4L, 0x51b3a93a8091a2b4L, 0x526431430091a2b4L,
750                0x5314b94b8091a2b4L, 0x53c841840091a2b4L, 0x5478c98c8091a2b4L,
751                0x552981980091a2b4L, 0x55da09a08091a2b4L, 0x568a91a90091a2b4L,
752                0x573b19b18091a2b4L, 0x57eba1ba0091a2b4L, 0x589c29c28091a2b4L,
753                0x594cb1cb0091a2b4L, 0x5a001d01c048d15aL, 0x5ab061060048d15aL,
754                0x5b60a50a4048d15aL, 0x5c1101100048d15aL, 0x5cc145144048d15aL,
755                0x5d7189188048d15aL, 0x5e21cd1cc048d15aL, 0x5ed211210048d15aL,
756                0x5f8255254048d15aL, 0x603419418048d15aL, 0x60e45d45c048d15aL,
757                0x6194a14a0048d15aL, 0x6244e54e4048d15aL, 0x62f541540048d15aL,
758                0x63a585584048d15aL, 0x6455c95c8048d15aL, 0x65060d60c048d15aL,
759                0x65b651650048d15aL, 0x666815814048d15aL, 0x671859858048d15aL,
760                0x67c89d89c048d15aL, 0x6878e18e0048d15aL, 0x692925924048d15aL,
761                0x69d981980048d15aL, 0x6a89c59c4048d15aL, 0x6b3a09a08048d15aL,
762                0x6bea4da4c048d15aL, 0x6c9c11c10048d15aL, 0x6d4c55c54048d15aL,
763                0x6dfc99c98048d15aL, 0x6eacddcdc048d15aL, 0x6f5d21d20048d15aL,
764                0x700d65d64048d15aL, 0x70bdc1dc0048d15aL, 0x716e05e04048d15aL,
765                0x721e49e48048d15aL, 0x72d00700602468adL, 0x73802902802468adL,
766                0x74304b04a02468adL, 0x74e06d06c02468adL, 0x75908f08e02468adL,
767                0x7640b10b002468adL, 0x76f0d30d202468adL, 0x77a10110002468adL,
768                0x78512312202468adL, 0x79020520402468adL, 0x79b22722602468adL,
769                0x7a624924802468adL, 0x7b126b26a02468adL, 0x7bc28d28c02468adL,
770                0x7c72af2ae02468adL, 0x7d22d12d002468adL, 0x7dd2f32f202468adL,
771                0x7e832132002468adL, 0x7f40011001012345L, 0x7ff0000000000000L,
772                0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L,
773                0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L,
774                0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L,
775                0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L,
776                0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L,
777                0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L,
778                0x7ff0000000000000L, 0x7ff0000000000000L };
779
780        for (int i = 0; i < expecteds.length; i++) {
781            int part = i * 11;
782            String inputString = "0x" + part + "." + part + "0123456789abcdefp" + part;
783
784            double actual = Double.parseDouble(inputString);
785            double expected = Double.longBitsToDouble(expecteds[i]);
786
787            String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected));
788            String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual));
789            String errorMsg = i + "th input string is:<" + inputString
790                    + ">.The expected result should be:<" + expectedString
791                    + ">, but was: <" + actualString + ">. ";
792
793            assertEquals(errorMsg, expected, actual, 0.0D);
794        }
795    }
796
797    /**
798     * java.lang.Double#parseDouble(java.lang.String)
799     */
800    public void test_parseDouble_LString_NormalNegativeExponent() {
801        long[] expecteds = {
802                0x3f323456789abcdfL, 0x3f8111012345678aL, 0x3ee1110091a2b3c5L,
803                0x3e39998091a2b3c5L, 0x3d91110048d159e2L, 0x3ce5554048d159e2L,
804                0x3c39998048d159e2L, 0x3b8dddc048d159e2L, 0x3ae111002468acf1L,
805                0x3a3333202468acf1L, 0x3991011001234568L, 0x38e2112101234568L,
806                0x3833213201234568L, 0x3784314301234568L, 0x36d5415401234568L,
807                0x3626516501234568L, 0x3577617601234568L, 0x34c8718701234568L,
808                0x3419819801234568L, 0x337049048091a2b4L, 0x32c101100091a2b4L,
809                0x321189188091a2b4L, 0x316211210091a2b4L, 0x30b299298091a2b4L,
810                0x300321320091a2b4L, 0x2f53a93a8091a2b4L, 0x2ea431430091a2b4L,
811                0x2df4b94b8091a2b4L, 0x2d4841840091a2b4L, 0x2c98c98c8091a2b4L,
812                0x2be981980091a2b4L, 0x2b3a09a08091a2b4L, 0x2a8a91a90091a2b4L,
813                0x29db19b18091a2b4L, 0x292ba1ba0091a2b4L, 0x287c29c28091a2b4L,
814                0x27ccb1cb0091a2b4L, 0x27201d01c048d15aL, 0x267061060048d15aL,
815                0x25c0a50a4048d15aL, 0x251101100048d15aL, 0x246145144048d15aL,
816                0x23b189188048d15aL, 0x2301cd1cc048d15aL, 0x225211210048d15aL,
817                0x21a255254048d15aL, 0x20f419418048d15aL, 0x20445d45c048d15aL,
818                0x1f94a14a0048d15aL, 0x1ee4e54e4048d15aL, 0x1e3541540048d15aL,
819                0x1d8585584048d15aL, 0x1cd5c95c8048d15aL, 0x1c260d60c048d15aL,
820                0x1b7651650048d15aL, 0x1ac815814048d15aL, 0x1a1859858048d15aL,
821                0x19689d89c048d15aL, 0x18b8e18e0048d15aL, 0x180925924048d15aL,
822                0x175981980048d15aL, 0x16a9c59c4048d15aL, 0x15fa09a08048d15aL,
823                0x154a4da4c048d15aL, 0x149c11c10048d15aL, 0x13ec55c54048d15aL,
824                0x133c99c98048d15aL, 0x128cddcdc048d15aL, 0x11dd21d20048d15aL,
825                0x112d65d64048d15aL, 0x107dc1dc0048d15aL, 0xfce05e04048d15aL,
826                0xf1e49e48048d15aL, 0xe700700602468adL, 0xdc02902802468adL,
827                0xd104b04a02468adL, 0xc606d06c02468adL, 0xbb08f08e02468adL,
828                0xb00b10b002468adL, 0xa50d30d202468adL, 0x9a10110002468adL,
829                0x8f12312202468adL, 0x8420520402468adL, 0x7922722602468adL,
830                0x6e24924802468adL, 0x6326b26a02468adL, 0x5828d28c02468adL,
831                0x4d2af2ae02468adL, 0x422d12d002468adL, 0x372f32f202468adL,
832                0x2c32132002468adL, 0x220011001012345L, 0x170121012012345L,
833                0xc0231023012345L, 0x10341034012345L, 0x208a208a024L,
834                0x41584158L, 0x83388L, 0x108L,
835                0x0L, 0x0L, 0x0L,
836                0x0L, 0x0L, 0x0L,
837                0x0L, 0x0L, 0x0L,
838                0x0L, 0x0L, 0x0L,
839                0x0L, 0x0L };
840
841        for (int i = 0; i < expecteds.length; i++) {
842            int part = i * 11;
843            String inputString = "0x" + part + "." + part + "0123456789abcdefp-" + part;
844
845            double actual = Double.parseDouble(inputString);
846            double expected = Double.longBitsToDouble(expecteds[i]);
847
848            String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected));
849            String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual));
850            String errorMsg = i + "th input string is:<" + inputString
851                    + ">.The expected result should be:<" + expectedString
852                    + ">, but was: <" + actualString + ">. ";
853
854            assertEquals(errorMsg, expected, actual, 0.0D);
855        }
856    }
857
858    /**
859     * java.lang.Double#parseDouble(java.lang.String)
860     */
861    public void test_parseDouble_LString_MaxNormalBoundary() {
862        long[] expecteds = {
863                0x7fefffffffffffffL, 0x7fefffffffffffffL, 0x7fefffffffffffffL,
864                0x7fefffffffffffffL, 0x7fefffffffffffffL, 0x7fefffffffffffffL,
865                0x7fefffffffffffffL, 0x7ff0000000000000L, 0x7ff0000000000000L,
866                0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L,
867                0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L,
868
869                0xffefffffffffffffL, 0xffefffffffffffffL, 0xffefffffffffffffL,
870                0xffefffffffffffffL, 0xffefffffffffffffL, 0xffefffffffffffffL,
871                0xffefffffffffffffL, 0xfff0000000000000L, 0xfff0000000000000L,
872                0xfff0000000000000L, 0xfff0000000000000L, 0xfff0000000000000L,
873                0xfff0000000000000L, 0xfff0000000000000L, 0xfff0000000000000L };
874
875        String[] inputs = {
876                "0x1.fffffffffffffp1023",
877                "0x1.fffffffffffff000000000000000000000000001p1023",
878                "0x1.fffffffffffff1p1023",
879                "0x1.fffffffffffff100000000000000000000000001p1023",
880                "0x1.fffffffffffff1fffffffffffffffffffffffffffffffffffffffffffffp1023",
881                "0x1.fffffffffffff7p1023",
882                "0x1.fffffffffffff700000000000000000000000001p1023",
883                "0x1.fffffffffffff8p1023",
884                "0x1.fffffffffffff800000000000000000000000001p1023",
885                "0x1.fffffffffffff8fffffffffffffffffffffffffffffffffffffffffffffp1023",
886                "0x1.fffffffffffff9p1023",
887                "0x1.fffffffffffff900000000000000000000000001p1023",
888                "0x1.ffffffffffffffp1023",
889                "0x1.ffffffffffffff00000000000000000000000001p1023",
890                "0x1.fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp1023",
891
892                "-0x1.fffffffffffffp1023",
893                "-0x1.fffffffffffff000000000000000000000000001p1023",
894                "-0x1.fffffffffffff1p1023",
895                "-0x1.fffffffffffff100000000000000000000000001p1023",
896                "-0x1.fffffffffffff1fffffffffffffffffffffffffffffffffffffffffffffp1023",
897                "-0x1.fffffffffffff7p1023",
898                "-0x1.fffffffffffff700000000000000000000000001p1023",
899                "-0x1.fffffffffffff8p1023",
900                "-0x1.fffffffffffff800000000000000000000000001p1023",
901                "-0x1.fffffffffffff8fffffffffffffffffffffffffffffffffffffffffffffp1023",
902                "-0x1.fffffffffffff9p1023",
903                "-0x1.fffffffffffff900000000000000000000000001p1023",
904                "-0x1.ffffffffffffffp1023",
905                "-0x1.ffffffffffffff00000000000000000000000001p1023",
906                "-0x1.fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp1023" };
907
908        for (int i = 0; i < inputs.length; i++) {
909            double actual = Double.parseDouble(inputs[i]);
910            double expected = Double.longBitsToDouble(expecteds[i]);
911
912            String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected));
913            String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual));
914            String errorMsg = i + "th input string is:<" + inputs[i]
915                    + ">.The expected result should be:<" + expectedString
916                    + ">, but was: <" + actualString + ">. ";
917
918            assertEquals(errorMsg, expected, actual, 0.0D);
919        }
920    }
921
922    /**
923     * java.lang.Double#parseDouble(java.lang.String)
924     */
925    public void test_parseDouble_LString_MinNormalBoundary() {
926        long[] expecteds = {
927                0x10000000000000L, 0x10000000000000L, 0x10000000000000L,
928                0x10000000000000L, 0x10000000000000L, 0x10000000000000L,
929                0x10000000000000L, 0x10000000000000L, 0x10000000000001L,
930                0x10000000000001L, 0x10000000000001L, 0x10000000000001L,
931                0x10000000000001L, 0x10000000000001L, 0x10000000000001L,
932
933                0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L,
934                0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L,
935                0x8010000000000000L, 0x8010000000000000L, 0x8010000000000001L,
936                0x8010000000000001L, 0x8010000000000001L, 0x8010000000000001L,
937                0x8010000000000001L, 0x8010000000000001L, 0x8010000000000001L };
938
939        String[] inputs = {
940                "0x1.0p-1022",
941                "0x1.00000000000001p-1022",
942                "0x1.000000000000010000000000000000001p-1022",
943                "0x1.00000000000001fffffffffffffffffffffffffffffffffp-1022",
944                "0x1.00000000000007p-1022",
945                "0x1.000000000000070000000000000000001p-1022",
946                "0x1.00000000000007fffffffffffffffffffffffffffffffffp-1022",
947                "0x1.00000000000008p-1022",
948                "0x1.000000000000080000000000000000001p-1022",
949                "0x1.00000000000008fffffffffffffffffffffffffffffffffp-1022",
950                "0x1.00000000000009p-1022",
951                "0x1.000000000000090000000000000000001p-1022",
952                "0x1.00000000000009fffffffffffffffffffffffffffffffffp-1022",
953                "0x1.0000000000000fp-1022",
954                "0x1.0000000000000ffffffffffffffffffffffffffffffffffp-1022",
955
956                "-0x1.0p-1022",
957                "-0x1.00000000000001p-1022",
958                "-0x1.000000000000010000000000000000001p-1022",
959                "-0x1.00000000000001fffffffffffffffffffffffffffffffffp-1022",
960                "-0x1.00000000000007p-1022",
961                "-0x1.000000000000070000000000000000001p-1022",
962                "-0x1.00000000000007fffffffffffffffffffffffffffffffffp-1022",
963                "-0x1.00000000000008p-1022",
964                "-0x1.000000000000080000000000000000001p-1022",
965                "-0x1.00000000000008fffffffffffffffffffffffffffffffffp-1022",
966                "-0x1.00000000000009p-1022",
967                "-0x1.000000000000090000000000000000001p-1022",
968                "-0x1.00000000000009fffffffffffffffffffffffffffffffffp-1022",
969                "-0x1.0000000000000fp-1022",
970                "-0x1.0000000000000ffffffffffffffffffffffffffffffffffp-1022" };
971
972        for (int i = 0; i < inputs.length; i++) {
973            double actual = Double.parseDouble(inputs[i]);
974            double expected = Double.longBitsToDouble(expecteds[i]);
975
976            String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected));
977            String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual));
978            String errorMsg = i + "th input string is:<" + inputs[i]
979                    + ">.The expected result should be:<" + expectedString
980                    + ">, but was: <" + actualString + ">. ";
981
982            assertEquals(errorMsg, expected, actual, 0.0D);
983        }
984    }
985
986    /**
987     * java.lang.Double#parseDouble(java.lang.String)
988     */
989    public void test_parseDouble_LString_MaxSubNormalBoundary() {
990        long[] expecteds = {
991                0xfffffffffffffL, 0xfffffffffffffL, 0xfffffffffffffL,
992                0xfffffffffffffL, 0xfffffffffffffL, 0xfffffffffffffL,
993                0xfffffffffffffL, 0x10000000000000L, 0x10000000000000L,
994                0x10000000000000L, 0x10000000000000L, 0x10000000000000L,
995                0x10000000000000L, 0x10000000000000L, 0x10000000000000L,
996
997                0x800fffffffffffffL, 0x800fffffffffffffL, 0x800fffffffffffffL,
998                0x800fffffffffffffL, 0x800fffffffffffffL, 0x800fffffffffffffL,
999                0x800fffffffffffffL, 0x8010000000000000L, 0x8010000000000000L,
1000                0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L,
1001                0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L };
1002
1003        String[] inputs = {
1004                "0x0.fffffffffffffp-1022",
1005                "0x0.fffffffffffff00000000000000000000000000000000001p-1022",
1006                "0x0.fffffffffffff1p-1022",
1007                "0x0.fffffffffffff10000000000000000000000000000000001p-1022",
1008                "0x0.fffffffffffff1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022",
1009                "0x0.fffffffffffff7p-1022",
1010                "0x0.fffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022",
1011                "0x0.fffffffffffff8p-1022",
1012                "0x0.fffffffffffff80000000000000000000000000000000001p-1022",
1013                "0x0.fffffffffffff8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022",
1014                "0x0.fffffffffffff9p-1022",
1015                "0x0.fffffffffffff9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022",
1016                "0x0.ffffffffffffffp-1022",
1017                "0x0.ffffffffffffff0000000000000000000000000000000001p-1022",
1018                "0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022",
1019
1020                "-0x0.fffffffffffffp-1022",
1021                "-0x0.fffffffffffff00000000000000000000000000000000001p-1022",
1022                "-0x0.fffffffffffff1p-1022",
1023                "-0x0.fffffffffffff10000000000000000000000000000000001p-1022",
1024                "-0x0.fffffffffffff1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022",
1025                "-0x0.fffffffffffff7p-1022",
1026                "-0x0.fffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022",
1027                "-0x0.fffffffffffff8p-1022",
1028                "-0x0.fffffffffffff80000000000000000000000000000000001p-1022",
1029                "-0x0.fffffffffffff8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022",
1030                "-0x0.fffffffffffff9p-1022",
1031                "-0x0.fffffffffffff9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022",
1032                "-0x0.ffffffffffffffp-1022",
1033                "-0x0.ffffffffffffff0000000000000000000000000000000001p-1022",
1034                "-0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022" };
1035
1036        for (int i = 0; i < inputs.length; i++) {
1037            double actual = Double.parseDouble(inputs[i]);
1038            double expected = Double.longBitsToDouble(expecteds[i]);
1039
1040            String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected));
1041            String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual));
1042            String errorMsg = i + "th input string is:<" + inputs[i]
1043                    + ">.The expected result should be:<" + expectedString
1044                    + ">, but was: <" + actualString + ">. ";
1045
1046            assertEquals(errorMsg, expected, actual, 0.0D);
1047        }
1048    }
1049
1050    /**
1051     * java.lang.Double#parseDouble(java.lang.String)
1052     */
1053    public void test_parseDouble_LString_MinSubNormalBoundary() {
1054        long[] expecteds = {
1055                0x1L, 0x1L, 0x2L,
1056                0x1L, 0x1L, 0x1L,
1057                0x2L, 0x2L, 0x2L,
1058                0x2L, 0x2L, 0x2L,
1059                0x2L, 0x2L, 0x2L,
1060
1061                0x8000000000000001L, 0x8000000000000001L, 0x8000000000000002L,
1062                0x8000000000000001L, 0x8000000000000001L, 0x8000000000000001L,
1063                0x8000000000000002L, 0x8000000000000002L, 0x8000000000000002L,
1064                0x8000000000000002L, 0x8000000000000002L, 0x8000000000000002L,
1065                0x8000000000000002L, 0x8000000000000002L, 0x8000000000000002L };
1066
1067        String[] inputs = {
1068                "0x0.0000000000001p-1022",
1069                "0x0.00000000000010000000000000000001p-1022",
1070                "0x0.0000000000001fffffffffffffffffffffffffffffffffp-1022",
1071                "0x0.00000000000017p-1022",
1072                "0x0.000000000000170000000000000000001p-1022",
1073                "0x0.00000000000017fffffffffffffffffffffffffffffffffp-1022",
1074                "0x0.00000000000018p-1022",
1075                "0x0.000000000000180000000000000000001p-1022",
1076                "0x0.00000000000018fffffffffffffffffffffffffffffffffp-1022",
1077                "0x0.00000000000019p-1022",
1078                "0x0.000000000000190000000000000000001p-1022",
1079                "0x0.00000000000019fffffffffffffffffffffffffffffffffp-1022",
1080                "0x0.0000000000001fp-1022",
1081                "0x0.0000000000001f0000000000000000001p-1022",
1082                "0x0.0000000000001ffffffffffffffffffffffffffffffffffp-1022",
1083
1084                "-0x0.0000000000001p-1022",
1085                "-0x0.00000000000010000000000000000001p-1022",
1086                "-0x0.0000000000001fffffffffffffffffffffffffffffffffp-1022",
1087                "-0x0.00000000000017p-1022",
1088                "-0x0.000000000000170000000000000000001p-1022",
1089                "-0x0.00000000000017fffffffffffffffffffffffffffffffffp-1022",
1090                "-0x0.00000000000018p-1022",
1091                "-0x0.000000000000180000000000000000001p-1022",
1092                "-0x0.00000000000018fffffffffffffffffffffffffffffffffp-1022",
1093                "-0x0.00000000000019p-1022",
1094                "-0x0.000000000000190000000000000000001p-1022",
1095                "-0x0.00000000000019fffffffffffffffffffffffffffffffffp-1022",
1096                "-0x0.0000000000001fp-1022",
1097                "-0x0.0000000000001f0000000000000000001p-1022",
1098                "-0x0.0000000000001ffffffffffffffffffffffffffffffffffp-1022" };
1099
1100        for (int i = 0; i < inputs.length; i++) {
1101            double actual = Double.parseDouble(inputs[i]);
1102            double expected = Double.longBitsToDouble(expecteds[i]);
1103
1104            String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected));
1105            String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual));
1106            String errorMsg = i + "th input string is:<" + inputs[i]
1107                    + ">.The expected result should be:<" + expectedString
1108                    + ">, but was: <" + actualString + ">. ";
1109
1110            assertEquals(errorMsg, expected, actual, 0.0D);
1111        }
1112    }
1113
1114    /**
1115     * java.lang.Double#parseDouble(java.lang.String)
1116     */
1117    public void test_parseDouble_LString_ZeroBoundary() {
1118        long[] expecteds = {
1119                0x0L, 0x0L, 0x0L,
1120                0x1L, 0x1L, 0x1L,
1121                0x1L, 0x1L, 0x1L,
1122                0x8000000000000000L, 0x8000000000000000L, 0x8000000000000000L,
1123                0x8000000000000001L, 0x8000000000000001L, 0x8000000000000001L,
1124                0x8000000000000001L, 0x8000000000000001L, 0x8000000000000001L };
1125
1126        String[] inputs = {
1127                "0x0.00000000000004p-1022",
1128                "0x0.00000000000007ffffffffffffffffffffffp-1022",
1129                "0x0.00000000000008p-1022",
1130                "0x0.000000000000080000000000000000001p-1022",
1131                "0x0.00000000000008fffffffffffffffffffffffffffffffp-1022",
1132                "0x0.00000000000009p-1022",
1133                "0x0.000000000000090000000000000000001p-1022",
1134                "0x0.00000000000009fffffffffffffffffffffffffffffffffp-1022",
1135                "0x0.0000000000000fffffffffffffffffffffffffffffffffffp-1022",
1136
1137                "-0x0.00000000000004p-1022",
1138                "-0x0.00000000000007ffffffffffffffffffffffp-1022",
1139                "-0x0.00000000000008p-1022",
1140                "-0x0.000000000000080000000000000000001p-1022",
1141                "-0x0.00000000000008fffffffffffffffffffffffffffffffp-1022",
1142                "-0x0.00000000000009p-1022",
1143                "-0x0.000000000000090000000000000000001p-1022",
1144                "-0x0.00000000000009fffffffffffffffffffffffffffffffffp-1022",
1145                "-0x0.0000000000000fffffffffffffffffffffffffffffffffffp-1022" };
1146
1147        for (int i = 0; i < inputs.length; i++) {
1148            double actual = Double.parseDouble(inputs[i]);
1149            double expected = Double.longBitsToDouble(expecteds[i]);
1150
1151            String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected));
1152            String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual));
1153            String errorMsg = i + "th input string is:<" + inputs[i]
1154                    + ">.The expected result should be:<" + expectedString
1155                    + ">, but was: <" + actualString + ">. ";
1156
1157            assertEquals(errorMsg, expected, actual, 0.0D);
1158        }
1159    }
1160
1161    /**
1162     * java.lang.Double#shortValue()
1163     */
1164    public void test_shortValue() {
1165        // Test for method short java.lang.Double.shortValue()
1166        Double d = new Double(1923311.47712);
1167        assertEquals("Returned incorrect short value", 22767, d.shortValue());
1168    }
1169
1170    /**
1171     * java.lang.Double#toString()
1172     */
1173    public void test_toString() {
1174        // Test for method java.lang.String java.lang.Double.toString()
1175        test_toString(1.7976931348623157E308, "1.7976931348623157E308");
1176        test_toString(5.0E-4, "5.0E-4");
1177    }
1178
1179    /**
1180     * java.lang.Double#toString(double)
1181     */
1182    public void test_toStringD() {
1183        // Test for method java.lang.String java.lang.Double.toString(double)
1184        test_toString(1.7976931348623157E308, "1.7976931348623157E308");
1185        test_toString(1.0 / 0.0, "Infinity");
1186        test_toString(0.0 / 0.0, "NaN");
1187        test_toString(-1.0 / 0.0, "-Infinity");
1188
1189        double d;
1190        d = Double.longBitsToDouble(0x470fffffffffffffL);
1191        test_toString(d, "2.0769187434139308E34");
1192        d = Double.longBitsToDouble(0x4710000000000000L);
1193        test_toString(d, "2.076918743413931E34");
1194
1195        d = Double.longBitsToDouble(0x470000000000000aL);
1196        test_toString(d, "1.0384593717069678E34");
1197        d = Double.longBitsToDouble(0x470000000000000bL);
1198        test_toString(d, "1.038459371706968E34");
1199
1200        d = Double.longBitsToDouble(0x4700000000000017L);
1201        test_toString(d, "1.0384593717069708E34");
1202        d = Double.longBitsToDouble(0x4700000000000018L);
1203        test_toString(d, "1.038459371706971E34");
1204
1205        d = Double.longBitsToDouble(0x4700000000000024L);
1206        test_toString(d, "1.0384593717069738E34");
1207        d = Double.longBitsToDouble(0x4700000000000025L);
1208        test_toString(d, "1.038459371706974E34");
1209
1210        d = Double.longBitsToDouble(0x4700000000000031L);
1211        test_toString(d, "1.0384593717069768E34");
1212        d = Double.longBitsToDouble(0x4700000000000032L);
1213        test_toString(d, "1.038459371706977E34");
1214
1215        d = Double.longBitsToDouble(0x470000000000003eL);
1216        test_toString(d, "1.0384593717069798E34");
1217        d = Double.longBitsToDouble(0x470000000000003fL);
1218        test_toString(d, "1.03845937170698E34");
1219
1220        d = Double.longBitsToDouble(0x7e00000000000003L);
1221        test_toString(d, "8.371160993642719E298");
1222        d = Double.longBitsToDouble(0x7e00000000000004L);
1223        test_toString(d, "8.37116099364272E298");
1224
1225        d = Double.longBitsToDouble(0x7e00000000000008L);
1226        test_toString(d, "8.371160993642728E298");
1227        d = Double.longBitsToDouble(0x7e00000000000009L);
1228        test_toString(d, "8.37116099364273E298");
1229
1230        d = Double.longBitsToDouble(0x7e00000000000013L);
1231        test_toString(d, "8.371160993642749E298");
1232        d = Double.longBitsToDouble(0x7e00000000000014L);
1233        test_toString(d, "8.37116099364275E298");
1234
1235        d = Double.longBitsToDouble(0x7e00000000000023L);
1236        test_toString(d, "8.371160993642779E298");
1237        d = Double.longBitsToDouble(0x7e00000000000024L);
1238        test_toString(d, "8.37116099364278E298");
1239
1240        d = Double.longBitsToDouble(0x7e0000000000002eL);
1241        test_toString(d, "8.371160993642799E298");
1242        d = Double.longBitsToDouble(0x7e0000000000002fL);
1243        test_toString(d, "8.3711609936428E298");
1244
1245        d = Double.longBitsToDouble(0xda00000000000001L);
1246        test_toString(d, "-3.3846065602060736E125");
1247        d = Double.longBitsToDouble(0xda00000000000002L);
1248        test_toString(d, "-3.384606560206074E125");
1249
1250        d = Double.longBitsToDouble(0xda00000000000005L);
1251        test_toString(d, "-3.3846065602060766E125");
1252        d = Double.longBitsToDouble(0xda00000000000006L);
1253        test_toString(d, "-3.384606560206077E125");
1254
1255        d = Double.longBitsToDouble(0xda00000000000009L);
1256        test_toString(d, "-3.3846065602060796E125");
1257        d = Double.longBitsToDouble(0xda0000000000000aL);
1258        test_toString(d, "-3.38460656020608E125");
1259
1260        d = Double.longBitsToDouble(0xda0000000000000dL);
1261        test_toString(d, "-3.3846065602060826E125");
1262        d = Double.longBitsToDouble(0xda0000000000000eL);
1263        test_toString(d, "-3.384606560206083E125");
1264    }
1265
1266    /**
1267     * java.lang.Double#valueOf(java.lang.String)
1268     */
1269    public void test_valueOfLjava_lang_String() {
1270        // Test for method java.lang.Double
1271        // java.lang.Double.valueOf(java.lang.String)
1272        assertTrue("Incorrect double returned", Math.abs(Double.valueOf("999999999999.999")
1273                .doubleValue() - 999999999999.999d) < 1);
1274
1275        try {
1276            Double.valueOf(null);
1277            fail("Expected Double.valueOf(null) to throw NPE.");
1278        } catch (NullPointerException ex) {
1279            // expected
1280        }
1281
1282        try {
1283            Double.valueOf("");
1284            fail("Expected Double.valueOf(\"\") to throw NFE");
1285        } catch (NumberFormatException e) {
1286            // expected
1287        }
1288
1289        Double pi = Double.valueOf("3.141592654");
1290        assertEquals(3.141592654, pi.doubleValue(), 0D);
1291
1292        Double posZero = Double.valueOf("+0.0");
1293        Double negZero = Double.valueOf("-0.0");
1294        assertFalse("Doubletest0", posZero.equals(negZero));
1295
1296        // Tests for double values by name.
1297        Double expectedNaN = new Double(Double.NaN);
1298
1299        Double posNaN = Double.valueOf("NaN");
1300        assertTrue("Doubletest1", posNaN.equals(expectedNaN));
1301
1302        Double posNaNSigned = Double.valueOf("+NaN");
1303        assertTrue("Doubletest2", posNaNSigned.equals(expectedNaN));
1304
1305        Double negNaNSigned = Double.valueOf("-NaN");
1306        assertTrue("Doubletest3", negNaNSigned.equals(expectedNaN));
1307
1308        Double posInfinite = Double.valueOf("Infinity");
1309        assertTrue("Doubletest4", posInfinite.equals(new Double(Double.POSITIVE_INFINITY)));
1310
1311        Double posInfiniteSigned = Double.valueOf("+Infinity");
1312        assertTrue("Doubletest5", posInfiniteSigned
1313                .equals(new Double(Double.POSITIVE_INFINITY)));
1314
1315        Double negInfiniteSigned = Double.valueOf("-Infinity");
1316        assertTrue("Doubletest6", negInfiniteSigned
1317                .equals(new Double(Double.NEGATIVE_INFINITY)));
1318    }
1319
1320    /**
1321     * java.lang.Double#compareTo(java.lang.Double)
1322     * java.lang.Double#compare(double, double)
1323     */
1324    public void test_compareToLjava_lang_Double() {
1325        // A selection of double values in ascending order.
1326        double[] values = new double[] { Double.NEGATIVE_INFINITY, -Double.MAX_VALUE, -2d,
1327                -Double.MIN_VALUE, -0d, 0d, Double.MIN_VALUE, 2d, Double.MAX_VALUE,
1328                Double.POSITIVE_INFINITY, Double.NaN };
1329        for (int i = 0; i < values.length; i++) {
1330            double d1 = values[i];
1331
1332            // Test that each value compares equal to itself; and each object is
1333            // equal to another object like itself.
1334            assertTrue("Assert 0: compare() should be equal: " + d1,
1335                    Double.compare(d1, d1) == 0);
1336            Double objDouble = new Double(d1);
1337            assertTrue("Assert 1: compareTo() should be equal: " + d1, objDouble
1338                    .compareTo(objDouble) == 0);
1339
1340            // Test that the Double-defined order is respected
1341            for (int j = i + 1; j < values.length; j++) {
1342                double d2 = values[j];
1343                assertTrue("Assert 2: compare() " + d1 + " should be less " + d2, Double
1344                        .compare(d1, d2) == -1);
1345                assertTrue("Assert 3: compare() " + d2 + " should be greater " + d1, Double
1346                        .compare(d2, d1) == 1);
1347                Double D2 = new Double(d2);
1348                assertTrue("Assert 4: compareTo() " + d1 + " should be less " + d2, objDouble
1349                        .compareTo(D2) == -1);
1350                assertTrue("Assert 5: compareTo() " + d2 + " should be greater " + d1, D2
1351                        .compareTo(objDouble) == 1);
1352            }
1353        }
1354
1355        try {
1356            new Double(0.0D).compareTo(null);
1357            fail("No NPE");
1358        } catch (NullPointerException e) {
1359        }
1360    }
1361
1362    /**
1363     * java.lang.Double#equals(java.lang.Object)
1364     */
1365    public void test_equalsLjava_lang_Object() {
1366        Double d1 = new Double(87654321.12345d);
1367        Double d2 = new Double(87654321.12345d);
1368        Double d3 = new Double(0.0002f);
1369        assertTrue("Assert 0: Equality test failed", d1.equals(d2) && !(d1.equals(d3)));
1370
1371        assertTrue("Assert 2: NaN should not be == Nan", Double.NaN != Double.NaN);
1372        assertTrue("Assert 3: NaN should not be == Nan", new Double(Double.NaN)
1373                .equals(new Double(Double.NaN)));
1374        assertTrue("Assert 4: -0d should be == 0d", 0d == -0d);
1375        assertTrue("Assert 5: -0d should not be equals() 0d", !new Double(0d)
1376                .equals(new Double(-0d)));
1377
1378        Double dmax = new Double(Double.MAX_VALUE);
1379        Double dmax1 = new Double(Double.MAX_VALUE);
1380
1381        assertTrue("Equality test failed", dmax.equals(dmax1) && !(dmax.equals(new Object())));
1382    }
1383
1384    /**
1385     * java.lang.Double#toHexString(double)
1386     */
1387    public void test_toHexStringF() {
1388        // the follow values come from the Double Javadoc/Spec
1389        assertEquals("0x0.0p0", Double.toHexString(0.0D));
1390        assertEquals("-0x0.0p0", Double.toHexString(-0.0D));
1391        assertEquals("0x1.0p0", Double.toHexString(1.0D));
1392        assertEquals("-0x1.0p0", Double.toHexString(-1.0D));
1393        assertEquals("0x1.0p1", Double.toHexString(2.0D));
1394        assertEquals("0x1.8p1", Double.toHexString(3.0D));
1395        assertEquals("0x1.0p-1", Double.toHexString(0.5D));
1396        assertEquals("0x1.0p-2", Double.toHexString(0.25D));
1397        assertEquals("0x1.fffffffffffffp1023", Double.toHexString(Double.MAX_VALUE));
1398        assertEquals("0x0.0000000000001p-1022", Double.toHexString(Double.MIN_VALUE));
1399
1400        // test edge cases
1401        assertEquals("NaN", Double.toHexString(Double.NaN));
1402        assertEquals("-Infinity", Double.toHexString(Double.NEGATIVE_INFINITY));
1403        assertEquals("Infinity", Double.toHexString(Double.POSITIVE_INFINITY));
1404
1405        // test various numbers
1406        assertEquals("-0x1.da8p6", Double.toHexString(-118.625D));
1407        assertEquals("0x1.2957874cccccdp23", Double.toHexString(9743299.65D));
1408        assertEquals("0x1.2957874cccccdp23", Double.toHexString(9743299.65000D));
1409        assertEquals("0x1.2957874cccf63p23", Double.toHexString(9743299.650001234D));
1410        assertEquals("0x1.700d1061d3333p33", Double.toHexString(12349743299.65000D));
1411
1412        // test HARMONY-2132
1413        assertEquals("0x1.01p10", Double.toHexString(0x1.01p10));
1414    }
1415
1416    /**
1417     * java.lang.Double#valueOf(double)
1418     */
1419    public void test_valueOfD() {
1420        assertEquals(new Double(Double.MIN_VALUE), Double.valueOf(Double.MIN_VALUE));
1421        assertEquals(new Double(Double.MAX_VALUE), Double.valueOf(Double.MAX_VALUE));
1422        assertEquals(new Double(0), Double.valueOf(0));
1423
1424        int s = -128;
1425        while (s < 128) {
1426            assertEquals(new Double(s), Double.valueOf(s));
1427            assertEquals(new Double(s + 0.1D), Double.valueOf(s + 0.1D));
1428            s++;
1429        }
1430    }
1431
1432    /**
1433     * {@link java.lang.Double#MAX_EXPONENT}
1434     * @since 1.6
1435     */
1436    public void test_MAX_EXPONENT() {
1437        assertTrue("Wrong value of java.lang.Double.MAX_EXPONENT",
1438                Double.MAX_EXPONENT == 1023);
1439        assertTrue("Wrong value of java.lang.Double.MAX_EXPONENT",
1440                Double.MAX_EXPONENT == Math.getExponent(Double.MAX_VALUE));
1441    }
1442
1443    /**
1444     * {@link java.lang.Double#MIN_EXPONENT}
1445     * @since 1.6
1446     */
1447    public void test_MIN_EXPONENT() {
1448        assertTrue("Wrong value of java.lang.Double.MIN_EXPONENT",
1449                Double.MIN_EXPONENT == -1022);
1450        assertTrue("Wrong value of java.lang.Double.MIN_EXPONENT",
1451                Double.MIN_EXPONENT == Math.getExponent(Double.MIN_NORMAL));
1452    }
1453
1454    /**
1455     * {@link java.lang.Double#MIN_NORMAL}
1456     * @since 1.6
1457     */
1458    public void test_MIN_NORMAL() {
1459        assertTrue("Wrong value of java.lang.Double.MIN_NORMAL",
1460                Double.MIN_NORMAL == 0x1.0p-1022);
1461        assertTrue("Wrong value of java.lang.Double.MIN_NORMAL",
1462                Double.MIN_NORMAL == Double
1463                        .longBitsToDouble(0x0010000000000000L));
1464        assertTrue("Wrong value of java.lang.Double.MIN_NORMAL",
1465                Double.MIN_NORMAL == 2.2250738585072014E-308);
1466    }
1467}
1468