vendor/golang.org/x/text/internal/number/pattern_test.go

   1 // Copyright 2015 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package number
   6
   7 import (
   8         "reflect"
   9         "testing"
  10         "unsafe"
  11 )
  12
  13 var testCases = []struct {
  14         pat  string
  15         want *Pattern
  16 }{{
  17         "#",
  18         &Pattern{
  19                 FormatWidth: 1,
  20                 // TODO: Should MinIntegerDigits be 1?
  21         },
  22 }, {
  23         "0",
  24         &Pattern{
  25                 FormatWidth: 1,
  26                 RoundingContext: RoundingContext{
  27                         MinIntegerDigits: 1,
  28                 },
  29         },
  30 }, {
  31         "+0",
  32         &Pattern{
  33                 Affix:       "\x01+\x00",
  34                 FormatWidth: 2,
  35                 RoundingContext: RoundingContext{
  36                         MinIntegerDigits: 1,
  37                 },
  38         },
  39 }, {
  40         "0+",
  41         &Pattern{
  42                 Affix:       "\x00\x01+",
  43                 FormatWidth: 2,
  44                 RoundingContext: RoundingContext{
  45                         MinIntegerDigits: 1,
  46                 },
  47         },
  48 }, {
  49         "0000",
  50         &Pattern{
  51                 FormatWidth: 4,
  52                 RoundingContext: RoundingContext{
  53                         MinIntegerDigits: 4,
  54                 },
  55         },
  56 }, {
  57         ".#",
  58         &Pattern{
  59                 FormatWidth: 2,
  60                 RoundingContext: RoundingContext{
  61                         MaxFractionDigits: 1,
  62                 },
  63         },
  64 }, {
  65         "#0.###",
  66         &Pattern{
  67                 FormatWidth: 6,
  68                 RoundingContext: RoundingContext{
  69                         MinIntegerDigits:  1,
  70                         MaxFractionDigits: 3,
  71                 },
  72         },
  73 }, {
  74         "#0.######",
  75         &Pattern{
  76                 FormatWidth: 9,
  77                 RoundingContext: RoundingContext{
  78                         MinIntegerDigits:  1,
  79                         MaxFractionDigits: 6,
  80                 },
  81         },
  82 }, {
  83         "#,0",
  84         &Pattern{
  85                 FormatWidth:  3,
  86                 GroupingSize: [2]uint8{1, 0},
  87                 RoundingContext: RoundingContext{
  88                         MinIntegerDigits: 1,
  89                 },
  90         },
  91 }, {
  92         "#,0.00",
  93         &Pattern{
  94                 FormatWidth:  6,
  95                 GroupingSize: [2]uint8{1, 0},
  96                 RoundingContext: RoundingContext{
  97                         MinIntegerDigits:  1,
  98                         MinFractionDigits: 2,
  99                         MaxFractionDigits: 2,
 100                 },
 101         },
 102 }, {
 103         "#,##0.###",
 104         &Pattern{
 105                 FormatWidth:  9,
 106                 GroupingSize: [2]uint8{3, 0},
 107                 RoundingContext: RoundingContext{
 108                         MinIntegerDigits:  1,
 109                         MaxFractionDigits: 3,
 110                 },
 111         },
 112 }, {
 113         "#,##,##0.###",
 114         &Pattern{
 115                 FormatWidth:  12,
 116                 GroupingSize: [2]uint8{3, 2},
 117                 RoundingContext: RoundingContext{
 118                         MinIntegerDigits:  1,
 119                         MaxFractionDigits: 3,
 120                 },
 121         },
 122 }, {
 123         // Ignore additional separators.
 124         "#,####,##,##0.###",
 125         &Pattern{
 126                 FormatWidth:  17,
 127                 GroupingSize: [2]uint8{3, 2},
 128                 RoundingContext: RoundingContext{
 129                         MinIntegerDigits:  1,
 130                         MaxFractionDigits: 3,
 131                 },
 132         },
 133 }, {
 134         "#E0",
 135         &Pattern{
 136                 FormatWidth: 3,
 137                 RoundingContext: RoundingContext{
 138                         MaxIntegerDigits:  1,
 139                         MinExponentDigits: 1,
 140                 },
 141         },
 142 }, {
 143         // At least one exponent digit is required. As long as this is true, one can
 144         // determine that scientific rendering is needed if MinExponentDigits > 0.
 145         "#E#",
 146         nil,
 147 }, {
 148         "0E0",
 149         &Pattern{
 150                 FormatWidth: 3,
 151                 RoundingContext: RoundingContext{
 152                         MinIntegerDigits:  1,
 153                         MinExponentDigits: 1,
 154                 },
 155         },
 156 }, {
 157         "##0.###E00",
 158         &Pattern{
 159                 FormatWidth: 10,
 160                 RoundingContext: RoundingContext{
 161                         MinIntegerDigits:  1,
 162                         MaxIntegerDigits:  3,
 163                         MaxFractionDigits: 3,
 164                         MinExponentDigits: 2,
 165                 },
 166         },
 167 }, {
 168         "##00.0#E0",
 169         &Pattern{
 170                 FormatWidth: 9,
 171                 RoundingContext: RoundingContext{
 172                         MinIntegerDigits:  2,
 173                         MaxIntegerDigits:  4,
 174                         MinFractionDigits: 1,
 175                         MaxFractionDigits: 2,
 176                         MinExponentDigits: 1,
 177                 },
 178         },
 179 }, {
 180         "#00.0E+0",
 181         &Pattern{
 182                 FormatWidth: 8,
 183                 Flags:       AlwaysExpSign,
 184                 RoundingContext: RoundingContext{
 185                         MinIntegerDigits:  2,
 186                         MaxIntegerDigits:  3,
 187                         MinFractionDigits: 1,
 188                         MaxFractionDigits: 1,
 189                         MinExponentDigits: 1,
 190                 },
 191         },
 192 }, {
 193         "0.0E++0",
 194         nil,
 195 }, {
 196         "#0E+",
 197         nil,
 198 }, {
 199         // significant digits
 200         "@",
 201         &Pattern{
 202                 FormatWidth: 1,
 203                 RoundingContext: RoundingContext{
 204                         MinSignificantDigits: 1,
 205                         MaxSignificantDigits: 1,
 206                 },
 207         },
 208 }, {
 209         // significant digits
 210         "@@@@",
 211         &Pattern{
 212                 FormatWidth: 4,
 213                 RoundingContext: RoundingContext{
 214                         MinSignificantDigits: 4,
 215                         MaxSignificantDigits: 4,
 216                 },
 217         },
 218 }, {
 219         "@###",
 220         &Pattern{
 221                 FormatWidth: 4,
 222                 RoundingContext: RoundingContext{
 223                         MinSignificantDigits: 1,
 224                         MaxSignificantDigits: 4,
 225                 },
 226         },
 227 }, {
 228         // Exponents in significant digits mode gets normalized.
 229         "@@E0",
 230         &Pattern{
 231                 FormatWidth: 4,
 232                 RoundingContext: RoundingContext{
 233                         MinIntegerDigits:  1,
 234                         MaxIntegerDigits:  1,
 235                         MinFractionDigits: 1,
 236                         MaxFractionDigits: 1,
 237                         MinExponentDigits: 1,
 238                 },
 239         },
 240 }, {
 241         "@###E00",
 242         &Pattern{
 243                 FormatWidth: 7,
 244                 RoundingContext: RoundingContext{
 245                         MinIntegerDigits:  1,
 246                         MaxIntegerDigits:  1,
 247                         MinFractionDigits: 0,
 248                         MaxFractionDigits: 3,
 249                         MinExponentDigits: 2,
 250                 },
 251         },
 252 }, {
 253         // The significant digits mode does not allow fractions.
 254         "@###.#E0",
 255         nil,
 256 }, {
 257         //alternative negative pattern
 258         "#0.###;(#0.###)",
 259         &Pattern{
 260                 Affix:       "\x00\x00\x01(\x01)",
 261                 NegOffset:   2,
 262                 FormatWidth: 6,
 263                 RoundingContext: RoundingContext{
 264                         MinIntegerDigits:  1,
 265                         MaxFractionDigits: 3,
 266                 },
 267         },
 268 }, {
 269         // Rounding increment
 270         "1.05",
 271         &Pattern{
 272                 FormatWidth: 4,
 273                 RoundingContext: RoundingContext{
 274                         Increment:         105,
 275                         IncrementScale:    2,
 276                         MinIntegerDigits:  1,
 277                         MinFractionDigits: 2,
 278                         MaxFractionDigits: 2,
 279                 },
 280         },
 281 }, {
 282         // Rounding increment with grouping
 283         "1,05",
 284         &Pattern{
 285                 FormatWidth:  4,
 286                 GroupingSize: [2]uint8{2, 0},
 287                 RoundingContext: RoundingContext{
 288                         Increment:         105,
 289                         IncrementScale:    0,
 290                         MinIntegerDigits:  3,
 291                         MinFractionDigits: 0,
 292                         MaxFractionDigits: 0,
 293                 },
 294         },
 295 }, {
 296         "0.0%",
 297         &Pattern{
 298                 Affix:       "\x00\x01%",
 299                 FormatWidth: 4,
 300                 RoundingContext: RoundingContext{
 301                         DigitShift:        2,
 302                         MinIntegerDigits:  1,
 303                         MinFractionDigits: 1,
 304                         MaxFractionDigits: 1,
 305                 },
 306         },
 307 }, {
 308         "0.0‰",
 309         &Pattern{
 310                 Affix:       "\x00\x03‰",
 311                 FormatWidth: 4,
 312                 RoundingContext: RoundingContext{
 313                         DigitShift:        3,
 314                         MinIntegerDigits:  1,
 315                         MinFractionDigits: 1,
 316                         MaxFractionDigits: 1,
 317                 },
 318         },
 319 }, {
 320         "#,##0.00¤",
 321         &Pattern{
 322                 Affix:        "\x00\x02¤",
 323                 FormatWidth:  9,
 324                 GroupingSize: [2]uint8{3, 0},
 325                 RoundingContext: RoundingContext{
 326                         MinIntegerDigits:  1,
 327                         MinFractionDigits: 2,
 328                         MaxFractionDigits: 2,
 329                 },
 330         },
 331 }, {
 332         "#,##0.00 ¤;(#,##0.00 ¤)",
 333         &Pattern{Affix: "\x00\x04\u00a0¤\x01(\x05\u00a0¤)",
 334                 NegOffset:    6,
 335                 FormatWidth:  10,
 336                 GroupingSize: [2]uint8{3, 0},
 337                 RoundingContext: RoundingContext{
 338                         DigitShift:        0,
 339                         MinIntegerDigits:  1,
 340                         MinFractionDigits: 2,
 341                         MaxFractionDigits: 2,
 342                 },
 343         },
 344 }, {
 345         // padding
 346         "*x#",
 347         &Pattern{
 348                 PadRune:     'x',
 349                 FormatWidth: 1,
 350         },
 351 }, {
 352         // padding
 353         "#*x",
 354         &Pattern{
 355                 PadRune:     'x',
 356                 FormatWidth: 1,
 357                 Flags:       PadBeforeSuffix,
 358         },
 359 }, {
 360         "*xpre#suf",
 361         &Pattern{
 362                 Affix:       "\x03pre\x03suf",
 363                 PadRune:     'x',
 364                 FormatWidth: 7,
 365         },
 366 }, {
 367         "pre*x#suf",
 368         &Pattern{
 369                 Affix:       "\x03pre\x03suf",
 370                 PadRune:     'x',
 371                 FormatWidth: 7,
 372                 Flags:       PadAfterPrefix,
 373         },
 374 }, {
 375         "pre#*xsuf",
 376         &Pattern{
 377                 Affix:       "\x03pre\x03suf",
 378                 PadRune:     'x',
 379                 FormatWidth: 7,
 380                 Flags:       PadBeforeSuffix,
 381         },
 382 }, {
 383         "pre#suf*x",
 384         &Pattern{
 385                 Affix:       "\x03pre\x03suf",
 386                 PadRune:     'x',
 387                 FormatWidth: 7,
 388                 Flags:       PadAfterSuffix,
 389         },
 390 }, {
 391         `* #0 o''clock`,
 392         &Pattern{Affix: "\x00\x09 o\\'clock",
 393                 FormatWidth: 10,
 394                 PadRune:     32,
 395                 RoundingContext: RoundingContext{
 396                         MinIntegerDigits: 0x1,
 397                 },
 398         },
 399 }, {
 400         `'123'* #0'456'`,
 401         &Pattern{Affix: "\x05'123'\x05'456'",
 402                 FormatWidth: 8,
 403                 PadRune:     32,
 404                 RoundingContext: RoundingContext{
 405                         MinIntegerDigits: 0x1,
 406                 },
 407                 Flags: PadAfterPrefix},
 408 }, {
 409         // no duplicate padding
 410         "*xpre#suf*x", nil,
 411 }, {
 412         // no duplicate padding
 413         "*xpre#suf*x", nil,
 414 }}
 415
 416 func TestParsePattern(t *testing.T) {
 417         for i, tc := range testCases {
 418                 t.Run(tc.pat, func(t *testing.T) {
 419                         f, err := ParsePattern(tc.pat)
 420                         if !reflect.DeepEqual(f, tc.want) {
 421                                 t.Errorf("%d:%s:\ngot %#v;\nwant %#v", i, tc.pat, f, tc.want)
 422                         }
 423                         if got, want := err != nil, tc.want == nil; got != want {
 424                                 t.Errorf("%d:%s:error: got %v; want %v", i, tc.pat, err, want)
 425                         }
 426                 })
 427         }
 428 }
 429
 430 func TestPatternSize(t *testing.T) {
 431         if sz := unsafe.Sizeof(Pattern{}); sz > 56 {
 432                 t.Errorf("got %d; want <= 56", sz)
 433         }
 434
 435 }