external/bsd/libc++/dist/libcxx/test/strings/string.conversions/stold.pass.cpp

   1 //===----------------------------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is dual licensed under the MIT and the University of Illinois Open
   6 // Source Licenses. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // <string>
  11
  12 // long double stold(const string& str, size_t *idx = 0);
  13 // long double stold(const wstring& str, size_t *idx = 0);
  14
  15 #include <iostream>
  16
  17 #include <string>
  18 #include <cmath>
  19 #include <cassert>
  20
  21 int main()
  22 {
  23     assert(std::stold("0") == 0);
  24     assert(std::stold(L"0") == 0);
  25     assert(std::stold("-0") == 0);
  26     assert(std::stold(L"-0") == 0);
  27     assert(std::stold("-10") == -10);
  28     assert(std::stold(L"-10.5") == -10.5);
  29     assert(std::stold(" 10") == 10);
  30     assert(std::stold(L" 10") == 10);
  31     size_t idx = 0;
  32     assert(std::stold("10g", &idx) == 10);
  33     assert(idx == 2);
  34     idx = 0;
  35     assert(std::stold(L"10g", &idx) == 10);
  36     assert(idx == 2);
  37     try
  38     {
  39         assert(std::stold("1.e60", &idx) == 1.e60L);
  40         assert(idx == 5);
  41     }
  42     catch (const std::out_of_range&)
  43     {
  44         assert(false);
  45     }
  46     try
  47     {
  48         assert(std::stold(L"1.e60", &idx) == 1.e60L);
  49         assert(idx == 5);
  50     }
  51     catch (const std::out_of_range&)
  52     {
  53         assert(false);
  54     }
  55     idx = 0;
  56     try
  57     {
  58         assert(std::stold("1.e6000", &idx) == INFINITY);
  59         assert(false);
  60     }
  61     catch (const std::out_of_range&)
  62     {
  63         assert(idx == 0);
  64     }
  65     try
  66     {
  67         assert(std::stold(L"1.e6000", &idx) == INFINITY);
  68         assert(false);
  69     }
  70     catch (const std::out_of_range&)
  71     {
  72         assert(idx == 0);
  73     }
  74     try
  75     {
  76         assert(std::stold("INF", &idx) == INFINITY);
  77         assert(idx == 3);
  78     }
  79     catch (const std::out_of_range&)
  80     {
  81         assert(false);
  82     }
  83     idx = 0;
  84     try
  85     {
  86         assert(std::stold(L"INF", &idx) == INFINITY);
  87         assert(idx == 3);
  88     }
  89     catch (const std::out_of_range&)
  90     {
  91         assert(false);
  92     }
  93     idx = 0;
  94     try
  95     {
  96         assert(std::isnan(std::stold("NAN", &idx)));
  97         assert(idx == 3);
  98     }
  99     catch (const std::out_of_range&)
 100     {
 101         assert(false);
 102     }
 103     idx = 0;
 104     try
 105     {
 106         assert(std::isnan(std::stold(L"NAN", &idx)));
 107         assert(idx == 3);
 108     }
 109     catch (const std::out_of_range&)
 110     {
 111         assert(false);
 112     }
 113     idx = 0;
 114     try
 115     {
 116         std::stold("", &idx);
 117         assert(false);
 118     }
 119     catch (const std::invalid_argument&)
 120     {
 121         assert(idx == 0);
 122     }
 123     try
 124     {
 125         std::stold(L"", &idx);
 126         assert(false);
 127     }
 128     catch (const std::invalid_argument&)
 129     {
 130         assert(idx == 0);
 131     }
 132     try
 133     {
 134         std::stold("  - 8", &idx);
 135         assert(false);
 136     }
 137     catch (const std::invalid_argument&)
 138     {
 139         assert(idx == 0);
 140     }
 141     try
 142     {
 143         std::stold(L"  - 8", &idx);
 144         assert(false);
 145     }
 146     catch (const std::invalid_argument&)
 147     {
 148         assert(idx == 0);
 149     }
 150     try
 151     {
 152         std::stold("a1", &idx);
 153         assert(false);
 154     }
 155     catch (const std::invalid_argument&)
 156     {
 157         assert(idx == 0);
 158     }
 159     try
 160     {
 161         std::stold(L"a1", &idx);
 162         assert(false);
 163     }
 164     catch (const std::invalid_argument&)
 165     {
 166         assert(idx == 0);
 167     }
 168 }