vendor/github.com/go-playground/locales/ksf/ksf_test.go

   1 package ksf
   2
   3 import (
   4         "testing"
   5         "time"
   6
   7         "github.com/go-playground/locales"
   8         "github.com/go-playground/locales/currency"
   9 )
  10
  11 func TestLocale(t *testing.T) {
  12
  13         trans := New()
  14         expected := "ksf"
  15
  16         if trans.Locale() != expected {
  17                 t.Errorf("Expected '%s' Got '%s'", expected, trans.Locale())
  18         }
  19 }
  20
  21 func TestPluralsRange(t *testing.T) {
  22
  23         trans := New()
  24
  25         tests := []struct {
  26                 expected locales.PluralRule
  27         }{
  28         // {
  29         //      expected: locales.PluralRuleOther,
  30         // },
  31         }
  32
  33         rules := trans.PluralsRange()
  34         // expected := 1
  35         // if len(rules) != expected {
  36         //      t.Errorf("Expected '%d' Got '%d'", expected, len(rules))
  37         // }
  38
  39         for _, tt := range tests {
  40
  41                 r := locales.PluralRuleUnknown
  42
  43                 for i := 0; i < len(rules); i++ {
  44                         if rules[i] == tt.expected {
  45                                 r = rules[i]
  46                                 break
  47                         }
  48                 }
  49                 if r == locales.PluralRuleUnknown {
  50                         t.Errorf("Expected '%s' Got '%s'", tt.expected, r)
  51                 }
  52         }
  53 }
  54
  55 func TestPluralsOrdinal(t *testing.T) {
  56
  57         trans := New()
  58
  59         tests := []struct {
  60                 expected locales.PluralRule
  61         }{
  62         // {
  63         //      expected: locales.PluralRuleOne,
  64         // },
  65         // {
  66         //      expected: locales.PluralRuleTwo,
  67         // },
  68         // {
  69         //      expected: locales.PluralRuleFew,
  70         // },
  71         // {
  72         //      expected: locales.PluralRuleOther,
  73         // },
  74         }
  75
  76         rules := trans.PluralsOrdinal()
  77         // expected := 4
  78         // if len(rules) != expected {
  79         //      t.Errorf("Expected '%d' Got '%d'", expected, len(rules))
  80         // }
  81
  82         for _, tt := range tests {
  83
  84                 r := locales.PluralRuleUnknown
  85
  86                 for i := 0; i < len(rules); i++ {
  87                         if rules[i] == tt.expected {
  88                                 r = rules[i]
  89                                 break
  90                         }
  91                 }
  92                 if r == locales.PluralRuleUnknown {
  93                         t.Errorf("Expected '%s' Got '%s'", tt.expected, r)
  94                 }
  95         }
  96 }
  97
  98 func TestPluralsCardinal(t *testing.T) {
  99
 100         trans := New()
 101
 102         tests := []struct {
 103                 expected locales.PluralRule
 104         }{
 105         // {
 106         //      expected: locales.PluralRuleOne,
 107         // },
 108         // {
 109         //      expected: locales.PluralRuleOther,
 110         // },
 111         }
 112
 113         rules := trans.PluralsCardinal()
 114         // expected := 2
 115         // if len(rules) != expected {
 116         //      t.Errorf("Expected '%d' Got '%d'", expected, len(rules))
 117         // }
 118
 119         for _, tt := range tests {
 120
 121                 r := locales.PluralRuleUnknown
 122
 123                 for i := 0; i < len(rules); i++ {
 124                         if rules[i] == tt.expected {
 125                                 r = rules[i]
 126                                 break
 127                         }
 128                 }
 129                 if r == locales.PluralRuleUnknown {
 130                         t.Errorf("Expected '%s' Got '%s'", tt.expected, r)
 131                 }
 132         }
 133 }
 134
 135 func TestRangePlurals(t *testing.T) {
 136
 137         trans := New()
 138
 139         tests := []struct {
 140                 num1     float64
 141                 v1       uint64
 142                 num2     float64
 143                 v2       uint64
 144                 expected locales.PluralRule
 145         }{
 146         // {
 147         //      num1:     1,
 148         //      v1:       1,
 149         //      num2:     2,
 150         //      v2:       2,
 151         //      expected: locales.PluralRuleOther,
 152         // },
 153         }
 154
 155         for _, tt := range tests {
 156                 rule := trans.RangePluralRule(tt.num1, tt.v1, tt.num2, tt.v2)
 157                 if rule != tt.expected {
 158                         t.Errorf("Expected '%s' Got '%s'", tt.expected, rule)
 159                 }
 160         }
 161 }
 162
 163 func TestOrdinalPlurals(t *testing.T) {
 164
 165         trans := New()
 166
 167         tests := []struct {
 168                 num      float64
 169                 v        uint64
 170                 expected locales.PluralRule
 171         }{
 172         // {
 173         //      num:      1,
 174         //      v:        0,
 175         //      expected: locales.PluralRuleOne,
 176         // },
 177         // {
 178         //      num:      2,
 179         //      v:        0,
 180         //      expected: locales.PluralRuleTwo,
 181         // },
 182         // {
 183         //      num:      3,
 184         //      v:        0,
 185         //      expected: locales.PluralRuleFew,
 186         // },
 187         // {
 188         //      num:      4,
 189         //      v:        0,
 190         //      expected: locales.PluralRuleOther,
 191         // },
 192         }
 193
 194         for _, tt := range tests {
 195                 rule := trans.OrdinalPluralRule(tt.num, tt.v)
 196                 if rule != tt.expected {
 197                         t.Errorf("Expected '%s' Got '%s'", tt.expected, rule)
 198                 }
 199         }
 200 }
 201
 202 func TestCardinalPlurals(t *testing.T) {
 203
 204         trans := New()
 205
 206         tests := []struct {
 207                 num      float64
 208                 v        uint64
 209                 expected locales.PluralRule
 210         }{
 211         // {
 212         //      num:      1,
 213         //      v:        0,
 214         //      expected: locales.PluralRuleOne,
 215         // },
 216         // {
 217         //      num:      4,
 218         //      v:        0,
 219         //      expected: locales.PluralRuleOther,
 220         // },
 221         }
 222
 223         for _, tt := range tests {
 224                 rule := trans.CardinalPluralRule(tt.num, tt.v)
 225                 if rule != tt.expected {
 226                         t.Errorf("Expected '%s' Got '%s'", tt.expected, rule)
 227                 }
 228         }
 229 }
 230
 231 func TestDaysAbbreviated(t *testing.T) {
 232
 233         trans := New()
 234         days := trans.WeekdaysAbbreviated()
 235
 236         for i, day := range days {
 237                 s := trans.WeekdayAbbreviated(time.Weekday(i))
 238                 if s != day {
 239                         t.Errorf("Expected '%s' Got '%s'", day, s)
 240                 }
 241         }
 242
 243         tests := []struct {
 244                 idx      int
 245                 expected string
 246         }{
 247         // {
 248         //      idx:      0,
 249         //      expected: "Sun",
 250         // },
 251         // {
 252         //      idx:      1,
 253         //      expected: "Mon",
 254         // },
 255         // {
 256         //      idx:      2,
 257         //      expected: "Tue",
 258         // },
 259         // {
 260         //      idx:      3,
 261         //      expected: "Wed",
 262         // },
 263         // {
 264         //      idx:      4,
 265         //      expected: "Thu",
 266         // },
 267         // {
 268         //      idx:      5,
 269         //      expected: "Fri",
 270         // },
 271         // {
 272         //      idx:      6,
 273         //      expected: "Sat",
 274         // },
 275         }
 276
 277         for _, tt := range tests {
 278                 s := trans.WeekdayAbbreviated(time.Weekday(tt.idx))
 279                 if s != tt.expected {
 280                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 281                 }
 282         }
 283 }
 284
 285 func TestDaysNarrow(t *testing.T) {
 286
 287         trans := New()
 288         days := trans.WeekdaysNarrow()
 289
 290         for i, day := range days {
 291                 s := trans.WeekdayNarrow(time.Weekday(i))
 292                 if s != day {
 293                         t.Errorf("Expected '%s' Got '%s'", string(day), s)
 294                 }
 295         }
 296
 297         tests := []struct {
 298                 idx      int
 299                 expected string
 300         }{
 301         // {
 302         //      idx:      0,
 303         //      expected: "S",
 304         // },
 305         // {
 306         //      idx:      1,
 307         //      expected: "M",
 308         // },
 309         // {
 310         //      idx:      2,
 311         //      expected: "T",
 312         // },
 313         // {
 314         //      idx:      3,
 315         //      expected: "W",
 316         // },
 317         // {
 318         //      idx:      4,
 319         //      expected: "T",
 320         // },
 321         // {
 322         //      idx:      5,
 323         //      expected: "F",
 324         // },
 325         // {
 326         //      idx:      6,
 327         //      expected: "S",
 328         // },
 329         }
 330
 331         for _, tt := range tests {
 332                 s := trans.WeekdayNarrow(time.Weekday(tt.idx))
 333                 if s != tt.expected {
 334                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 335                 }
 336         }
 337 }
 338
 339 func TestDaysShort(t *testing.T) {
 340
 341         trans := New()
 342         days := trans.WeekdaysShort()
 343
 344         for i, day := range days {
 345                 s := trans.WeekdayShort(time.Weekday(i))
 346                 if s != day {
 347                         t.Errorf("Expected '%s' Got '%s'", day, s)
 348                 }
 349         }
 350
 351         tests := []struct {
 352                 idx      int
 353                 expected string
 354         }{
 355         // {
 356         //      idx:      0,
 357         //      expected: "Su",
 358         // },
 359         // {
 360         //      idx:      1,
 361         //      expected: "Mo",
 362         // },
 363         // {
 364         //      idx:      2,
 365         //      expected: "Tu",
 366         // },
 367         // {
 368         //      idx:      3,
 369         //      expected: "We",
 370         // },
 371         // {
 372         //      idx:      4,
 373         //      expected: "Th",
 374         // },
 375         // {
 376         //      idx:      5,
 377         //      expected: "Fr",
 378         // },
 379         // {
 380         //      idx:      6,
 381         //      expected: "Sa",
 382         // },
 383         }
 384
 385         for _, tt := range tests {
 386                 s := trans.WeekdayShort(time.Weekday(tt.idx))
 387                 if s != tt.expected {
 388                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 389                 }
 390         }
 391 }
 392
 393 func TestDaysWide(t *testing.T) {
 394
 395         trans := New()
 396         days := trans.WeekdaysWide()
 397
 398         for i, day := range days {
 399                 s := trans.WeekdayWide(time.Weekday(i))
 400                 if s != day {
 401                         t.Errorf("Expected '%s' Got '%s'", day, s)
 402                 }
 403         }
 404
 405         tests := []struct {
 406                 idx      int
 407                 expected string
 408         }{
 409         // {
 410         //      idx:      0,
 411         //      expected: "Sunday",
 412         // },
 413         // {
 414         //      idx:      1,
 415         //      expected: "Monday",
 416         // },
 417         // {
 418         //      idx:      2,
 419         //      expected: "Tuesday",
 420         // },
 421         // {
 422         //      idx:      3,
 423         //      expected: "Wednesday",
 424         // },
 425         // {
 426         //      idx:      4,
 427         //      expected: "Thursday",
 428         // },
 429         // {
 430         //      idx:      5,
 431         //      expected: "Friday",
 432         // },
 433         // {
 434         //      idx:      6,
 435         //      expected: "Saturday",
 436         // },
 437         }
 438
 439         for _, tt := range tests {
 440                 s := trans.WeekdayWide(time.Weekday(tt.idx))
 441                 if s != tt.expected {
 442                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 443                 }
 444         }
 445 }
 446
 447 func TestMonthsAbbreviated(t *testing.T) {
 448
 449         trans := New()
 450         months := trans.MonthsAbbreviated()
 451
 452         for i, month := range months {
 453                 s := trans.MonthAbbreviated(time.Month(i + 1))
 454                 if s != month {
 455                         t.Errorf("Expected '%s' Got '%s'", month, s)
 456                 }
 457         }
 458
 459         tests := []struct {
 460                 idx      int
 461                 expected string
 462         }{
 463         // {
 464         //      idx:      1,
 465         //      expected: "Jan",
 466         // },
 467         // {
 468         //      idx:      2,
 469         //      expected: "Feb",
 470         // },
 471         // {
 472         //      idx:      3,
 473         //      expected: "Mar",
 474         // },
 475         // {
 476         //      idx:      4,
 477         //      expected: "Apr",
 478         // },
 479         // {
 480         //      idx:      5,
 481         //      expected: "May",
 482         // },
 483         // {
 484         //      idx:      6,
 485         //      expected: "Jun",
 486         // },
 487         // {
 488         //      idx:      7,
 489         //      expected: "Jul",
 490         // },
 491         // {
 492         //      idx:      8,
 493         //      expected: "Aug",
 494         // },
 495         // {
 496         //      idx:      9,
 497         //      expected: "Sep",
 498         // },
 499         // {
 500         //      idx:      10,
 501         //      expected: "Oct",
 502         // },
 503         // {
 504         //      idx:      11,
 505         //      expected: "Nov",
 506         // },
 507         // {
 508         //      idx:      12,
 509         //      expected: "Dec",
 510         // },
 511         }
 512
 513         for _, tt := range tests {
 514                 s := trans.MonthAbbreviated(time.Month(tt.idx))
 515                 if s != tt.expected {
 516                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 517                 }
 518         }
 519 }
 520
 521 func TestMonthsNarrow(t *testing.T) {
 522
 523         trans := New()
 524         months := trans.MonthsNarrow()
 525
 526         for i, month := range months {
 527                 s := trans.MonthNarrow(time.Month(i + 1))
 528                 if s != month {
 529                         t.Errorf("Expected '%s' Got '%s'", month, s)
 530                 }
 531         }
 532
 533         tests := []struct {
 534                 idx      int
 535                 expected string
 536         }{
 537         // {
 538         //      idx:      1,
 539         //      expected: "J",
 540         // },
 541         // {
 542         //      idx:      2,
 543         //      expected: "F",
 544         // },
 545         // {
 546         //      idx:      3,
 547         //      expected: "M",
 548         // },
 549         // {
 550         //      idx:      4,
 551         //      expected: "A",
 552         // },
 553         // {
 554         //      idx:      5,
 555         //      expected: "M",
 556         // },
 557         // {
 558         //      idx:      6,
 559         //      expected: "J",
 560         // },
 561         // {
 562         //      idx:      7,
 563         //      expected: "J",
 564         // },
 565         // {
 566         //      idx:      8,
 567         //      expected: "A",
 568         // },
 569         // {
 570         //      idx:      9,
 571         //      expected: "S",
 572         // },
 573         // {
 574         //      idx:      10,
 575         //      expected: "O",
 576         // },
 577         // {
 578         //      idx:      11,
 579         //      expected: "N",
 580         // },
 581         // {
 582         //      idx:      12,
 583         //      expected: "D",
 584         // },
 585         }
 586
 587         for _, tt := range tests {
 588                 s := trans.MonthNarrow(time.Month(tt.idx))
 589                 if s != tt.expected {
 590                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 591                 }
 592         }
 593 }
 594
 595 func TestMonthsWide(t *testing.T) {
 596
 597         trans := New()
 598         months := trans.MonthsWide()
 599
 600         for i, month := range months {
 601                 s := trans.MonthWide(time.Month(i + 1))
 602                 if s != month {
 603                         t.Errorf("Expected '%s' Got '%s'", month, s)
 604                 }
 605         }
 606
 607         tests := []struct {
 608                 idx      int
 609                 expected string
 610         }{
 611         // {
 612         //      idx:      1,
 613         //      expected: "January",
 614         // },
 615         // {
 616         //      idx:      2,
 617         //      expected: "February",
 618         // },
 619         // {
 620         //      idx:      3,
 621         //      expected: "March",
 622         // },
 623         // {
 624         //      idx:      4,
 625         //      expected: "April",
 626         // },
 627         // {
 628         //      idx:      5,
 629         //      expected: "May",
 630         // },
 631         // {
 632         //      idx:      6,
 633         //      expected: "June",
 634         // },
 635         // {
 636         //      idx:      7,
 637         //      expected: "July",
 638         // },
 639         // {
 640         //      idx:      8,
 641         //      expected: "August",
 642         // },
 643         // {
 644         //      idx:      9,
 645         //      expected: "September",
 646         // },
 647         // {
 648         //      idx:      10,
 649         //      expected: "October",
 650         // },
 651         // {
 652         //      idx:      11,
 653         //      expected: "November",
 654         // },
 655         // {
 656         //      idx:      12,
 657         //      expected: "December",
 658         // },
 659         }
 660
 661         for _, tt := range tests {
 662                 s := string(trans.MonthWide(time.Month(tt.idx)))
 663                 if s != tt.expected {
 664                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 665                 }
 666         }
 667 }
 668
 669 func TestFmtTimeFull(t *testing.T) {
 670
 671         // loc, err := time.LoadLocation("America/Toronto")
 672         // if err != nil {
 673         //      t.Errorf("Expected '<nil>' Got '%s'", err)
 674         // }
 675
 676         // fixed := time.FixedZone("OTHER", -4)
 677
 678         tests := []struct {
 679                 t        time.Time
 680                 expected string
 681         }{
 682         // {
 683         //      t:        time.Date(2016, 02, 03, 9, 5, 1, 0, loc),
 684         //      expected: "9:05:01 am Eastern Standard Time",
 685         // },
 686         // {
 687         //      t:        time.Date(2016, 02, 03, 20, 5, 1, 0, fixed),
 688         //      expected: "8:05:01 pm OTHER",
 689         // },
 690         }
 691
 692         trans := New()
 693
 694         for _, tt := range tests {
 695                 s := trans.FmtTimeFull(tt.t)
 696                 if s != tt.expected {
 697                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 698                 }
 699         }
 700 }
 701
 702 func TestFmtTimeLong(t *testing.T) {
 703
 704         // loc, err := time.LoadLocation("America/Toronto")
 705         // if err != nil {
 706         //      t.Errorf("Expected '<nil>' Got '%s'", err)
 707         // }
 708
 709         tests := []struct {
 710                 t        time.Time
 711                 expected string
 712         }{
 713         // {
 714         //      t:        time.Date(2016, 02, 03, 9, 5, 1, 0, loc),
 715         //      expected: "9:05:01 am EST",
 716         // },
 717         // {
 718         //      t:        time.Date(2016, 02, 03, 20, 5, 1, 0, loc),
 719         //      expected: "8:05:01 pm EST",
 720         // },
 721         }
 722
 723         trans := New()
 724
 725         for _, tt := range tests {
 726                 s := trans.FmtTimeLong(tt.t)
 727                 if s != tt.expected {
 728                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 729                 }
 730         }
 731 }
 732
 733 func TestFmtTimeMedium(t *testing.T) {
 734
 735         tests := []struct {
 736                 t        time.Time
 737                 expected string
 738         }{
 739         // {
 740         //      t:        time.Date(2016, 02, 03, 9, 5, 1, 0, time.UTC),
 741         //      expected: "9:05:01 am",
 742         // },
 743         // {
 744         //      t:        time.Date(2016, 02, 03, 20, 5, 1, 0, time.UTC),
 745         //      expected: "8:05:01 pm",
 746         // },
 747         }
 748
 749         trans := New()
 750
 751         for _, tt := range tests {
 752                 s := trans.FmtTimeMedium(tt.t)
 753                 if s != tt.expected {
 754                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 755                 }
 756         }
 757 }
 758
 759 func TestFmtTimeShort(t *testing.T) {
 760
 761         tests := []struct {
 762                 t        time.Time
 763                 expected string
 764         }{
 765         // {
 766         //      t:        time.Date(2016, 02, 03, 9, 5, 1, 0, time.UTC),
 767         //      expected: "9:05 am",
 768         // },
 769         // {
 770         //      t:        time.Date(2016, 02, 03, 20, 5, 1, 0, time.UTC),
 771         //      expected: "8:05 pm",
 772         // },
 773         }
 774
 775         trans := New()
 776
 777         for _, tt := range tests {
 778                 s := trans.FmtTimeShort(tt.t)
 779                 if s != tt.expected {
 780                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 781                 }
 782         }
 783 }
 784
 785 func TestFmtDateFull(t *testing.T) {
 786
 787         tests := []struct {
 788                 t        time.Time
 789                 expected string
 790         }{
 791         // {
 792         //      t:        time.Date(2016, 02, 03, 9, 0, 1, 0, time.UTC),
 793         //      expected: "Wednesday, February 3, 2016",
 794         // },
 795         }
 796
 797         trans := New()
 798
 799         for _, tt := range tests {
 800                 s := trans.FmtDateFull(tt.t)
 801                 if s != tt.expected {
 802                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 803                 }
 804         }
 805 }
 806
 807 func TestFmtDateLong(t *testing.T) {
 808
 809         tests := []struct {
 810                 t        time.Time
 811                 expected string
 812         }{
 813         // {
 814         //      t:        time.Date(2016, 02, 03, 9, 0, 1, 0, time.UTC),
 815         //      expected: "February 3, 2016",
 816         // },
 817         }
 818
 819         trans := New()
 820
 821         for _, tt := range tests {
 822                 s := trans.FmtDateLong(tt.t)
 823                 if s != tt.expected {
 824                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 825                 }
 826         }
 827 }
 828
 829 func TestFmtDateMedium(t *testing.T) {
 830
 831         tests := []struct {
 832                 t        time.Time
 833                 expected string
 834         }{
 835         // {
 836         //      t:        time.Date(2016, 02, 03, 9, 0, 1, 0, time.UTC),
 837         //      expected: "Feb 3, 2016",
 838         // },
 839         }
 840
 841         trans := New()
 842
 843         for _, tt := range tests {
 844                 s := trans.FmtDateMedium(tt.t)
 845                 if s != tt.expected {
 846                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 847                 }
 848         }
 849 }
 850
 851 func TestFmtDateShort(t *testing.T) {
 852
 853         tests := []struct {
 854                 t        time.Time
 855                 expected string
 856         }{
 857         // {
 858         //      t:        time.Date(2016, 02, 03, 9, 0, 1, 0, time.UTC),
 859         //      expected: "2/3/16",
 860         // },
 861         // {
 862         //      t:        time.Date(-500, 02, 03, 9, 0, 1, 0, time.UTC),
 863         //      expected: "2/3/500",
 864         // },
 865         }
 866
 867         trans := New()
 868
 869         for _, tt := range tests {
 870                 s := trans.FmtDateShort(tt.t)
 871                 if s != tt.expected {
 872                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 873                 }
 874         }
 875 }
 876
 877 func TestFmtNumber(t *testing.T) {
 878
 879         tests := []struct {
 880                 num      float64
 881                 v        uint64
 882                 expected string
 883         }{
 884         // {
 885         //      num:      1123456.5643,
 886         //      v:        2,
 887         //      expected: "1,123,456.56",
 888         // },
 889         // {
 890         //      num:      1123456.5643,
 891         //      v:        1,
 892         //      expected: "1,123,456.6",
 893         // },
 894         // {
 895         //      num:      221123456.5643,
 896         //      v:        3,
 897         //      expected: "221,123,456.564",
 898         // },
 899         // {
 900         //      num:      -221123456.5643,
 901         //      v:        3,
 902         //      expected: "-221,123,456.564",
 903         // },
 904         // {
 905         //      num:      -221123456.5643,
 906         //      v:        3,
 907         //      expected: "-221,123,456.564",
 908         // },
 909         // {
 910         //      num:      0,
 911         //      v:        2,
 912         //      expected: "0.00",
 913         // },
 914         // {
 915         //      num:      -0,
 916         //      v:        2,
 917         //      expected: "0.00",
 918         // },
 919         // {
 920         //      num:      -0,
 921         //      v:        2,
 922         //      expected: "0.00",
 923         // },
 924         }
 925
 926         trans := New()
 927
 928         for _, tt := range tests {
 929                 s := trans.FmtNumber(tt.num, tt.v)
 930                 if s != tt.expected {
 931                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
 932                 }
 933         }
 934 }
 935
 936 func TestFmtCurrency(t *testing.T) {
 937
 938         tests := []struct {
 939                 num      float64
 940                 v        uint64
 941                 currency currency.Type
 942                 expected string
 943         }{
 944         // {
 945         //      num:      1123456.5643,
 946         //      v:        2,
 947         //      currency: currency.USD,
 948         //      expected: "$1,123,456.56",
 949         // },
 950         // {
 951         //      num:      1123456.5643,
 952         //      v:        1,
 953         //      currency: currency.USD,
 954         //      expected: "$1,123,456.60",
 955         // },
 956         // {
 957         //      num:      221123456.5643,
 958         //      v:        3,
 959         //      currency: currency.USD,
 960         //      expected: "$221,123,456.564",
 961         // },
 962         // {
 963         //      num:      -221123456.5643,
 964         //      v:        3,
 965         //      currency: currency.USD,
 966         //      expected: "-$221,123,456.564",
 967         // },
 968         // {
 969         //      num:      -221123456.5643,
 970         //      v:        3,
 971         //      currency: currency.CAD,
 972         //      expected: "-CAD 221,123,456.564",
 973         // },
 974         // {
 975         //      num:      0,
 976         //      v:        2,
 977         //      currency: currency.USD,
 978         //      expected: "$0.00",
 979         // },
 980         // {
 981         //      num:      -0,
 982         //      v:        2,
 983         //      currency: currency.USD,
 984         //      expected: "$0.00",
 985         // },
 986         // {
 987         //      num:      -0,
 988         //      v:        2,
 989         //      currency: currency.CAD,
 990         //      expected: "CAD 0.00",
 991         // },
 992         // {
 993         //      num:      1.23,
 994         //      v:        0,
 995         //      currency: currency.USD,
 996         //      expected: "$1.00",
 997         // },
 998         }
 999
1000         trans := New()
1001
1002         for _, tt := range tests {
1003                 s := trans.FmtCurrency(tt.num, tt.v, tt.currency)
1004                 if s != tt.expected {
1005                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
1006                 }
1007         }
1008 }
1009
1010 func TestFmtAccounting(t *testing.T) {
1011
1012         tests := []struct {
1013                 num      float64
1014                 v        uint64
1015                 currency currency.Type
1016                 expected string
1017         }{
1018         // {
1019         //      num:      1123456.5643,
1020         //      v:        2,
1021         //      currency: currency.USD,
1022         //      expected: "$1,123,456.56",
1023         // },
1024         // {
1025         //      num:      1123456.5643,
1026         //      v:        1,
1027         //      currency: currency.USD,
1028         //      expected: "$1,123,456.60",
1029         // },
1030         // {
1031         //      num:      221123456.5643,
1032         //      v:        3,
1033         //      currency: currency.USD,
1034         //      expected: "$221,123,456.564",
1035         // },
1036         // {
1037         //      num:      -221123456.5643,
1038         //      v:        3,
1039         //      currency: currency.USD,
1040         //      expected: "($221,123,456.564)",
1041         // },
1042         // {
1043         //      num:      -221123456.5643,
1044         //      v:        3,
1045         //      currency: currency.CAD,
1046         //      expected: "(CAD 221,123,456.564)",
1047         // },
1048         // {
1049         //      num:      -0,
1050         //      v:        2,
1051         //      currency: currency.USD,
1052         //      expected: "$0.00",
1053         // },
1054         // {
1055         //      num:      -0,
1056         //      v:        2,
1057         //      currency: currency.CAD,
1058         //      expected: "CAD 0.00",
1059         // },
1060         // {
1061         //      num:      1.23,
1062         //      v:        0,
1063         //      currency: currency.USD,
1064         //      expected: "$1.00",
1065         // },
1066         }
1067
1068         trans := New()
1069
1070         for _, tt := range tests {
1071                 s := trans.FmtAccounting(tt.num, tt.v, tt.currency)
1072                 if s != tt.expected {
1073                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
1074                 }
1075         }
1076 }
1077
1078 func TestFmtPercent(t *testing.T) {
1079
1080         tests := []struct {
1081                 num      float64
1082                 v        uint64
1083                 expected string
1084         }{
1085         // {
1086         //      num:      15,
1087         //      v:        0,
1088         //      expected: "15%",
1089         // },
1090         // {
1091         //      num:      15,
1092         //      v:        2,
1093         //      expected: "15.00%",
1094         // },
1095         // {
1096         //      num:      434.45,
1097         //      v:        0,
1098         //      expected: "434%",
1099         // },
1100         // {
1101         //      num:      34.4,
1102         //      v:        2,
1103         //      expected: "34.40%",
1104         // },
1105         // {
1106         //      num:      -34,
1107         //      v:        0,
1108         //      expected: "-34%",
1109         // },
1110         }
1111
1112         trans := New()
1113
1114         for _, tt := range tests {
1115                 s := trans.FmtPercent(tt.num, tt.v)
1116                 if s != tt.expected {
1117                         t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
1118                 }
1119         }
1120 }