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 @SuppressWarnings("EqualsNaN") 1366 public void test_equalsLjava_lang_Object() { 1367 Double d1 = new Double(87654321.12345d); 1368 Double d2 = new Double(87654321.12345d); 1369 Double d3 = new Double(0.0002f); 1370 assertTrue("Assert 0: Equality test failed", d1.equals(d2) && !(d1.equals(d3))); 1371 1372 assertTrue("Assert 2: NaN should not be == Nan", Double.NaN != Double.NaN); 1373 assertTrue("Assert 3: NaN should not be == Nan", new Double(Double.NaN) 1374 .equals(new Double(Double.NaN))); 1375 assertTrue("Assert 4: -0d should be == 0d", 0d == -0d); 1376 assertTrue("Assert 5: -0d should not be equals() 0d", !new Double(0d) 1377 .equals(new Double(-0d))); 1378 1379 Double dmax = new Double(Double.MAX_VALUE); 1380 Double dmax1 = new Double(Double.MAX_VALUE); 1381 1382 assertTrue("Equality test failed", dmax.equals(dmax1) && !(dmax.equals(new Object()))); 1383 } 1384 1385 /** 1386 * java.lang.Double#toHexString(double) 1387 */ 1388 public void test_toHexStringF() { 1389 // the follow values come from the Double Javadoc/Spec 1390 assertEquals("0x0.0p0", Double.toHexString(0.0D)); 1391 assertEquals("-0x0.0p0", Double.toHexString(-0.0D)); 1392 assertEquals("0x1.0p0", Double.toHexString(1.0D)); 1393 assertEquals("-0x1.0p0", Double.toHexString(-1.0D)); 1394 assertEquals("0x1.0p1", Double.toHexString(2.0D)); 1395 assertEquals("0x1.8p1", Double.toHexString(3.0D)); 1396 assertEquals("0x1.0p-1", Double.toHexString(0.5D)); 1397 assertEquals("0x1.0p-2", Double.toHexString(0.25D)); 1398 assertEquals("0x1.fffffffffffffp1023", Double.toHexString(Double.MAX_VALUE)); 1399 assertEquals("0x0.0000000000001p-1022", Double.toHexString(Double.MIN_VALUE)); 1400 1401 // test edge cases 1402 assertEquals("NaN", Double.toHexString(Double.NaN)); 1403 assertEquals("-Infinity", Double.toHexString(Double.NEGATIVE_INFINITY)); 1404 assertEquals("Infinity", Double.toHexString(Double.POSITIVE_INFINITY)); 1405 1406 // test various numbers 1407 assertEquals("-0x1.da8p6", Double.toHexString(-118.625D)); 1408 assertEquals("0x1.2957874cccccdp23", Double.toHexString(9743299.65D)); 1409 assertEquals("0x1.2957874cccccdp23", Double.toHexString(9743299.65000D)); 1410 assertEquals("0x1.2957874cccf63p23", Double.toHexString(9743299.650001234D)); 1411 assertEquals("0x1.700d1061d3333p33", Double.toHexString(12349743299.65000D)); 1412 1413 // test HARMONY-2132 1414 assertEquals("0x1.01p10", Double.toHexString(0x1.01p10)); 1415 } 1416 1417 /** 1418 * java.lang.Double#valueOf(double) 1419 */ 1420 public void test_valueOfD() { 1421 assertEquals(new Double(Double.MIN_VALUE), Double.valueOf(Double.MIN_VALUE)); 1422 assertEquals(new Double(Double.MAX_VALUE), Double.valueOf(Double.MAX_VALUE)); 1423 assertEquals(new Double(0), Double.valueOf(0)); 1424 1425 int s = -128; 1426 while (s < 128) { 1427 assertEquals(new Double(s), Double.valueOf(s)); 1428 assertEquals(new Double(s + 0.1D), Double.valueOf(s + 0.1D)); 1429 s++; 1430 } 1431 } 1432 1433 /** 1434 * {@link java.lang.Double#MAX_EXPONENT} 1435 * @since 1.6 1436 */ 1437 public void test_MAX_EXPONENT() { 1438 assertTrue("Wrong value of java.lang.Double.MAX_EXPONENT", 1439 Double.MAX_EXPONENT == 1023); 1440 assertTrue("Wrong value of java.lang.Double.MAX_EXPONENT", 1441 Double.MAX_EXPONENT == Math.getExponent(Double.MAX_VALUE)); 1442 } 1443 1444 /** 1445 * {@link java.lang.Double#MIN_EXPONENT} 1446 * @since 1.6 1447 */ 1448 public void test_MIN_EXPONENT() { 1449 assertTrue("Wrong value of java.lang.Double.MIN_EXPONENT", 1450 Double.MIN_EXPONENT == -1022); 1451 assertTrue("Wrong value of java.lang.Double.MIN_EXPONENT", 1452 Double.MIN_EXPONENT == Math.getExponent(Double.MIN_NORMAL)); 1453 } 1454 1455 /** 1456 * {@link java.lang.Double#MIN_NORMAL} 1457 * @since 1.6 1458 */ 1459 public void test_MIN_NORMAL() { 1460 assertTrue("Wrong value of java.lang.Double.MIN_NORMAL", 1461 Double.MIN_NORMAL == 0x1.0p-1022); 1462 assertTrue("Wrong value of java.lang.Double.MIN_NORMAL", 1463 Double.MIN_NORMAL == Double 1464 .longBitsToDouble(0x0010000000000000L)); 1465 assertTrue("Wrong value of java.lang.Double.MIN_NORMAL", 1466 Double.MIN_NORMAL == 2.2250738585072014E-308); 1467 } 1468} 1469