scalatestCoreDotty/org.scalatest.prop/HavingLength

HavingLength

trait HavingLength[T] extends HavingSize[T]

This trait is mixed in to Generators that have a well-defined notion of "length".

Broadly speaking, this applies when T is a type that has a length method. For example, Generator.listGenerator (also known as CommonGenerators.lists) has the HavingLength trait because List has a length method.

Generators with this trait provide several functions that allow you to create more-specialized Generators, with specific length bounds.

Note that this trait extends HavingSize, and is quite similar to it, reflecting the relationship between the length and size methods in many standard library types. The functions in here are basically just a shell around those in HavingSize.

Type parameters:

T: the type that this Generator produces

trait HavingSize[T]

class Object

trait Matchable

class Any

Value members

Concrete methods

Create a version of this Generator that produces values of exactly the specified length.

For example, consider:

 val stringLists: Generator[List[String]] =
   Generator.ListGenerator[String]

 val singleStringLists: Generator[List[String]] =
   stringLists.havingSize(1)

The singleStringLists Generator will always produce Lists of exactly one String.

Value parameters:

len: the length of the values to produce

Returns:

a new Generator that produces values of that length

Create a version of this Generator that produces values within the specified length range.

The bounds are inclusive: the resulting Generator may produce values with a length of to or from.

For example, consider:

 val stringLists: Generator[List[String]] =
   Generator.ListGenerator[String]

 val smallStringLists: Generator[List[String]] =
   stringLists.havingLengthsBetween(0, 3)

The smallStringLists Generator will always produce Lists of zero through three Strings.

The from parameter must be smaller than the to parameter, and may not be equal to it. If you want a Generator with a single specific length, use havingLength instead.

Value parameters:

from: The smallest desired size to produce
to: The largest desired size to produce

Returns:

a Generator that will only produce values within that length range

Create a version of this Generator whose legal lengths are adjusted by a specified function.

For example:

 def currentLimit: PosZInt = ...

 def limitedSize(szp: SizeParam): SizeParam = {
   val limit = currentLimit
   val sz = if (szp.maxSize < limit) szp.maxSize else limit
   szp.copy(size = sz)
 }

 val sizelimitedLists = lists[Int].havingLengthsDeterminedBy(limitedSize)

This doesn't hard-code the length of the sizeLimitedLists Generator, but allows the maximum length to be clamped based on a dynamic currentLimit function.

Value parameters:

f: a transformation function that takes the current SizeParam and returns a new one

Returns:

a Generator that will base its lengths on the given function

Inherited methods

Create a version of this Generator that produces values of exactly the specified size.

For example, consider:

 val stringSets: Generator[Set[String]] =
   Generator.setGenerator[String]

 val singleStringSets: Generator[Set[String]] =
   stringSets.havingSize(1)

The singleStringSets Generator will always produce Sets of exactly one String.

Value parameters:

len: the size of the values to produce

Returns:

a new Generator that produces values of that size

Inherited from:

HavingSize

Create a version of this Generator that produces values within the specified size range.

The bounds are inclusive: the resulting Generator may produce values with a size of to or from.

For example, consider:

 val stringSets: Generator[Set[String]] =
   Generator.setGenerator[String]

 val smallStringSets: Generator[Set[String]] =
   stringSets.havingSizesBetween(0, 3)

The smallStringSets Generator will always produce Sets of zero through three Strings.

Value parameters:

from: The smallest desired size to produce
to: The largest desired size to produce

Returns:

a Generator that will only produce values within that size range

Inherited from:

HavingSize

Create a version of this Generator whose legal sizes are adjusted by a specified function.

For example:

 def currentLimit: PosZInt = ...

 def limitedSize(szp: SizeParam): SizeParam = {
   val limit = currentLimit
   val sz = if (szp.maxSize < limit) szp.maxSize else limit
   szp.copy(size = sz)
 }

 val sizelimitedLists = lists[Int].havingSizesDeterminedBy(limitedSize)

This doesn't hard-code the size of the sizeLimitedLists Generator, but allows the maximum size to be clamped based on a dynamic currentLimit function.

Value parameters:

f: a transformation function that takes the current SizeParam and returns a new one

Returns:

a Generator that will base its sizes on the given function

Inherited from:

HavingSize