func TestJSONMarshal(t *testing.T) {
// @todo these tests will fail once i18n has been fully implemented. so fix this.
var prefix = `"` + string(i18n.DefaultCurrencySign) + " "
tests := []struct {
prec int
haveI int64
haveEnc money.JSONMarshaller
haveValid bool
want string
wantErr error
}{
{100, 123456, money.JSONNumber, true, `1234.56`, nil},
{1000, 123456, money.JSONNumber, true, `123.456`, nil},
{10000, 123456, money.JSONNumber, true, `12.3456`, nil},
{10, 123456, money.JSONNumber, true, `12345.6`, nil},
{100, 123456, money.JSONNumber, false, `null`, nil},
{0, 123456, money.JSONNumber, true, `123456`, nil},
{100, 123456, money.JSONLocale, true, prefix + `1,234.56"`, nil},
{1000, 123456, money.JSONLocale, true, prefix + `123.46"`, nil},
{10000, 123456, money.JSONLocale, true, prefix + `12.35"`, nil},
{10, 123456, money.JSONLocale, true, prefix + `12,345.60"`, nil},
{100, 123456, money.JSONLocale, false, `null`, nil},
{0, 123456, money.JSONLocale, true, prefix + `123,456.00"`, nil},
{100, 123456, money.JSONExtended, true, `[1234.56, "$", "$ 1,234.56"]`, nil},
{1000, 123456, money.JSONExtended, true, `[123.456, "$", "$ 123.46"]`, nil},
{10000, 123456, money.JSONExtended, true, `[12.3456, "$", "$ 12.35"]`, nil},
{10, 123456, money.JSONExtended, true, `[12345.6, "$", "$ 12,345.60"]`, nil},
{100, 123456, money.JSONExtended, false, `null`, nil},
{0, 123456, money.JSONExtended, true, `[123456, "$", "$ 123,456.00"]`, nil},
}
for _, test := range tests {
c := money.New(
money.Precision(test.prec),
money.JSONMarshal(test.haveEnc),
money.FormatCurrency(testFmtCur),
money.FormatNumber(testFmtNum),
).Set(test.haveI)
c.Valid = test.haveValid
have, err := c.MarshalJSON()
if test.wantErr != nil {
assert.Error(t, err, "%v", test)
assert.Nil(t, have, "%v", test)
} else {
haveS := string(have)
assert.NoError(t, err, "%v", test)
if haveS != test.want {
// assert.Equal... is not useful in this case
t.Errorf("\nHave: %s\nWant: %s\n", haveS, test.want)
}
}
}
}
func TestScan(t *testing.T) {
tests := []struct {
src interface{}
want string
wantErr error
}{
{nil, `NaN`, nil},
{[]byte{0x39, 0x39, 0x39, 0x2e, 0x30, 0x30, 0x30, 0x30}, `999.0000`, nil},
{[]byte{0x37, 0x30, 0x35, 0x2e, 0x39, 0x39, 0x33, 0x33}, `705.9933`, nil},
{[]byte{0x37, 0x30, 0x35, 0x2e, 0x39, 0x39, 0x33, 0x33}, `705.9933`, nil},
{[]byte{0x37, 0x30, 0x35, 0x2e, 0x39, 0x39, 0x33, 0x33}, `705.9933`, nil},
{[]byte{0x37, 0x30, 0x35, 0x2e, 0x39, 0x39, 0x33, 0x33}, `705.9933`, nil},
{[]byte{0x37, 0x30, 0x35, 0x2e, 0x19, 0x39, 0x33, 0x13}, `0.0000`, strconv.ErrSyntax},
{[]byte{0x37, 0x33}, `73.0000`, nil},
{[]byte{0x37, 0x38}, `78.0000`, nil},
{[]byte{0x37, 0x34}, `74.0000`, nil},
{[]byte{0x37, 0x37}, `77.0000`, nil},
{[]byte{0xa7, 0x3e}, `0.0000`, strconv.ErrSyntax},
{int(33), `0.0000`, errors.New("Unsupported Type int for value. Supported: []byte")},
}
var buf bytes.Buffer
for _, test := range tests {
var c money.Currency
err := c.Scan(test.src)
c.Option(
money.FormatCurrency(testFmtCur),
money.FormatNumber(testFmtNum),
)
if test.wantErr != nil {
assert.Error(t, err, "%v", test)
assert.Contains(t, err.Error(), test.wantErr.Error())
} else {
assert.NoError(t, err, "%v", test)
assert.EqualValues(t, test.want, string(c.Ftoa()), "%v", test)
if _, err := c.NumberWriter(&buf); err != nil {
t.Error(err)
}
buf.WriteString("; ")
}
}
want := `NaN; 999.000; 705.993; 705.993; 705.993; 705.993; 73.000; 78.000; 74.000; 77.000; `
have := buf.String()
if want != have {
t.Errorf("\nHave: %s\n\nWant: %s\n", have, want)
}
}
func TestMulNumber(t *testing.T) {
tests := []struct {
prec int
have1 int64
have2 int64
want string
}{
{0, 1300, 1300, "1690000.000"},
{100, 1300, 1300, "169.000"},
{1000, 18100, 18100, "327.610"},
{100, 1319, 1488, "196.270"},
{1000, 1319, 1488, "1.963"},
{100, 13, -13, "-0.020"},
{100, 1300, -1300, "-169.000"},
{1000, 1300, -1300, "-1.690"},
{100, 13, 13, "0.020"},
{100, 45628734653, -45628734653, "250065429529630.200"}, // overflow of int64 ?
{100, 45628734653, -456287346, "-237307016244604.920"},
{100, math.MaxInt64, 2, "0.000"},
}
for _, test := range tests {
c := money.New(
money.Precision(test.prec),
money.FormatCurrency(testFmtCur),
money.FormatNumber(testFmtNum),
).Set(test.have1)
c = c.Mul(money.New(money.Precision(test.prec)).Set(test.have2))
haveB, err := c.Number()
assert.NoError(t, err)
have := string(haveB)
if have != test.want {
t.Errorf("\nWant: %s\nHave: %s\nSign %d\nIndex: %v\n", test.want, have, c.Sign(), test)
}
}
}
func TestString(t *testing.T) {
tests := []struct {
prec int
have int64
want string
}{
{0, 13, "$ 13.00"},
{10, 13, "$ 1.30"},
{100, 13, "$ 0.13"},
{1000, 13, "$ 0.01"},
{100, -13, "$ -0.13"},
{0, -45628734653, "$ -45,628,734,653.00"},
{10, -45628734653, "$ -4,562,873,465.30"},
{100, -45628734653, "$ -456,287,346.53"},
{1000, -45628734653, "$ -45,628,734.65"},
{100, 256, "$ 2.56"},
10: {1234, -45628734653, "$ -4,562,873.47"},
{100, -45628734655, "$ -456,287,346.55"},
{100, -45628734611, "$ -456,287,346.11"},
{100, -45628734699, "$ -456,287,346.99"},
14: {10000000, 45628734699, "$ 4,562.87"},
15: {10000000, 45628734655, "$ 4,562.87"},
}
for i, test := range tests {
c := money.New(
money.Precision(test.prec),
money.FormatCurrency(testFmtCur),
money.FormatNumber(testFmtNum),
).Set(test.have)
have := c.String()
if have != test.want {
t.Errorf("\nWant: %s\nHave: %s\nIndex: %d\n", test.want, have, i)
}
}
}
func TestSwedishNumber(t *testing.T) {
tests := []struct {
prec int
iv money.Interval
have int64
want string
}{
{0, money.Interval005, 25689, "25689.000"},
{100, money.Interval005, 25600, "256.000"},
{10, money.Interval005, 25689, "2568.900"},
{100, money.Interval005, 25689, "256.900"},
{1000, money.Interval005, 25689, "25.700"},
{100, money.Interval005, 25642, "256.400"},
{100, money.Interval005, 25644, "256.450"},
{0, money.Interval010, 25689, "25689.000"},
{10, money.Interval010, 25689, "2568.900"},
{100, money.Interval010, 25689, "256.900"},
{1000, money.Interval010, 25689, "25.700"},
{100, money.Interval010, 25642, "256.400"},
{100, money.Interval010, 25644, "256.400"},
{100, money.Interval010, 25639, "256.400"},
{100, money.Interval010, 25635, "256.400"},
{100, money.Interval010, 25634, "256.300"},
{100, money.Interval010, 256345, "2563.500"},
{0, money.Interval015, 25689, "25689.000"},
{10, money.Interval015, 25689, "2568.900"},
{10, money.Interval015, 25685, "2568.400"},
{100, money.Interval015, 25689, "256.900"},
{1000, money.Interval015, 25689, "25.700"},
{100, money.Interval015, 25642, "256.400"},
{100, money.Interval015, 25644, "256.400"},
{100, money.Interval015, 25639, "256.400"},
{100, money.Interval015, 25635, "256.300"},
{100, money.Interval015, 25636, "256.400"},
{100, money.Interval015, 25634, "256.300"},
{100, money.Interval015, 256345, "2563.400"},
{0, money.Interval025, 25689, "25689.000"},
{10, money.Interval025, 25689, "2569.000"},
{10, money.Interval025, 25685, "2568.500"},
{100, money.Interval025, 25689, "257.000"},
{1000, money.Interval025, 25689, "25.750"},
{100, money.Interval025, 25642, "256.500"},
{100, money.Interval025, 25644, "256.500"},
{100, money.Interval025, 25639, "256.500"},
{100, money.Interval025, 25624, "256.250"},
{100, money.Interval025, 25625, "256.250"},
{100, money.Interval025, 25634, "256.250"},
{100, money.Interval025, 256345, "2563.500"},
{0, money.Interval050, 25689, "25689.000"},
{10, money.Interval050, 25689, "2569.000"},
{10, money.Interval050, 25685, "2568.500"},
{100, money.Interval050, 25689, "257.000"},
{1000, money.Interval050, 25689, "25.500"},
{100, money.Interval050, 25642, "256.500"},
{100, money.Interval050, 25644, "256.500"},
{100, money.Interval050, 25639, "256.500"},
{100, money.Interval050, 25624, "256.000"},
{100, money.Interval050, 25625, "256.500"},
{100, money.Interval050, 25634, "256.500"},
{100, money.Interval050, 256345, "2563.500"},
{0, money.Interval100, 25689, "25689.000"},
{10, money.Interval100, 25689, "2569.000"},
{10, money.Interval100, 25685, "2569.000"},
{10, money.Interval100, 25684, "2568.000"},
{100, money.Interval100, 25689, "257.000"},
{1000, money.Interval100, 25689, "26.000"},
{100, money.Interval100, 25642, "256.000"},
{100, money.Interval100, 25644, "256.000"},
{100, money.Interval100, 25639, "256.000"},
{100, money.Interval100, 25624, "256.000"},
{100, money.Interval100, 25625, "256.000"},
{100, money.Interval100, 25634, "256.000"},
{100, money.Interval100, 256345, "2563.000"},
}
for _, test := range tests {
c := money.New(
money.Precision(test.prec),
money.FormatCurrency(testFmtCur),
money.FormatNumber(testFmtNum),
).Set(test.have)
haveB, err := c.Swedish(money.Swedish(test.iv)).Number()
assert.NoError(t, err, "%v", test)
have := string(haveB)
if have != test.want {
t.Errorf("\nWant: %s\nHave: %s\nIndex: %v\n", test.want, have, test)
}
}
}