Exemple #1
0
func TestGraphFilters(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(DirectedGraphArcsFilterSpec)
	r.AddSpec(UndirectedGraphEdgesFilterSpec)
	r.AddSpec(MixedGraphConnectionsFilterSpec)
	gospec.MainGoTest(r, t)
}
Exemple #2
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(LoadSpriteSpec)
	r.AddSpec(CommandNSpec)
	r.AddSpec(SyncSpec)
	gospec.MainGoTest(r, t)
}
Exemple #3
0
func TestSearch(t *testing.T) {
	r := gospec.NewRunner()

	{
		// paramenerized test creator
		cr := func(checkPathFunction CheckDirectedPath) func(c gospec.Context) {
			return func(c gospec.Context) {
				CheckDirectedPathSpec(c, checkPathFunction)
			}
		}
		r.AddNamedSpec("CheckDirectedPath(Dijkstra)", cr(CheckDirectedPathDijkstra))
	}
	{
		// paramenerized test creator
		cr := func(checkPathFunction CheckMixedPath) func(c gospec.Context) {
			return func(c gospec.Context) {
				CheckMixedPathSpec(c, checkPathFunction)
			}
		}
		r.AddNamedSpec("CheckMixedPath(Dijkstra)", cr(CheckMixedPathDijkstra))
	}

	r.AddSpec(GetAllMixedPathsSpec)
	r.AddSpec(BellmanFordSingleSourceSpec)

	gospec.MainGoTest(r, t)
}
Exemple #4
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(AiSpec)
	r.AddSpec(TermSpec)
	r.AddSpec(ChunkSpec)
	gospec.MainGoTest(r, t)
}
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()

	//	r.AddSpec(BatcherSortSpec)
	r.AddSpec(AcceptanceSpec)

	gospec.MainGoTest(r, t)
}
Exemple #6
0
// List of all specs here
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(CMWCSpec)
	r.AddSpec(SlowCMWCSpec)
	r.AddSpec(CMWCRandSpec)
	r.AddSpec(CMWCGobSpec)
	gospec.MainGoTest(r, t)
}
func TestMemcachedServerProcessSpecs(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping test in benchmark mode.")
		return
	}
	r := gospec.NewRunner()
	r.AddSpec(MemcachedServerProcessSpecs)
	gospec.MainGoTest(r, t)
}
Exemple #8
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(SimpleServerSpec)
	r.AddSpec(BasicTypeRegistrySpec)
	r.AddSpec(UnorderedTypeRegistrySpec)
	r.AddSpec(BlockWriteTypeRegistrySpec)
	r.AddSpec(InterfaceTypeRegistrySpec)
	gospec.MainGoTest(r, t)
}
func TestRedisClientInterfaceSpecs(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping test in benchmark mode.")
		return
	}
	r := gospec.NewRunner()
	r.AddSpec(RedisClientInterfaceSpecs)
	gospec.MainGoTest(r, t)
}
Exemple #10
0
func TestMoneySpecs(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping test in benchmark mode.")
		return
	}
	r := gospec.NewRunner()
	r.AddSpec(MoneySpecs)
	gospec.MainGoTest(r, t)
}
func TestStopWatchTimerLapSpecs(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping test in benchmark mode.")
		return
	}
	r := gospec.NewRunner()
	r.AddSpec(StopWatchTimerLapSpecs)
	gospec.MainGoTest(r, t)
}
Exemple #12
0
func TestAlgorithms(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(ReduceDirectPathsSpec)
	r.AddSpec(TopologicalSortSpec)
	r.AddSpec(SplitGraphToIndependentSubgraphs_mixedSpec)
	r.AddSpec(SplitGraphToIndependentSubgraphs_directedSpec)
	r.AddSpec(SplitGraphToIndependentSubgraphs_undirectedSpec)
	gospec.MainGoTest(r, t)
}
func TestRedisBatchCommandsSpecs(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping test in benchmark mode.")
		return
	}
	r := gospec.NewRunner()
	r.AddSpec(RedisBatchCommandsSpecs)
	gospec.MainGoTest(r, t)
}
func TestPreciseLocationSpecs(t *testing.T) {
	// Setup the suite
	r := gospec.NewRunner()

	// Add new specs here:
	r.AddSpec(PreciseLocationSpecs)

	// Execute the suite
	gospec.MainGoTest(r, t)
}
Exemple #15
0
func TestUtilsSpecs(t *testing.T) {
	// Setup the suite
	r := gospec.NewRunner()

	// Add new specs here:
	r.AddSpec(UtilsSpecs)

	// Execute the suite
	gospec.MainGoTest(r, t)
}
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(NaturalKeySpec)
	r.AddSpec(DerivedKeySpec)
	r.AddSpec(NestedDerivedKeySpec)
	r.AddSpec(EventSpec)
	r.AddSpec(EventListenerSpec)
	r.AddSpec(AxisSpec)
	gospec.MainGoTest(r, t)
}
Exemple #17
0
func TestAllSpecs(t *testing.T) {
	// Setup the suite
	r := gospec.NewRunner()

	// Add new specs here:
	r.AddSpec(GeoHashSpec)

	// Execute the suite
	gospec.MainGoTest(r, t)
}
func TestDecodePositionSpecs(t *testing.T) {
	// Setup the suite
	r := gospec.NewRunner()

	// Add new specs here:
	r.AddSpec(DecodePositionSpecs)

	// Execute the suite
	gospec.MainGoTest(r, t)
}
// List of all specs here
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(ZBoxSpec)
	r.AddSpec(ZBoxReverseSpec)
	r.AddSpec(LongestSuffixAsPrefixSpec)
	r.AddSpec(BoyerMooreSpec)
	r.AddSpec(BoyerMooreReaderSpec)
	r.AddSpec(AhoCorasickSpec)
	r.AddSpec(AhoCorasickReaderSpec)
	gospec.MainGoTest(r, t)
}
Exemple #20
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(GCSpec)
	r.AddSpec(NewArraySpec)
	r.AddSpec(NewArray2Spec)
	r.AddSpec(NewArray3Spec)
	gospec.MainGoTest(r, t)

	// TODO: Investigate a less stupid way of doing tests in serial
	// TODO: Investigate what about fftw makes tests need to be serial
	r = gospec.NewRunner()
	r.AddSpec(FFTSpec)
	gospec.MainGoTest(r, t)
	r = gospec.NewRunner()
	r.AddSpec(FFT2Spec)
	gospec.MainGoTest(r, t)
	r = gospec.NewRunner()
	r.AddSpec(FFT3Spec)
	gospec.MainGoTest(r, t)
}
Exemple #21
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(DijkstraSpec)
	r.AddSpec(ReachableSpec)
	r.AddSpec(ReachableDestinationsSpec)
	r.AddSpec(ChooserSpec)
	r.AddSpec(Chooser2Spec)
	r.AddSpec(MapperSpec)
	r.AddSpec(Mapper2Spec)
	r.AddSpec(TopoSpec)
	gospec.MainGoTest(r, t)
}
Exemple #22
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()

	// List all specs here
	r.AddSpec(ExecutionModelSpec)
	r.AddSpec(ExpectationSyntaxSpec)
	r.AddSpec(FibSpec)
	r.AddSpec(StackSpec)

	// Run GoSpec and report any errors to gotest's `testing.T` instance
	gospec.MainGoTest(r, t)
}
Exemple #23
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(GCSpec)
	r.AddSpec(Alloc1dSpec)
	r.AddSpec(Alloc2dSpec)
	r.AddSpec(Alloc3dSpec)
	gospec.MainGoTest(r, t)

	// TODO: Investigate a less stupid way of doing tests in serial
	// TODO: Investigate what about fftw makes tests need to be serial
	r = gospec.NewRunner()
	r.AddSpec(FFT1dSpec)
	gospec.MainGoTest(r, t)
	r = gospec.NewRunner()
	r.AddSpec(FFT2dSpec)
	gospec.MainGoTest(r, t)
	r = gospec.NewRunner()
	r.AddSpec(FFT3dSpec)
	gospec.MainGoTest(r, t)
	r = gospec.NewRunner()
	r.AddSpec(FFTR2CSpec)
	gospec.MainGoTest(r, t)
	r = gospec.NewRunner()
	r.AddSpec(FFTC2RSpec)
	gospec.MainGoTest(r, t)
}
Exemple #24
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(Float64ContextSpec)
	r.AddSpec(Float64AndBooleanContextSpec)
	r.AddSpec(IntContextSpec)
	r.AddSpec(MultiValueReturnSpec)
	r.AddSpec(ErrorSpec)
	r.AddSpec(NumRemainingValuesSpec)
	r.AddSpec(ParsingSpec)
	r.AddSpec(ParseOrderSpec)
	r.AddSpec(IntOperatorSpec)
	gospec.MainGoTest(r, t)
}
Exemple #25
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(NetworkMockSpec)
	r.AddSpec(NetworkStandardSpec)
	r.AddSpec(NetworkStandardGobbingSpec)
	r.AddSpec(EngineUdpTcpSpec)
	r.AddSpec(BundlerSpec)
	r.AddSpec(UpdaterSpec)
	r.AddSpec(CommunicatorSpec)
	r.AddSpec(AuditorSpec)
	r.AddSpec(BaseSpec)
	r.AddSpec(EngineSpec)
	gospec.MainGoTest(r, t)
}
Exemple #26
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(BasicOperationsSpec)
	r.AddSpec(ComplexOperationsSpec)
	r.AddSpec(BasicPropertiesSpec)
	r.AddSpec(AnglesSpec)
	r.AddSpec(SegmentsSpec)
	r.AddSpec(SegmentsSpec2)
	r.AddSpec(PolySpec1)
	r.AddSpec(PolySpec2)
	r.AddSpec(TriangleSpec)
	r.AddSpec(PolyOverlapSpec)
	gospec.MainGoTest(r, t)
}
Exemple #27
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(NaturalKeySpec)
	r.AddSpec(DerivedKeyBugSpec)
	r.AddSpec(DerivedKeySpec)
	r.AddSpec(DeviceSpec)
	r.AddSpec(DeviceFamilySpec)
	r.AddSpec(NestedDerivedKeySpec)
	r.AddSpec(NestedDerivedKey2Spec)
	r.AddSpec(EventSpec)
	r.AddSpec(GeneralSpec)
	r.AddSpec(AxisSpec)
	r.AddSpec(EventListenerSpec)
	r.AddSpec(FocusSpec)
	gospec.MainGoTest(r, t)
}
Exemple #28
0
func TestMixedGraphSpec(t *testing.T) {
	r := gospec.NewRunner()

	// paramenerized test creator
	cr := func(graphCreator func() MixedGraph) func(c gospec.Context) {
		return func(c gospec.Context) {
			MixedGraphSpec(c, graphCreator)
		}
	}

	r.AddNamedSpec("MixedGraph(MixedMap)", cr(func() MixedGraph {
		return MixedGraph(NewMixedMap())
	}))
	r.AddNamedSpec("MixedGraph(MixedMatrix)", cr(func() MixedGraph {
		return MixedGraph(NewMixedMatrix(10))
	}))

	gospec.MainGoTest(r, t)
}
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(YedSpec)
	gospec.MainGoTest(r, t)
}
Exemple #30
0
func TestAllSpecs(t *testing.T) {
	r := gospec.NewRunner()
	r.AddSpec(DecodersSpec)
	r.AddSpec(MessageEqualsSpec)
	gospec.MainGoTest(r, t)
}