Golang Context.Specify方法代碼示例

func DirectedGraphArcsFilterSpec(c gospec.Context) {
	gr := NewDirectedMap()
	gr.AddArc(1, 2)
	gr.AddArc(2, 3)
	gr.AddArc(3, 4)
	gr.AddArc(2, 4)
	gr.AddArc(4, 5)
	gr.AddArc(1, 6)
	gr.AddArc(2, 6)

	c.Specify("Single filtered arc", func() {
		ftail := VertexId(2)
		fhead := VertexId(3)
		f := NewDirectedGraphArcFilter(gr, ftail, fhead)

		c.Specify("shouldn't be checked", func() {
			c.Expect(f.CheckArc(ftail, fhead), IsFalse)
		})

		c.Specify("shouldn't appear in accessors", func() {
			c.Expect(CollectVertexes(f.GetAccessors(VertexId(ftail))), Not(Contains), fhead)
		})
		c.Specify("shouldn't appear in predecessors", func() {
			c.Expect(CollectVertexes(f.GetPredecessors(VertexId(fhead))), Not(Contains), ftail)
		})
		c.Specify("shouldn't appear in iterator", func() {
			for conn := range f.ArcsIter() {
				c.Expect(conn.Tail == ftail && conn.Head == fhead, IsFalse)
			}
		})
	})
}

func Alloc3dSpec(c gospec.Context) {
	d100x20x10 := Alloc3d(100, 20, 10)
	c.Specify("Allocates the appropriate memory for 3d arrays.", func() {
		c.Expect(len(d100x20x10), gospec.Equals, 100)
		for _, v := range d100x20x10 {
			c.Expect(len(v), gospec.Equals, 20)
			for _, v := range v {
				c.Expect(len(v), gospec.Equals, 10)
			}
		}
		counter := 0.0
		for i := range d100x20x10 {
			for j := range d100x20x10[i] {
				for k := range d100x20x10[i][j] {
					d100x20x10[i][j][k] = complex(counter, 0)
					counter += 1.0
				}
			}
		}
		counter = 0.0
		for i := range d100x20x10 {
			for j := range d100x20x10[i] {
				for k := range d100x20x10[i][j] {
					c.Expect(real(d100x20x10[i][j][k]), gospec.Equals, counter)
					counter += 1.0
				}
			}
		}
	})
}

func ActionSpec(c gospec.Context) {
	game.RegisterActions()
	c.Specify("Actions are loaded properly.", func() {
		basic := game.MakeAction("Basic Test")
		_, ok := basic.(*actions.BasicAttack)
		c.Expect(ok, Equals, true)
	})

	c.Specify("Actions can be gobbed without loss of type.", func() {
		buf := bytes.NewBuffer(nil)
		enc := gob.NewEncoder(buf)

		var as []game.Action
		as = append(as, game.MakeAction("Move Test"))
		as = append(as, game.MakeAction("Basic Test"))

		err := enc.Encode(as)
		c.Assume(err, Equals, nil)

		dec := gob.NewDecoder(buf)
		var as2 []game.Action
		err = dec.Decode(&as2)
		c.Assume(err, Equals, nil)

		_, ok := as2[0].(*actions.Move)
		c.Expect(ok, Equals, true)

		_, ok = as2[1].(*actions.BasicAttack)
		c.Expect(ok, Equals, true)

	})
}

func LoadSpriteSpec(c gospec.Context) {
	c.Specify("Sample sprite loads correctly", func() {
		s, err := sprite.LoadSprite("test_sprite")
		c.Expect(err, Equals, nil)
		for i := 0; i < 2000; i++ {
			s.Think(50)
		}
		s.Command("defend")
		s.Command("undamaged")
		s.Command("defend")
		s.Command("undamaged")
		for i := 0; i < 3000; i++ {
			s.Think(50)
		}
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_left")
		s.Command("turn_left")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_right")
		s.Command("turn_left")
		s.Command("turn_left")
		// s.Think(5000)
		for i := 0; i < 300; i++ {
			s.Think(50)
		}
		c.Expect(s.Facing(), Equals, 1)
	})
}

func CommandNSpec(c gospec.Context) {
	c.Specify("Sample sprite loads correctly", func() {
		s, err := sprite.LoadSprite("test_sprite")
		c.Expect(err, Equals, nil)
		for i := 0; i < 2000; i++ {
			s.Think(50)
		}
		s.CommandN([]string{
			"turn_right",
			"turn_right",
			"turn_right",
			"turn_right",
			"turn_right",
			"turn_right",
			"turn_left",
			"turn_left",
			"turn_right",
			"turn_right",
			"turn_right",
			"turn_left",
			"turn_left"})
		s.Think(5000)
		c.Expect(s.Facing(), Equals, 1)
		for i := 0; i < 3000; i++ {
			s.Think(50)
		}
	})
}

func FFTR2CSpec(c gospec.Context) {
	signal := make([]float64, 16)
	F_signal := make([]complex128, 9)

	for i := range signal {
		signal[i] = math.Sin(float64(i) / float64(len(signal)) * math.Pi * 2)
	}
	forward := PlanDftR2C1d(signal, F_signal, Estimate)
	forward.Execute()
	c.Specify("Running a R2C transform doesn't destroy the input.", func() {
		for i := range signal {
			c.Expect(signal[i], gospec.Equals, math.Sin(float64(i)/float64(len(signal))*math.Pi*2))
		}
	})

	c.Specify("Forward 1d Real to Complex FFT  works properly.", func() {
		c.Expect(real(F_signal[0]), gospec.IsWithin(1e-9), 0.0)
		c.Expect(imag(F_signal[0]), gospec.IsWithin(1e-9), 0.0)
		c.Expect(real(F_signal[1]), gospec.IsWithin(1e-9), 0.0)
		c.Expect(imag(F_signal[1]), gospec.IsWithin(1e-9), -float64(len(signal))/2)
		for i := 2; i < len(F_signal)-1; i++ {
			c.Expect(real(F_signal[i]), gospec.IsWithin(1e-9), 0.0)
			c.Expect(imag(F_signal[i]), gospec.IsWithin(1e-9), 0.0)
		}
	})
}

func ComplexOperationsSpec(c gospec.Context) {
	c.Specify("Vec2.DistToLine() works.", func() {
		centers := []linear.Vec2{
			linear.Vec2{10, 12},
			linear.Vec2{1, -9},
			linear.Vec2{-100, -42},
			linear.Vec2{0, 1232},
		}
		radiuses := []float64{3, 10.232, 435, 1}
		thetas := []float64{0.001, 0.1, 1, 1.01, 0.034241, 0.789, 90, 179, 180}
		angles := []float64{1.01, 1.0, 1.11111, 930142}
		for _, center := range centers {
			for _, radius := range radiuses {
				for _, angle := range angles {
					for _, theta := range thetas {
						a := linear.Vec2{math.Cos(angle), math.Sin(angle)}
						b := linear.Vec2{math.Cos(angle + theta), math.Sin(angle + theta)}
						seg := linear.Seg2{a.Scale(radius).Add(center), b.Scale(radius).Add(center)}
						dist := center.DistToLine(seg)
						real_dist := radius * math.Cos(theta/2)
						if real_dist < 0 {
							real_dist = -real_dist
						}
						c.Expect(dist, IsWithin(1e-9), real_dist)
					}
				}
			}
		}
	})
}

func PolySpec2(c gospec.Context) {
	p := linear.Poly{
		{-1, 0},
		{-3, 0},
		{0, 10},
		{3, 0},
		{1, 0},
		{2, 1},
		{-2, 1},
	}
	c.Specify("Check that exterior and interior segments of a polygon are correctly identified.", func() {
		visible_exterior := []linear.Seg2{
			linear.MakeSeg2(-1, 0, -3, 0),
			linear.MakeSeg2(2, 1, -2, 1),
			linear.MakeSeg2(3, 0, 1, 0),
		}
		visible_interior := []linear.Seg2{
			linear.MakeSeg2(2, 1, -2, 1),
			linear.MakeSeg2(-3, 0, 0, 10),
			linear.MakeSeg2(0, 10, 3, 0),
			linear.MakeSeg2(-1, 0, -3, 0),
			linear.MakeSeg2(3, 0, 1, 0),
		}
		c.Expect(p.VisibleExterior(linear.Vec2{0, -10}), ContainsExactly, visible_exterior)
		c.Expect(p.VisibleInterior(linear.Vec2{0, 5}), ContainsExactly, visible_interior)
	})
}

func CMWCRandSpec(c gospec.Context) {
	c.Specify("CMWC32 conforms properly to math/rand.Rand interface.", func() {
		c1 := cmwc.MakeCmwc(3278470471, 4)
		c2 := cmwc.MakeCmwc(3278470471, 4)
		c1.Seed(1234)
		c2.Seed(4321)

		// Make sure that we don't generate numbers with the most significant
		// bit set
		for i := 0; i < 1000000; i++ {
			v1 := c1.Int63()
			c.Expect(v1 >= 0, Equals, true)
			if v1 < 0 {
				break
			}
			c2.Int63()
		}

		// Make sure that two generators with the same parameters, but in
		// different states, are in the exact same state when seeded with
		// the same seed.
		c1.Seed(0xabcdef12)
		c2.Seed(0xabcdef12)
		for i := 0; i < 10000; i++ {
			v1 := c1.Int63()
			v2 := c2.Int63()
			c.Expect(v1, Equals, v2)
			if v1 != v2 {
				break
			}
		}
	})
}

func checkOrder(c gospec.Context, a adag, order []int) {
	c.Expect(len(a), Equals, len(order))
	c.Specify("Ordering contains all vertices exactly once", func() {
		all := make(map[int]bool)
		for _, v := range order {
			all[v] = true
		}
		c.Expect(len(all), Equals, len(order))
		for i := 0; i < len(a); i++ {
			c.Expect(all[i], Equals, true)
		}
	})
	c.Specify("Successors of a vertex always occur later in the ordering", func() {
		for i := 0; i < len(order); i++ {
			all := a.AllSuccessors(order[i])
			for j := range order {
				if i == j {
					continue
				}
				succ, ok := all[order[j]]
				if j < i {
					c.Expect(!ok, Equals, true)
				} else {
					c.Expect(!ok || succ, Equals, true)
				}
			}
		}
	})
}

func MultiValueReturnSpec(c gospec.Context) {
	c.Specify("Functions with zero or more than one return values work.", func() {
		context := polish.MakeContext()
		polish.AddIntMathContext(context)
		rev3 := func(a, b, c int) (int, int, int) {
			return c, b, a
		}
		context.AddFunc("rev3", rev3)
		rev5 := func(a, b, c, d, e int) (int, int, int, int, int) {
			return e, d, c, b, a
		}
		context.AddFunc("rev5", rev5)

		res, err := context.Eval("- - - - rev5 rev3 1 2 rev3 4 5 6")
		c.Assume(len(res), Equals, 1)
		c.Assume(err, Equals, nil)
		// - - - - rev5 rev3 1 2 rev3 4 5 6
		// - - - - rev5 rev3 1 2 6 5 4
		// - - - - rev5 6 2 1 5 4
		// - - - - 4 5 1 2 6
		// - - - -1 1 2 6
		// - - -2 2 6
		// - -4 6
		// -10
		c.Expect(int(res[0].Int()), Equals, -10)
	})
}

func CheckDirectedPathSpec(c gospec.Context, checkPathFunction CheckDirectedPath) {
	gr := generateDirectedGraph1()

	c.Specify("Check path to self", func() {
		c.Expect(checkPathFunction(gr, 1, 1, nil, SimpleWeightFunc), IsTrue)
		c.Expect(checkPathFunction(gr, 6, 6, nil, SimpleWeightFunc), IsTrue)
	})

	c.Specify("Check neighbours path", func() {
		c.Expect(checkPathFunction(gr, 1, 2, nil, SimpleWeightFunc), IsTrue)
		c.Expect(checkPathFunction(gr, 2, 4, nil, SimpleWeightFunc), IsTrue)
		c.Expect(checkPathFunction(gr, 1, 6, nil, SimpleWeightFunc), IsTrue)
	})

	c.Specify("Check reversed neighbours", func() {
		c.Expect(checkPathFunction(gr, 6, 1, nil, SimpleWeightFunc), IsFalse)
		c.Expect(checkPathFunction(gr, 4, 3, nil, SimpleWeightFunc), IsFalse)
		c.Expect(checkPathFunction(gr, 5, 4, nil, SimpleWeightFunc), IsFalse)
	})

	c.Specify("Check long path", func() {
		c.Expect(checkPathFunction(gr, 1, 6, nil, SimpleWeightFunc), IsTrue)
		c.Expect(checkPathFunction(gr, 1, 5, nil, SimpleWeightFunc), IsTrue)
	})

	c.Specify("Check weight limit", func() {
		c.Expect(checkPathFunction(gr, 1, 5, func(node VertexId, weight float64) bool {
			return weight < 2.0
		}, SimpleWeightFunc), IsFalse)
	})
}

func MemcachedServerProcessSpecs(c gospec.Context) {
	logger := log4go.NewDefaultLogger(log4go.CRITICAL)

	c.Specify("[MemcachedServerProcess] Starts a new Memcached-Server", func() {
		server, err := StartMemcachedServer(&logger)
		defer server.Close()

		c.Expect(err, gospec.Equals, nil)
		c.Expect(server, gospec.Satisfies, server != nil)
		c.Expect(server.logger, gospec.Equals, &logger)
		c.Expect(server.port, gospec.Satisfies, server.port >= 1024)
		c.Expect(server.cmd, gospec.Satisfies, nil != server.cmd)
		c.Expect(server.connection, gospec.Satisfies, nil == server.connection)
	})

	c.Specify("[MemcachedServerProcess] Creates a connection to a Memcached-Server", func() {
		server, err := StartMemcachedServer(&logger)
		defer server.Close()

		c.Expect(err, gospec.Equals, nil)
		c.Expect(server, gospec.Satisfies, server != nil)

		connection := server.Connection()
		c.Expect(connection, gospec.Satisfies, nil != connection)
		c.Expect(server.connection, gospec.Equals, connection)

		err = connection.Open()
		c.Expect(err, gospec.Equals, nil)
		c.Expect(connection.IsOpen(), gospec.Equals, true)
	})
}

func FFT1dSpec(c gospec.Context) {
	signal := Alloc1d(16)
	for i := range signal {
		signal[i] = complex(float64(i), float64(-i))
	}
	forward := PlanDft1d(signal, signal, Forward, Estimate)
	c.Specify("Creating a plan doesn't overwrite an existing array if fftw.Estimate is used.", func() {
		for i := range signal {
			c.Expect(signal[i], gospec.Equals, complex(float64(i), float64(-i)))
		}
	})

	// A simple real cosine should result in transform with two spikes, one at S[1] and one at S[-1]
	// The spikes should be real and have amplitude equal to len(S)/2 (because fftw doesn't normalize)
	for i := range signal {
		signal[i] = complex(math.Cos(float64(i)/float64(len(signal))*math.Pi*2), 0)
	}
	forward.Execute()
	c.Specify("Forward 1d FFT works properly.", func() {
		c.Expect(real(signal[0]), gospec.IsWithin(1e-9), 0.0)
		c.Expect(imag(signal[0]), gospec.IsWithin(1e-9), 0.0)
		c.Expect(real(signal[1]), gospec.IsWithin(1e-9), float64(len(signal))/2)
		c.Expect(imag(signal[1]), gospec.IsWithin(1e-9), 0.0)
		for i := 2; i < len(signal)-1; i++ {
			c.Expect(real(signal[i]), gospec.IsWithin(1e-9), 0.0)
			c.Expect(imag(signal[i]), gospec.IsWithin(1e-9), 0.0)
		}
		c.Expect(real(signal[len(signal)-1]), gospec.IsWithin(1e-9), float64(len(signal))/2)
		c.Expect(imag(signal[len(signal)-1]), gospec.IsWithin(1e-9), 0.0)
	})
}

func NewArray3Spec(c gospec.Context) {
	d100x20x10 := NewArray3(100, 20, 10)
	c.Specify("Allocates the appropriate memory for 3D arrays.", func() {
		n0, n1, n2 := d100x20x10.Dims()
		c.Expect(n0, gospec.Equals, 100)
		c.Expect(n1, gospec.Equals, 20)
		c.Expect(n2, gospec.Equals, 10)
		var counter float32 = 0.0
		for i := 0; i < n0; i++ {
			for j := 0; j < n1; j++ {
				for k := 0; k < n2; k++ {
					d100x20x10.Set(i, j, k, complex(counter, 0))
					counter += 1.0
				}
			}
		}
		counter = 0.0
		for i := 0; i < n0; i++ {
			for j := 0; j < n1; j++ {
				for k := 0; k < n2; k++ {
					c.Expect(real(d100x20x10.At(i, j, k)), gospec.Equals, counter)
					counter += 1.0
				}
			}
		}
	})
}