Example #1
4
func TestFalse(t *testing.T) {
	t.Run("should not end testing if the condition is falsey", func(t *testing.T) {
		tester := new(mockTester)

		assert.False(tester, false, "")

		if tester.errorfCalls != 0 {
			t.Errorf(
				"Expected Errorf not to have been called, it had been called %d times.",
				tester.errorfCalls,
			)
		}
	})

	t.Run("should end testing if the condition is truthy", func(t *testing.T) {
		tester := new(mockTester)

		assert.False(tester, true, "")

		if tester.errorfCalls != 1 {
			t.Errorf(
				"Expected Errorf to have been called once, it had been called %d times.",
				tester.errorfCalls,
			)
		}
	})
}
Example #2
1
func TestExamples(t *testing.T) {
	flag.Parse()
	if !*examplesTest && os.Getenv("CI") == "" {
		t.Skip("skipping examples tests, pass --examples to execute it")
		return
	}

	defer deleteTempFolders()

	examples, err := filepath.Glob(examplesFolder())
	if err != nil {
		t.Errorf("error finding tests: %s", err)
	}

	for _, example := range examples {
		_, name := filepath.Split(filepath.Dir(example))

		if ignored[name] {
			continue
		}

		t.Run(name, func(t *testing.T) {
			testExample(t, name, example)
		})
	}
}
Example #3
1
func TestParseHexColor(t *testing.T) {
	for _, tc := range []struct {
		hex      string
		expected color.Color
	}{
		{
			hex:      "F84",
			expected: color.NRGBA{R: 0xff, G: 0x88, B: 0x44, A: 0xff},
		},
		{
			hex:      "F842",
			expected: color.NRGBA{R: 0x88, G: 0x44, B: 0x22, A: 0xff},
		},
		{
			hex:      "FC8642",
			expected: color.NRGBA{R: 0xfc, G: 0x86, B: 0x42, A: 0xff},
		},
		{
			hex:      "FC864210",
			expected: color.NRGBA{R: 0x86, G: 0x42, B: 0x10, A: 0xfc},
		},
	} {
		t.Run(tc.hex, func(t *testing.T) {
			res, err := parseHexColor(tc.hex)
			if err != nil {
				t.Fatal(err)
			}
			if res != tc.expected {
				t.Fatalf("unexpected result for \"%s\": got %#v, want %#v", tc.hex, res, tc.expected)
			}
		})
	}
}
Example #4
1
func TestHandlerAdd(t *testing.T) {
	tests := []struct {
		description string
		params      *articles.HandlerAddParams
		code        int
	}{
		{"No Title", &articles.HandlerAddParams{}, http.StatusBadRequest},
		{"Title filled with spaces", &articles.HandlerAddParams{Title: "       "}, http.StatusBadRequest},
		{"As few params as possible", &articles.HandlerAddParams{Title: "My Super Article"}, http.StatusCreated},
		{"Duplicate title", &articles.HandlerAddParams{Title: "My Super Article"}, http.StatusCreated},
	}

	for _, tc := range tests {
		t.Run(tc.description, func(t *testing.T) {
			rec := callHandlerAdd(t, tc.params)
			assert.Equal(t, tc.code, rec.Code)

			if rec.Code == http.StatusCreated {
				var a articles.Article
				if err := json.NewDecoder(rec.Body).Decode(&a); err != nil {
					t.Fatal(err)
				}

				assert.NotEmpty(t, a.ID)
				assert.NotEmpty(t, a.Slug)
				assert.Equal(t, tc.params.Title, a.Title)
				if err := a.FullyDelete(); err != nil {
					t.Fatal(err)
				}
			}
		})
	}
}
Example #5
0
func TestScanln(t *testing.T) {
	for _, r := range readers {
		t.Run(r.name, func(t *testing.T) {
			testScan(t, r.f, Fscanln)
		})
	}
}
Example #6
0
func TestRefreshAsync(t *testing.T) {
	t.Parallel()

	for _, scenario := range refreshAsyncScenarios {
		t.Run(scenario.description, func(t *testing.T) {
			discovery := dnsdisco.NewDiscovery(scenario.service, scenario.proto, scenario.name)
			discovery.SetRetriever(scenario.retriever)
			discovery.SetHealthChecker(scenario.healthChecker)

			finish := discovery.RefreshAsync(scenario.refreshInterval)
			defer close(finish)

			time.Sleep(scenario.refreshInterval + (50 * time.Millisecond))
			target, port := discovery.Choose()

			if target != scenario.expectedTarget {
				t.Errorf("mismatch targets. Expecting: “%s”; found “%s”", scenario.expectedTarget, target)
			}

			if port != scenario.expectedPort {
				t.Errorf("mismatch ports. Expecting: “%d”; found “%d”", scenario.expectedPort, port)
			}

			if errs := discovery.Errors(); !reflect.DeepEqual(errs, scenario.expectedErrors) {
				t.Errorf("mismatch errors. Expecting: “%#v”; found “%#v”", scenario.expectedErrors, errs)
			}
		})
	}
}
Example #7
0
func TestReplace(t *testing.T) {
	tests := []struct {
		where  string
		start  int
		end    int
		what   string
		result string
	}{
		{"0123456789", 3, 5, "abcdef", "012abcdef56789"},
		{"0123456789", 3, 5, "ab", "012ab56789"},
		{"0123456789", 3, 3, "abcd", "012abcd3456789"},
		{"0123456789", 0, 2, "abcd", "abcd23456789"},
		{"0123456789", 0, 0, "ab", "ab0123456789"},
		{"0123456789", 10, 10, "ab", "0123456789ab"},
		{"0123456789", 8, 10, "ab", "01234567ab"},
		{"0123456789", 5, 5, "", "0123456789"},
		{"0123456789", 3, 8, "", "01289"},
		{"0123456789", 3, 8, "ab", "012ab89"},
		{"0123456789", 0, 5, "a", "a56789"},
		{"0123456789", 5, 10, "ab", "01234ab"},
	}
	for _, test := range tests {
		t.Run(fmt.Sprintf("%+v", test), func(t *testing.T) {
			result := replace([]byte(test.where), test.start, test.end, []byte(test.what))
			if test.result != string(result) {
				t.Errorf("want '%v', got '%v'", test.result, string(result))
			}
		})
	}
}
Example #8
0
// Test if two runs produce identical results
// even when writing different sizes to the Writer.
func TestDeterministic(t *testing.T) {
	t.Parallel()
	for i := 0; i <= 9; i++ {
		t.Run(fmt.Sprint("L", i), func(t *testing.T) { testDeterministic(i, t) })
	}
	t.Run("LM2", func(t *testing.T) { testDeterministic(-2, t) })
}
Example #9
0
func TestDiff_DeepCopy(t *testing.T) {
	cases := map[string]*Diff{
		"empty": &Diff{},

		"basic diff": &Diff{
			Modules: []*ModuleDiff{
				&ModuleDiff{
					Path: []string{"root"},
					Resources: map[string]*InstanceDiff{
						"aws_instance.foo": &InstanceDiff{
							Attributes: map[string]*ResourceAttrDiff{
								"num": &ResourceAttrDiff{
									Old: "0",
									New: "2",
								},
							},
						},
					},
				},
			},
		},
	}

	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			dup := tc.DeepCopy()
			if !reflect.DeepEqual(dup, tc) {
				t.Fatalf("\n%#v\n\n%#v", dup, tc)
			}
		})
	}
}
Example #10
0
func TestCredentialDescribe(t *testing.T) {
	cases := map[string]struct {
		args  []string
		reply stack.Descriptions
		want  []*stack.Description
	}{
		"all credentials": {
			nil,
			stack.Descriptions{
				"provider 1": {Credential: []stack.Value{{Name: "key", Type: "string"}}},
				"provider 2": {Credential: []stack.Value{{Name: "token", Type: "string"}}},
			},
			[]*stack.Description{
				{Provider: "provider 1", Credential: []stack.Value{{Name: "key", Type: "string"}}},
				{Provider: "provider 2", Credential: []stack.Value{{Name: "token", Type: "string"}}},
			},
		},
		"filtered credential": {
			[]string{"--provider", "foobar"},
			stack.Descriptions{
				"provider 1": {Credential: []stack.Value{{Name: "key", Type: "string"}}},
				"provider 2": {Credential: []stack.Value{{Name: "token", Type: "string"}}},
				"foobar":     {Credential: []stack.Value{{Name: "foo", Type: "enum"}}},
			},
			[]*stack.Description{
				{Provider: "foobar", Credential: []stack.Value{{Name: "foo", Type: "enum"}}},
			},
		},
	}

	for name, cas := range cases {
		t.Run(name, func(t *testing.T) {
			var buf bytes.Buffer

			cmd := &MainCmd{
				Stdout: &buf,
				Stderr: os.Stderr,
			}

			cmd.FT.Add("credential.describe", stack.CredentialDescribeResponse{Description: cas.reply})

			args := []string{"credential", "describe", "--json"}

			err := cmd.Run(append(args, cas.args...)...)
			if err != nil {
				t.Fatalf("Run()=%s", err)
			}

			var got []*stack.Description

			if err := json.Unmarshal(buf.Bytes(), &got); err != nil {
				t.Fatalf("Unmarshal()=%s", err)
			}

			if !reflect.DeepEqual(got, cas.want) {
				t.Fatalf("got %#v, want %#v", got, cas.want)
			}
		})
	}
}
Example #11
0
func TestStateDeepCopy(t *testing.T) {
	cases := []struct {
		One, Two *State
		F        func(*State) interface{}
	}{
		// Version
		{
			&State{Version: 5},
			&State{Version: 5},
			func(s *State) interface{} { return s.Version },
		},

		// TFVersion
		{
			&State{TFVersion: "5"},
			&State{TFVersion: "5"},
			func(s *State) interface{} { return s.TFVersion },
		},
	}

	for i, tc := range cases {
		t.Run(fmt.Sprintf("copy-%d", i), func(t *testing.T) {
			actual := tc.F(tc.One.DeepCopy())
			expected := tc.F(tc.Two)
			if !reflect.DeepEqual(actual, expected) {
				t.Fatalf("Bad: %d\n\n%s\n\n%s", i, actual, expected)
			}
		})
	}
}
Example #12
0
func testOrm(t *testing.T, o *Orm, name string) {
	tests := []func(*testing.T, *Orm){
		testCodecs,
		testAutoIncrement,
		testTime,
		testSaveDelete,
		testLoadSaveMethods,
		testLoadSaveMethodsErrors,
		testData,
		testInnerPointer,
		testTransactions,
		testFuncTransactions,
		testCompositePrimaryKey,
		testReferences,
		testQueryAll,
		testDefaults,
		testMigrations,
		testSaveUnchanged,
		testQueryTransform,
	}
	for _, v := range tests {
		t.Run(testName(name, v), func(t *testing.T) {
			clearRegistry(o)
			v(t, o)
		})
	}
}
Example #13
0
func TestGenerator(t *testing.T) {
	for _, s := range []string{"gen_anyof_good_bad"} {
		t.Run(s, func(t *testing.T) {
			testHelper(t, "data/"+s)
		})
	}
}
Example #14
0
func TestEqual(t *testing.T) {
	t.Run("should not end testing if the expected equals the actual", func(t *testing.T) {
		tester := new(mockTester)

		assert.Equal(tester, 42, 42)

		if tester.errorfCalls != 0 {
			t.Errorf(
				"Expected Errorf not to have been called, it had been called %d times.",
				tester.errorfCalls,
			)
		}
	})

	t.Run("should end testing if the expected does not equal the actual", func(t *testing.T) {
		tester := new(mockTester)

		assert.Equal(tester, 24, 42)

		if tester.errorfCalls != 1 {
			t.Errorf(
				"Expected Errorf to have been called once, it had been called %d times.",
				tester.errorfCalls,
			)
		}
	})
}
Example #15
0
func TestParseSysRCOutput(t *testing.T) {
	table := []struct {
		Input string
		K     string
		V     string
	}{
		{
			Input: "keyrate: fast\n",
			K:     "keyrate",
			V:     "fast",
		},
		{
			Input: "dumpdev: \n",
			K:     "dumpdev",
			V:     "",
		},
	}

	for _, item := range table {
		t.Run(item.Input, func(t *testing.T) {
			k, v, err := parseSysRCOutput(item.Input)
			if err != nil {
				t.Error(err)
			}
			if k != item.K || v != item.V {
				t.Errorf("expected: k=%q, v=%q, got: k=%q, v=%q", item.K, item.V, k, v)
			}
		})
	}
}
Example #16
0
func TestMedia(t *testing.T) {
	cases := []struct {
		input    []int64
		expected []int64
	}{
		{
			[]int64{1, 2, 3, 4, 5, 6},
			[]int64{1, 1, 2, 2, 3, 3},
		},
		{
			[]int64{10, 30, 20, 31, 32, 33, 40, 1, 2},
			[]int64{10, 10, 20, 20, 30, 30, 31, 30, 30},
		},
	}

	for i, tc := range cases {
		t.Run(strconv.Itoa(i), func(t *testing.T) {
			m := &Median{}
			for i, n := range tc.input {
				m.Add(n)
				t.Logf("Added %d Median: %d Struct: %v", n, m.Value(), m)
				if m.Value() != tc.expected[i] {
					t.Errorf("got median %d wanted %d", m.Value(), tc.expected[i])
				}
			}
		})
	}
}
Example #17
0
// TestContentTypes tests the content-type regexp that is used as
// an example in fabio.properties
func TestContentTypes(t *testing.T) {
	tests := []string{
		"text/foo",
		"text/foo; charset=UTF-8",
		"text/plain",
		"text/plain; charset=UTF-8",
		"application/json",
		"application/json; charset=UTF-8",
		"application/javascript",
		"application/javascript; charset=UTF-8",
		"application/font-woff",
		"application/font-woff; charset=UTF-8",
		"application/xml",
		"application/xml; charset=UTF-8",
		"vendor/vendor.foo+json",
		"vendor/vendor.foo+json; charset=UTF-8",
		"vendor/vendor.foo+xml",
		"vendor/vendor.foo+xml; charset=UTF-8",
	}

	for _, tt := range tests {
		tt := tt // capture loop var
		t.Run(tt, func(t *testing.T) {
			if !contentTypes.MatchString(tt) {
				t.Fatalf("%q does not match content types regexp", tt)
			}
		})
	}
}
Example #18
0
// ListTest tests the List handler
func TestHandlerList(t *testing.T) {
	for i := 0; i < 10; i++ {
		a := articles.NewTestArticle(t, nil)
		testhelpers.SaveModel(t, a)
	}
	defer testhelpers.PurgeModels(t)

	tests := []struct {
		description string
		countWanted int
		code        int
	}{
		{"No params", 10, http.StatusOK},
	}

	for _, tc := range tests {
		t.Run(tc.description, func(t *testing.T) {
			rec := callHandlerList(t)
			assert.Equal(t, tc.code, rec.Code)

			if rec.Code == http.StatusOK {
				var body []*articles.Article
				if err := json.NewDecoder(rec.Body).Decode(&body); err != nil {
					t.Fatal(err)
				}

				assert.Equal(t, tc.countWanted, len(body))
			}
		})
	}
}
Example #19
0
func TestDiscover(t *testing.T) {
	t.Parallel()

	for _, scenario := range discoverScenarios {
		t.Run(scenario.description, func(t *testing.T) {
			target, port, err := dnsdisco.Discover(scenario.service, scenario.proto, scenario.name)

			if target != scenario.expectedTarget {
				t.Errorf("mismatch targets. Expecting: “%s”; found “%s”", scenario.expectedTarget, target)
			}

			if port != scenario.expectedPort {
				t.Errorf("mismatch ports. Expecting: “%d”; found “%d”", scenario.expectedPort, port)
			}

			// As the resolver change between machines, we can't guess the DNSError name's attribute. So we
			// need to inject the value on the expected error
			dnsError, ok1 := err.(*net.DNSError)
			expectedDNSError, ok2 := scenario.expectedError.(*net.DNSError)

			if ok1 && ok2 {
				expectedDNSError.Server = dnsError.Server
			}

			if !reflect.DeepEqual(err, scenario.expectedError) {
				t.Errorf("mismatch errors. Expecting: “%v”; found “%v”", scenario.expectedError, err)
			}
		})
	}
}
func TestTableDriven(t *testing.T) {
	elts := []setElement{
		setElement{val: strconv.Itoa(rand.Int())},
		setElement{val: strconv.Itoa(rand.Int())},
		setElement{val: strconv.Itoa(rand.Int())},
		setElement{val: strconv.Itoa(rand.Int())},
		setElement{val: strconv.Itoa(rand.Int())},
		setElement{val: strconv.Itoa(rand.Int())},
	}
	st := newSet()
	for i, elt := range elts {
		t.Run(fmt.Sprintf("element%d", i), func(t *testing.T) {
			if st.exists(elt) {
				t.Errorf("element %d reported as existing", i)
				return
			}
			if !st.add(elt) {
				t.Errorf("element %d reported as existing", i)
			}
			if !st.exists(elt) {
				t.Errorf("element %d reported as missing", i)
				return
			}
			if !st.remove(elt) {
				t.Errorf("element %d reported as not removed", i)
				return
			}
		})
	}
}
Example #21
0
func TestMetricSetFactory(t *testing.T) {
	t.Run("without HostParser", func(t *testing.T) {
		registry := NewRegister()
		err := registry.AddMetricSet(moduleName, metricSetName, fakeMetricSetFactory)
		if err != nil {
			t.Fatal(err)
		}

		ms, hp, err := registry.metricSetFactory(moduleName, metricSetName)
		if err != nil {
			t.Fatal(err)
		}
		assert.NotNil(t, ms)
		assert.Nil(t, hp)
	})

	t.Run("with HostParser", func(t *testing.T) {
		registry := NewRegister()
		hostParser := func(Module, string) (HostData, error) { return HostData{}, nil }
		err := registry.AddMetricSet(moduleName, metricSetName, fakeMetricSetFactory, hostParser)
		if err != nil {
			t.Fatal(err)
		}

		ms, hp, err := registry.metricSetFactory(moduleName, metricSetName)
		if err != nil {
			t.Fatal(err)
		}
		assert.NotNil(t, ms)
		assert.NotNil(t, hp) // Can't compare functions in Go so just check for non-nil.
	})
}
Example #22
0
// TestTags verifies that the -tags argument controls which files to check.
func TestTags(t *testing.T) {
	t.Parallel()
	Build(t)
	for _, tag := range []string{"testtag", "x testtag y", "x,testtag,y"} {
		tag := tag
		t.Run(tag, func(t *testing.T) {
			t.Parallel()
			t.Logf("-tags=%s", tag)
			args := []string{
				"-tags=" + tag,
				"-v", // We're going to look at the files it examines.
				"testdata/tagtest",
			}
			cmd := exec.Command("./"+binary, args...)
			output, err := cmd.CombinedOutput()
			if err != nil {
				t.Fatal(err)
			}
			// file1 has testtag and file2 has !testtag.
			if !bytes.Contains(output, []byte(filepath.Join("tagtest", "file1.go"))) {
				t.Error("file1 was excluded, should be included")
			}
			if bytes.Contains(output, []byte(filepath.Join("tagtest", "file2.go"))) {
				t.Error("file2 was included, should be excluded")
			}
		})
	}
}
Example #23
0
func TestScanfMulti(t *testing.T) {
	for _, r := range readers {
		t.Run(r.name, func(t *testing.T) {
			testScanfMulti(t, r.f)
		})
	}
}
Example #24
0
// TestVet tests self-contained files in testdata/*.go.
//
// If a file contains assembly or has inter-dependencies, it should be
// in its own test, like TestVetAsm, TestDivergentPackagesExamples,
// etc below.
func TestVet(t *testing.T) {
	Build(t)
	t.Parallel()

	// errchk ./testvet
	gos, err := filepath.Glob(filepath.Join(dataDir, "*.go"))
	if err != nil {
		t.Fatal(err)
	}
	wide := runtime.GOMAXPROCS(0)
	if wide > len(gos) {
		wide = len(gos)
	}
	batch := make([][]string, wide)
	for i, file := range gos {
		batch[i%wide] = append(batch[i%wide], file)
	}
	for i, files := range batch {
		files := files
		t.Run(fmt.Sprint(i), func(t *testing.T) {
			t.Parallel()
			t.Logf("files: %q", files)
			Vet(t, files)
		})
	}
}
Example #25
0
func TestPosString(t *testing.T) {
	cases := []struct {
		Input  Pos
		String string
	}{
		{
			Pos{Line: 1, Column: 1},
			"1:1",
		},
		{
			Pos{Line: 2, Column: 3},
			"2:3",
		},
		{
			Pos{Line: 3, Column: 2, Filename: "template.hil"},
			"template.hil:3:2",
		},
	}

	for i, tc := range cases {
		t.Run(strconv.Itoa(i), func(t *testing.T) {
			got := tc.Input.String()
			if want, got := tc.String, got; want != got {
				t.Errorf("%#v produced %q; want %q", tc.Input, got, want)
			}
		})
	}
}
Example #26
0
func TestSimplifyAndExpr(t *testing.T) {
	defer leaktest.AfterTest(t)()

	testData := []struct {
		expr     string
		expected string
	}{
		{`a < 1 AND b < 1 AND a < 2 AND b < 2`, `(a < 1) AND (b < 1)`},
		{`(a > 1 AND a < 2) AND (a > 0 AND a < 3)`, `(a > 1) AND (a < 2)`},

		{`a = 1 AND a = 2`, `false`},
		{`a = 1 AND a = NULL`, `false`},
		{`a = 1 AND a != NULL`, `false`},
		{`a = 1 AND b = 1`, `(a = 1) AND (b = 1)`},
	}
	for _, d := range testData {
		t.Run(d.expr+"~"+d.expected, func(t *testing.T) {
			sel := makeSelectNode(t)
			expr1 := parseAndNormalizeExpr(t, d.expr, sel)
			expr2, equiv := simplifyExpr(expr1)
			if s := expr2.String(); d.expected != s {
				t.Errorf("%s: expected %s, but found %s", d.expr, d.expected, s)
			}
			if !equiv {
				t.Errorf("%s: expected equivalent, but found %v", d.expr, equiv)
			}
		})
	}
}
Example #27
0
func TestDockerCLI(t *testing.T) {
	containerConfig := container.Config{
		Image: postgresTestImage,
		Cmd:   []string{"stat", cluster.CockroachBinaryInContainer},
	}
	if err := testDockerOneShot(t, "cli_test", containerConfig); err != nil {
		t.Skipf(`TODO(dt): No binary in one-shot container, see #6086: %s`, err)
	}

	paths, err := filepath.Glob(testGlob)
	if err != nil {
		t.Fatal(err)
	}
	if len(paths) == 0 {
		t.Fatalf("no testfiles found (%v)", testGlob)
	}

	verbose := testing.Verbose() || log.V(1)
	for _, p := range paths {
		testFile := filepath.Base(p)
		testPath := filepath.Join(containerPath, testFile)
		t.Run(testFile, func(t *testing.T) {
			cmd := cmdBase
			if verbose {
				cmd = append(cmd, "-d")
			}
			cmd = append(cmd, "-f", testPath, cluster.CockroachBinaryInContainer)
			containerConfig.Cmd = cmd
			if err := testDockerOneShot(t, "cli_test", containerConfig); err != nil {
				t.Error(err)
			}
		})
	}
}
Example #28
0
func TestBatchPrevNextWithNoop(t *testing.T) {
	defer leaktest.AfterTest(t)()

	leftKey := roachpb.Key("a")
	middleKey := roachpb.RKey("b")
	rightKey := roachpb.Key("c")
	var ba roachpb.BatchRequest
	ba.Add(&roachpb.GetRequest{Span: roachpb.Span{Key: leftKey}})
	ba.Add(&roachpb.NoopRequest{})
	ba.Add(&roachpb.GetRequest{Span: roachpb.Span{Key: rightKey}})

	t.Run("prev", func(t *testing.T) {
		rk, err := prev(ba, middleKey)
		if err != nil {
			t.Fatal(err)
		}
		if !rk.Equal(leftKey) {
			t.Errorf("got %s, expected %s", rk, leftKey)
		}
	})
	t.Run("next", func(t *testing.T) {
		rk, err := next(ba, middleKey)
		if err != nil {
			t.Fatal(err)
		}
		if !rk.Equal(rightKey) {
			t.Errorf("got %s, expected %s", rk, rightKey)
		}
	})
}
Example #29
0
func TestHexStringToInts(t *testing.T) {
	for _, tc := range []struct {
		hex      string
		expected []uint8
	}{
		{
			hex:      "",
			expected: nil,
		},
		{
			hex:      "1",
			expected: []uint8{0x1},
		},
		{
			hex: "0123456789abcdefABCDEF",
			expected: []uint8{
				0x0, 0x1, 0x2, 0x3, 0x4,
				0x5, 0x6, 0x7, 0x8, 0x9,
				0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
				0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
			},
		},
	} {
		t.Run(tc.hex, func(t *testing.T) {
			res, err := hexStringToInts(tc.hex)
			if err != nil {
				t.Fatal(err)
			}
			if !reflect.DeepEqual(res, tc.expected) {
				t.Fatalf("unexpected result for \"%s\": got %#v, want %#v", tc.hex, res, tc.expected)
			}
		})
	}
}
Example #30
0
func TestNotOK(t *testing.T) {
	t.Run("should not end testing if the given error is not nil", func(t *testing.T) {
		tester := new(mockTester)

		assert.NotOK(tester, errors.New("Testing"))

		if tester.errorfCalls != 0 {
			t.Errorf(
				"Expected Errorf not to have been called, it had been called %d times.",
				tester.errorfCalls,
			)
		}
	})

	t.Run("should end testing if the given error is nil", func(t *testing.T) {
		tester := new(mockTester)

		assert.NotOK(tester, nil)

		if tester.errorfCalls != 1 {
			t.Errorf(
				"Expected Errorf to have been called once, it had been called %d times.",
				tester.errorfCalls,
			)
		}
	})
}