tests

package
v0.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 8, 2024 License: MIT Imports: 8 Imported by: 0

Documentation

Overview

Implmenents all the tests that verify the containers in the [container] package properly implmenent the interfaces defined in the dynamicContainers and staticContainers packages. These tests only operate on the interface values that are defined in the two afformentioned packages, meaning they only test the high level functionality of each collection. For tests that require knowing details internal to each collection refer to the tests in the [containers] package.

The tests in this package are not standard go test tests. The functions in this package are called from templated test functions that were generated using go:generate in the [containers] package. This allows for many container types to be tested against the same set of interface functionality.

Due to this package only testing interface values many tests will rely on multiple functions from the interface working correctly.

There are several conventions that must be observed when writing these tests:

  1. All values placed in the tested containers must be of type int. This facilitates populating values in the containers as it can simply be done with standard for loops.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func DynDequeInterfaceAddressableInterface 

func DynDequeInterfaceAddressableInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynDequeInterfaceCapacityInterface 

func DynDequeInterfaceCapacityInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Capacity interface.

func DynDequeInterfaceClear 

func DynDequeInterfaceClear(
	factory func(capacity int) dynamicContainers.Deque[int],
	t *testing.T,
)

Tests the Clear method functionality of a dynamic Deque.

func DynDequeInterfaceClearInterface 

func DynDequeInterfaceClearInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func DynDequeInterfaceFirstElemDeleteInterface 

func DynDequeInterfaceFirstElemDeleteInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.FirstElemDelete interface.

func DynDequeInterfaceFirstElemReadInterface 

func DynDequeInterfaceFirstElemReadInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.FirstElemRead interface.

func DynDequeInterfaceFirstElemWriteInterface 

func DynDequeInterfaceFirstElemWriteInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.FirstElemWrite interface.

func DynDequeInterfaceForcePushBack 

func DynDequeInterfaceForcePushBack(
	factory func(capacity int) dynamicContainers.Deque[int],
	t *testing.T,
)

Tests the ForcePushBack method functionality of a dynamic Deque.

func DynDequeInterfaceForcePushFront 

func DynDequeInterfaceForcePushFront(
	factory func(capacity int) dynamicContainers.Deque[int],
	t *testing.T,
)

Tests the ForcePopFront method functionality of a dynamic Deque.

func DynDequeInterfaceInterface 

func DynDequeInterfaceInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.Deque interface.

func DynDequeInterfaceLastElemDeleteInterface 

func DynDequeInterfaceLastElemDeleteInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemDelete interface.

func DynDequeInterfaceLastElemReadInterface 

func DynDequeInterfaceLastElemReadInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemRead interface.

func DynDequeInterfaceLastElemWriteInterface 

func DynDequeInterfaceLastElemWriteInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemWrite interface.

func DynDequeInterfaceLengthInterface 

func DynDequeInterfaceLengthInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Length interface.

func DynDequeInterfacePeekBack 

func DynDequeInterfacePeekBack(
	factory func(capacity int) dynamicContainers.Deque[int],
	t *testing.T,
)

Tests the PeekBack method functionality of a dynamic Deque.

func DynDequeInterfacePeekFront 

func DynDequeInterfacePeekFront(
	factory func(capacity int) dynamicContainers.Deque[int],
	t *testing.T,
)

Tests the PeekFront method functionality of a dynamic Deque.

func DynDequeInterfacePeekPntrBack 

func DynDequeInterfacePeekPntrBack(
	factory func(capacity int) dynamicContainers.Deque[int],
	t *testing.T,
)

Tests the PeekPntrBack method functionality of a dynamic Deque.

func DynDequeInterfacePeekPntrFront 

func DynDequeInterfacePeekPntrFront(
	factory func(capacity int) dynamicContainers.Deque[int],
	t *testing.T,
)

Tests the PeekPntrFront method functionality of a dynamic Deque.

func DynDequeInterfacePopBack 

func DynDequeInterfacePopBack(
	factory func(capacity int) dynamicContainers.Deque[int],
	t *testing.T,
)

Tests the PopBack method functionality of a dynamic Deque.

func DynDequeInterfacePopFront 

func DynDequeInterfacePopFront(
	factory func(capacity int) dynamicContainers.Deque[int],
	t *testing.T,
)

Tests the PopFront method functionality of a dynamic Deque.

func DynDequeInterfacePushBack 

func DynDequeInterfacePushBack(
	factory func(capacity int) dynamicContainers.Deque[int],
	t *testing.T,
)

Tests the PushBack method functionality of a dynamic Deque.

func DynDequeInterfacePushFront 

func DynDequeInterfacePushFront(
	factory func(capacity int) dynamicContainers.Deque[int],
	t *testing.T,
)

Tests the PopFront method functionality of a dynamic Deque.

func DynDequeInterfaceStaticCapacityInterface 

func DynDequeInterfaceStaticCapacityInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory does not implement the staticContainers.Deque interface.

func DynDequeInterfaceSyncableInterface 

func DynDequeInterfaceSyncableInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynDirectedGraphClear 

func DynDirectedGraphClear(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the Clear method functionality of a dynamic directed graph.

func DynDirectedGraphDeleteEdge 

func DynDirectedGraphDeleteEdge(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the DeleteEdge method functionality of a dynamic directed graph.

func DynDirectedGraphDeleteEdgePntr 

func DynDirectedGraphDeleteEdgePntr(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the DeleteEdgePntr method functionality of a dynamic directed graph. 

func DynDirectedGraphDeleteLink(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the DeleteLink method functionality of a dynamic directed graph.

func DynDirectedGraphDeleteLinkPntr 

func DynDirectedGraphDeleteLinkPntr(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the DeleteLinkPntr method functionality of a dynamic directed graph. 

func DynDirectedGraphDeleteLinks(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the DeleteLinks method functionality of a dynamic directed graph.

func DynDirectedGraphDeleteLinksPntr 

func DynDirectedGraphDeleteLinksPntr(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the DeleteLinks method functionality of a dynamic directed graph.

func DynDirectedGraphDeleteVertex 

func DynDirectedGraphDeleteVertex(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the DeleteVertex method functionality of a dynamic directed graph.

func DynDirectedGraphDeleteVertexPntr 

func DynDirectedGraphDeleteVertexPntr(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the DeleteVertexPntr method functionality of a dynamic directed graph.

func DynDirectedGraphDifference 

func DynDirectedGraphDifference(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the Difference method functionality of a dynamic directed graph.

func DynDirectedGraphEdgesBetween 

func DynDirectedGraphEdgesBetween(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the EdgesBetween method functionality of a dynamic directed graph.

func DynDirectedGraphEdgesBetweenPntr 

func DynDirectedGraphEdgesBetweenPntr(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the EdgesBetweenPntr method functionality of a dynamic directed graph.

func DynDirectedGraphInterfaceAddressableInterface 

func DynDirectedGraphInterfaceAddressableInterface[V any, E any](
	factory func(capacity int) dynamicContainers.DirectedGraph[V, E],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynDirectedGraphInterfaceClearInterface 

func DynDirectedGraphInterfaceClearInterface[V any, E any](
	factory func(capacity int) dynamicContainers.DirectedGraph[V, E],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func DynDirectedGraphInterfaceContainsEdge 

func DynDirectedGraphInterfaceContainsEdge(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the ContainsEdge method functionality of a dynamic graph

func DynDirectedGraphInterfaceContainsEdgePntr 

func DynDirectedGraphInterfaceContainsEdgePntr(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the ContainsEdgePntr method functionality of a dynamic graph

func DynDirectedGraphInterfaceContainsVertex 

func DynDirectedGraphInterfaceContainsVertex(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the ContainsVertex method functionality of a dynamic graph

func DynDirectedGraphInterfaceContainsVertexPntr 

func DynDirectedGraphInterfaceContainsVertexPntr(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the ContainsVertexPntr method functionality of a dynamic graph

func DynDirectedGraphInterfaceEdgePntrs 

func DynDirectedGraphInterfaceEdgePntrs(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the EdgePntrs method functionality of a dynamic directed graph.

func DynDirectedGraphInterfaceEdges 

func DynDirectedGraphInterfaceEdges(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the Edges method functionality of a dynamic directed graph.

func DynDirectedGraphInterfaceInterface 

func DynDirectedGraphInterfaceInterface[V any, E any](
	factory func(capacity int) dynamicContainers.DirectedGraph[V, E],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.DirectedGraph interface.

func DynDirectedGraphInterfaceStaticCapacityInterface 

func DynDirectedGraphInterfaceStaticCapacityInterface[V any, E any](
	factory func(capacity int) dynamicContainers.DirectedGraph[V, E],
	t *testing.T,
)

Tests that the value supplied by the factory does not implement the staticContainers.Map interface.

func DynDirectedGraphInterfaceSyncableInterface 

func DynDirectedGraphInterfaceSyncableInterface[V any, E any](
	factory func(capacity int) dynamicContainers.DirectedGraph[V, E],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynDirectedGraphInterfaceVerticePntrs 

func DynDirectedGraphInterfaceVerticePntrs(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the VerticePntrs method functionality of a dynamic directed graph.

func DynDirectedGraphInterfaceVertices 

func DynDirectedGraphInterfaceVertices(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the Vertices method functionality of a dynamic directed graph.

func DynDirectedGraphIntersection 

func DynDirectedGraphIntersection(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the Intersection method functionality of a dynamic directed graph.

func DynDirectedGraphIsSubset 

func DynDirectedGraphIsSubset(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the IsSuperset method functionality of a dynamic directed graph.

func DynDirectedGraphIsSuperset 

func DynDirectedGraphIsSuperset(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the IsSuperset method functionality of a dynamic directed graph.

func DynDirectedGraphKeyedEq 

func DynDirectedGraphKeyedEq(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the KeyedEq method functionality of a dynamic directed graph. 

func DynDirectedGraphLink(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the Link method functionality of a dynamic directed graph.

func DynDirectedGraphLinkPntr 

func DynDirectedGraphLinkPntr(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the LinkPntr method functionality of a dynamic directed graph. 

func DynDirectedGraphNumOutLinks(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the NumOutLinks method functionality of a dynamic directed graph.

func DynDirectedGraphNumOutLinksPntr 

func DynDirectedGraphNumOutLinksPntr(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the NumOutLinksPntr method functionality of a dynamic directed graph.

func DynDirectedGraphOutEdgePntrs 

func DynDirectedGraphOutEdgePntrs(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the OutEdgePntrs method functionality of a dynamic directed graph.

func DynDirectedGraphOutEdges 

func DynDirectedGraphOutEdges(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the OutEdges method functionality of a dynamic directed graph.

func DynDirectedGraphOutEdgesAndVerticePntrs 

func DynDirectedGraphOutEdgesAndVerticePntrs(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the OutEdgesAndVerticePntrs method functionality of a dynamic directed graph.

func DynDirectedGraphOutEdgesAndVertices 

func DynDirectedGraphOutEdgesAndVertices(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the OutEdgesAndVertices method functionality of a dynamic directed graph.

func DynDirectedGraphOutVerticePntrs 

func DynDirectedGraphOutVerticePntrs(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the OutVerticePntrs method functionality of a dynamic directed graph.

func DynDirectedGraphOutVertices 

func DynDirectedGraphOutVertices(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the OutVertices method functionality of a dynamic directed graph.

func DynDirectedGraphUnion 

func DynDirectedGraphUnion(
	factory func(capacity int) dynamicContainers.DirectedGraph[int, int],
	t *testing.T,
)

Tests the Union method functionality of a dynamic directed graph.

func DynMapInterfaceAddressableInterface 

func DynMapInterfaceAddressableInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynMapInterfaceClear 

func DynMapInterfaceClear(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the Clear method functionality of a dynamic map.

func DynMapInterfaceClearInterface 

func DynMapInterfaceClearInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func DynMapInterfaceContains 

func DynMapInterfaceContains(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the Contains method functionality of a dynamic map.

func DynMapInterfaceContainsPntr 

func DynMapInterfaceContainsPntr(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the ContainsPntr method functionality of a dynamic map.

func DynMapInterfaceDelete 

func DynMapInterfaceDelete(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the Delete method functionality of a dynamic map.

func DynMapInterfaceDeleteKeyedOpsInterface 

func DynMapInterfaceDeleteKeyedOpsInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedDeleteOps interface.

func DynMapInterfaceDeleteOpsInterface 

func DynMapInterfaceDeleteOpsInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.DeleteOps interface.

func DynMapInterfaceGet 

func DynMapInterfaceGet(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the Get method functionality of a dynamic map.

func DynMapInterfaceGetPntr 

func DynMapInterfaceGetPntr(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the GetPntr method functionality of a dynamic map.

func DynMapInterfaceInterface 

func DynMapInterfaceInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.Map interface.

func DynMapInterfaceKeyOf 

func DynMapInterfaceKeyOf(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the KeyOf method functionality of a dynamic map.

func DynMapInterfaceKeyOfPntr 

func DynMapInterfaceKeyOfPntr(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the KeyOfPntr method functionality of a dynamic map.

func DynMapInterfaceKeys 

func DynMapInterfaceKeys(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the Keys method functionality of a dynamic map.

func DynMapInterfaceLengthInterface 

func DynMapInterfaceLengthInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Length interface.

func DynMapInterfacePop 

func DynMapInterfacePop(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the Pop method functionality of a dynamic map.

func DynMapInterfacePopPntr 

func DynMapInterfacePopPntr(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the PopPntr method functionality of a dynamic map.

func DynMapInterfaceReadKeyedOpsInterface 

func DynMapInterfaceReadKeyedOpsInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedReadOps interface.

func DynMapInterfaceReadOpsInterface 

func DynMapInterfaceReadOpsInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.ReadOps interface.

func DynMapInterfaceSet 

func DynMapInterfaceSet(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the Set method functionality of a dynamic map.

func DynMapInterfaceStaticCapacityInterface 

func DynMapInterfaceStaticCapacityInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory does not implement the staticContainers.Map interface.

func DynMapInterfaceSyncableInterface 

func DynMapInterfaceSyncableInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynMapInterfaceValPntrs 

func DynMapInterfaceValPntrs(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the Vals method functionality of a dynamic map.

func DynMapInterfaceVals 

func DynMapInterfaceVals(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the Vals method functionality of a dynamic map.

func DynMapInterfaceWriteKeyedOpsInterface 

func DynMapInterfaceWriteKeyedOpsInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedWriteOps interface.

func DynQueueInterfaceAddressableInterface 

func DynQueueInterfaceAddressableInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynQueueInterfaceCapacityInterface 

func DynQueueInterfaceCapacityInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Capacity interface.

func DynQueueInterfaceClear 

func DynQueueInterfaceClear(
	factory func(capacity int) dynamicContainers.Queue[int],
	t *testing.T,
)

Tests the Clear method functionality of a dynamic Queue.

func DynQueueInterfaceClearInterface 

func DynQueueInterfaceClearInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func DynQueueInterfaceFirstElemDeleteInterface 

func DynQueueInterfaceFirstElemDeleteInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.FirstElemDelete interface.

func DynQueueInterfaceFirstElemReadInterface 

func DynQueueInterfaceFirstElemReadInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.FirstElemRead interface.

func DynQueueInterfaceForcePushBack 

func DynQueueInterfaceForcePushBack(
	factory func(capacity int) dynamicContainers.Queue[int],
	t *testing.T,
)

Tests the ForcePushBack method functionality of a dynamic Queue.

func DynQueueInterfaceInterface 

func DynQueueInterfaceInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.Queue interface.

func DynQueueInterfaceLastElemWriteInterface 

func DynQueueInterfaceLastElemWriteInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemWrite interface.

func DynQueueInterfaceLengthInterface 

func DynQueueInterfaceLengthInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Length interface.

func DynQueueInterfacePeekFront 

func DynQueueInterfacePeekFront(
	factory func(capacity int) dynamicContainers.Queue[int],
	t *testing.T,
)

Tests the PeekFront method functionality of a dynamic Queue.

func DynQueueInterfacePeekPntrFront 

func DynQueueInterfacePeekPntrFront(
	factory func(capacity int) dynamicContainers.Queue[int],
	t *testing.T,
)

Tests the PeekPntrFront method functionality of a dynamic Queue.

func DynQueueInterfacePopFront 

func DynQueueInterfacePopFront(
	factory func(capacity int) dynamicContainers.Queue[int],
	t *testing.T,
)

Tests the PopFront method functionality of a dynamic Queue.

func DynQueueInterfacePushBack 

func DynQueueInterfacePushBack(
	factory func(capacity int) dynamicContainers.Queue[int],
	t *testing.T,
)

Tests the PushBack method functionality of a dynamic Queue.

func DynQueueInterfaceStaticCapacityInterface 

func DynQueueInterfaceStaticCapacityInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory does not implement the staticContainers.Queue interface.

func DynQueueInterfaceSyncableInterface 

func DynQueueInterfaceSyncableInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynSetInterfaceAddressableInterface 

func DynSetInterfaceAddressableInterface[V any](
	factory func(capacity int) dynamicContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynSetInterfaceAppendUnique 

func DynSetInterfaceAppendUnique(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the AppendUnique method functionality of a dynamic set.

func DynSetInterfaceClear 

func DynSetInterfaceClear(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the Clear method functionality of a dynamic set.

func DynSetInterfaceClearInterface 

func DynSetInterfaceClearInterface[V any](
	factory func(capacity int) dynamicContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func DynSetInterfaceContains 

func DynSetInterfaceContains(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the Contains method functionality of a dynamic set.

func DynSetInterfaceContainsPntr 

func DynSetInterfaceContainsPntr(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the ContainsPntr method functionality of a dynamic set.

func DynSetInterfaceDeleteOpsInterface 

func DynSetInterfaceDeleteOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.DeleteOps interface.

func DynSetInterfaceDifference 

func DynSetInterfaceDifference(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the Difference method functionality of a dynamic set.

func DynSetInterfaceGetUnique 

func DynSetInterfaceGetUnique(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the GetUnique method functionality of a dynamic set.

func DynSetInterfaceInterface 

func DynSetInterfaceInterface[V any](
	factory func(capacity int) dynamicContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.Vector interface.

func DynSetInterfaceIntersection 

func DynSetInterfaceIntersection(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the Intersection method functionality of a dynamic set.

func DynSetInterfaceIsSubset 

func DynSetInterfaceIsSubset(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

func DynSetInterfaceIsSuperset 

func DynSetInterfaceIsSuperset(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

func DynSetInterfaceLengthInterface 

func DynSetInterfaceLengthInterface[V any](
	factory func(capacity int) dynamicContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Length interface.

func DynSetInterfacePop 

func DynSetInterfacePop(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the Pop method functionality of a dynamic set.

func DynSetInterfacePopPntr 

func DynSetInterfacePopPntr(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the PopPntr method functionality of a dynamic set.

func DynSetInterfaceReadOpsInterface 

func DynSetInterfaceReadOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.ReadOps interface.

func DynSetInterfaceStaticCapacityInterface 

func DynSetInterfaceStaticCapacityInterface[V any](
	factory func(capacity int) dynamicContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory does not implement the containerTypes.StaticCapacity interface.

func DynSetInterfaceSyncableInterface 

func DynSetInterfaceSyncableInterface[V any](
	factory func(capacity int) dynamicContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynSetInterfaceUnion 

func DynSetInterfaceUnion(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the Union method functionality of a dynamic set.

func DynSetInterfaceUnorderedEq 

func DynSetInterfaceUnorderedEq(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the UnorderedEq method functionality of a dynamic set.

func DynSetInterfaceUpdateUnique 

func DynSetInterfaceUpdateUnique(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the UpdateUnique method functionality of a dynamic set.

func DynSetInterfaceValPntrs 

func DynSetInterfaceValPntrs(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the ValPntrs method functionality of a dynamic set.

func DynSetInterfaceVals 

func DynSetInterfaceVals(
	factory func(capacity int) dynamicContainers.Set[int],
	t *testing.T,
)

Tests the Vals method functionality of a dynamic set.

func DynSetInterfaceWriteUniqueOpsInterface 

func DynSetInterfaceWriteUniqueOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.WriteUniqueOps interface.

func DynStackInterfaceAddressableInterface 

func DynStackInterfaceAddressableInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynStackInterfaceCapacityInterface 

func DynStackInterfaceCapacityInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Capacity interface.

func DynStackInterfaceClear 

func DynStackInterfaceClear(
	factory func(capacity int) dynamicContainers.Stack[int],
	t *testing.T,
)

Tests the Clear method functionality of a dynamic Stack.

func DynStackInterfaceClearInterface 

func DynStackInterfaceClearInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func DynStackInterfaceForcePushBack 

func DynStackInterfaceForcePushBack(
	factory func(capacity int) dynamicContainers.Stack[int],
	t *testing.T,
)

Tests the ForcePushBack method functionality of a dynamic Stack.

func DynStackInterfaceInterface 

func DynStackInterfaceInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.Stack interface.

func DynStackInterfaceLastElemDeleteInterface 

func DynStackInterfaceLastElemDeleteInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemDelete interface.

func DynStackInterfaceLastElemReadInterface 

func DynStackInterfaceLastElemReadInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemRead interface.

func DynStackInterfaceLastElemWriteInterface 

func DynStackInterfaceLastElemWriteInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemWrite interface.

func DynStackInterfaceLengthInterface 

func DynStackInterfaceLengthInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Length interface.

func DynStackInterfacePeekBack 

func DynStackInterfacePeekBack(
	factory func(capacity int) dynamicContainers.Stack[int],
	t *testing.T,
)

Tests the PeekBack method functionality of a dynamic Stack.

func DynStackInterfacePeekPntrBack 

func DynStackInterfacePeekPntrBack(
	factory func(capacity int) dynamicContainers.Stack[int],
	t *testing.T,
)

Tests the PeekPntrBack method functionality of a dynamic Stack.

func DynStackInterfacePopBack 

func DynStackInterfacePopBack(
	factory func(capacity int) dynamicContainers.Stack[int],
	t *testing.T,
)

Tests the PopBack method functionality of a dynamic Stack.

func DynStackInterfacePushBack 

func DynStackInterfacePushBack(
	factory func(capacity int) dynamicContainers.Stack[int],
	t *testing.T,
)

Tests the PushBack method functionality of a dynamic Stack.

func DynStackInterfaceStaticCapacityInterface 

func DynStackInterfaceStaticCapacityInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory does not implement the staticContainers.Stack interface.

func DynStackInterfaceSyncableInterface 

func DynStackInterfaceSyncableInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynVectorInterfaceAddressableInterface 

func DynVectorInterfaceAddressableInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Addressable interface.

func DynVectorInterfaceAppend 

func DynVectorInterfaceAppend(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Append method functionality of a dynamic vector.

func DynVectorInterfaceCapacityInterface 

func DynVectorInterfaceCapacityInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Capacity interface.

func DynVectorInterfaceClear 

func DynVectorInterfaceClear(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Clear method functionality of a dynamic vector.

func DynVectorInterfaceClearInterface 

func DynVectorInterfaceClearInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func DynVectorInterfaceContains 

func DynVectorInterfaceContains(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Contains method functionality of a dynamic vector.

func DynVectorInterfaceContainsPntr 

func DynVectorInterfaceContainsPntr(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the ContainsPntr method functionality of a dynamic vector.

func DynVectorInterfaceDelete 

func DynVectorInterfaceDelete(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Delete method functionality of a dynamic vector.

func DynVectorInterfaceDeleteKeyedOpsInterface 

func DynVectorInterfaceDeleteKeyedOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedDeleteOps interface.

func DynVectorInterfaceDeleteKeyedSequentialOpsInterface 

func DynVectorInterfaceDeleteKeyedSequentialOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedDeleteOps interface.

func DynVectorInterfaceDeleteOpsInterface 

func DynVectorInterfaceDeleteOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.DeleteOps interface.

func DynVectorInterfaceDeleteSequential 

func DynVectorInterfaceDeleteSequential(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the DeleteSequential method functionality of a dynamic vector.

func DynVectorInterfaceDeleteSequentialOpsInterface 

func DynVectorInterfaceDeleteSequentialOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedDeleteOps interface.

func DynVectorInterfaceDifference 

func DynVectorInterfaceDifference(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Difference method functionality of a dynamic vector.

func DynVectorInterfaceGet 

func DynVectorInterfaceGet(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Get method functionality of a dynamic vector.

func DynVectorInterfaceGetPntr 

func DynVectorInterfaceGetPntr(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the GetPntr method functionality of a dynamic vector.

func DynVectorInterfaceInsert 

func DynVectorInterfaceInsert(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Insert method functionality of a dynamic vector.

func DynVectorInterfaceInsertSequential 

func DynVectorInterfaceInsertSequential(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the InsertSequential method functionality of a dynamic vector.

func DynVectorInterfaceInterface 

func DynVectorInterfaceInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.Vector interface.

func DynVectorInterfaceIntersection 

func DynVectorInterfaceIntersection(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Intersection method functionality of a dynamic vector.

func DynVectorInterfaceIsSubset 

func DynVectorInterfaceIsSubset(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

func DynVectorInterfaceIsSuperset 

func DynVectorInterfaceIsSuperset(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

func DynVectorInterfaceKeyOf 

func DynVectorInterfaceKeyOf(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the KeyOf method functionality of a dynamic vector.

func DynVectorInterfaceKeyOfPntr 

func DynVectorInterfaceKeyOfPntr(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the KeyOfPntr method functionality of a dynamic vector.

func DynVectorInterfaceKeyedEq 

func DynVectorInterfaceKeyedEq(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the KeyedEq method functionality of a dynamic vector.

func DynVectorInterfaceKeys 

func DynVectorInterfaceKeys(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Keys method functionality of a dynamic vector.

func DynVectorInterfaceLengthInterface 

func DynVectorInterfaceLengthInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Length interface.

func DynVectorInterfacePop 

func DynVectorInterfacePop(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Pop method functionality of a dynamic vector.

func DynVectorInterfacePopPntr 

func DynVectorInterfacePopPntr(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the PopPntr method functionality of a dynamic vector.

func DynVectorInterfacePopSequential 

func DynVectorInterfacePopSequential(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the PopSequential method functionality of a dynamic vector.

func DynVectorInterfaceReadKeyedOpsInterface 

func DynVectorInterfaceReadKeyedOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedReadOps interface.

func DynVectorInterfaceReadOpsInterface 

func DynVectorInterfaceReadOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.ReadOps interface.

func DynVectorInterfaceSet 

func DynVectorInterfaceSet(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Set method functionality of a dynamic vector.

func DynVectorInterfaceSetSequential 

func DynVectorInterfaceSetSequential(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the SetSequential method functionality of a dynamic vector.

func DynVectorInterfaceStaticCapacityInterface 

func DynVectorInterfaceStaticCapacityInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory does not implement the staticContainers.Vector interface.

func DynVectorInterfaceSyncableInterface 

func DynVectorInterfaceSyncableInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.RWSyncable interface.

func DynVectorInterfaceUnion 

func DynVectorInterfaceUnion(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Union method functionality of a dynamic vector.

func DynVectorInterfaceUnorderedEq 

func DynVectorInterfaceUnorderedEq(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the UnorderedEq method functionality of a dynamic vector.

func DynVectorInterfaceValPntrs 

func DynVectorInterfaceValPntrs(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the ValPntrs method functionality of a dynamic vector.

func DynVectorInterfaceVals 

func DynVectorInterfaceVals(
	factory func(capacity int) dynamicContainers.Vector[int],
	t *testing.T,
)

Tests the Vals method functionality of a dynamic vector.

func DynVectorInterfaceWriteDynKeyedOpsInterface 

func DynVectorInterfaceWriteDynKeyedOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedWriteOps interface.

func DynVectorInterfaceWriteKeyedOpsInterface 

func DynVectorInterfaceWriteKeyedOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.WriteKeyedOps interface.

func DynVectorInterfaceWriteKeyedSequentialOpsInterface 

func DynVectorInterfaceWriteKeyedSequentialOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.WriteKeyedSequentialOps interface.

func DynVectorInterfaceWriteOpsInterface 

func DynVectorInterfaceWriteOpsInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.WriteOps interface.

func HashDynMapInterfaceKeyedEq 

func HashDynMapInterfaceKeyedEq(
	factory func(capacity int) dynamicContainers.Map[int, int],
	t *testing.T,
)

Tests the KeyedEq method functionality of a dynamic hash map.

func ReadDynDequeInterface 

func ReadDynDequeInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.DequeRead interface.

func ReadDynDirectedGraphInterface 

func ReadDynDirectedGraphInterface[V any, E any](
	factory func(capacity int) dynamicContainers.DirectedGraph[V, E],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.DirectedGraphRead interface.

func ReadDynMapInterface 

func ReadDynMapInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.MapRead interface.

func ReadDynQueueInterface 

func ReadDynQueueInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.QueueRead interface.

func ReadDynSetInterface 

func ReadDynSetInterface[V any](
	factory func(capacity int) dynamicContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.VectorRead interface.

func ReadDynStackInterface 

func ReadDynStackInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.StackRead interface.

func ReadDynVectorInterface 

func ReadDynVectorInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.VectorRead interface.

func ReadStaticDequeInterface 

func ReadStaticDequeInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.DequeRead interface.

func ReadStaticQueueInterface 

func ReadStaticQueueInterface[V any](
	factory func(capacity int) staticContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.QueueRead interface.

func ReadStaticSetInterface 

func ReadStaticSetInterface[V any](
	factory func(capacity int) staticContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.VectorRead interface.

func ReadStaticStackInterface 

func ReadStaticStackInterface[V any](
	factory func(capacity int) staticContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.StackRead interface.

func ReadStaticVectorInterface 

func ReadStaticVectorInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.VectorRead interface.

func StaticDequeInterfaceCapacityInterface 

func StaticDequeInterfaceCapacityInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Capacity interface.

func StaticDequeInterfaceClear 

func StaticDequeInterfaceClear(
	factory func(capacity int) staticContainers.Deque[int],
	t *testing.T,
)

Tests the Clear method functionality of a static Deque.

func StaticDequeInterfaceClearInterface 

func StaticDequeInterfaceClearInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func StaticDequeInterfaceFirstElemDeleteInterface 

func StaticDequeInterfaceFirstElemDeleteInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.FirstElemDelete interface.

func StaticDequeInterfaceFirstElemReadInterface 

func StaticDequeInterfaceFirstElemReadInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.FirstElemRead interface.

func StaticDequeInterfaceFirstElemWriteInterface 

func StaticDequeInterfaceFirstElemWriteInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.FirstElemWrite interface.

func StaticDequeInterfaceForcePushBack 

func StaticDequeInterfaceForcePushBack(
	factory func(capacity int) staticContainers.Deque[int],
	t *testing.T,
)

Tests the ForcePopFront method functionality of a static Deque.

func StaticDequeInterfaceForcePushFront 

func StaticDequeInterfaceForcePushFront(
	factory func(capacity int) staticContainers.Deque[int],
	t *testing.T,
)

Tests the ForcePopFront method functionality of a static Deque.

func StaticDequeInterfaceInterface 

func StaticDequeInterfaceInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.Deque interface.

func StaticDequeInterfaceLastElemDeleteInterface 

func StaticDequeInterfaceLastElemDeleteInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemDelete interface.

func StaticDequeInterfaceLastElemReadInterface 

func StaticDequeInterfaceLastElemReadInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemRead interface.

func StaticDequeInterfaceLastElemWriteInterface 

func StaticDequeInterfaceLastElemWriteInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemWrite interface.

func StaticDequeInterfaceLengthInterface 

func StaticDequeInterfaceLengthInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Length interface.

func StaticDequeInterfacePeekBack 

func StaticDequeInterfacePeekBack(
	factory func(capacity int) staticContainers.Deque[int],
	t *testing.T,
)

Tests the PeekBack method functionality of a static Deque.

func StaticDequeInterfacePeekFront 

func StaticDequeInterfacePeekFront(
	factory func(capacity int) staticContainers.Deque[int],
	t *testing.T,
)

Tests the PeekFront method functionality of a static Deque.

func StaticDequeInterfacePeekPntrBack 

func StaticDequeInterfacePeekPntrBack(
	factory func(capacity int) staticContainers.Deque[int],
	t *testing.T,
)

Tests the PeekPntrBack method functionality of a static Deque.

func StaticDequeInterfacePeekPntrFront 

func StaticDequeInterfacePeekPntrFront(
	factory func(capacity int) staticContainers.Deque[int],
	t *testing.T,
)

Tests the PeekPntrFront method functionality of a static Deque.

func StaticDequeInterfacePopBack 

func StaticDequeInterfacePopBack(
	factory func(capacity int) staticContainers.Deque[int],
	t *testing.T,
)

Tests the PopBack method functionality of a static Deque.

func StaticDequeInterfacePopFront 

func StaticDequeInterfacePopFront(
	factory func(capacity int) staticContainers.Deque[int],
	t *testing.T,
)

Tests the PopFront method functionality of a static Deque.

func StaticDequeInterfacePushBack 

func StaticDequeInterfacePushBack(
	factory func(capacity int) staticContainers.Deque[int],
	t *testing.T,
)

Tests the PushBack method functionality of a static Deque.

func StaticDequeInterfacePushFront 

func StaticDequeInterfacePushFront(
	factory func(capacity int) staticContainers.Deque[int],
	t *testing.T,
)

Tests the PopFront method functionality of a static Deque.

func StaticDequeInterfaceStaticCapacity 

func StaticDequeInterfaceStaticCapacity[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.StaticCapacity interface.

func StaticQueueInterfaceCapacityInterface 

func StaticQueueInterfaceCapacityInterface[V any](
	factory func(capacity int) staticContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Capacity interface.

func StaticQueueInterfaceClear 

func StaticQueueInterfaceClear(
	factory func(capacity int) staticContainers.Queue[int],
	t *testing.T,
)

Tests the Clear method functionality of a static Queue.

func StaticQueueInterfaceClearInterface 

func StaticQueueInterfaceClearInterface[V any](
	factory func(capacity int) staticContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func StaticQueueInterfaceFirstElemDeleteInterface 

func StaticQueueInterfaceFirstElemDeleteInterface[V any](
	factory func(capacity int) staticContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.FirstElemDelete interface.

func StaticQueueInterfaceFirstElemReadInterface 

func StaticQueueInterfaceFirstElemReadInterface[V any](
	factory func(capacity int) staticContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.FirstElemRead interface.

func StaticQueueInterfaceForcePushBack 

func StaticQueueInterfaceForcePushBack(
	factory func(capacity int) staticContainers.Queue[int],
	t *testing.T,
)

Tests the ForcePopFront method functionality of a static Queue.

func StaticQueueInterfaceInterface 

func StaticQueueInterfaceInterface[V any](
	factory func(capacity int) staticContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.Queue interface.

func StaticQueueInterfaceLastElemWriteInterface 

func StaticQueueInterfaceLastElemWriteInterface[V any](
	factory func(capacity int) staticContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemWrite interface.

func StaticQueueInterfaceLengthInterface 

func StaticQueueInterfaceLengthInterface[V any](
	factory func(capacity int) staticContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Length interface.

func StaticQueueInterfacePeekFront 

func StaticQueueInterfacePeekFront(
	factory func(capacity int) staticContainers.Queue[int],
	t *testing.T,
)

Tests the PeekFront method functionality of a static Queue.

func StaticQueueInterfacePeekPntrFront 

func StaticQueueInterfacePeekPntrFront(
	factory func(capacity int) staticContainers.Queue[int],
	t *testing.T,
)

Tests the PeekPntrFront method functionality of a static Queue.

func StaticQueueInterfacePopFront 

func StaticQueueInterfacePopFront(
	factory func(capacity int) staticContainers.Queue[int],
	t *testing.T,
)

Tests the PopFront method functionality of a static Queue.

func StaticQueueInterfacePushBack 

func StaticQueueInterfacePushBack(
	factory func(capacity int) staticContainers.Queue[int],
	t *testing.T,
)

Tests the PushBack method functionality of a static Queue.

func StaticQueueInterfaceStaticCapacity 

func StaticQueueInterfaceStaticCapacity[V any](
	factory func(capacity int) staticContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.StaticCapacity interface.

func StaticSetInterfaceAppendUnique 

func StaticSetInterfaceAppendUnique(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the AppendUnique method functionality of a static set.

func StaticSetInterfaceClear 

func StaticSetInterfaceClear(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the Clear method functionality of a static set.

func StaticSetInterfaceClearInterface 

func StaticSetInterfaceClearInterface[V any](
	factory func(capacity int) staticContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func StaticSetInterfaceContains 

func StaticSetInterfaceContains(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the Contains method functionality of a static set.

func StaticSetInterfaceContainsPntr 

func StaticSetInterfaceContainsPntr(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the ContainsPntr method functionality of a static set.

func StaticSetInterfaceDeleteOpsInterface 

func StaticSetInterfaceDeleteOpsInterface[V any](
	factory func(capacity int) staticContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.DeleteOps interface.

func StaticSetInterfaceDifference 

func StaticSetInterfaceDifference(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the Difference method functionality of a static set.

func StaticSetInterfaceGetUnique 

func StaticSetInterfaceGetUnique(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the GetUnique method functionality of a dynamic set.

func StaticSetInterfaceInterface 

func StaticSetInterfaceInterface[V any](
	factory func(capacity int) staticContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.Vector interface.

func StaticSetInterfaceIntersection 

func StaticSetInterfaceIntersection(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the Intersection method functionality of a static set.

func StaticSetInterfaceIsSubset 

func StaticSetInterfaceIsSubset(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

func StaticSetInterfaceIsSuperset 

func StaticSetInterfaceIsSuperset(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

func StaticSetInterfaceLengthInterface 

func StaticSetInterfaceLengthInterface[V any](
	factory func(capacity int) staticContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Length interface.

func StaticSetInterfacePop 

func StaticSetInterfacePop(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the Pop method functionality of a static set.

func StaticSetInterfaceReadOpsInterface 

func StaticSetInterfaceReadOpsInterface[V any](
	factory func(capacity int) staticContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.ReadOps interface.

func StaticSetInterfaceStaticCapacity 

func StaticSetInterfaceStaticCapacity[V any](
	factory func(capacity int) staticContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.StaticCapacity interface.

func StaticSetInterfaceUnion 

func StaticSetInterfaceUnion(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the Union method functionality of a static set.

func StaticSetInterfaceUnorderedEq 

func StaticSetInterfaceUnorderedEq(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the UnorderedEq method functionality of a static set.

func StaticSetInterfaceUpdateUnique 

func StaticSetInterfaceUpdateUnique(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the UpdateUnique method functionality of a static set.

func StaticSetInterfaceValPntrs 

func StaticSetInterfaceValPntrs(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the ValPntrs method functionality of a static set.

func StaticSetInterfaceVals 

func StaticSetInterfaceVals(
	factory func(capacity int) staticContainers.Set[int],
	t *testing.T,
)

Tests the Vals method functionality of a static set.

func StaticSetInterfaceWriteUniqueOpsInterface 

func StaticSetInterfaceWriteUniqueOpsInterface[V any](
	factory func(capacity int) staticContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.WriteUniqueOps interface.

func StaticStackInterfaceCapacityInterface 

func StaticStackInterfaceCapacityInterface[V any](
	factory func(capacity int) staticContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Capacity interface.

func StaticStackInterfaceClear 

func StaticStackInterfaceClear(
	factory func(capacity int) staticContainers.Stack[int],
	t *testing.T,
)

Tests the Clear method functionality of a static Stack.

func StaticStackInterfaceClearInterface 

func StaticStackInterfaceClearInterface[V any](
	factory func(capacity int) staticContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func StaticStackInterfaceForcePushBack 

func StaticStackInterfaceForcePushBack(
	factory func(capacity int) staticContainers.Stack[int],
	t *testing.T,
)

Tests the ForcePopFront method functionality of a static Stack.

func StaticStackInterfaceInterface 

func StaticStackInterfaceInterface[V any](
	factory func(capacity int) staticContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.Stack interface.

func StaticStackInterfaceLastElemDeleteInterface 

func StaticStackInterfaceLastElemDeleteInterface[V any](
	factory func(capacity int) staticContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemDelete interface.

func StaticStackInterfaceLastElemReadInterface 

func StaticStackInterfaceLastElemReadInterface[V any](
	factory func(capacity int) staticContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemRead interface.

func StaticStackInterfaceLastElemWriteInterface 

func StaticStackInterfaceLastElemWriteInterface[V any](
	factory func(capacity int) staticContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.LastElemWrite interface.

func StaticStackInterfaceLengthInterface 

func StaticStackInterfaceLengthInterface[V any](
	factory func(capacity int) staticContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Length interface.

func StaticStackInterfacePeekBack 

func StaticStackInterfacePeekBack(
	factory func(capacity int) staticContainers.Stack[int],
	t *testing.T,
)

Tests the PeekBack method functionality of a static Stack.

func StaticStackInterfacePeekPntrBack 

func StaticStackInterfacePeekPntrBack(
	factory func(capacity int) staticContainers.Stack[int],
	t *testing.T,
)

Tests the PeekPntrBack method functionality of a static Stack.

func StaticStackInterfacePopBack 

func StaticStackInterfacePopBack(
	factory func(capacity int) staticContainers.Stack[int],
	t *testing.T,
)

Tests the PopBack method functionality of a static Stack.

func StaticStackInterfacePushBack 

func StaticStackInterfacePushBack(
	factory func(capacity int) staticContainers.Stack[int],
	t *testing.T,
)

Tests the PushBack method functionality of a static Stack.

func StaticStackInterfaceStaticCapacity 

func StaticStackInterfaceStaticCapacity[V any](
	factory func(capacity int) staticContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.StaticCapacity interface.

func StaticVectorInterfaceAddressableInterface 

func StaticVectorInterfaceAddressableInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Addressable interface.

func StaticVectorInterfaceAppend 

func StaticVectorInterfaceAppend(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the Append method functionality of a static vector.

func StaticVectorInterfaceCapacityInterface 

func StaticVectorInterfaceCapacityInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Capacity interface.

func StaticVectorInterfaceClear 

func StaticVectorInterfaceClear(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the Clear method functionality of a static vector.

func StaticVectorInterfaceClearInterface 

func StaticVectorInterfaceClearInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Clear interface.

func StaticVectorInterfaceContains 

func StaticVectorInterfaceContains(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the Contains method functionality of a static vector.

func StaticVectorInterfaceContainsPntr 

func StaticVectorInterfaceContainsPntr(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the ContainsPntr method functionality of a static vector.

func StaticVectorInterfaceDelete 

func StaticVectorInterfaceDelete(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the Delete method functionality of a static vector.

func StaticVectorInterfaceDeleteKeyedOpsInterface 

func StaticVectorInterfaceDeleteKeyedOpsInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedDeleteOps interface.

func StaticVectorInterfaceDeleteKeyedSequentialOpsInterface 

func StaticVectorInterfaceDeleteKeyedSequentialOpsInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedDeleteOps interface.

func StaticVectorInterfaceDeleteOpsInterface 

func StaticVectorInterfaceDeleteOpsInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.DeleteOps interface.

func StaticVectorInterfaceDeleteSequential 

func StaticVectorInterfaceDeleteSequential(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the DeleteSequential method functionality of a static vector.

func StaticVectorInterfaceDeleteSequentialOpsInterface 

func StaticVectorInterfaceDeleteSequentialOpsInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedDeleteOps interface.

func StaticVectorInterfaceGet 

func StaticVectorInterfaceGet(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the Get method functionality of a static vector.

func StaticVectorInterfaceGetPntr 

func StaticVectorInterfaceGetPntr(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the GetPntr method functionality of a static vector.

func StaticVectorInterfaceInsert 

func StaticVectorInterfaceInsert(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the Insert method functionality of a static vector.

func StaticVectorInterfaceInsertSequential 

func StaticVectorInterfaceInsertSequential(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the InsertSequential method functionality of a static vector.

func StaticVectorInterfaceInterface 

func StaticVectorInterfaceInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.Vector interface.

func StaticVectorInterfaceKeyOf 

func StaticVectorInterfaceKeyOf(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the KeyOf method functionality of a static vector.

func StaticVectorInterfaceKeyOfPntr 

func StaticVectorInterfaceKeyOfPntr(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the KeyOfPntr method functionality of a static vector.

func StaticVectorInterfaceKeyedEq 

func StaticVectorInterfaceKeyedEq(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the KeyedEq method functionality of a static vector.

func StaticVectorInterfaceKeys 

func StaticVectorInterfaceKeys(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the Keys method functionality of a static vector.

func StaticVectorInterfaceLengthInterface 

func StaticVectorInterfaceLengthInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.Length interface.

func StaticVectorInterfacePop 

func StaticVectorInterfacePop(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the Pop method functionality of a static vector.

func StaticVectorInterfacePopPntr 

func StaticVectorInterfacePopPntr(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the Pop method functionality of a static vector.

func StaticVectorInterfacePopSequential 

func StaticVectorInterfacePopSequential(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the PopSequential method functionality of a static vector.

func StaticVectorInterfaceReadKeyedOpsInterface 

func StaticVectorInterfaceReadKeyedOpsInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedReadOps interface.

func StaticVectorInterfaceReadOpsInterface 

func StaticVectorInterfaceReadOpsInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.ReadOps interface.

func StaticVectorInterfaceSet 

func StaticVectorInterfaceSet(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the Set method functionality of a static vector.

func StaticVectorInterfaceSetSequential 

func StaticVectorInterfaceSetSequential(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the SetSequential method functionality of a static vector.

func StaticVectorInterfaceStaticCapacity 

func StaticVectorInterfaceStaticCapacity[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.StaticCapacity interface.

func StaticVectorInterfaceValPntrs 

func StaticVectorInterfaceValPntrs(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the ValPntrs method functionality of a dynamic vector.

func StaticVectorInterfaceVals 

func StaticVectorInterfaceVals(
	factory func(capacity int) staticContainers.Vector[int],
	t *testing.T,
)

Tests the Vals method functionality of a dynamic vector.

func StaticVectorInterfaceWriteDynKeyedOpsInterface 

func StaticVectorInterfaceWriteDynKeyedOpsInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.KeyedWriteOps interface.

func StaticVectorInterfaceWriteKeyedOpsInterface 

func StaticVectorInterfaceWriteKeyedOpsInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.WriteKeyedOps interface.

func StaticVectorInterfaceWriteKeyedSequentialOpsInterface 

func StaticVectorInterfaceWriteKeyedSequentialOpsInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.WriteKeyedSequentialOps interface.

func StaticVectorInterfaceWriteOpsInterface 

func StaticVectorInterfaceWriteOpsInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the containerTypes.WriteOps interface.

func WriteDynDequeInterface 

func WriteDynDequeInterface[V any](
	factory func(capacity int) dynamicContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.WriteDeque interface.

func WriteDynDirectedGraphInterface 

func WriteDynDirectedGraphInterface[V any, E any](
	factory func(capacity int) dynamicContainers.DirectedGraph[V, E],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.WriteDirectedGraph interface.

func WriteDynMapInterface 

func WriteDynMapInterface[K any, V any](
	factory func(capacity int) dynamicContainers.Map[K, V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.WriteMap interface.

func WriteDynQueueInterface 

func WriteDynQueueInterface[V any](
	factory func(capacity int) dynamicContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.WriteQueue interface.

func WriteDynSetInterface 

func WriteDynSetInterface[V any](
	factory func(capacity int) dynamicContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.WriteVector interface.

func WriteDynStackInterface 

func WriteDynStackInterface[V any](
	factory func(capacity int) dynamicContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.WriteStack interface.

func WriteDynVectorInterface 

func WriteDynVectorInterface[V any](
	factory func(capacity int) dynamicContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the dynamicContainers.WriteVector interface.

func WriteStaticDequeInterface 

func WriteStaticDequeInterface[V any](
	factory func(capacity int) staticContainers.Deque[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.WriteDeque interface.

func WriteStaticQueueInterface 

func WriteStaticQueueInterface[V any](
	factory func(capacity int) staticContainers.Queue[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.WriteQueue interface.

func WriteStaticSetInterface 

func WriteStaticSetInterface[V any](
	factory func(capacity int) staticContainers.Set[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.WriteVector interface.

func WriteStaticStackInterface 

func WriteStaticStackInterface[V any](
	factory func(capacity int) staticContainers.Stack[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.WriteStack interface.

func WriteStaticVectorInterface 

func WriteStaticVectorInterface[V any](
	factory func(capacity int) staticContainers.Vector[V],
	t *testing.T,
)

Tests that the value supplied by the factory implements the staticContainers.WriteVector interface.

Types

This section is empty.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.