Property-based testing

package fizzbuzz

import (
	"strconv"
	"strings"
)

// FizzBuzz return "Fizz" for 3*n number, "Buzz" for 5*n number,
// "FizzBuzz" for 15*n number and number as string otherwise.
func FizzBuzz(n int) string {
	res := strings.Builder{}
	if n%3 == 0 {
		res.WriteString("Fizz")
	}
	if n%5 == 0 {
		res.WriteString("Buzz")
	}
	if res.Len() == 0 {
		res.WriteString(strconv.Itoa(n))
	}

	return res.String()
}

package fizzbuzz

import (
	"strconv"
	"testing"
)

func TestFizzBuzzCases(t *testing.T) {
	cases := []struct {
		input  int
		output string
	}{
		{
			input:  2,
			output: "2",
		},
		{
			input:  12,
			output: "Fizz",
		},
		{
			input:  25,
			output: "Buzz",
		},
		{
			input:  60,
			output: "FizzBuzz",
		},
	}

	for _, c := range cases {
		t.Run(strconv.Itoa(c.input), func(t *testing.T) {
			t.Parallel()

			res := FizzBuzz(c.input)
			if res != c.output {
				t.Errorf("expected %q but got %q", c.output, res)
			}
		})
	}
}

package fizzbuzz

import (
	"math"
	"strconv"
	"strings"
	"testing"

	"github.com/leanovate/gopter"
	"github.com/leanovate/gopter/gen"
	"github.com/leanovate/gopter/prop"
)

func TestFizzBuzzProperties(t *testing.T) {
	properties := gopter.NewProperties(nil)

	properties.Property("Start with Fizz for all multiples of 3", prop.ForAll(
		func(i int) bool {
			result := FizzBuzz(i * 3)
			return strings.HasPrefix(result, "Fizz")
		},
		gen.IntRange(1, math.MaxInt32/3),
	))

	properties.Property("Ends with Buzz for all multiples of 5", prop.ForAll(
		func(i int) bool {
			result := FizzBuzz(i * 5)
			return strings.HasSuffix(result, "Buzz")
		},
		gen.IntRange(1, math.MaxInt32/5),
	))

	properties.Property("Int as string for all non-divisible by 3 or 5", prop.ForAll(
		func(number int) bool {
			result := FizzBuzz(number)
			parsed, err := strconv.ParseInt(result, 10, 64)
			return err == nil && parsed == int64(number)
		},
		gen.IntRange(1, math.MaxInt32).SuchThat(func(v interface{}) bool {
			return v.(int)%3 != 0 && v.(int)%5 != 0
		}),
	))

	properties.TestingRun(t)
}

package coverage

import (
	"github.com/leanovate/gopter"
)

func CoverageGen(mod uint32, count uint32) gopter.Gen {
	return func(params *gopter.GenParameters) *gopter.GenResult {
		coverage := make([][]uint32, count)

		for i := range coverage {
			n := int(uint64(mod/3) + params.NextUint64()%uint64(mod/3))
			set := make(map[uint32]struct{}, n)
			coverage[i] = make([]uint32, 0, n)
			for len(set) < n {
				x := uint32(params.NextUint64() % uint64(mod))
				if _, ok := set[x]; !ok {
					coverage[i] = append(coverage[i], x)
					set[x] = struct{}{}
				}
			}
		}

		return gopter.NewGenResult(coverage, CoverageShrinker)
	}
}

type coverageShrink struct {
	coverage [][]uint32
}

func CoverageShrinker(coverage interface{}) gopter.Shrink {

	shrink := coverageShrink{coverage.([][]uint32)}

	return shrink.Next
}

func (cs *coverageShrink) Next() (interface{}, bool) {
	cs.coverage = cs.coverage[:len(cs.coverage)/2]
	if len(cs.coverage) == 0 {

		return nil, false
	}

	return cs.coverage, true
}

package coverage

import (
	"bytes"
	"encoding/binary"
	"testing"

	"github.com/leanovate/gopter"
	"github.com/leanovate/gopter/prop"
)

func TestCoverageProperties(t *testing.T) {
	properties := gopter.NewProperties(nil)

	properties.Property("Output is a coverage", prop.ForAll(
		func(coverage [][]uint32) bool {
			universe := universeOfCoverage(coverage)
			result := universeOfCoverage(GetMinimalSubcoverage(coverage))

			for item := range universe {
				if _, ok := result[item]; !ok {

					return false
				}
			}

			return true
		},
		CoverageGen(20, 20),
	))

	properties.Property("Length of output less or equal length of input", prop.ForAll(
		func(coverage [][]uint32) bool {
			result := GetMinimalSubcoverage(coverage)

			return len(coverage) >= len(result)
		},
		CoverageGen(200, 200),
	))

	properties.Property("Every output set must be in input", prop.ForAll(
		func(coverage [][]uint32) bool {
			coverageAsBytes := coverageToBytes(coverage)
			result := GetMinimalSubcoverage(coverage)

			for _, set := range result {
				if !isInCoverage(set, coverageAsBytes) {
					t.Log(set)

					return false
				}
			}

			return true
		},
		CoverageGen(200, 200),
	))

	properties.TestingRun(t)
}

func universeOfCoverage(coverage [][]uint32) map[uint32]struct{} {
	universe := map[uint32]struct{}{}
	for _, set := range coverage {
		for _, item := range set {
			universe[item] = struct{}{}
		}
	}

	return universe
}

func coverageToBytes(coverage [][]uint32) [][]byte {
	res := make([][]byte, len(coverage))
	for i := range res {
		res[i] = setToBytes(coverage[i])
	}

	return res
}

func isInCoverage(set []uint32, coverageAsBytes [][]byte) bool {
	setAsBytes := setToBytes(set)

	for _, item := range coverageAsBytes {
		if bytes.Equal(setAsBytes, item) {

			return true
		}
	}

	return false
}

func setToBytes(set []uint32) []byte {
	buf := bytes.Buffer{}
	binary.Write(&buf, binary.LittleEndian, set)

	return buf.Bytes()
}

func CoverageGen(mod uint32, count uint32) gopter.Gen {
	return func(params *gopter.GenParameters) *gopter.GenResult {
		coverage := make([][]uint32, count)

		for i := range coverage {
			n := int(uint64(mod/3) + params.NextUint64()%uint64(mod/3))
			set := make(map[uint32]struct{}, n)
			coverage[i] = make([]uint32, 0, n)
			for len(set) < n {
				x := uint32(params.NextUint64() % uint64(mod))
				if _, ok := set[x]; !ok {
					coverage[i] = append(coverage[i], x)
					set[x] = struct{}{}
				}
			}
		}

		return gopter.NewGenResult(coverage, CoverageShrinker)
	}
}

type coverageShrink struct {
	coverage [][]uint32
}

func CoverageShrinker(coverage interface{}) gopter.Shrink {

	shrink := coverageShrink{coverage.([][]uint32)}

	return shrink.Next
}

func (cs *coverageShrink) Next() (interface{}, bool) {
	cs.coverage = cs.coverage[:len(cs.coverage)/2]
	if len(cs.coverage) == 0 {

		return nil, false
	}

	return cs.coverage, true
}