Source file src/math/big/intconv_test.go

Documentation: math/big

		 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 big
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"fmt"
		10  	"testing"
		11  )
		12  
		13  var stringTests = []struct {
		14  	in	 string
		15  	out	string
		16  	base int
		17  	val	int64
		18  	ok	 bool
		19  }{
		20  	// invalid inputs
		21  	{in: ""},
		22  	{in: "a"},
		23  	{in: "z"},
		24  	{in: "+"},
		25  	{in: "-"},
		26  	{in: "0b"},
		27  	{in: "0o"},
		28  	{in: "0x"},
		29  	{in: "0y"},
		30  	{in: "2", base: 2},
		31  	{in: "0b2", base: 0},
		32  	{in: "08"},
		33  	{in: "8", base: 8},
		34  	{in: "0xg", base: 0},
		35  	{in: "g", base: 16},
		36  
		37  	// invalid inputs with separators
		38  	// (smoke tests only - a comprehensive set of tests is in natconv_test.go)
		39  	{in: "_"},
		40  	{in: "0_"},
		41  	{in: "_0"},
		42  	{in: "-1__0"},
		43  	{in: "0x10_"},
		44  	{in: "1_000", base: 10}, // separators are not permitted for bases != 0
		45  	{in: "d_e_a_d", base: 16},
		46  
		47  	// valid inputs
		48  	{"0", "0", 0, 0, true},
		49  	{"0", "0", 10, 0, true},
		50  	{"0", "0", 16, 0, true},
		51  	{"+0", "0", 0, 0, true},
		52  	{"-0", "0", 0, 0, true},
		53  	{"10", "10", 0, 10, true},
		54  	{"10", "10", 10, 10, true},
		55  	{"10", "10", 16, 16, true},
		56  	{"-10", "-10", 16, -16, true},
		57  	{"+10", "10", 16, 16, true},
		58  	{"0b10", "2", 0, 2, true},
		59  	{"0o10", "8", 0, 8, true},
		60  	{"0x10", "16", 0, 16, true},
		61  	{in: "0x10", base: 16},
		62  	{"-0x10", "-16", 0, -16, true},
		63  	{"+0x10", "16", 0, 16, true},
		64  	{"00", "0", 0, 0, true},
		65  	{"0", "0", 8, 0, true},
		66  	{"07", "7", 0, 7, true},
		67  	{"7", "7", 8, 7, true},
		68  	{"023", "19", 0, 19, true},
		69  	{"23", "23", 8, 19, true},
		70  	{"cafebabe", "cafebabe", 16, 0xcafebabe, true},
		71  	{"0b0", "0", 0, 0, true},
		72  	{"-111", "-111", 2, -7, true},
		73  	{"-0b111", "-7", 0, -7, true},
		74  	{"0b1001010111", "599", 0, 0x257, true},
		75  	{"1001010111", "1001010111", 2, 0x257, true},
		76  	{"A", "a", 36, 10, true},
		77  	{"A", "A", 37, 36, true},
		78  	{"ABCXYZ", "abcxyz", 36, 623741435, true},
		79  	{"ABCXYZ", "ABCXYZ", 62, 33536793425, true},
		80  
		81  	// valid input with separators
		82  	// (smoke tests only - a comprehensive set of tests is in natconv_test.go)
		83  	{"1_000", "1000", 0, 1000, true},
		84  	{"0b_1010", "10", 0, 10, true},
		85  	{"+0o_660", "432", 0, 0660, true},
		86  	{"-0xF00D_1E", "-15731998", 0, -0xf00d1e, true},
		87  }
		88  
		89  func TestIntText(t *testing.T) {
		90  	z := new(Int)
		91  	for _, test := range stringTests {
		92  		if !test.ok {
		93  			continue
		94  		}
		95  
		96  		_, ok := z.SetString(test.in, test.base)
		97  		if !ok {
		98  			t.Errorf("%v: failed to parse", test)
		99  			continue
	 100  		}
	 101  
	 102  		base := test.base
	 103  		if base == 0 {
	 104  			base = 10
	 105  		}
	 106  
	 107  		if got := z.Text(base); got != test.out {
	 108  			t.Errorf("%v: got %s; want %s", test, got, test.out)
	 109  		}
	 110  	}
	 111  }
	 112  
	 113  func TestAppendText(t *testing.T) {
	 114  	z := new(Int)
	 115  	var buf []byte
	 116  	for _, test := range stringTests {
	 117  		if !test.ok {
	 118  			continue
	 119  		}
	 120  
	 121  		_, ok := z.SetString(test.in, test.base)
	 122  		if !ok {
	 123  			t.Errorf("%v: failed to parse", test)
	 124  			continue
	 125  		}
	 126  
	 127  		base := test.base
	 128  		if base == 0 {
	 129  			base = 10
	 130  		}
	 131  
	 132  		i := len(buf)
	 133  		buf = z.Append(buf, base)
	 134  		if got := string(buf[i:]); got != test.out {
	 135  			t.Errorf("%v: got %s; want %s", test, got, test.out)
	 136  		}
	 137  	}
	 138  }
	 139  
	 140  func format(base int) string {
	 141  	switch base {
	 142  	case 2:
	 143  		return "%b"
	 144  	case 8:
	 145  		return "%o"
	 146  	case 16:
	 147  		return "%x"
	 148  	}
	 149  	return "%d"
	 150  }
	 151  
	 152  func TestGetString(t *testing.T) {
	 153  	z := new(Int)
	 154  	for i, test := range stringTests {
	 155  		if !test.ok {
	 156  			continue
	 157  		}
	 158  		z.SetInt64(test.val)
	 159  
	 160  		if test.base == 10 {
	 161  			if got := z.String(); got != test.out {
	 162  				t.Errorf("#%da got %s; want %s", i, got, test.out)
	 163  			}
	 164  		}
	 165  
	 166  		f := format(test.base)
	 167  		got := fmt.Sprintf(f, z)
	 168  		if f == "%d" {
	 169  			if got != fmt.Sprintf("%d", test.val) {
	 170  				t.Errorf("#%db got %s; want %d", i, got, test.val)
	 171  			}
	 172  		} else {
	 173  			if got != test.out {
	 174  				t.Errorf("#%dc got %s; want %s", i, got, test.out)
	 175  			}
	 176  		}
	 177  	}
	 178  }
	 179  
	 180  func TestSetString(t *testing.T) {
	 181  	tmp := new(Int)
	 182  	for i, test := range stringTests {
	 183  		// initialize to a non-zero value so that issues with parsing
	 184  		// 0 are detected
	 185  		tmp.SetInt64(1234567890)
	 186  		n1, ok1 := new(Int).SetString(test.in, test.base)
	 187  		n2, ok2 := tmp.SetString(test.in, test.base)
	 188  		expected := NewInt(test.val)
	 189  		if ok1 != test.ok || ok2 != test.ok {
	 190  			t.Errorf("#%d (input '%s') ok incorrect (should be %t)", i, test.in, test.ok)
	 191  			continue
	 192  		}
	 193  		if !ok1 {
	 194  			if n1 != nil {
	 195  				t.Errorf("#%d (input '%s') n1 != nil", i, test.in)
	 196  			}
	 197  			continue
	 198  		}
	 199  		if !ok2 {
	 200  			if n2 != nil {
	 201  				t.Errorf("#%d (input '%s') n2 != nil", i, test.in)
	 202  			}
	 203  			continue
	 204  		}
	 205  
	 206  		if ok1 && !isNormalized(n1) {
	 207  			t.Errorf("#%d (input '%s'): %v is not normalized", i, test.in, *n1)
	 208  		}
	 209  		if ok2 && !isNormalized(n2) {
	 210  			t.Errorf("#%d (input '%s'): %v is not normalized", i, test.in, *n2)
	 211  		}
	 212  
	 213  		if n1.Cmp(expected) != 0 {
	 214  			t.Errorf("#%d (input '%s') got: %s want: %d", i, test.in, n1, test.val)
	 215  		}
	 216  		if n2.Cmp(expected) != 0 {
	 217  			t.Errorf("#%d (input '%s') got: %s want: %d", i, test.in, n2, test.val)
	 218  		}
	 219  	}
	 220  }
	 221  
	 222  var formatTests = []struct {
	 223  	input	string
	 224  	format string
	 225  	output string
	 226  }{
	 227  	{"<nil>", "%x", "<nil>"},
	 228  	{"<nil>", "%#x", "<nil>"},
	 229  	{"<nil>", "%#y", "%!y(big.Int=<nil>)"},
	 230  
	 231  	{"10", "%b", "1010"},
	 232  	{"10", "%o", "12"},
	 233  	{"10", "%d", "10"},
	 234  	{"10", "%v", "10"},
	 235  	{"10", "%x", "a"},
	 236  	{"10", "%X", "A"},
	 237  	{"-10", "%X", "-A"},
	 238  	{"10", "%y", "%!y(big.Int=10)"},
	 239  	{"-10", "%y", "%!y(big.Int=-10)"},
	 240  
	 241  	{"10", "%#b", "0b1010"},
	 242  	{"10", "%#o", "012"},
	 243  	{"10", "%O", "0o12"},
	 244  	{"-10", "%#b", "-0b1010"},
	 245  	{"-10", "%#o", "-012"},
	 246  	{"-10", "%O", "-0o12"},
	 247  	{"10", "%#d", "10"},
	 248  	{"10", "%#v", "10"},
	 249  	{"10", "%#x", "0xa"},
	 250  	{"10", "%#X", "0XA"},
	 251  	{"-10", "%#X", "-0XA"},
	 252  	{"10", "%#y", "%!y(big.Int=10)"},
	 253  	{"-10", "%#y", "%!y(big.Int=-10)"},
	 254  
	 255  	{"1234", "%d", "1234"},
	 256  	{"1234", "%3d", "1234"},
	 257  	{"1234", "%4d", "1234"},
	 258  	{"-1234", "%d", "-1234"},
	 259  	{"1234", "% 5d", " 1234"},
	 260  	{"1234", "%+5d", "+1234"},
	 261  	{"1234", "%-5d", "1234 "},
	 262  	{"1234", "%x", "4d2"},
	 263  	{"1234", "%X", "4D2"},
	 264  	{"-1234", "%3x", "-4d2"},
	 265  	{"-1234", "%4x", "-4d2"},
	 266  	{"-1234", "%5x", " -4d2"},
	 267  	{"-1234", "%-5x", "-4d2 "},
	 268  	{"1234", "%03d", "1234"},
	 269  	{"1234", "%04d", "1234"},
	 270  	{"1234", "%05d", "01234"},
	 271  	{"1234", "%06d", "001234"},
	 272  	{"-1234", "%06d", "-01234"},
	 273  	{"1234", "%+06d", "+01234"},
	 274  	{"1234", "% 06d", " 01234"},
	 275  	{"1234", "%-6d", "1234	"},
	 276  	{"1234", "%-06d", "1234	"},
	 277  	{"-1234", "%-06d", "-1234 "},
	 278  
	 279  	{"1234", "%.3d", "1234"},
	 280  	{"1234", "%.4d", "1234"},
	 281  	{"1234", "%.5d", "01234"},
	 282  	{"1234", "%.6d", "001234"},
	 283  	{"-1234", "%.3d", "-1234"},
	 284  	{"-1234", "%.4d", "-1234"},
	 285  	{"-1234", "%.5d", "-01234"},
	 286  	{"-1234", "%.6d", "-001234"},
	 287  
	 288  	{"1234", "%8.3d", "		1234"},
	 289  	{"1234", "%8.4d", "		1234"},
	 290  	{"1234", "%8.5d", "	 01234"},
	 291  	{"1234", "%8.6d", "	001234"},
	 292  	{"-1234", "%8.3d", "	 -1234"},
	 293  	{"-1234", "%8.4d", "	 -1234"},
	 294  	{"-1234", "%8.5d", "	-01234"},
	 295  	{"-1234", "%8.6d", " -001234"},
	 296  
	 297  	{"1234", "%+8.3d", "	 +1234"},
	 298  	{"1234", "%+8.4d", "	 +1234"},
	 299  	{"1234", "%+8.5d", "	+01234"},
	 300  	{"1234", "%+8.6d", " +001234"},
	 301  	{"-1234", "%+8.3d", "	 -1234"},
	 302  	{"-1234", "%+8.4d", "	 -1234"},
	 303  	{"-1234", "%+8.5d", "	-01234"},
	 304  	{"-1234", "%+8.6d", " -001234"},
	 305  
	 306  	{"1234", "% 8.3d", "		1234"},
	 307  	{"1234", "% 8.4d", "		1234"},
	 308  	{"1234", "% 8.5d", "	 01234"},
	 309  	{"1234", "% 8.6d", "	001234"},
	 310  	{"-1234", "% 8.3d", "	 -1234"},
	 311  	{"-1234", "% 8.4d", "	 -1234"},
	 312  	{"-1234", "% 8.5d", "	-01234"},
	 313  	{"-1234", "% 8.6d", " -001234"},
	 314  
	 315  	{"1234", "%.3x", "4d2"},
	 316  	{"1234", "%.4x", "04d2"},
	 317  	{"1234", "%.5x", "004d2"},
	 318  	{"1234", "%.6x", "0004d2"},
	 319  	{"-1234", "%.3x", "-4d2"},
	 320  	{"-1234", "%.4x", "-04d2"},
	 321  	{"-1234", "%.5x", "-004d2"},
	 322  	{"-1234", "%.6x", "-0004d2"},
	 323  
	 324  	{"1234", "%8.3x", "		 4d2"},
	 325  	{"1234", "%8.4x", "		04d2"},
	 326  	{"1234", "%8.5x", "	 004d2"},
	 327  	{"1234", "%8.6x", "	0004d2"},
	 328  	{"-1234", "%8.3x", "		-4d2"},
	 329  	{"-1234", "%8.4x", "	 -04d2"},
	 330  	{"-1234", "%8.5x", "	-004d2"},
	 331  	{"-1234", "%8.6x", " -0004d2"},
	 332  
	 333  	{"1234", "%+8.3x", "		+4d2"},
	 334  	{"1234", "%+8.4x", "	 +04d2"},
	 335  	{"1234", "%+8.5x", "	+004d2"},
	 336  	{"1234", "%+8.6x", " +0004d2"},
	 337  	{"-1234", "%+8.3x", "		-4d2"},
	 338  	{"-1234", "%+8.4x", "	 -04d2"},
	 339  	{"-1234", "%+8.5x", "	-004d2"},
	 340  	{"-1234", "%+8.6x", " -0004d2"},
	 341  
	 342  	{"1234", "% 8.3x", "		 4d2"},
	 343  	{"1234", "% 8.4x", "		04d2"},
	 344  	{"1234", "% 8.5x", "	 004d2"},
	 345  	{"1234", "% 8.6x", "	0004d2"},
	 346  	{"1234", "% 8.7x", " 00004d2"},
	 347  	{"1234", "% 8.8x", " 000004d2"},
	 348  	{"-1234", "% 8.3x", "		-4d2"},
	 349  	{"-1234", "% 8.4x", "	 -04d2"},
	 350  	{"-1234", "% 8.5x", "	-004d2"},
	 351  	{"-1234", "% 8.6x", " -0004d2"},
	 352  	{"-1234", "% 8.7x", "-00004d2"},
	 353  	{"-1234", "% 8.8x", "-000004d2"},
	 354  
	 355  	{"1234", "%-8.3d", "1234		"},
	 356  	{"1234", "%-8.4d", "1234		"},
	 357  	{"1234", "%-8.5d", "01234	 "},
	 358  	{"1234", "%-8.6d", "001234	"},
	 359  	{"1234", "%-8.7d", "0001234 "},
	 360  	{"1234", "%-8.8d", "00001234"},
	 361  	{"-1234", "%-8.3d", "-1234	 "},
	 362  	{"-1234", "%-8.4d", "-1234	 "},
	 363  	{"-1234", "%-8.5d", "-01234	"},
	 364  	{"-1234", "%-8.6d", "-001234 "},
	 365  	{"-1234", "%-8.7d", "-0001234"},
	 366  	{"-1234", "%-8.8d", "-00001234"},
	 367  
	 368  	{"16777215", "%b", "111111111111111111111111"}, // 2**24 - 1
	 369  
	 370  	{"0", "%.d", ""},
	 371  	{"0", "%.0d", ""},
	 372  	{"0", "%3.d", ""},
	 373  }
	 374  
	 375  func TestFormat(t *testing.T) {
	 376  	for i, test := range formatTests {
	 377  		var x *Int
	 378  		if test.input != "<nil>" {
	 379  			var ok bool
	 380  			x, ok = new(Int).SetString(test.input, 0)
	 381  			if !ok {
	 382  				t.Errorf("#%d failed reading input %s", i, test.input)
	 383  			}
	 384  		}
	 385  		output := fmt.Sprintf(test.format, x)
	 386  		if output != test.output {
	 387  			t.Errorf("#%d got %q; want %q, {%q, %q, %q}", i, output, test.output, test.input, test.format, test.output)
	 388  		}
	 389  	}
	 390  }
	 391  
	 392  var scanTests = []struct {
	 393  	input		 string
	 394  	format		string
	 395  	output		string
	 396  	remaining int
	 397  }{
	 398  	{"1010", "%b", "10", 0},
	 399  	{"0b1010", "%v", "10", 0},
	 400  	{"12", "%o", "10", 0},
	 401  	{"012", "%v", "10", 0},
	 402  	{"10", "%d", "10", 0},
	 403  	{"10", "%v", "10", 0},
	 404  	{"a", "%x", "10", 0},
	 405  	{"0xa", "%v", "10", 0},
	 406  	{"A", "%X", "10", 0},
	 407  	{"-A", "%X", "-10", 0},
	 408  	{"+0b1011001", "%v", "89", 0},
	 409  	{"0xA", "%v", "10", 0},
	 410  	{"0 ", "%v", "0", 1},
	 411  	{"2+3", "%v", "2", 2},
	 412  	{"0XABC 12", "%v", "2748", 3},
	 413  }
	 414  
	 415  func TestScan(t *testing.T) {
	 416  	var buf bytes.Buffer
	 417  	for i, test := range scanTests {
	 418  		x := new(Int)
	 419  		buf.Reset()
	 420  		buf.WriteString(test.input)
	 421  		if _, err := fmt.Fscanf(&buf, test.format, x); err != nil {
	 422  			t.Errorf("#%d error: %s", i, err)
	 423  		}
	 424  		if x.String() != test.output {
	 425  			t.Errorf("#%d got %s; want %s", i, x.String(), test.output)
	 426  		}
	 427  		if buf.Len() != test.remaining {
	 428  			t.Errorf("#%d got %d bytes remaining; want %d", i, buf.Len(), test.remaining)
	 429  		}
	 430  	}
	 431  }
	 432  

View as plain text