failure_external_test.go

// Copyright 2019 Gregory Petrosyan <gregory.petrosyan@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

package rapid_test

import (
	"math"
	"testing"

	. "pgregory.net/rapid"
)

// wrapper to test (*T).Helper()
func fatalf(t *T, format string, args ...any) {
	t.Helper()
	t.Fatalf(format, args...)
}

func TestFailure_ImpossibleData(t *testing.T) {
	t.Skip("expected failure")

	Check(t, func(t *T) {
		_ = Int().Filter(func(i int) bool { return false }).Draw(t, "i")
	})
}

func TestFailure_Trivial(t *testing.T) {
	t.Skip("expected failure")

	Check(t, func(t *T) {
		i := Int().Draw(t, "i")
		if i > 1000000000 {
			fatalf(t, "got a huge integer: %v", i)
		}
	})
}

func TestFailure_SimpleCollection(t *testing.T) {
	t.Skip("expected failure")

	Check(t, func(t *T) {
		s := SliceOf(Int().Filter(func(i int) bool { return i%2 == -1 })).Draw(t, "s")
		if len(s) > 3 {
			fatalf(t, "got a long sequence: %v", s)
		}
	})
}

func TestFailure_CollectionElements(t *testing.T) {
	t.Skip("expected failure")

	Check(t, func(t *T) {
		s := SliceOfN(Int(), 2, -1).Draw(t, "s")

		n := 0
		for _, i := range s {
			if i > 1000000 {
				n++
			}
		}

		if n > 1 {
			fatalf(t, "got %v huge elements", n)
		}
	})
}

func TestFailure_TrivialString(t *testing.T) {
	t.Skip("expected failure")

	Check(t, func(t *T) {
		s := String().Draw(t, "s")
		if len(s) > 7 {
			fatalf(t, "got bad string %v", s)
		}
	})
}

func TestFailure_Make(t *testing.T) {
	t.Skip("expected failure")

	Check(t, func(t *T) {
		n := IntMin(0).Draw(t, "n")
		_ = make([]int, n)
	})
}

func TestFailure_Mean(t *testing.T) {
	t.Skip("expected failure")

	Check(t, func(t *T) {
		s := SliceOf(Float64()).Draw(t, "s")

		mean := 0.0
		for _, f := range s {
			mean += f
		}
		mean /= float64(len(s))

		min, max := math.Inf(0), math.Inf(-1)
		for _, f := range s {
			if f < min {
				min = f
			}
			if f > max {
				max = f
			}
		}

		if mean < min || mean > max {
			t.Fatalf("got mean %v for range [%v, %v]", mean, min, max)
		}
	})
}

func TestFailure_ExampleParseDate(t *testing.T) {
	t.Skip("expected failure")

	Check(t, testParseDate)
}

func TestFailure_ExampleQueue(t *testing.T) {
	t.Skip("expected failure")

	Check(t, testQueue)
}

// LastIndex returns the index of the last instance of x in list, or
// -1 if x is not present. The loop condition has a fault that
// causes some tests to fail. Change it to i >= 0 to see them pass.
func LastIndex(list []int, x int) int {
	for i := len(list) - 1; i > 0; i-- {
		if list[i] == x {
			return i
		}
	}
	return -1
}

// This can be a good example of property-based test; however, it is unclear
// what is the "best" way to generate input. Either it is concise (like in
// the test below), but requires high quality data generation (and even then
// is flaky), or it can be verbose, explicitly covering important input classes --
// however, how do we know them when writing a test?
func TestFailure_LastIndex(t *testing.T) {
	t.Skip("expected failure (flaky)")

	Check(t, func(t *T) {
		s := SliceOf(Int()).Draw(t, "s")
		x := Int().Draw(t, "x")
		ix := LastIndex(s, x)

		// index is either -1 or in bounds
		if ix != -1 && (ix < 0 || ix >= len(s)) {
			t.Fatalf("%v is not a valid last index", ix)
		}

		// index is either -1 or a valid index of x
		if ix != -1 && s[ix] != x {
			t.Fatalf("%v is not a valid index of %v", ix, x)
		}

		// no valid index of x is bigger than ix
		for i := ix + 1; i < len(s); i++ {
			if s[i] == x {
				t.Fatalf("%v is not the last index of %v (%v is bigger)", ix, x, i)
			}
		}
	})
}