DoubleTest.java revision 561ee011997c6c2f1befbfaa9d5f0a99771c1d63
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.luni.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 * @tests 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 * @tests 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 * @tests 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 * @tests java.lang.Double#compareTo(java.lang.Double) 245 * @tests 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 * @tests 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 * @tests 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 * @tests 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 * @tests 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 * @tests 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 * @tests 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 * @tests 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 * @tests java.lang.Double#isInfinite(double) 358 */ 359 public void test_isInfiniteD() { 360 // Test for method boolean java.lang.Double.isInfinite(double) 361 assertTrue("Infinity check failed", Double.isInfinite(Double.NEGATIVE_INFINITY) 362 && (Double.isInfinite(Double.POSITIVE_INFINITY)) 363 && !(Double.isInfinite(Double.MAX_VALUE))); 364 } 365 366 /** 367 * @tests java.lang.Double#isNaN() 368 */ 369 public void test_isNaN() { 370 // Test for method boolean java.lang.Double.isNaN() 371 Double d = new Double(0.0 / 0.0); 372 assertTrue("NAN returned false", d.isNaN()); 373 d = new Double(0); 374 assertTrue("Non NAN returned true", !d.isNaN()); 375 } 376 377 /** 378 * @tests java.lang.Double#isNaN(double) 379 */ 380 public void test_isNaND() { 381 // Test for method boolean java.lang.Double.isNaN(double) 382 383 Double d = new Double(0.0 / 0.0); 384 assertTrue("NAN check failed", Double.isNaN(d.doubleValue())); 385 } 386 387 /** 388 * @tests java.lang.Double#longBitsToDouble(long) 389 */ 390 public void test_longBitsToDoubleJ() { 391 // Test for method double java.lang.Double.longBitsToDouble(long) 392 393 Double d = new Double(Double.MAX_VALUE); 394 long lbits = Double.doubleToLongBits(d.doubleValue()); 395 double r = Double.longBitsToDouble(lbits); 396 397 assertTrue("Bit conversion failed", d.doubleValue() == r); 398 } 399 400 /** 401 * @tests java.lang.Double#longValue() 402 */ 403 public void test_longValue() { 404 // Test for method long java.lang.Double.longValue() 405 Double d = new Double(1923311.47712); 406 assertEquals("Returned incorrect long value", 1923311, d.longValue()); 407 } 408 409 /** 410 * @tests java.lang.Double#parseDouble(java.lang.String) 411 */ 412 public void test_parseDoubleLjava_lang_String() { 413 assertEquals("Incorrect double returned, expected zero.", 0.0, Double 414 .parseDouble("2.4703282292062327208828439643411e-324"), 0.0); 415 assertTrue("Incorrect double returned, expected minimum double.", Double 416 .parseDouble("2.4703282292062327208828439643412e-324") == Double.MIN_VALUE); 417 418 for (int i = 324; i > 0; i--) { 419 Double.parseDouble("3.4e-" + i); 420 } 421 for (int i = 0; i <= 309; i++) { 422 Double.parseDouble("1.2e" + i); 423 } 424 425 /* 426 * The first two cases and the last four cases have to placed outside 427 * the loop due to the difference in the expected output string. 428 */ 429 doTestCompareRawBits("3.4e-324", rawBitsFor3_4en324ToN1[0], "4.9e-324"); 430 doTestCompareRawBits("3.4e-323", rawBitsFor3_4en324ToN1[1], "3.5e-323"); 431 for (int i = 322; i > 3; i--) { 432 String testString, expectedString; 433 testString = expectedString = "3.4e-" + i; 434 doTestCompareRawBits(testString, rawBitsFor3_4en324ToN1[324 - i], expectedString); 435 } 436 doTestCompareRawBits("3.4e-3", rawBitsFor3_4en324ToN1[321], "0.0034"); 437 doTestCompareRawBits("3.4e-2", rawBitsFor3_4en324ToN1[322], "0.034"); 438 doTestCompareRawBits("3.4e-1", rawBitsFor3_4en324ToN1[323], "0.34"); 439 doTestCompareRawBits("3.4e-0", rawBitsFor3_4en324ToN1[324], "3.4"); 440 441 doTestCompareRawBits("1.2e0", rawBitsFor1_2e0To309[0], "1.2"); 442 doTestCompareRawBits("1.2e1", rawBitsFor1_2e0To309[1], "12.0"); 443 doTestCompareRawBits("1.2e2", rawBitsFor1_2e0To309[2], "120.0"); 444 doTestCompareRawBits("1.2e3", rawBitsFor1_2e0To309[3], "1200.0"); 445 doTestCompareRawBits("1.2e4", rawBitsFor1_2e0To309[4], "12000.0"); 446 doTestCompareRawBits("1.2e5", rawBitsFor1_2e0To309[5], "120000.0"); 447 doTestCompareRawBits("1.2e6", rawBitsFor1_2e0To309[6], "1200000.0"); 448 for (int i = 7; i <= 308; i++) { 449 String testString, expectedString; 450 testString = expectedString = "1.2e" + i; 451 doTestCompareRawBits(testString, rawBitsFor1_2e0To309[i], expectedString); 452 } 453 doTestCompareRawBits("1.2e309", rawBitsFor1_2e0To309[309], "Infinity"); 454 455 doTestCompareRawBits( 456 "111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000.92233720368547758079223372036854775807", 457 0x7e054218c295e43fL, "1.1122233344455567E299"); 458 doTestCompareRawBits( 459 "-111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000.92233720368547758079223372036854775807", 460 0xfe054218c295e43fL, "-1.1122233344455567E299"); 461 462 doTestCompareRawBits("1.234123412431233E107", 0x562ae7a25fe706ebL, 463 "1.234123412431233E107"); 464 doTestCompareRawBits("1.2341234124312331E107", 0x562ae7a25fe706ecL, 465 "1.2341234124312331E107"); 466 doTestCompareRawBits("1.2341234124312332E107", 0x562ae7a25fe706ecL, 467 "1.2341234124312331E107"); 468 doTestCompareRawBits("-1.234123412431233E107", 0xd62ae7a25fe706ebL, 469 "-1.234123412431233E107"); 470 doTestCompareRawBits("-1.2341234124312331E107", 0xd62ae7a25fe706ecL, 471 "-1.2341234124312331E107"); 472 doTestCompareRawBits("-1.2341234124312332E107", 0xd62ae7a25fe706ecL, 473 "-1.2341234124312331E107"); 474 475 doTestCompareRawBits("1e23", 0x44b52d02c7e14af6L, "1.0e23"); 476 477 /* 478 * These particular tests verify that the extreme boundary conditions 479 * are converted correctly. 480 */ 481 doTestCompareRawBits("0.0e-309", 0L, "0.0"); 482 doTestCompareRawBits("-0.0e-309", 0x8000000000000000L, "-0.0"); 483 doTestCompareRawBits("0.0e309", 0L, "0.0"); 484 doTestCompareRawBits("-0.0e309", 0x8000000000000000L, "-0.0"); 485 doTestCompareRawBits("0.1e309", 0x7fe1ccf385ebc8a0L, "1.0e308"); 486 doTestCompareRawBits("0.2e309", 0x7ff0000000000000L, "Infinity"); 487 doTestCompareRawBits("65e-325", 1L, "4.9e-324"); 488 doTestCompareRawBits("1000e-326", 2L, "1.0e-323"); 489 490 doTestCompareRawBits("4.0e-306", 0x86789e3750f791L, "4.0e-306"); 491 doTestCompareRawBits("2.22507e-308", 0xffffe2e8159d0L, "2.22507e-308"); 492 doTestCompareRawBits( 493 "111222333444555666777888999000111228999000.92233720368547758079223372036854775807", 494 0x48746da623f1dd8bL, "1.1122233344455567E41"); 495 doTestCompareRawBits( 496 "-111222333444555666777888999000111228999000.92233720368547758079223372036854775807", 497 0xc8746da623f1dd8bL, "-1.1122233344455567E41"); 498 doTestCompareRawBits( 499 "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890.987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210", 500 0x54820fe0ba17f469L, "1.2345678901234567E99"); 501 doTestCompareRawBits( 502 "-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890.987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210", 503 0xd4820fe0ba17f469L, "-1.2345678901234567E99"); 504 505 doTestCompareRawBits( 506 "179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01", 507 0x7fefffffffffffffL, "1.7976931348623157E308"); 508 doTestCompareRawBits( 509 "-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01", 510 0xffefffffffffffffL, "-1.7976931348623157E308"); 511 doTestCompareRawBits( 512 "1112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001234567890", 513 0x7ff0000000000000L, "Infinity"); 514 doTestCompareRawBits( 515 "-1112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001234567890", 516 0xfff0000000000000L, "-Infinity"); 517 doTestCompareRawBits( 518 "179769313486231590000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01", 519 0x7ff0000000000000L, "Infinity"); 520 doTestCompareRawBits( 521 "-179769313486231590000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01", 522 0xfff0000000000000L, "-Infinity"); 523 doTestCompareRawBits( 524 "0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", 525 0x2b392a32afcc661eL, "1.7976931348623157E-100"); 526 doTestCompareRawBits( 527 "-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", 528 0xab392a32afcc661eL, "-1.7976931348623157E-100"); 529 doTestCompareRawBits( 530 "0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", 531 0x1b3432f0cb68e61L, "1.7976931348623157E-300"); 532 doTestCompareRawBits( 533 "-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", 534 0x81b3432f0cb68e61L, "-1.7976931348623157E-300"); 535 doTestCompareRawBits( 536 "0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", 537 0x2117b590b942L, "1.79769313486234E-310"); 538 doTestCompareRawBits( 539 "-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", 540 0x80002117b590b942L, "-1.79769313486234E-310"); 541 doTestCompareRawBits( 542 "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", 543 0xe37L, "1.798E-320"); 544 doTestCompareRawBits( 545 "-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", 546 0x8000000000000e37L, "-1.798E-320"); 547 doTestCompareRawBits( 548 "0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", 549 0x2L, "1.0E-323"); 550 doTestCompareRawBits( 551 "-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", 552 0x8000000000000002L, "-1.0E-323"); 553 doTestCompareRawBits( 554 "0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055595409854908458349204328908234982349050934129878452378432452458968024357823490509341298784523784324524589680243578234905093412987845237843245245896802435782349050934129878452378432452458968024357868024357823490509341298784523784324524589680243578234905093412987845237843245245896802435786802435782349050934129878452378432452458968024357823490509341298784523784324524589680243578", 555 0x1L, "4.9E-324"); 556 doTestCompareRawBits( 557 "-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055595409854908458349204328908234982349050934129878452378432452458968024357823490509341298784523784324524589680243578234905093412987845237843245245896802435782349050934129878452378432452458968024357868024357823490509341298784523784324524589680243578234905093412987845237843245245896802435786802435782349050934129878452378432452458968024357823490509341298784523784324524589680243578", 558 0x8000000000000001L, "-4.9E-324"); 559 } 560 561 /** 562 * @tests java.lang.Double#parseDouble(java.lang.String) 563 */ 564 public void test_parseDouble_LString_Illegal() { 565 try { 566 Double.parseDouble("0.0p0D"); 567 fail("Should throw NumberFormatException."); 568 } catch (NumberFormatException e) { 569 // expected 570 } 571 572 try { 573 Double.parseDouble("+0x.p1d"); 574 fail("Should throw NumberFormatException."); 575 } catch (NumberFormatException e) { 576 // expected 577 } 578 579 try { 580 Double.parseDouble("0Xg.gp1D"); 581 fail("Should throw NumberFormatException."); 582 } catch (NumberFormatException e) { 583 // expected 584 } 585 586 try { 587 Double.parseDouble("-0x1.1p"); 588 fail("Should throw NumberFormatException."); 589 } catch (NumberFormatException e) { 590 // expected 591 } 592 593 try { 594 Double.parseDouble("+0x 1.1 p2d"); 595 fail("Should throw NumberFormatException."); 596 } catch (NumberFormatException e) { 597 // expected 598 } 599 600 try { 601 Double.parseDouble("x1.1p2d"); 602 fail("Should throw NumberFormatException."); 603 } catch (NumberFormatException e) { 604 // expected 605 } 606 607 try { 608 Double.parseDouble(" 0x-2.1p2"); 609 fail("Should throw NumberFormatException."); 610 } catch (NumberFormatException e) { 611 // expected 612 } 613 614 try { 615 Double.parseDouble(" 0x2.1pad"); 616 fail("Should throw NumberFormatException."); 617 } catch (NumberFormatException e) { 618 // expected 619 } 620 621 try { 622 Double.parseDouble(" 0x111.222p 22d"); 623 fail("Should throw NumberFormatException."); 624 } catch (NumberFormatException e) { 625 // expected 626 } 627 } 628 629 /** 630 * @tests java.lang.Double#parseDouble(java.lang.String) 631 */ 632 public void test_parseDouble_LString_FromHexString() { 633 double actual; 634 double expected; 635 636 actual = Double.parseDouble("0x0.0p0D"); 637 assertEquals("Returned incorrect value", 0.0d, actual, 0.0D); 638 639 actual = Double.parseDouble("0xa.ap+9d"); 640 assertEquals("Returned incorrect value", 5440.0d, actual, 0.0D); 641 642 actual = Double.parseDouble("+0Xb.10ap8"); 643 assertEquals("Returned incorrect value", 2832.625d, actual, 0.0D); 644 645 actual = Double.parseDouble("-0X.a0P2D"); 646 assertEquals("Returned incorrect value", -2.5d, actual, 0.0D); 647 648 actual = Double.parseDouble("\r 0x22.1p2d \t"); 649 assertEquals("Returned incorrect value", 136.25d, actual, 0.0D); 650 651 actual = Double.parseDouble("0x1.0p-1"); 652 assertEquals("Returned incorrect value", 0.5, actual, 0.0D); 653 654 actual = Double 655 .parseDouble("0x00000000000000000000000000000000001.0p-1"); 656 assertEquals("Returned incorrect value", 0.5, actual, 0.0D); 657 658 actual = Double.parseDouble("0x1.0p-00000000000000000000000000001"); 659 assertEquals("Returned incorrect value", 0.5, actual, 0.0D); 660 661 actual = Double.parseDouble("0x.100000000000000000000000000000000p1"); 662 assertEquals("Returned incorrect value", 0.125, actual, 0.0D); 663 664 actual = Double.parseDouble("0x0.0p999999999999999999999999999999999999999999999999999999999999999"); 665 assertEquals("Returned incorrect value", 0.0, actual, 0.0D); 666 667 actual = Double.parseDouble("0xf1.0p9999999999999999999999999999999999999999999999999999999999999999"); 668 assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D); 669 670 actual = Double.parseDouble("0xffffffffffffffffffffffffffffffffffff.ffffffffffffffffffffffffffffffffffffffffffffffp1"); 671 expected = Double.longBitsToDouble(0x4900000000000000L); 672 assertEquals("Returned incorrect value", expected, actual, 0.0D); 673 674 actual = Double.parseDouble("0x0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001p1600"); 675 expected = Double.longBitsToDouble(0x7f30000000000000L); 676 assertEquals("Returned incorrect value", expected, actual, 0.0D); 677 678 actual = Double.parseDouble("0x0.0p-999999999999999999999999999999999999999999999999999999"); 679 assertEquals("Returned incorrect value", 0.0, actual, 0.0D); 680 681 actual = Double.parseDouble("0xf1.0p-9999999999999999999999999999999999999999999999999999999999999999"); 682 assertEquals("Returned incorrect value", 0.0, actual, 0.0D); 683 684 actual = Double.parseDouble("0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000p-1600"); 685 expected = Double.longBitsToDouble(0xf0000000000000L); 686 assertEquals("Returned incorrect value", expected, actual, 0.0D); 687 688 actual = Double.parseDouble("0x1.p9223372036854775807"); 689 assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D); 690 691 actual = Double.parseDouble("0x1.p9223372036854775808"); 692 assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D); 693 694 actual = Double.parseDouble("0x10.p9223372036854775808"); 695 assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D); 696 697 actual = Double.parseDouble("0xabcd.ffffffffp+2000"); 698 assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D); 699 700 actual = Double.parseDouble("0x1.p-9223372036854775808"); 701 assertEquals("Returned incorrect value", 0.0, actual, 0.0D); 702 703 actual = Double.parseDouble("0x1.p-9223372036854775809"); 704 assertEquals("Returned incorrect value", 0.0, actual, 0.0D); 705 706 actual = Double.parseDouble("0x.1p-9223372036854775809"); 707 assertEquals("Returned incorrect value", 0.0, actual, 0.0D); 708 709 actual = Double.parseDouble("0xabcd.ffffffffffffffp-2000"); 710 assertEquals("Returned incorrect value", 0.0, actual, 0.0D); 711 } 712 713 /** 714 * @tests java.lang.Double#parseDouble(java.lang.String) 715 */ 716 public void test_parseDouble_LString_NormalPositiveExponent() { 717 long[] expecteds = { 718 0x3f323456789abcdfL, 0x40e111012345678aL, 0x41a1110091a2b3c5L, 719 0x4259998091a2b3c5L, 0x4311110048d159e2L, 0x43c5554048d159e2L, 720 0x4479998048d159e2L, 0x452dddc048d159e2L, 0x45e111002468acf1L, 721 0x469333202468acf1L, 0x4751011001234568L, 0x4802112101234568L, 722 0x48b3213201234568L, 0x4964314301234568L, 0x4a15415401234568L, 723 0x4ac6516501234568L, 0x4b77617601234568L, 0x4c28718701234568L, 724 0x4cd9819801234568L, 0x4d9049048091a2b4L, 0x4e4101100091a2b4L, 725 0x4ef189188091a2b4L, 0x4fa211210091a2b4L, 0x505299298091a2b4L, 726 0x510321320091a2b4L, 0x51b3a93a8091a2b4L, 0x526431430091a2b4L, 727 0x5314b94b8091a2b4L, 0x53c841840091a2b4L, 0x5478c98c8091a2b4L, 728 0x552981980091a2b4L, 0x55da09a08091a2b4L, 0x568a91a90091a2b4L, 729 0x573b19b18091a2b4L, 0x57eba1ba0091a2b4L, 0x589c29c28091a2b4L, 730 0x594cb1cb0091a2b4L, 0x5a001d01c048d15aL, 0x5ab061060048d15aL, 731 0x5b60a50a4048d15aL, 0x5c1101100048d15aL, 0x5cc145144048d15aL, 732 0x5d7189188048d15aL, 0x5e21cd1cc048d15aL, 0x5ed211210048d15aL, 733 0x5f8255254048d15aL, 0x603419418048d15aL, 0x60e45d45c048d15aL, 734 0x6194a14a0048d15aL, 0x6244e54e4048d15aL, 0x62f541540048d15aL, 735 0x63a585584048d15aL, 0x6455c95c8048d15aL, 0x65060d60c048d15aL, 736 0x65b651650048d15aL, 0x666815814048d15aL, 0x671859858048d15aL, 737 0x67c89d89c048d15aL, 0x6878e18e0048d15aL, 0x692925924048d15aL, 738 0x69d981980048d15aL, 0x6a89c59c4048d15aL, 0x6b3a09a08048d15aL, 739 0x6bea4da4c048d15aL, 0x6c9c11c10048d15aL, 0x6d4c55c54048d15aL, 740 0x6dfc99c98048d15aL, 0x6eacddcdc048d15aL, 0x6f5d21d20048d15aL, 741 0x700d65d64048d15aL, 0x70bdc1dc0048d15aL, 0x716e05e04048d15aL, 742 0x721e49e48048d15aL, 0x72d00700602468adL, 0x73802902802468adL, 743 0x74304b04a02468adL, 0x74e06d06c02468adL, 0x75908f08e02468adL, 744 0x7640b10b002468adL, 0x76f0d30d202468adL, 0x77a10110002468adL, 745 0x78512312202468adL, 0x79020520402468adL, 0x79b22722602468adL, 746 0x7a624924802468adL, 0x7b126b26a02468adL, 0x7bc28d28c02468adL, 747 0x7c72af2ae02468adL, 0x7d22d12d002468adL, 0x7dd2f32f202468adL, 748 0x7e832132002468adL, 0x7f40011001012345L, 0x7ff0000000000000L, 749 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, 750 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, 751 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, 752 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, 753 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, 754 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, 755 0x7ff0000000000000L, 0x7ff0000000000000L }; 756 757 for (int i = 0; i < expecteds.length; i++) { 758 int part = i*11; 759 String inputString = "0x" + part + "." + part + "0123456789abcdefp" + part; 760 761 double actual = Double.parseDouble(inputString); 762 double expected = Double.longBitsToDouble(expecteds[i]); 763 764 String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); 765 String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); 766 String errorMsg = i + "th input string is:<" + inputString 767 + ">.The expected result should be:<" + expectedString 768 + ">, but was: <" + actualString + ">. "; 769 770 assertEquals(errorMsg, expected, actual, 0.0D); 771 } 772 } 773 774 /** 775 * @tests java.lang.Double#parseDouble(java.lang.String) 776 */ 777 public void test_parseDouble_LString_NormalNegativeExponent() { 778 long[] expecteds = { 779 0x3f323456789abcdfL, 0x3f8111012345678aL, 0x3ee1110091a2b3c5L, 780 0x3e39998091a2b3c5L, 0x3d91110048d159e2L, 0x3ce5554048d159e2L, 781 0x3c39998048d159e2L, 0x3b8dddc048d159e2L, 0x3ae111002468acf1L, 782 0x3a3333202468acf1L, 0x3991011001234568L, 0x38e2112101234568L, 783 0x3833213201234568L, 0x3784314301234568L, 0x36d5415401234568L, 784 0x3626516501234568L, 0x3577617601234568L, 0x34c8718701234568L, 785 0x3419819801234568L, 0x337049048091a2b4L, 0x32c101100091a2b4L, 786 0x321189188091a2b4L, 0x316211210091a2b4L, 0x30b299298091a2b4L, 787 0x300321320091a2b4L, 0x2f53a93a8091a2b4L, 0x2ea431430091a2b4L, 788 0x2df4b94b8091a2b4L, 0x2d4841840091a2b4L, 0x2c98c98c8091a2b4L, 789 0x2be981980091a2b4L, 0x2b3a09a08091a2b4L, 0x2a8a91a90091a2b4L, 790 0x29db19b18091a2b4L, 0x292ba1ba0091a2b4L, 0x287c29c28091a2b4L, 791 0x27ccb1cb0091a2b4L, 0x27201d01c048d15aL, 0x267061060048d15aL, 792 0x25c0a50a4048d15aL, 0x251101100048d15aL, 0x246145144048d15aL, 793 0x23b189188048d15aL, 0x2301cd1cc048d15aL, 0x225211210048d15aL, 794 0x21a255254048d15aL, 0x20f419418048d15aL, 0x20445d45c048d15aL, 795 0x1f94a14a0048d15aL, 0x1ee4e54e4048d15aL, 0x1e3541540048d15aL, 796 0x1d8585584048d15aL, 0x1cd5c95c8048d15aL, 0x1c260d60c048d15aL, 797 0x1b7651650048d15aL, 0x1ac815814048d15aL, 0x1a1859858048d15aL, 798 0x19689d89c048d15aL, 0x18b8e18e0048d15aL, 0x180925924048d15aL, 799 0x175981980048d15aL, 0x16a9c59c4048d15aL, 0x15fa09a08048d15aL, 800 0x154a4da4c048d15aL, 0x149c11c10048d15aL, 0x13ec55c54048d15aL, 801 0x133c99c98048d15aL, 0x128cddcdc048d15aL, 0x11dd21d20048d15aL, 802 0x112d65d64048d15aL, 0x107dc1dc0048d15aL, 0xfce05e04048d15aL, 803 0xf1e49e48048d15aL, 0xe700700602468adL, 0xdc02902802468adL, 804 0xd104b04a02468adL, 0xc606d06c02468adL, 0xbb08f08e02468adL, 805 0xb00b10b002468adL, 0xa50d30d202468adL, 0x9a10110002468adL, 806 0x8f12312202468adL, 0x8420520402468adL, 0x7922722602468adL, 807 0x6e24924802468adL, 0x6326b26a02468adL, 0x5828d28c02468adL, 808 0x4d2af2ae02468adL, 0x422d12d002468adL, 0x372f32f202468adL, 809 0x2c32132002468adL, 0x220011001012345L, 0x170121012012345L, 810 0xc0231023012345L, 0x10341034012345L, 0x208a208a024L, 811 0x41584158L, 0x83388L, 0x108L, 812 0x0L, 0x0L, 0x0L, 813 0x0L, 0x0L, 0x0L, 814 0x0L, 0x0L, 0x0L, 815 0x0L, 0x0L, 0x0L, 816 0x0L, 0x0L }; 817 818 for (int i = 0; i < expecteds.length; i++) { 819 int part = i*11; 820 String inputString = "0x" + part + "." + part + "0123456789abcdefp-" + part; 821 822 double actual = Double.parseDouble(inputString); 823 double expected = Double.longBitsToDouble(expecteds[i]); 824 825 String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); 826 String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); 827 String errorMsg = i + "th input string is:<" + inputString 828 + ">.The expected result should be:<" + expectedString 829 + ">, but was: <" + actualString + ">. "; 830 831 assertEquals(errorMsg, expected, actual, 0.0D); 832 } 833 } 834 835 /** 836 * @tests java.lang.Double#parseDouble(java.lang.String) 837 */ 838 public void test_parseDouble_LString_MaxNormalBoundary() { 839 long[] expecteds = { 840 0x7fefffffffffffffL, 0x7fefffffffffffffL, 0x7fefffffffffffffL, 841 0x7fefffffffffffffL, 0x7fefffffffffffffL, 0x7fefffffffffffffL, 842 0x7fefffffffffffffL, 0x7ff0000000000000L, 0x7ff0000000000000L, 843 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, 844 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, 845 846 0xffefffffffffffffL, 0xffefffffffffffffL, 0xffefffffffffffffL, 847 0xffefffffffffffffL, 0xffefffffffffffffL, 0xffefffffffffffffL, 848 0xffefffffffffffffL, 0xfff0000000000000L, 0xfff0000000000000L, 849 0xfff0000000000000L, 0xfff0000000000000L, 0xfff0000000000000L, 850 0xfff0000000000000L, 0xfff0000000000000L, 0xfff0000000000000L }; 851 852 String[] inputs = { 853 "0x1.fffffffffffffp1023", 854 "0x1.fffffffffffff000000000000000000000000001p1023", 855 "0x1.fffffffffffff1p1023", 856 "0x1.fffffffffffff100000000000000000000000001p1023", 857 "0x1.fffffffffffff1fffffffffffffffffffffffffffffffffffffffffffffp1023", 858 "0x1.fffffffffffff7p1023", 859 "0x1.fffffffffffff700000000000000000000000001p1023", 860 "0x1.fffffffffffff8p1023", 861 "0x1.fffffffffffff800000000000000000000000001p1023", 862 "0x1.fffffffffffff8fffffffffffffffffffffffffffffffffffffffffffffp1023", 863 "0x1.fffffffffffff9p1023", 864 "0x1.fffffffffffff900000000000000000000000001p1023", 865 "0x1.ffffffffffffffp1023", 866 "0x1.ffffffffffffff00000000000000000000000001p1023", 867 "0x1.fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp1023", 868 869 "-0x1.fffffffffffffp1023", 870 "-0x1.fffffffffffff000000000000000000000000001p1023", 871 "-0x1.fffffffffffff1p1023", 872 "-0x1.fffffffffffff100000000000000000000000001p1023", 873 "-0x1.fffffffffffff1fffffffffffffffffffffffffffffffffffffffffffffp1023", 874 "-0x1.fffffffffffff7p1023", 875 "-0x1.fffffffffffff700000000000000000000000001p1023", 876 "-0x1.fffffffffffff8p1023", 877 "-0x1.fffffffffffff800000000000000000000000001p1023", 878 "-0x1.fffffffffffff8fffffffffffffffffffffffffffffffffffffffffffffp1023", 879 "-0x1.fffffffffffff9p1023", 880 "-0x1.fffffffffffff900000000000000000000000001p1023", 881 "-0x1.ffffffffffffffp1023", 882 "-0x1.ffffffffffffff00000000000000000000000001p1023", 883 "-0x1.fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp1023" }; 884 885 for (int i = 0; i < inputs.length; i++) { 886 double actual = Double.parseDouble(inputs[i]); 887 double expected = Double.longBitsToDouble(expecteds[i]); 888 889 String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); 890 String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); 891 String errorMsg = i + "th input string is:<" + inputs[i] 892 + ">.The expected result should be:<" + expectedString 893 + ">, but was: <" + actualString + ">. "; 894 895 assertEquals(errorMsg, expected, actual, 0.0D); 896 } 897 } 898 899 /** 900 * @tests java.lang.Double#parseDouble(java.lang.String) 901 */ 902 public void test_parseDouble_LString_MinNormalBoundary() { 903 long[] expecteds = { 904 0x10000000000000L, 0x10000000000000L, 0x10000000000000L, 905 0x10000000000000L, 0x10000000000000L, 0x10000000000000L, 906 0x10000000000000L, 0x10000000000000L, 0x10000000000001L, 907 0x10000000000001L, 0x10000000000001L, 0x10000000000001L, 908 0x10000000000001L, 0x10000000000001L, 0x10000000000001L, 909 910 0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L, 911 0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L, 912 0x8010000000000000L, 0x8010000000000000L, 0x8010000000000001L, 913 0x8010000000000001L, 0x8010000000000001L, 0x8010000000000001L, 914 0x8010000000000001L, 0x8010000000000001L, 0x8010000000000001L }; 915 916 String[] inputs = { 917 "0x1.0p-1022", 918 "0x1.00000000000001p-1022", 919 "0x1.000000000000010000000000000000001p-1022", 920 "0x1.00000000000001fffffffffffffffffffffffffffffffffp-1022", 921 "0x1.00000000000007p-1022", 922 "0x1.000000000000070000000000000000001p-1022", 923 "0x1.00000000000007fffffffffffffffffffffffffffffffffp-1022", 924 "0x1.00000000000008p-1022", 925 "0x1.000000000000080000000000000000001p-1022", 926 "0x1.00000000000008fffffffffffffffffffffffffffffffffp-1022", 927 "0x1.00000000000009p-1022", 928 "0x1.000000000000090000000000000000001p-1022", 929 "0x1.00000000000009fffffffffffffffffffffffffffffffffp-1022", 930 "0x1.0000000000000fp-1022", 931 "0x1.0000000000000ffffffffffffffffffffffffffffffffffp-1022", 932 933 "-0x1.0p-1022", 934 "-0x1.00000000000001p-1022", 935 "-0x1.000000000000010000000000000000001p-1022", 936 "-0x1.00000000000001fffffffffffffffffffffffffffffffffp-1022", 937 "-0x1.00000000000007p-1022", 938 "-0x1.000000000000070000000000000000001p-1022", 939 "-0x1.00000000000007fffffffffffffffffffffffffffffffffp-1022", 940 "-0x1.00000000000008p-1022", 941 "-0x1.000000000000080000000000000000001p-1022", 942 "-0x1.00000000000008fffffffffffffffffffffffffffffffffp-1022", 943 "-0x1.00000000000009p-1022", 944 "-0x1.000000000000090000000000000000001p-1022", 945 "-0x1.00000000000009fffffffffffffffffffffffffffffffffp-1022", 946 "-0x1.0000000000000fp-1022", 947 "-0x1.0000000000000ffffffffffffffffffffffffffffffffffp-1022" }; 948 949 for (int i = 0; i < inputs.length; i++) { 950 double actual = Double.parseDouble(inputs[i]); 951 double expected = Double.longBitsToDouble(expecteds[i]); 952 953 String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); 954 String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); 955 String errorMsg = i + "th input string is:<" + inputs[i] 956 + ">.The expected result should be:<" + expectedString 957 + ">, but was: <" + actualString + ">. "; 958 959 assertEquals(errorMsg, expected, actual, 0.0D); 960 } 961 } 962 963 /** 964 * @tests java.lang.Double#parseDouble(java.lang.String) 965 */ 966 public void test_parseDouble_LString_MaxSubNormalBoundary() { 967 long[] expecteds = { 968 0xfffffffffffffL, 0xfffffffffffffL, 0xfffffffffffffL, 969 0xfffffffffffffL, 0xfffffffffffffL, 0xfffffffffffffL, 970 0xfffffffffffffL, 0x10000000000000L, 0x10000000000000L, 971 0x10000000000000L, 0x10000000000000L, 0x10000000000000L, 972 0x10000000000000L, 0x10000000000000L, 0x10000000000000L, 973 974 0x800fffffffffffffL, 0x800fffffffffffffL, 0x800fffffffffffffL, 975 0x800fffffffffffffL, 0x800fffffffffffffL, 0x800fffffffffffffL, 976 0x800fffffffffffffL, 0x8010000000000000L, 0x8010000000000000L, 977 0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L, 978 0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L }; 979 980 String[] inputs = { 981 "0x0.fffffffffffffp-1022", 982 "0x0.fffffffffffff00000000000000000000000000000000001p-1022", 983 "0x0.fffffffffffff1p-1022", 984 "0x0.fffffffffffff10000000000000000000000000000000001p-1022", 985 "0x0.fffffffffffff1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", 986 "0x0.fffffffffffff7p-1022", 987 "0x0.fffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", 988 "0x0.fffffffffffff8p-1022", 989 "0x0.fffffffffffff80000000000000000000000000000000001p-1022", 990 "0x0.fffffffffffff8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", 991 "0x0.fffffffffffff9p-1022", 992 "0x0.fffffffffffff9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", 993 "0x0.ffffffffffffffp-1022", 994 "0x0.ffffffffffffff0000000000000000000000000000000001p-1022", 995 "0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", 996 997 "-0x0.fffffffffffffp-1022", 998 "-0x0.fffffffffffff00000000000000000000000000000000001p-1022", 999 "-0x0.fffffffffffff1p-1022", 1000 "-0x0.fffffffffffff10000000000000000000000000000000001p-1022", 1001 "-0x0.fffffffffffff1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", 1002 "-0x0.fffffffffffff7p-1022", 1003 "-0x0.fffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", 1004 "-0x0.fffffffffffff8p-1022", 1005 "-0x0.fffffffffffff80000000000000000000000000000000001p-1022", 1006 "-0x0.fffffffffffff8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", 1007 "-0x0.fffffffffffff9p-1022", 1008 "-0x0.fffffffffffff9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", 1009 "-0x0.ffffffffffffffp-1022", 1010 "-0x0.ffffffffffffff0000000000000000000000000000000001p-1022", 1011 "-0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022" }; 1012 1013 for (int i = 0; i < inputs.length; i++) { 1014 double actual = Double.parseDouble(inputs[i]); 1015 double expected = Double.longBitsToDouble(expecteds[i]); 1016 1017 String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); 1018 String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); 1019 String errorMsg = i + "th input string is:<" + inputs[i] 1020 + ">.The expected result should be:<" + expectedString 1021 + ">, but was: <" + actualString + ">. "; 1022 1023 assertEquals(errorMsg, expected, actual, 0.0D); 1024 } 1025 } 1026 1027 /** 1028 * @tests java.lang.Double#parseDouble(java.lang.String) 1029 */ 1030 public void test_parseDouble_LString_MinSubNormalBoundary() { 1031 long[] expecteds = { 1032 0x1L, 0x1L, 0x2L, 1033 0x1L, 0x1L, 0x1L, 1034 0x2L, 0x2L, 0x2L, 1035 0x2L, 0x2L, 0x2L, 1036 0x2L, 0x2L, 0x2L, 1037 1038 0x8000000000000001L, 0x8000000000000001L, 0x8000000000000002L, 1039 0x8000000000000001L, 0x8000000000000001L, 0x8000000000000001L, 1040 0x8000000000000002L, 0x8000000000000002L, 0x8000000000000002L, 1041 0x8000000000000002L, 0x8000000000000002L, 0x8000000000000002L, 1042 0x8000000000000002L, 0x8000000000000002L, 0x8000000000000002L }; 1043 1044 String[] inputs = { 1045 "0x0.0000000000001p-1022", 1046 "0x0.00000000000010000000000000000001p-1022", 1047 "0x0.0000000000001fffffffffffffffffffffffffffffffffp-1022", 1048 "0x0.00000000000017p-1022", 1049 "0x0.000000000000170000000000000000001p-1022", 1050 "0x0.00000000000017fffffffffffffffffffffffffffffffffp-1022", 1051 "0x0.00000000000018p-1022", 1052 "0x0.000000000000180000000000000000001p-1022", 1053 "0x0.00000000000018fffffffffffffffffffffffffffffffffp-1022", 1054 "0x0.00000000000019p-1022", 1055 "0x0.000000000000190000000000000000001p-1022", 1056 "0x0.00000000000019fffffffffffffffffffffffffffffffffp-1022", 1057 "0x0.0000000000001fp-1022", 1058 "0x0.0000000000001f0000000000000000001p-1022", 1059 "0x0.0000000000001ffffffffffffffffffffffffffffffffffp-1022", 1060 1061 "-0x0.0000000000001p-1022", 1062 "-0x0.00000000000010000000000000000001p-1022", 1063 "-0x0.0000000000001fffffffffffffffffffffffffffffffffp-1022", 1064 "-0x0.00000000000017p-1022", 1065 "-0x0.000000000000170000000000000000001p-1022", 1066 "-0x0.00000000000017fffffffffffffffffffffffffffffffffp-1022", 1067 "-0x0.00000000000018p-1022", 1068 "-0x0.000000000000180000000000000000001p-1022", 1069 "-0x0.00000000000018fffffffffffffffffffffffffffffffffp-1022", 1070 "-0x0.00000000000019p-1022", 1071 "-0x0.000000000000190000000000000000001p-1022", 1072 "-0x0.00000000000019fffffffffffffffffffffffffffffffffp-1022", 1073 "-0x0.0000000000001fp-1022", 1074 "-0x0.0000000000001f0000000000000000001p-1022", 1075 "-0x0.0000000000001ffffffffffffffffffffffffffffffffffp-1022" }; 1076 1077 for (int i = 0; i < inputs.length; i++) { 1078 double actual = Double.parseDouble(inputs[i]); 1079 double expected = Double.longBitsToDouble(expecteds[i]); 1080 1081 String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); 1082 String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); 1083 String errorMsg = i + "th input string is:<" + inputs[i] 1084 + ">.The expected result should be:<" + expectedString 1085 + ">, but was: <" + actualString + ">. "; 1086 1087 assertEquals(errorMsg, expected, actual, 0.0D); 1088 } 1089 } 1090 1091 /** 1092 * @tests java.lang.Double#parseDouble(java.lang.String) 1093 */ 1094 public void test_parseDouble_LString_ZeroBoundary() { 1095 long[] expecteds = { 1096 0x0L, 0x0L, 0x0L, 1097 0x1L, 0x1L, 0x1L, 1098 0x1L, 0x1L, 0x1L, 1099 0x8000000000000000L, 0x8000000000000000L, 0x8000000000000000L, 1100 0x8000000000000001L, 0x8000000000000001L, 0x8000000000000001L, 1101 0x8000000000000001L, 0x8000000000000001L, 0x8000000000000001L }; 1102 1103 String[] inputs = { 1104 "0x0.00000000000004p-1022", 1105 "0x0.00000000000007ffffffffffffffffffffffp-1022", 1106 "0x0.00000000000008p-1022", 1107 "0x0.000000000000080000000000000000001p-1022", 1108 "0x0.00000000000008fffffffffffffffffffffffffffffffp-1022", 1109 "0x0.00000000000009p-1022", 1110 "0x0.000000000000090000000000000000001p-1022", 1111 "0x0.00000000000009fffffffffffffffffffffffffffffffffp-1022", 1112 "0x0.0000000000000fffffffffffffffffffffffffffffffffffp-1022", 1113 1114 "-0x0.00000000000004p-1022", 1115 "-0x0.00000000000007ffffffffffffffffffffffp-1022", 1116 "-0x0.00000000000008p-1022", 1117 "-0x0.000000000000080000000000000000001p-1022", 1118 "-0x0.00000000000008fffffffffffffffffffffffffffffffp-1022", 1119 "-0x0.00000000000009p-1022", 1120 "-0x0.000000000000090000000000000000001p-1022", 1121 "-0x0.00000000000009fffffffffffffffffffffffffffffffffp-1022", 1122 "-0x0.0000000000000fffffffffffffffffffffffffffffffffffp-1022" }; 1123 1124 for (int i = 0; i < inputs.length; i++) { 1125 double actual = Double.parseDouble(inputs[i]); 1126 double expected = Double.longBitsToDouble(expecteds[i]); 1127 1128 String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); 1129 String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); 1130 String errorMsg = i + "th input string is:<" + inputs[i] 1131 + ">.The expected result should be:<" + expectedString 1132 + ">, but was: <" + actualString + ">. "; 1133 1134 assertEquals(errorMsg, expected, actual, 0.0D); 1135 } 1136 } 1137 1138 /** 1139 * @tests java.lang.Double#shortValue() 1140 */ 1141 public void test_shortValue() { 1142 // Test for method short java.lang.Double.shortValue() 1143 Double d = new Double(1923311.47712); 1144 assertEquals("Returned incorrect short value", 22767, d.shortValue()); 1145 } 1146 1147 /** 1148 * @tests java.lang.Double#toString() 1149 */ 1150 public void test_toString() { 1151 // Test for method java.lang.String java.lang.Double.toString() 1152 test_toString(1.7976931348623157E308, "1.7976931348623157E308"); 1153 test_toString(5.0E-4, "5.0E-4"); 1154 } 1155 1156 /** 1157 * @tests java.lang.Double#toString(double) 1158 */ 1159 public void test_toStringD() { 1160 // Test for method java.lang.String java.lang.Double.toString(double) 1161 test_toString(1.7976931348623157E308, "1.7976931348623157E308"); 1162 test_toString(1.0 / 0.0, "Infinity"); 1163 test_toString(0.0 / 0.0, "NaN"); 1164 test_toString(-1.0 / 0.0, "-Infinity"); 1165 1166 double d; 1167 d = Double.longBitsToDouble(0x470fffffffffffffL); 1168 test_toString(d, "2.0769187434139308E34"); 1169 d = Double.longBitsToDouble(0x4710000000000000L); 1170 test_toString(d, "2.076918743413931E34"); 1171 1172 d = Double.longBitsToDouble(0x470000000000000aL); 1173 test_toString(d, "1.0384593717069678E34"); 1174 d = Double.longBitsToDouble(0x470000000000000bL); 1175 test_toString(d, "1.038459371706968E34"); 1176 1177 d = Double.longBitsToDouble(0x4700000000000017L); 1178 test_toString(d, "1.0384593717069708E34"); 1179 d = Double.longBitsToDouble(0x4700000000000018L); 1180 test_toString(d, "1.038459371706971E34"); 1181 1182 d = Double.longBitsToDouble(0x4700000000000024L); 1183 test_toString(d, "1.0384593717069738E34"); 1184 d = Double.longBitsToDouble(0x4700000000000025L); 1185 test_toString(d, "1.038459371706974E34"); 1186 1187 d = Double.longBitsToDouble(0x4700000000000031L); 1188 test_toString(d, "1.0384593717069768E34"); 1189 d = Double.longBitsToDouble(0x4700000000000032L); 1190 test_toString(d, "1.038459371706977E34"); 1191 1192 d = Double.longBitsToDouble(0x470000000000003eL); 1193 test_toString(d, "1.0384593717069798E34"); 1194 d = Double.longBitsToDouble(0x470000000000003fL); 1195 test_toString(d, "1.03845937170698E34"); 1196 1197 d = Double.longBitsToDouble(0x7e00000000000003L); 1198 test_toString(d, "8.371160993642719E298"); 1199 d = Double.longBitsToDouble(0x7e00000000000004L); 1200 test_toString(d, "8.37116099364272E298"); 1201 1202 d = Double.longBitsToDouble(0x7e00000000000008L); 1203 test_toString(d, "8.371160993642728E298"); 1204 d = Double.longBitsToDouble(0x7e00000000000009L); 1205 test_toString(d, "8.37116099364273E298"); 1206 1207 d = Double.longBitsToDouble(0x7e00000000000013L); 1208 test_toString(d, "8.371160993642749E298"); 1209 d = Double.longBitsToDouble(0x7e00000000000014L); 1210 test_toString(d, "8.37116099364275E298"); 1211 1212 d = Double.longBitsToDouble(0x7e00000000000023L); 1213 test_toString(d, "8.371160993642779E298"); 1214 d = Double.longBitsToDouble(0x7e00000000000024L); 1215 test_toString(d, "8.37116099364278E298"); 1216 1217 d = Double.longBitsToDouble(0x7e0000000000002eL); 1218 test_toString(d, "8.371160993642799E298"); 1219 d = Double.longBitsToDouble(0x7e0000000000002fL); 1220 test_toString(d, "8.3711609936428E298"); 1221 1222 d = Double.longBitsToDouble(0xda00000000000001L); 1223 test_toString(d, "-3.3846065602060736E125"); 1224 d = Double.longBitsToDouble(0xda00000000000002L); 1225 test_toString(d, "-3.384606560206074E125"); 1226 1227 d = Double.longBitsToDouble(0xda00000000000005L); 1228 test_toString(d, "-3.3846065602060766E125"); 1229 d = Double.longBitsToDouble(0xda00000000000006L); 1230 test_toString(d, "-3.384606560206077E125"); 1231 1232 d = Double.longBitsToDouble(0xda00000000000009L); 1233 test_toString(d, "-3.3846065602060796E125"); 1234 d = Double.longBitsToDouble(0xda0000000000000aL); 1235 test_toString(d, "-3.38460656020608E125"); 1236 1237 d = Double.longBitsToDouble(0xda0000000000000dL); 1238 test_toString(d, "-3.3846065602060826E125"); 1239 d = Double.longBitsToDouble(0xda0000000000000eL); 1240 test_toString(d, "-3.384606560206083E125"); 1241 } 1242 1243 /** 1244 * @tests java.lang.Double#valueOf(java.lang.String) 1245 */ 1246 public void test_valueOfLjava_lang_String() { 1247 // Test for method java.lang.Double 1248 // java.lang.Double.valueOf(java.lang.String) 1249 assertTrue("Incorrect double returned", Math.abs(Double.valueOf("999999999999.999") 1250 .doubleValue() - 999999999999.999d) < 1); 1251 1252 try { 1253 Double.valueOf(null); 1254 fail("Expected Double.valueOf(null) to throw NPE."); 1255 } catch (NullPointerException ex) { 1256 // expected 1257 } 1258 1259 try { 1260 Double.valueOf(""); 1261 fail("Expected Double.valueOf(\"\") to throw NFE"); 1262 } catch (NumberFormatException e) { 1263 // expected 1264 } 1265 1266 Double pi = Double.valueOf("3.141592654"); 1267 assertEquals(3.141592654, pi.doubleValue(), 0D); 1268 1269 Double posZero = Double.valueOf("+0.0"); 1270 Double negZero = Double.valueOf("-0.0"); 1271 assertFalse("Doubletest0", posZero.equals(negZero)); 1272 1273 // Tests for double values by name. 1274 Double expectedNaN = new Double(Double.NaN); 1275 1276 Double posNaN = Double.valueOf("NaN"); 1277 assertTrue("Doubletest1", posNaN.equals(expectedNaN)); 1278 1279 Double posNaNSigned = Double.valueOf("+NaN"); 1280 assertTrue("Doubletest2", posNaNSigned.equals(expectedNaN)); 1281 1282 Double negNaNSigned = Double.valueOf("-NaN"); 1283 assertTrue("Doubletest3", negNaNSigned.equals(expectedNaN)); 1284 1285 Double posInfinite = Double.valueOf("Infinity"); 1286 assertTrue("Doubletest4", posInfinite.equals(new Double(Double.POSITIVE_INFINITY))); 1287 1288 Double posInfiniteSigned = Double.valueOf("+Infinity"); 1289 assertTrue("Doubletest5", posInfiniteSigned 1290 .equals(new Double(Double.POSITIVE_INFINITY))); 1291 1292 Double negInfiniteSigned = Double.valueOf("-Infinity"); 1293 assertTrue("Doubletest6", negInfiniteSigned 1294 .equals(new Double(Double.NEGATIVE_INFINITY))); 1295 } 1296 1297 /** 1298 * @tests java.lang.Double#compareTo(java.lang.Double) 1299 * @tests java.lang.Double#compare(double, double) 1300 */ 1301 public void test_compareToLjava_lang_Double() { 1302 // A selection of double values in ascending order. 1303 double[] values = new double[] { Double.NEGATIVE_INFINITY, -Double.MAX_VALUE, -2d, 1304 -Double.MIN_VALUE, -0d, 0d, Double.MIN_VALUE, 2d, Double.MAX_VALUE, 1305 Double.POSITIVE_INFINITY, Double.NaN }; 1306 for (int i = 0; i < values.length; i++) { 1307 double d1 = values[i]; 1308 1309 // Test that each value compares equal to itself; and each object is 1310 // equal to another object like itself. 1311 assertTrue("Assert 0: compare() should be equal: " + d1, 1312 Double.compare(d1, d1) == 0); 1313 Double objDouble = new Double(d1); 1314 assertTrue("Assert 1: compareTo() should be equal: " + d1, objDouble 1315 .compareTo(objDouble) == 0); 1316 1317 // Test that the Double-defined order is respected 1318 for (int j = i + 1; j < values.length; j++) { 1319 double d2 = values[j]; 1320 assertTrue("Assert 2: compare() " + d1 + " should be less " + d2, Double 1321 .compare(d1, d2) == -1); 1322 assertTrue("Assert 3: compare() " + d2 + " should be greater " + d1, Double 1323 .compare(d2, d1) == 1); 1324 Double D2 = new Double(d2); 1325 assertTrue("Assert 4: compareTo() " + d1 + " should be less " + d2, objDouble 1326 .compareTo(D2) == -1); 1327 assertTrue("Assert 5: compareTo() " + d2 + " should be greater " + d1, D2 1328 .compareTo(objDouble) == 1); 1329 } 1330 } 1331 1332 try { 1333 new Double(0.0D).compareTo(null); 1334 fail("No NPE"); 1335 } catch (NullPointerException e) { 1336 } 1337 } 1338 1339 /** 1340 * @tests java.lang.Double#equals(java.lang.Object) 1341 */ 1342 public void test_equalsLjava_lang_Object() { 1343 Double d1 = new Double(87654321.12345d); 1344 Double d2 = new Double(87654321.12345d); 1345 Double d3 = new Double(0.0002f); 1346 assertTrue("Assert 0: Equality test failed", d1.equals(d2) && !(d1.equals(d3))); 1347 1348 assertTrue("Assert 2: NaN should not be == Nan", Double.NaN != Double.NaN); 1349 assertTrue("Assert 3: NaN should not be == Nan", new Double(Double.NaN) 1350 .equals(new Double(Double.NaN))); 1351 assertTrue("Assert 4: -0d should be == 0d", 0d == -0d); 1352 assertTrue("Assert 5: -0d should not be equals() 0d", !new Double(0d) 1353 .equals(new Double(-0d))); 1354 1355 Double dmax = new Double(Double.MAX_VALUE); 1356 Double dmax1 = new Double(Double.MAX_VALUE); 1357 1358 assertTrue("Equality test failed", dmax.equals(dmax1) && !(dmax.equals(new Object()))); 1359 } 1360 1361 /** 1362 * @tests java.lang.Double#toHexString(double) 1363 */ 1364 public void test_toHexStringF() { 1365 // the follow values come from the Double Javadoc/Spec 1366 assertEquals("0x0.0p0", Double.toHexString(0.0D)); 1367 assertEquals("-0x0.0p0", Double.toHexString(-0.0D)); 1368 assertEquals("0x1.0p0", Double.toHexString(1.0D)); 1369 assertEquals("-0x1.0p0", Double.toHexString(-1.0D)); 1370 assertEquals("0x1.0p1", Double.toHexString(2.0D)); 1371 assertEquals("0x1.8p1", Double.toHexString(3.0D)); 1372 assertEquals("0x1.0p-1", Double.toHexString(0.5D)); 1373 assertEquals("0x1.0p-2", Double.toHexString(0.25D)); 1374 assertEquals("0x1.fffffffffffffp1023", Double.toHexString(Double.MAX_VALUE)); 1375 assertEquals("0x0.0000000000001p-1022", Double.toHexString(Double.MIN_VALUE)); 1376 1377 // test edge cases 1378 assertEquals("NaN", Double.toHexString(Double.NaN)); 1379 assertEquals("-Infinity", Double.toHexString(Double.NEGATIVE_INFINITY)); 1380 assertEquals("Infinity", Double.toHexString(Double.POSITIVE_INFINITY)); 1381 1382 // test various numbers 1383 assertEquals("-0x1.da8p6", Double.toHexString(-118.625D)); 1384 assertEquals("0x1.2957874cccccdp23", Double.toHexString(9743299.65D)); 1385 assertEquals("0x1.2957874cccccdp23", Double.toHexString(9743299.65000D)); 1386 assertEquals("0x1.2957874cccf63p23", Double.toHexString(9743299.650001234D)); 1387 assertEquals("0x1.700d1061d3333p33", Double.toHexString(12349743299.65000D)); 1388 1389 // test HARMONY-2132 1390 assertEquals("0x1.01p10", Double.toHexString(0x1.01p10)); 1391 } 1392 1393 /** 1394 * @tests java.lang.Double#valueOf(double) 1395 */ 1396 public void test_valueOfD() { 1397 assertEquals(new Double(Double.MIN_VALUE), Double.valueOf(Double.MIN_VALUE)); 1398 assertEquals(new Double(Double.MAX_VALUE), Double.valueOf(Double.MAX_VALUE)); 1399 assertEquals(new Double(0), Double.valueOf(0)); 1400 1401 int s = -128; 1402 while (s < 128) { 1403 assertEquals(new Double(s), Double.valueOf(s)); 1404 assertEquals(new Double(s + 0.1D), Double.valueOf(s + 0.1D)); 1405 s++; 1406 } 1407 } 1408 1409 /** 1410 * @tests {@link java.lang.Double#MAX_EXPONENT} 1411 * @since 1.6 1412 */ 1413 public void test_MAX_EXPONENT() { 1414 assertTrue("Wrong value of java.lang.Double.MAX_EXPONENT", 1415 Double.MAX_EXPONENT == 1023); 1416 assertTrue("Wrong value of java.lang.Double.MAX_EXPONENT", 1417 Double.MAX_EXPONENT == Math.getExponent(Double.MAX_VALUE)); 1418 } 1419 1420 /** 1421 * @tests {@link java.lang.Double#MIN_EXPONENT} 1422 * @since 1.6 1423 */ 1424 public void test_MIN_EXPONENT() { 1425 assertTrue("Wrong value of java.lang.Double.MIN_EXPONENT", 1426 Double.MIN_EXPONENT == -1022); 1427 assertTrue("Wrong value of java.lang.Double.MIN_EXPONENT", 1428 Double.MIN_EXPONENT == Math.getExponent(Double.MIN_NORMAL)); 1429 } 1430 1431 /** 1432 * @tests {@link java.lang.Double#MIN_NORMAL} 1433 * @since 1.6 1434 */ 1435 public void test_MIN_NORMAL() { 1436 assertTrue("Wrong value of java.lang.Double.MIN_NORMAL", 1437 Double.MIN_NORMAL == 0x1.0p-1022); 1438 assertTrue("Wrong value of java.lang.Double.MIN_NORMAL", 1439 Double.MIN_NORMAL == Double 1440 .longBitsToDouble(0x0010000000000000L)); 1441 assertTrue("Wrong value of java.lang.Double.MIN_NORMAL", 1442 Double.MIN_NORMAL == 2.2250738585072014E-308); 1443 } 1444} 1445