CS计算机代考程序代写 /*

/*
* Copyright (c) 2018, 2020. Phasmid Software
*/

package edu.neu.coe.csye7200.asstll

import org.scalatest.flatspec
import org.scalatest.matchers.should
import scala.language.postfixOps

class MyLazyListSpec extends flatspec.AnyFlatSpec with should.Matchers {

behavior of “Cons”
it should “produce a single of 1” in {
val x: ListLike[Int] = MyLazyList(1, () => EmptyList)
x.head shouldBe 1
x.tail shouldBe EmptyList
}

it should “produce a stream of xs using Cons directly” in {
lazy val x: ListLike[String] = MyLazyList(“x”, () => x)
val y = x.take(3).toSeq
y.size shouldBe 3
y.head shouldBe “x”
y shouldBe Seq(“x”, “x”, “x”)
}

behavior of “toSeq”
it should “produce a single 1” in {
val x: ListLike[Int] = MyLazyList(1, () => EmptyList)
x.toSeq shouldBe Seq(1)
}
it should “produce a sequence of 1, 2” in {
val x = MyLazyList(1, () => MyLazyList(2, () => EmptyList))
x.toSeq shouldBe Seq(1, 2)
}

behavior of “ones”
it should “produce a stream of 1s” in {
val x: ListLike[Int] = MyLazyList.ones
val y = x.take(3).toSeq
y.size shouldBe 3
y.head shouldBe 1
y shouldBe Seq(1, 1, 1)
}

behavior of “take”
it should “take zero from a finite stream” in {
MyLazyList(1).take(0).toSeq shouldBe Nil
}

it should “take zero from an infinite stream” in {
MyLazyList.continually(1).take(0).toSeq shouldBe Nil
}

it should “take 3 from a finite stream of actual length 1” in {
(MyLazyList(1) take 3).toSeq shouldBe Seq(1)
}

it should “take 3 from an infinite stream” in {
(MyLazyList.continually(1) take 3).toSeq shouldBe Seq(1, 1, 1)
}

it should “take 3 from an infinite stream of 1s that counts” in {
var count = 0

def incrementCountAndProvideValue: Int = {
count = count + 1
1
}

val lazyList = MyLazyList.continually(incrementCountAndProvideValue) take 3
count shouldBe 1
lazyList.toSeq shouldBe Seq(1, 1, 1)
// LazyList is not memorizing the elements that have been evaluated already.
count shouldBe 4
}

it should “take 3 from an infinite incrementing stream that counts” in {
var count = 0

def incrementCountAndProvideValue: Int = {
count = count + 1
count
}

val lazyList = MyLazyList.continually(incrementCountAndProvideValue) take 3
count shouldBe 1
lazyList.toSeq shouldBe Seq(1, 2, 3)
// LazyList is not memorizing the elements that have been evaluated already.
count shouldBe 4
}

behavior of “drop”
it should “work correctly” in {
val x = MyLazyList.from(1)
val y = x drop 3 take 3
y.toSeq shouldBe Seq(4, 5, 6)
}

behavior of “++”
it should “join two Empty streams together” in {
val x = EmptyList
val y = x.++(EmptyList)
y shouldBe x
}
it should “join a stream with an Empty stream” in {
val empty = EmptyList
val ones = MyLazyList.continually(1)
val y = ones.++(empty)
val z = y.take(3).toSeq
z.size shouldBe 3
z shouldBe Seq(1, 1, 1)
}
it should “join an Empty stream with a stream” in {
val x: ListLike[Int] = EmptyList.asInstanceOf[ListLike[Int]]
val ones = MyLazyList.continually(1)
val y = x.++(ones)
(y take 3).toSeq shouldBe Seq(1, 1, 1)
}

behavior of “map”
it should “produce a stream of 2s” in {
lazy val x: ListLike[Int] = MyLazyList(1, () => x)
val y = x map (_ * 2)
assert(y.head == 2)
assert(y.tail.head == 2)
(y take 4).toSeq shouldBe Seq(2, 2, 2, 2)
}

behavior of “flatMap”
it should “produce a stream of 2s from a single element 1” in {
val x = MyLazyList(1)
val y = x flatMap (z => MyLazyList.continually(z * 2))
assert(y.head == 2)
assert(y.tail.head == 2)
(y take 4).toSeq shouldBe Seq(2, 2, 2, 2)
}

it should “produce a stream of 2s from a stream of 1s” in {
lazy val x: ListLike[Int] = MyLazyList(1, () => x)
val y = x flatMap (z => MyLazyList.continually(z * 2))
assert(y.head == 2)
assert(y.tail.head == 2)
(y take 4).toSeq shouldBe Seq(2, 2, 2, 2)
}

behavior of “from”
it should “get a Seq(2, 4, 6, 8)” in {
val x = MyLazyList.from(2, 2)
(x take 4 toSeq) shouldBe Seq(2, 4, 6, 8)
}

it should “get a Seq(1, -1, -3, -5)” in {
val x = MyLazyList.from(1, -2)
(x take 4 toSeq) shouldBe Seq(1, -1, -3, -5)
}

behavior of “filter”
it should “produce a stream of even numbers using from(1)” in {
def even(x: Int): Boolean = x % 2 == 0

val y = MyLazyList.from(1) filter even
assert(y.head == 2)
assert(y.tail.head == 4)
(y take 4).toSeq shouldBe Seq(2, 4, 6, 8)
}

it should “produce a stream of even numbers using from(2,2)” in {
def even(x: Int): Boolean = x % 2 == 0

val y = MyLazyList.from(2, 2) filter even
assert(y.head == 2)
assert(y.tail.head == 4)
(y take 4).toSeq shouldBe Seq(2, 4, 6, 8)
}

behavior of “filterNot”
it should “produce a stream of even numbers using from(1)” in {
def odd(x: Int): Boolean = x % 2 != 0

val y = MyLazyList.from(1) filterNot odd
assert(y.head == 2)
assert(y.tail.head == 4)
(y take 4).toSeq shouldBe Seq(2, 4, 6, 8)
}

it should “produce a stream of even numbers using from(2,2)” in {
def odd(x: Int): Boolean = x % 2 != 0

val y = MyLazyList.from(2, 2) filterNot odd
assert(y.head == 2)
assert(y.tail.head == 4)
(y take 4).toSeq shouldBe Seq(2, 4, 6, 8)
}

behavior of “zip”
it should “zip together two empty streams” in {
EmptyList.zip(EmptyList) shouldBe EmptyList
}
it should “zip together a stream and an empty stream” in {
MyLazyList.continually(1).zip(EmptyList) shouldBe EmptyList
}
it should “zip together an empty stream and a stream” in {
EmptyList.zip(MyLazyList.continually(1)) shouldBe EmptyList
}
it should “zip together two non-empty streams” in {
val x = MyLazyList.from(1).zip(MyLazyList.from(2))
x.head shouldBe(1, 2)
x.tail.head shouldBe(2, 3)
}

behavior of “apply”
it should “produce a stream of a single 1” in {
val y = MyLazyList(1) take 3
y.toSeq shouldBe Seq(1)
}

behavior of “continually”
it should “produce a stream of 1s” in {
val y = MyLazyList.continually(1) take 3
y.toSeq shouldBe Seq(1, 1, 1)
}

it should “produce a stream of 1 thru 3” in {
val x = MyLazyList.from(1)
val y = x take 3
y.toSeq shouldBe Seq(1, 2, 3)
}

behavior of “MyLazyList as a monad”
it should “support a for-comprehension” in {
val zs = for (x <- MyLazyList.from(1); y <- MyLazyList(Seq(1, 2, 3))) yield (x, y) (zs take 5).toSeq shouldBe Seq(1 -> 1, 1 -> 2, 1 -> 3, 2 -> 1, 2 -> 2)
}

it should “support a for-comprehension with filter” in {
val zs = for (x <- MyLazyList.from(1); if x > 1; y <- MyLazyList(Seq(1, 2, 3)); if y == 2) yield (x, y) (zs take 3).toSeq shouldBe Seq(2 -> 2, 3 -> 2, 4 -> 2)
}

behavior of “singleton”
it should “allow for 1” in {
val x = MyLazyList.singleton(1)
x.toSeq shouldBe Seq(1)
}

behavior of “Iterator”
it should “support EmptyList” in {
val x = EmptyList
val i = x.iterator
i.hasNext shouldBe false
}

it should “support from” in {
val x = MyLazyList.from(1)
val i = x.iterator
i.hasNext shouldBe true
i.next() shouldBe 1
i.hasNext shouldBe true
i.next() shouldBe 2
}

it should “support singleton” in {
val x = MyLazyList.singleton(1)
val i = x.iterator
i.hasNext shouldBe true
i.next() shouldBe 1
i.hasNext shouldBe false
}
}