test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_float.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 // PR11871
  11 // XFAIL: with_system_cxx_lib=macosx10.7
  12
  13 // <locale>
  14
  15 // class num_get<charT, InputIterator>
  16
  17 // iter_type get(iter_type in, iter_type end, ios_base&,
  18 //               ios_base::iostate& err, float& v) const;
  19
  20 #include <locale>
  21 #include <ios>
  22 #include <cassert>
  23 #include <streambuf>
  24 #include <cmath>
  25 #include "test_iterators.h"
  26 #include "hexfloat.h"
  27
  28 typedef std::num_get<char, input_iterator<const char*> > F;
  29
  30 class my_facet
  31     : public F
  32 {
  33 public:
  34     explicit my_facet(std::size_t refs = 0)
  35         : F(refs) {}
  36 };
  37
  38
  39 int main()
  40 {
  41     const my_facet f(1);
  42     std::ios ios(0);
  43     float v = -1;
  44     {
  45         const char str[] = "123";
  46         assert((ios.flags() & ios.basefield) == ios.dec);
  47         assert(ios.getloc().name() == "C");
  48         std::ios_base::iostate err = ios.goodbit;
  49         input_iterator<const char*> iter =
  50             f.get(input_iterator<const char*>(str),
  51                   input_iterator<const char*>(str+sizeof(str)),
  52                   ios, err, v);
  53         assert(iter.base() == str+sizeof(str)-1);
  54         assert(err == ios.goodbit);
  55         assert(v == 123);
  56     }
  57     {
  58         const char str[] = "-123";
  59         std::ios_base::iostate err = ios.goodbit;
  60         input_iterator<const char*> iter =
  61             f.get(input_iterator<const char*>(str),
  62                   input_iterator<const char*>(str+sizeof(str)),
  63                   ios, err, v);
  64         assert(iter.base() == str+sizeof(str)-1);
  65         assert(err == ios.goodbit);
  66         assert(v == -123);
  67     }
  68     {
  69         const char str[] = "123.5";
  70         std::ios_base::iostate err = ios.goodbit;
  71         input_iterator<const char*> iter =
  72             f.get(input_iterator<const char*>(str),
  73                   input_iterator<const char*>(str+sizeof(str)),
  74                   ios, err, v);
  75         assert(iter.base() == str+sizeof(str)-1);
  76         assert(err == ios.goodbit);
  77         assert(v == 123.5);
  78     }
  79     {
  80         const char str[] = "125e-1";
  81         hex(ios);
  82         std::ios_base::iostate err = ios.goodbit;
  83         input_iterator<const char*> iter =
  84             f.get(input_iterator<const char*>(str),
  85                   input_iterator<const char*>(str+sizeof(str)),
  86                   ios, err, v);
  87         assert(iter.base() == str+sizeof(str)-1);
  88         assert(err == ios.goodbit);
  89         assert(v == 125e-1);
  90     }
  91     {
  92         const char str[] = "0x125p-1";
  93         hex(ios);
  94         std::ios_base::iostate err = ios.goodbit;
  95         input_iterator<const char*> iter =
  96             f.get(input_iterator<const char*>(str),
  97                   input_iterator<const char*>(str+sizeof(str)),
  98                   ios, err, v);
  99         assert(iter.base() == str+sizeof(str)-1);
 100         assert(err == ios.goodbit);
 101         assert(v == hexfloat<float>(0x125, 0, -1));
 102     }
 103     {
 104         const char str[] = "inf";
 105         hex(ios);
 106         std::ios_base::iostate err = ios.goodbit;
 107         input_iterator<const char*> iter =
 108             f.get(input_iterator<const char*>(str),
 109                   input_iterator<const char*>(str+sizeof(str)),
 110                   ios, err, v);
 111         assert(iter.base() == str+sizeof(str)-1);
 112         assert(err == ios.goodbit);
 113         assert(v == INFINITY);
 114     }
 115     {
 116         const char str[] = "INF";
 117         hex(ios);
 118         std::ios_base::iostate err = ios.goodbit;
 119         input_iterator<const char*> iter =
 120             f.get(input_iterator<const char*>(str),
 121                   input_iterator<const char*>(str+sizeof(str)),
 122                   ios, err, v);
 123         assert(iter.base() == str+sizeof(str)-1);
 124         assert(err == ios.goodbit);
 125         assert(v == INFINITY);
 126     }
 127     {
 128         const char str[] = "-inf";
 129         hex(ios);
 130         std::ios_base::iostate err = ios.goodbit;
 131         input_iterator<const char*> iter =
 132             f.get(input_iterator<const char*>(str),
 133                   input_iterator<const char*>(str+sizeof(str)),
 134                   ios, err, v);
 135         assert(iter.base() == str+sizeof(str)-1);
 136         assert(err == ios.goodbit);
 137         assert(v == -INFINITY);
 138     }
 139     {
 140         const char str[] = "-INF";
 141         hex(ios);
 142         std::ios_base::iostate err = ios.goodbit;
 143         input_iterator<const char*> iter =
 144             f.get(input_iterator<const char*>(str),
 145                   input_iterator<const char*>(str+sizeof(str)),
 146                   ios, err, v);
 147         assert(iter.base() == str+sizeof(str)-1);
 148         assert(err == ios.goodbit);
 149         assert(v == -INFINITY);
 150     }
 151     {
 152         const char str[] = "nan";
 153         hex(ios);
 154         std::ios_base::iostate err = ios.goodbit;
 155         input_iterator<const char*> iter =
 156             f.get(input_iterator<const char*>(str),
 157                   input_iterator<const char*>(str+sizeof(str)),
 158                   ios, err, v);
 159         assert(iter.base() == str+sizeof(str)-1);
 160         assert(err == ios.goodbit);
 161         assert(std::isnan(v));
 162     }
 163     {
 164         const char str[] = "NAN";
 165         hex(ios);
 166         std::ios_base::iostate err = ios.goodbit;
 167         input_iterator<const char*> iter =
 168             f.get(input_iterator<const char*>(str),
 169                   input_iterator<const char*>(str+sizeof(str)),
 170                   ios, err, v);
 171         assert(iter.base() == str+sizeof(str)-1);
 172         assert(err == ios.goodbit);
 173         assert(std::isnan(v));
 174     }
 175     {
 176         v = -1;
 177         const char str[] = "3.40283e+39"; // unrepresentable
 178         std::ios_base::iostate err = ios.goodbit;
 179         input_iterator<const char*> iter =
 180             f.get(input_iterator<const char*>(str),
 181                   input_iterator<const char*>(str+sizeof(str)),
 182                   ios, err, v);
 183         assert(iter.base() == str+sizeof(str)-1);
 184         assert(err == ios.failbit);
 185         assert(v == HUGE_VALF);
 186     }
 187     {
 188         v = -1;
 189         const char str[] = "-3.40283e+38"; // unrepresentable
 190         std::ios_base::iostate err = ios.goodbit;
 191         input_iterator<const char*> iter =
 192             f.get(input_iterator<const char*>(str),
 193                   input_iterator<const char*>(str+sizeof(str)),
 194                   ios, err, v);
 195         assert(iter.base() == str+sizeof(str)-1);
 196         assert(err == ios.failbit);
 197         assert(v == -HUGE_VALF);
 198
 199     }
 200     {
 201         v = -1;
 202         const char str[] = "2-";
 203         std::ios_base::iostate err = ios.goodbit;
 204         input_iterator<const char*> iter =
 205             f.get(input_iterator<const char*>(str),
 206                   input_iterator<const char*>(str+sizeof(str)),
 207                   ios, err, v);
 208         assert(iter.base() == str+1);
 209         assert(err == ios.goodbit);
 210         assert(v == 2);
 211     }
 212 }