1 package ru_RU
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 := "ru_RU"
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 := 4
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.PluralRuleOther,
64 },
65 }
66
67 rules := trans.PluralsOrdinal()
68 expected := 1
69 if len(rules) != expected {
70 t.Errorf("Expected '%d' Got '%d'", expected, len(rules))
71 }
72
73 for _, tt := range tests {
74
75 r := locales.PluralRuleUnknown
76
77 for i := 0; i < len(rules); i++ {
78 if rules[i] == tt.expected {
79 r = rules[i]
80 break
81 }
82 }
83 if r == locales.PluralRuleUnknown {
84 t.Errorf("Expected '%s' Got '%s'", tt.expected, r)
85 }
86 }
87 }
88
89 func TestPluralsCardinal(t *testing.T) {
90
91 trans := New()
92
93 tests := []struct {
94 expected locales.PluralRule
95 }{
96 {
97 expected: locales.PluralRuleOne,
98 },
99 {
100 expected: locales.PluralRuleFew,
101 },
102 {
103 expected: locales.PluralRuleMany,
104 },
105 {
106 expected: locales.PluralRuleOther,
107 },
108 }
109
110 rules := trans.PluralsCardinal()
111 expected := 4
112 if len(rules) != expected {
113 t.Errorf("Expected '%d' Got '%d'", expected, len(rules))
114 }
115
116 for _, tt := range tests {
117
118 r := locales.PluralRuleUnknown
119
120 for i := 0; i < len(rules); i++ {
121 if rules[i] == tt.expected {
122 r = rules[i]
123 break
124 }
125 }
126 if r == locales.PluralRuleUnknown {
127 t.Errorf("Expected '%s' Got '%s'", tt.expected, r)
128 }
129 }
130 }
131
132 func TestRangePlurals(t *testing.T) {
133
134 trans := New()
135
136 tests := []struct {
137 num1 float64
138 v1 uint64
139 num2 float64
140 v2 uint64
141 expected locales.PluralRule
142 }{
143 {
144 num1: 1,
145 v1: 1,
146 num2: 2,
147 v2: 2,
148 expected: locales.PluralRuleOther,
149 },
150 {
151 num1: 1,
152 v1: 0,
153 num2: 2,
154 v2: 0,
155 expected: locales.PluralRuleFew,
156 },
157 {
158 num1: 1,
159 v1: 0,
160 num2: 21,
161 v2: 0,
162 expected: locales.PluralRuleOne,
163 },
164 {
165 num1: 1,
166 v1: 0,
167 num2: 5,
168 v2: 0,
169 expected: locales.PluralRuleMany,
170 },
171 {
172 num1: 1,
173 v1: 0,
174 num2: 10,
175 v2: 0,
176 expected: locales.PluralRuleMany,
177 },
178 {
179 num1: 1,
180 v1: 0,
181 num2: 10.0,
182 v2: 1,
183 expected: locales.PluralRuleOther,
184 },
185 {
186 num1: 2,
187 v1: 0,
188 num2: 21,
189 v2: 0,
190 expected: locales.PluralRuleOne,
191 },
192 {
193 num1: 2,
194 v1: 0,
195 num2: 22,
196 v2: 0,
197 expected: locales.PluralRuleFew,
198 },
199 {
200 num1: 2,
201 v1: 0,
202 num2: 5,
203 v2: 0,
204 expected: locales.PluralRuleMany,
205 },
206 {
207 num1: 2,
208 v1: 0,
209 num2: 10,
210 v2: 1,
211 expected: locales.PluralRuleOther,
212 },
213 {
214 num1: 0,
215 v1: 0,
216 num2: 1,
217 v2: 0,
218 expected: locales.PluralRuleOne,
219 },
220 {
221 num1: 0,
222 v1: 0,
223 num2: 2,
224 v2: 0,
225 expected: locales.PluralRuleFew,
226 },
227 {
228 num1: 0,
229 v1: 0,
230 num2: 5,
231 v2: 0,
232 expected: locales.PluralRuleMany,
233 },
234 {
235 num1: 0,
236 v1: 0,
237 num2: 10,
238 v2: 1,
239 expected: locales.PluralRuleOther,
240 },
241 {
242 num1: 0.0,
243 v1: 1,
244 num2: 1,
245 v2: 0,
246 expected: locales.PluralRuleOne,
247 },
248 {
249 num1: 0.0,
250 v1: 1,
251 num2: 2,
252 v2: 0,
253 expected: locales.PluralRuleFew,
254 },
255 {
256 num1: 0.0,
257 v1: 1,
258 num2: 5,
259 v2: 0,
260 expected: locales.PluralRuleMany,
261 },
262 {
263 num1: 0.0,
264 v1: 1,
265 num2: 10.0,
266 v2: 1,
267 expected: locales.PluralRuleOther,
268 },
269 }
270
271 for _, tt := range tests {
272 rule := trans.RangePluralRule(tt.num1, tt.v1, tt.num2, tt.v2)
273 if rule != tt.expected {
274 t.Errorf("Expected '%s' Got '%s'", tt.expected, rule)
275 }
276 }
277 }
278
279 func TestOrdinalPlurals(t *testing.T) {
280
281 trans := New()
282
283 tests := []struct {
284 num float64
285 v uint64
286 expected locales.PluralRule
287 }{
288 {
289 num: 1,
290 v: 0,
291 expected: locales.PluralRuleOther,
292 },
293 {
294 num: 2,
295 v: 0,
296 expected: locales.PluralRuleOther,
297 },
298 {
299 num: 3,
300 v: 0,
301 expected: locales.PluralRuleOther,
302 },
303 {
304 num: 4,
305 v: 0,
306 expected: locales.PluralRuleOther,
307 },
308 }
309
310 for _, tt := range tests {
311 rule := trans.OrdinalPluralRule(tt.num, tt.v)
312 if rule != tt.expected {
313 t.Errorf("Expected '%s' Got '%s'", tt.expected, rule)
314 }
315 }
316 }
317
318 func TestCardinalPlurals(t *testing.T) {
319
320 trans := New()
321
322 tests := []struct {
323 num float64
324 v uint64
325 expected locales.PluralRule
326 }{
327 {
328 num: 1,
329 v: 0,
330 expected: locales.PluralRuleOne,
331 },
332 {
333 num: 21,
334 v: 0,
335 expected: locales.PluralRuleOne,
336 },
337 {
338 num: 31,
339 v: 0,
340 expected: locales.PluralRuleOne,
341 },
342 {
343 num: 2,
344 v: 0,
345 expected: locales.PluralRuleFew,
346 },
347 {
348 num: 3,
349 v: 0,
350 expected: locales.PluralRuleFew,
351 },
352 {
353 num: 22,
354 v: 0,
355 expected: locales.PluralRuleFew,
356 },
357 {
358 num: 23,
359 v: 0,
360 expected: locales.PluralRuleFew,
361 },
362 {
363 num: 0,
364 v: 0,
365 expected: locales.PluralRuleMany,
366 },
367 {
368 num: 5,
369 v: 0,
370 expected: locales.PluralRuleMany,
371 },
372 {
373 num: 11,
374 v: 0,
375 expected: locales.PluralRuleMany,
376 },
377 {
378 num: 100,
379 v: 0,
380 expected: locales.PluralRuleMany,
381 },
382 }
383
384 for _, tt := range tests {
385 rule := trans.CardinalPluralRule(tt.num, tt.v)
386 if rule != tt.expected {
387 t.Errorf("Expected '%s' Got '%s'", tt.expected, rule)
388 }
389 }
390 }
391
392 func TestDaysAbbreviated(t *testing.T) {
393
394 trans := New()
395 days := trans.WeekdaysAbbreviated()
396
397 for i, day := range days {
398 s := trans.WeekdayAbbreviated(time.Weekday(i))
399 if s != day {
400 t.Errorf("Expected '%s' Got '%s'", day, s)
401 }
402 }
403
404 tests := []struct {
405 idx int
406 expected string
407 }{
408 {
409 idx: 0,
410 expected: "вс",
411 },
412 {
413 idx: 1,
414 expected: "пн",
415 },
416 {
417 idx: 2,
418 expected: "вт",
419 },
420 {
421 idx: 3,
422 expected: "ср",
423 },
424 {
425 idx: 4,
426 expected: "чт",
427 },
428 {
429 idx: 5,
430 expected: "пт",
431 },
432 {
433 idx: 6,
434 expected: "сб",
435 },
436 }
437
438 for _, tt := range tests {
439 s := trans.WeekdayAbbreviated(time.Weekday(tt.idx))
440 if s != tt.expected {
441 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
442 }
443 }
444 }
445
446 func TestDaysNarrow(t *testing.T) {
447
448 trans := New()
449 days := trans.WeekdaysNarrow()
450
451 for i, day := range days {
452 s := trans.WeekdayNarrow(time.Weekday(i))
453 if s != day {
454 t.Errorf("Expected '%s' Got '%s'", string(day), s)
455 }
456 }
457
458 tests := []struct {
459 idx int
460 expected string
461 }{
462 {
463 idx: 0,
464 expected: "вс",
465 },
466 {
467 idx: 1,
468 expected: "пн",
469 },
470 {
471 idx: 2,
472 expected: "вт",
473 },
474 {
475 idx: 3,
476 expected: "ср",
477 },
478 {
479 idx: 4,
480 expected: "чт",
481 },
482 {
483 idx: 5,
484 expected: "пт",
485 },
486 {
487 idx: 6,
488 expected: "сб",
489 },
490 }
491
492 for _, tt := range tests {
493 s := trans.WeekdayNarrow(time.Weekday(tt.idx))
494 if s != tt.expected {
495 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
496 }
497 }
498 }
499
500 func TestDaysShort(t *testing.T) {
501
502 trans := New()
503 days := trans.WeekdaysShort()
504
505 for i, day := range days {
506 s := trans.WeekdayShort(time.Weekday(i))
507 if s != day {
508 t.Errorf("Expected '%s' Got '%s'", day, s)
509 }
510 }
511
512 tests := []struct {
513 idx int
514 expected string
515 }{
516 {
517 idx: 0,
518 expected: "вс",
519 },
520 {
521 idx: 1,
522 expected: "пн",
523 },
524 {
525 idx: 2,
526 expected: "вт",
527 },
528 {
529 idx: 3,
530 expected: "ср",
531 },
532 {
533 idx: 4,
534 expected: "чт",
535 },
536 {
537 idx: 5,
538 expected: "пт",
539 },
540 {
541 idx: 6,
542 expected: "сб",
543 },
544 }
545
546 for _, tt := range tests {
547 s := trans.WeekdayShort(time.Weekday(tt.idx))
548 if s != tt.expected {
549 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
550 }
551 }
552 }
553
554 func TestDaysWide(t *testing.T) {
555
556 trans := New()
557 days := trans.WeekdaysWide()
558
559 for i, day := range days {
560 s := trans.WeekdayWide(time.Weekday(i))
561 if s != day {
562 t.Errorf("Expected '%s' Got '%s'", day, s)
563 }
564 }
565
566 tests := []struct {
567 idx int
568 expected string
569 }{
570 {
571 idx: 0,
572 expected: "воскресенье",
573 },
574 {
575 idx: 1,
576 expected: "понедельник",
577 },
578 {
579 idx: 2,
580 expected: "вторник",
581 },
582 {
583 idx: 3,
584 expected: "среда",
585 },
586 {
587 idx: 4,
588 expected: "четверг",
589 },
590 {
591 idx: 5,
592 expected: "пятница",
593 },
594 {
595 idx: 6,
596 expected: "суббота",
597 },
598 }
599
600 for _, tt := range tests {
601 s := trans.WeekdayWide(time.Weekday(tt.idx))
602 if s != tt.expected {
603 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
604 }
605 }
606 }
607
608 func TestMonthsAbbreviated(t *testing.T) {
609
610 trans := New()
611 months := trans.MonthsAbbreviated()
612
613 for i, month := range months {
614 s := trans.MonthAbbreviated(time.Month(i + 1))
615 if s != month {
616 t.Errorf("Expected '%s' Got '%s'", month, s)
617 }
618 }
619
620 tests := []struct {
621 idx int
622 expected string
623 }{
624 {
625 idx: 1,
626 expected: "янв.",
627 },
628 {
629 idx: 2,
630 expected: "февр.",
631 },
632 {
633 idx: 3,
634 expected: "мар.",
635 },
636 {
637 idx: 4,
638 expected: "апр.",
639 },
640 {
641 idx: 5,
642 expected: "мая",
643 },
644 {
645 idx: 6,
646 expected: "июн.",
647 },
648 {
649 idx: 7,
650 expected: "июл.",
651 },
652 {
653 idx: 8,
654 expected: "авг.",
655 },
656 {
657 idx: 9,
658 expected: "сент.",
659 },
660 {
661 idx: 10,
662 expected: "окт.",
663 },
664 {
665 idx: 11,
666 expected: "нояб.",
667 },
668 {
669 idx: 12,
670 expected: "дек.",
671 },
672 }
673
674 for _, tt := range tests {
675 s := trans.MonthAbbreviated(time.Month(tt.idx))
676 if s != tt.expected {
677 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
678 }
679 }
680 }
681
682 func TestMonthsNarrow(t *testing.T) {
683
684 trans := New()
685 months := trans.MonthsNarrow()
686
687 for i, month := range months {
688 s := trans.MonthNarrow(time.Month(i + 1))
689 if s != month {
690 t.Errorf("Expected '%s' Got '%s'", month, s)
691 }
692 }
693
694 tests := []struct {
695 idx int
696 expected string
697 }{
698 {
699 idx: 1,
700 expected: "Я",
701 },
702 {
703 idx: 2,
704 expected: "Ф",
705 },
706 {
707 idx: 3,
708 expected: "М",
709 },
710 {
711 idx: 4,
712 expected: "А",
713 },
714 {
715 idx: 5,
716 expected: "М",
717 },
718 {
719 idx: 6,
720 expected: "И",
721 },
722 {
723 idx: 7,
724 expected: "И",
725 },
726 {
727 idx: 8,
728 expected: "А",
729 },
730 {
731 idx: 9,
732 expected: "С",
733 },
734 {
735 idx: 10,
736 expected: "О",
737 },
738 {
739 idx: 11,
740 expected: "Н",
741 },
742 {
743 idx: 12,
744 expected: "Д",
745 },
746 }
747
748 for _, tt := range tests {
749 s := trans.MonthNarrow(time.Month(tt.idx))
750 if s != tt.expected {
751 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
752 }
753 }
754 }
755
756 func TestMonthsWide(t *testing.T) {
757
758 trans := New()
759 months := trans.MonthsWide()
760
761 for i, month := range months {
762 s := trans.MonthWide(time.Month(i + 1))
763 if s != month {
764 t.Errorf("Expected '%s' Got '%s'", month, s)
765 }
766 }
767
768 tests := []struct {
769 idx int
770 expected string
771 }{
772 {
773 idx: 1,
774 expected: "января",
775 },
776 {
777 idx: 2,
778 expected: "февраля",
779 },
780 {
781 idx: 3,
782 expected: "марта",
783 },
784 {
785 idx: 4,
786 expected: "апреля",
787 },
788 {
789 idx: 5,
790 expected: "мая",
791 },
792 {
793 idx: 6,
794 expected: "июня",
795 },
796 {
797 idx: 7,
798 expected: "июля",
799 },
800 {
801 idx: 8,
802 expected: "августа",
803 },
804 {
805 idx: 9,
806 expected: "сентября",
807 },
808 {
809 idx: 10,
810 expected: "октября",
811 },
812 {
813 idx: 11,
814 expected: "ноября",
815 },
816 {
817 idx: 12,
818 expected: "декабря",
819 },
820 }
821
822 for _, tt := range tests {
823 s := string(trans.MonthWide(time.Month(tt.idx)))
824 if s != tt.expected {
825 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
826 }
827 }
828 }
829
830 func TestFmtTimeFull(t *testing.T) {
831
832 loc, err := time.LoadLocation("America/Toronto")
833 if err != nil {
834 t.Errorf("Expected '<nil>' Got '%s'", err)
835 }
836
837 fixed := time.FixedZone("OTHER", -4)
838
839 tests := []struct {
840 t time.Time
841 expected string
842 }{
843 {
844 t: time.Date(2016, 02, 03, 9, 5, 1, 0, loc),
845 expected: "09:05:01 Восточная Америка, стандартное время",
846 },
847 {
848 t: time.Date(2016, 02, 03, 20, 5, 1, 0, fixed),
849 expected: "20:05:01 OTHER",
850 },
851 }
852
853 trans := New()
854
855 for _, tt := range tests {
856 s := trans.FmtTimeFull(tt.t)
857 if s != tt.expected {
858 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
859 }
860 }
861 }
862
863 func TestFmtTimeLong(t *testing.T) {
864
865 loc, err := time.LoadLocation("America/Toronto")
866 if err != nil {
867 t.Errorf("Expected '<nil>' Got '%s'", err)
868 }
869
870 tests := []struct {
871 t time.Time
872 expected string
873 }{
874 {
875 t: time.Date(2016, 02, 03, 9, 5, 1, 0, loc),
876 expected: "09:05:01 EST",
877 },
878 {
879 t: time.Date(2016, 02, 03, 20, 5, 1, 0, loc),
880 expected: "20:05:01 EST",
881 },
882 }
883
884 trans := New()
885
886 for _, tt := range tests {
887 s := trans.FmtTimeLong(tt.t)
888 if s != tt.expected {
889 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
890 }
891 }
892 }
893
894 func TestFmtTimeMedium(t *testing.T) {
895
896 tests := []struct {
897 t time.Time
898 expected string
899 }{
900 {
901 t: time.Date(2016, 02, 03, 9, 5, 1, 0, time.UTC),
902 expected: "09:05:01",
903 },
904 {
905 t: time.Date(2016, 02, 03, 20, 5, 1, 0, time.UTC),
906 expected: "20:05:01",
907 },
908 }
909
910 trans := New()
911
912 for _, tt := range tests {
913 s := trans.FmtTimeMedium(tt.t)
914 if s != tt.expected {
915 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
916 }
917 }
918 }
919
920 func TestFmtTimeShort(t *testing.T) {
921
922 tests := []struct {
923 t time.Time
924 expected string
925 }{
926 {
927 t: time.Date(2016, 02, 03, 9, 5, 1, 0, time.UTC),
928 expected: "09:05",
929 },
930 {
931 t: time.Date(2016, 02, 03, 20, 5, 1, 0, time.UTC),
932 expected: "20:05",
933 },
934 }
935
936 trans := New()
937
938 for _, tt := range tests {
939 s := trans.FmtTimeShort(tt.t)
940 if s != tt.expected {
941 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
942 }
943 }
944 }
945
946 func TestFmtDateFull(t *testing.T) {
947
948 tests := []struct {
949 t time.Time
950 expected string
951 }{
952 {
953 t: time.Date(2016, 02, 03, 9, 0, 1, 0, time.UTC),
954 expected: "среда, 3 февраля 2016 г.",
955 },
956 }
957
958 trans := New()
959
960 for _, tt := range tests {
961 s := trans.FmtDateFull(tt.t)
962 if s != tt.expected {
963 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
964 }
965 }
966 }
967
968 func TestFmtDateLong(t *testing.T) {
969
970 tests := []struct {
971 t time.Time
972 expected string
973 }{
974 {
975 t: time.Date(2016, 02, 03, 9, 0, 1, 0, time.UTC),
976 expected: "3 февраля 2016 г.",
977 },
978 }
979
980 trans := New()
981
982 for _, tt := range tests {
983 s := trans.FmtDateLong(tt.t)
984 if s != tt.expected {
985 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
986 }
987 }
988 }
989
990 func TestFmtDateMedium(t *testing.T) {
991
992 tests := []struct {
993 t time.Time
994 expected string
995 }{
996 {
997 t: time.Date(2016, 02, 03, 9, 0, 1, 0, time.UTC),
998 expected: "3 февр. 2016 г.",
999 },
1000 }
1001
1002 trans := New()
1003
1004 for _, tt := range tests {
1005 s := trans.FmtDateMedium(tt.t)
1006 if s != tt.expected {
1007 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
1008 }
1009 }
1010 }
1011
1012 func TestFmtDateShort(t *testing.T) {
1013
1014 tests := []struct {
1015 t time.Time
1016 expected string
1017 }{
1018 {
1019 t: time.Date(2016, 02, 03, 9, 0, 1, 0, time.UTC),
1020 expected: "03.02.2016",
1021 },
1022 {
1023 t: time.Date(-500, 02, 03, 9, 0, 1, 0, time.UTC),
1024 expected: "03.02.500",
1025 },
1026 }
1027
1028 trans := New()
1029
1030 for _, tt := range tests {
1031 s := trans.FmtDateShort(tt.t)
1032 if s != tt.expected {
1033 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
1034 }
1035 }
1036 }
1037
1038 func TestFmtNumber(t *testing.T) {
1039
1040 tests := []struct {
1041 num float64
1042 v uint64
1043 expected string
1044 }{
1045 {
1046 num: 1123456.5643,
1047 v: 2,
1048 expected: "1 123 456,56",
1049 },
1050 {
1051 num: 1123456.5643,
1052 v: 1,
1053 expected: "1 123 456,6",
1054 },
1055 {
1056 num: 221123456.5643,
1057 v: 3,
1058 expected: "221 123 456,564",
1059 },
1060 {
1061 num: -221123456.5643,
1062 v: 3,
1063 expected: "-221 123 456,564",
1064 },
1065 {
1066 num: -221123456.5643,
1067 v: 3,
1068 expected: "-221 123 456,564",
1069 },
1070 {
1071 num: 0,
1072 v: 2,
1073 expected: "0,00",
1074 },
1075 {
1076 num: -0,
1077 v: 2,
1078 expected: "0,00",
1079 },
1080 {
1081 num: -0,
1082 v: 2,
1083 expected: "0,00",
1084 },
1085 }
1086
1087 trans := New()
1088
1089 for _, tt := range tests {
1090 s := trans.FmtNumber(tt.num, tt.v)
1091 if s != tt.expected {
1092 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
1093 }
1094 }
1095 }
1096
1097 func TestFmtCurrency(t *testing.T) {
1098
1099 tests := []struct {
1100 num float64
1101 v uint64
1102 currency currency.Type
1103 expected string
1104 }{
1105 {
1106 num: 1123456.5643,
1107 v: 2,
1108 currency: currency.USD,
1109 expected: "1 123 456,56 USD",
1110 },
1111 {
1112 num: 1123456.5643,
1113 v: 1,
1114 currency: currency.USD,
1115 expected: "1 123 456,60 USD",
1116 },
1117 {
1118 num: 221123456.5643,
1119 v: 3,
1120 currency: currency.USD,
1121 expected: "221 123 456,564 USD",
1122 },
1123 {
1124 num: -221123456.5643,
1125 v: 3,
1126 currency: currency.USD,
1127 expected: "-221 123 456,564 USD",
1128 },
1129 {
1130 num: -221123456.5643,
1131 v: 3,
1132 currency: currency.CAD,
1133 expected: "-221 123 456,564 CAD",
1134 },
1135 {
1136 num: 0,
1137 v: 2,
1138 currency: currency.USD,
1139 expected: "0,00 USD",
1140 },
1141 {
1142 num: -0,
1143 v: 2,
1144 currency: currency.USD,
1145 expected: "0,00 USD",
1146 },
1147 {
1148 num: -0,
1149 v: 2,
1150 currency: currency.CAD,
1151 expected: "0,00 CAD",
1152 },
1153 {
1154 num: 1.23,
1155 v: 0,
1156 currency: currency.USD,
1157 expected: "1,00 USD",
1158 },
1159 }
1160
1161 trans := New()
1162
1163 for _, tt := range tests {
1164 s := trans.FmtCurrency(tt.num, tt.v, tt.currency)
1165 if s != tt.expected {
1166 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
1167 }
1168 }
1169 }
1170
1171 func TestFmtAccounting(t *testing.T) {
1172
1173 tests := []struct {
1174 num float64
1175 v uint64
1176 currency currency.Type
1177 expected string
1178 }{
1179 {
1180 num: 1123456.5643,
1181 v: 2,
1182 currency: currency.USD,
1183 expected: "1 123 456,56 USD",
1184 },
1185 {
1186 num: 1123456.5643,
1187 v: 1,
1188 currency: currency.USD,
1189 expected: "1 123 456,60 USD",
1190 },
1191 {
1192 num: 221123456.5643,
1193 v: 3,
1194 currency: currency.USD,
1195 expected: "221 123 456,564 USD",
1196 },
1197 {
1198 num: -221123456.5643,
1199 v: 3,
1200 currency: currency.USD,
1201 expected: "-221 123 456,564 USD",
1202 },
1203 {
1204 num: -221123456.5643,
1205 v: 3,
1206 currency: currency.CAD,
1207 expected: "-221 123 456,564 CAD",
1208 },
1209 {
1210 num: -0,
1211 v: 2,
1212 currency: currency.USD,
1213 expected: "0,00 USD",
1214 },
1215 {
1216 num: -0,
1217 v: 2,
1218 currency: currency.CAD,
1219 expected: "0,00 CAD",
1220 },
1221 {
1222 num: 1.23,
1223 v: 0,
1224 currency: currency.USD,
1225 expected: "1,00 USD",
1226 },
1227 }
1228
1229 trans := New()
1230
1231 for _, tt := range tests {
1232 s := trans.FmtAccounting(tt.num, tt.v, tt.currency)
1233 if s != tt.expected {
1234 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
1235 }
1236 }
1237 }
1238
1239 func TestFmtPercent(t *testing.T) {
1240
1241 tests := []struct {
1242 num float64
1243 v uint64
1244 expected string
1245 }{
1246 {
1247 num: 15,
1248 v: 0,
1249 expected: "15%",
1250 },
1251 {
1252 num: 15,
1253 v: 2,
1254 expected: "15,00%",
1255 },
1256 {
1257 num: 434.45,
1258 v: 0,
1259 expected: "434%",
1260 },
1261 {
1262 num: 34.4,
1263 v: 2,
1264 expected: "34,40%",
1265 },
1266 {
1267 num: -34,
1268 v: 0,
1269 expected: "-34%",
1270 },
1271 }
1272
1273 trans := New()
1274
1275 for _, tt := range tests {
1276 s := trans.FmtPercent(tt.num, tt.v)
1277 if s != tt.expected {
1278 t.Errorf("Expected '%s' Got '%s'", tt.expected, s)
1279 }
1280 }
1281 }
1282
View as plain text