[轉] org.scalatest.FunSuite Scala Examples - Scala FunSuite 測試的例子

[From]  https://www.programcreek.com/scala/org.scalatest.FunSuite

 

org.scalatest.FunSuite Scala Examples

The following code examples show how to use org.scalatest.FunSuite. These examples are extracted from open source projects. You can vote up the examples you like and your votes will be used in our system to product more good examples. 

+  Save this class

 

Example 1

Project: train-stamp-rally   Author: ponkotuy   File: MissionTimeSuite.scala View Source Project (license)

7 votes

package utils import org.scalatest.FunSuite class MissionTimeSuite extends FunSuite { test("MissionTime.addMinutes") { assert(MissionTime(1, 6, 1).addMinutes(15) === MissionTime(1, 6, 16)) assert(MissionTime(1, 6, 23).addMinutes(-10) === MissionTime(1, 6, 13)) } test("MissionTime.addMinutes if carry") { assert(MissionTime(1, 6, 59).addMinutes(3) === MissionTime(1, 7, 2)) assert(MissionTime(1, 7, 3).addMinutes(-5) === MissionTime(1, 6, 58)) } test("MissionTime.addMinutes if over hour") { assert(MissionTime(1, 23, 44).addMinutes(25) === MissionTime(2, 0, 9)) assert(MissionTime(2, 0, 15).addMinutes(-18) === MissionTime(1, 23, 57)) } test("MissionTime.fromString") { assert(MissionTime.fromString("1-06:15") === Some(MissionTime(1, 6, 15))) } }

Example 2

Project: scala-dom   Author: rrramiro   File: MappedNamespaceContextTest.scala View Source Project(license)

5 votes

package fr.ramiro.scala.dom import javax.xml.XMLConstants import org.scalatest.FunSuite import scala.collection.JavaConverters.asScalaIteratorConverter class MappedNamespaceContextTest extends FunSuite { test("get prefix and get namespaceURI") { val customUri = "www.ramiro.fr" val customPrefix = "ramiro" val namespaceContext = new MappedNamespaceContext(Map(customPrefix -> customUri)) assert(namespaceContext.getNamespaceURI(customPrefix) === customUri) assert(namespaceContext.getNamespaceURI(XMLConstants.XML_NS_PREFIX) === XMLConstants.XML_NS_URI) assert(namespaceContext.getNamespaceURI(XMLConstants.XMLNS_ATTRIBUTE) === XMLConstants.XMLNS_ATTRIBUTE_NS_URI) assert(namespaceContext.getPrefix(customUri) === customPrefix) assert(namespaceContext.getPrefix(XMLConstants.XML_NS_URI) === XMLConstants.XML_NS_PREFIX) assert(namespaceContext.getPrefix(XMLConstants.XMLNS_ATTRIBUTE_NS_URI) === XMLConstants.XMLNS_ATTRIBUTE) assert(namespaceContext.getPrefixes(customUri).asScala.toList === List(customPrefix)) assert(namespaceContext.getPrefixes(XMLConstants.XML_NS_URI).asScala.toList === List(XMLConstants.XML_NS_PREFIX)) assert(namespaceContext.getPrefixes(XMLConstants.XMLNS_ATTRIBUTE_NS_URI).asScala.toList === List(XMLConstants.XMLNS_ATTRIBUTE)) } test("getNamespaceURI with null") { intercept[IllegalArgumentException] { new MappedNamespaceContext(Map.empty).getNamespaceURI(null) } } test("getPrefix with null") { intercept[IllegalArgumentException] { new MappedNamespaceContext(Map.empty).getPrefix(null) } } test("getPrefixes with null") { intercept[IllegalArgumentException] { new MappedNamespaceContext(Map.empty).getPrefixes(null) } } }

Example 3

Project: Functional-Programming-in-Scala   Author: vincenzobaz   File: CountChangeSuite.scala View Source Project (license)

5 votes

package recfun import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class CountChangeSuite extends FunSuite { import Main.countChange test("countChange: example given in instructions") { assert(countChange(4,List(1,2)) === 3) } test("countChange: sorted CHF") { assert(countChange(300,List(5,10,20,50,100,200,500)) === 1022) } test("countChange: no pennies") { assert(countChange(301,List(5,10,20,50,100,200,500)) === 0) } test("countChange: unsorted CHF") { assert(countChange(300,List(500,5,50,100,20,200,10)) === 1022) } }

Example 4

Project: Earlgrey   Author: PatrickHuang888   File: RepositoryTest.scala View Source Project (license)

5 votes

package com.hxm.earlgrey.jobs import org.scalatest.{BeforeAndAfter, FunSuite} import org.mongodb.scala.Document class RepositoryTest extends FunSuite with BeforeAndAfter { val repository = Repository() val jobId = "scalaTestId" before { repository.deleteJob(jobId) } test("job insert and query") { val doc = Document("_id" -> jobId, "type" -> Job.Type.FlowQuery, "name" -> "scalatest", "status" -> Job.Status.Created) val job = new Job(doc) repository.insertJob(job) val j = repository.findJob(jobId) assert(j.isDefined) assert(j.get.doc.getString("_id") == jobId) } }

Example 5

Project: hwork   Author: Masebeni   File: PositionPackageTest.scala View Source Project (license)

5 votes

package factories.position import domain.position.PositionPackage import org.joda.time.DateTime import org.scalatest.FunSuite class PositionPackageTest extends FunSuite { test("testCreatePositionFunding") { val des = new PositionPackageFactory; val date = new DateTime(2016, 4, 2, 1, 20, 2, 0); val values = Map("positionId" -> "1", "positionPackageId" -> "1", "gradeId" -> "1", "notchId" -> "1", "state" -> "testState" ); val posdes = des.createPositionPackageFactory(values, date); assert(posdes == PositionPackage(positionId = "1", positionPackageId = "1", gradeId = "1", notchId = "1", state = "testState", date = new DateTime(2016, 4, 2, 1, 20, 2, 0))); } }

Example 6

Project: hwork   Author: Masebeni   File: PositionTest.scala View Source Project (license)

5 votes

package factories.position import domain.position.Position import org.joda.time.DateTime import org.scalatest.FunSuite class PositionTest extends FunSuite{ test("testCreatePosition")P val des = new PositionFactory; val date = new DateTime(2016, 10, 11, 5, 20, 0, 0); val values = Map("positionId" -> "1", "organisationId" -> "1", "code" -> "123", "title" -> "testPosition", "jobId" -> "1", "positionTypeId" -> "1", "description" -> "test Position", "supervisorId" -> "2", "state" -> "testState"); val posdes = des.createPosition(values, date); assert(posdes == Position(positionId = "1", positionTypeId = "1", organisationId = "1", code = "123", title = "testPosition", jobId = "1", description = "test Position", supervisorId = "2", state = "testState", date = new DateTime(2016, 10, 11, 5, 20, 0, 0)); }

Example 7

Project: sqs-kafka-connect   Author: ConnectedHomes   File: SQSSourceConnectorSuite.scala View Source Project (license)

5 votes

package com.hivehome.kafka.connect.sqs import org.scalatest.{FunSuite, Matchers} import scala.collection.JavaConverters._ class SQSSourceConnectorSuite extends FunSuite with Matchers { val connector = new SQSSourceConnector() val props = Map[String, String]( Conf.SourceSqsQueue -> "in", Conf.DestinationKafkaTopic -> "out" ).asJava test("should return task class") { connector.taskClass shouldEqual classOf[SQSSourceTask] } test("should return config def") { connector.config shouldEqual Conf.ConfigDef } test("should return successfully from start") { connector.start(props) } test("should create task configs") { connector.start(props) val maxTasks = 10 val taskConfigs = connector.taskConfigs(maxTasks).asScala taskConfigs should have size maxTasks taskConfigs foreach { taskConfig => taskConfig shouldEqual props } } }

Example 8

Project: sqs-kafka-connect   Author: ConnectedHomes   File: ConfSuite.scala View Source Project(license)

5 votes

package com.hivehome.kafka.connect.sqs import org.apache.kafka.connect.errors.ConnectException import org.scalatest.OptionValues._ import org.scalatest.TryValues._ import org.scalatest.{FunSuite, Matchers} class ConfSuite extends FunSuite with Matchers { private val UsEast = "us-east-1" private val EuWest = "eu-west-1" val mandatoryProps = Map[String, String]( Conf.SourceSqsQueue -> "in", Conf.DestinationKafkaTopic -> "out" ) val optionalProps = Map[String, String]( Conf.AwsKey -> "key", Conf.AwsSecret -> "secret", Conf.AwsRegion -> UsEast ) val allProps = mandatoryProps ++ optionalProps test("should parse all configurations from a map") { val tryConf = Conf.parse(allProps) val conf = tryConf.success.value conf.queueName.value shouldEqual "in" conf.topicName.value shouldEqual "out" conf.awsRegion shouldEqual UsEast conf.awsKey.value shouldEqual "key" conf.awsSecret.value shouldEqual "secret" } test("should parse mandatory configurations from a map") { val tryConf = Conf.parse(mandatoryProps) val conf = tryConf.success.value conf.queueName.value shouldEqual "in" conf.topicName.value shouldEqual "out" conf.awsRegion shouldEqual EuWest } test("should fail when mandatory config is missing") { val tryConf = Conf.parse(Map()) tryConf.failure.exception.getClass shouldBe classOf[ConnectException] } }

Example 9

Project: sqs-kafka-connect   Author: ConnectedHomes   File: E2ESpec.scala View Source Project(license)

5 votes

package com.hivehome.kafka.connect.sqs import java.time.Instant import org.scalatest.{FunSuite, Matchers} import org.slf4j.LoggerFactory import scala.concurrent.ExecutionContext.Implicits.global import scala.concurrent.Future class E2ESpec extends FunSuite with Matchers with SQSSupport { val logger = LoggerFactory.getLogger(getClass.getName) private val KafkaTopic: String = "connect-test" override val queueName = "test-sqs" // kafka connect should be setup with this SQS queueUrl = sqs.getQueueUrl(queueName).getQueueUrl private val props = Map( "bootstrap.servers" -> sys.env.getOrElse("KAFKA", "localhost:9092"), "schema.registry.url" -> sys.env.getOrElse("SCHEMA_REGISTRY", "http://localhost:8081")) val consumer = KafkaAvroConsumer[String, String](props, topicName = KafkaTopic) // Test is ignored because it does not run without dependent services ignore("should route message SQS -> Kafka") { Future { // sleep is required so that the message to SQS // is sent after the consumer is listening on the kafka topic Thread.sleep(500) logger.debug("sending message..") sendMessage(Instant.now().toString) logger.debug("sent message..") } val msgs = consumer.poll(1, accept = _ => true) msgs should have size 1 } }

Example 10

Project: progfun_assignments   Author: letalvoj   File: HuffmanSuite.scala View Source Project (license)

5 votes

package patmat import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner import org.scalatest.{FunSuite, ShouldMatchers} import patmat.Huffman._ @RunWith(classOf[JUnitRunner]) class HuffmanSuite extends FunSuite with ShouldMatchers { trait TestTrees { val t1 = Fork(Leaf('a',2), Leaf('b',3), List('a','b'), 5) val t2 = Fork(Fork(Leaf('a',2), Leaf('b',3), List('a','b'), 5), Leaf('d',4), List('a','b','d'), 9) } test("weight of a larger tree") { new TestTrees { weight(t1) should be(5) } } test("chars of a larger tree") { new TestTrees { chars(t2) should be(List('a', 'b', 'd')) } } test("string2chars(\"hello, world\")") { string2Chars("hello, world") should be(List('h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd')) } test("makeOrderedLeafList for some frequency table") { makeOrderedLeafList(List(('t', 2), ('e', 1), ('x', 3))) should be(List(Leaf('e', 1), Leaf('t', 2), Leaf('x', 3))) } test("combine of some leaf list") { val leaflist = List(Leaf('e', 1), Leaf('t', 2), Leaf('x', 4)) combine(leaflist) should be(List(Fork(Leaf('e', 1), Leaf('t', 2), List('e', 't'), 3), Leaf('x', 4))) } test("decode and encode a very short text should be identity") { val fc = Huffman.frenchCode decode(fc, encode(fc)("letsmakeitmorecomplicated".toList)) should be("letsmakeitmorecomplicated".toList) } }

Example 11

Project: progfun_assignments   Author: letalvoj   File: PascalSuite.scala View Source Project (license)

5 votes

package recfun import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class PascalSuite extends FunSuite { import Week1.pascal test("pascal: col=0,row=2") { assert(pascal(0,2) === 1) } test("pascal: col=1,row=2") { assert(pascal(1,2) === 2) } test("pascal: col=1,row=3") { assert(pascal(1,3) === 3) } }

Example 12

Project: progfun_assignments   Author: letalvoj   File: BalanceSuite.scala View Source Project (license)

5 votes

package recfun import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class BalanceSuite extends FunSuite { import Week1.balance test("balance: '(if (zero? x) max (/ 1 x))' is balanced") { assert(balance("(if (zero? x) max (/ 1 x))".toList)) } test("balance: 'I told him ...' is balanced") { assert(balance("I told him (that it's not (yet) done).\n(But he wasn't listening)".toList)) } test("balance: ':-)' is unbalanced") { assert(!balance(":-)".toList)) } test("balance: counting is not enough") { assert(!balance("())(".toList)) } }

Example 13

Project: progfun_assignments   Author: letalvoj   File: CountChangeSuite.scala View Source Project(license)

5 votes

package recfun import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner import org.scalatest.{FunSuite, ShouldMatchers} @RunWith(classOf[JUnitRunner]) class CountChangeSuite extends FunSuite with ShouldMatchers { import Week1.countChange test("countChange: example given in instructions") { countChange(4, List(1, 2)) should be(3) } test("countChange: sorted CHF") { countChange(300, List(5, 10, 20, 50, 100, 200, 500)) should be(1022) } test("countChange: no pennies") { countChange(301, List(5, 10, 20, 50, 100, 200, 500)) should be(0) } test("countChange: unsorted CHF") { countChange(300, List(500, 5, 50, 100, 20, 200, 10)) should be(1022) } }

Example 14

Project: scala-course-one   Author: mumukiller   File: PascalSuite.scala View Source Project (license)

5 votes

package functions import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class PascalSuite extends FunSuite { import Main.pascal test("pascal: col=0,row=2") { assert(pascal(0,2) === 1) } test("pascal: col=1,row=2") { assert(pascal(1,2) === 2) } test("pascal: col=1,row=3") { assert(pascal(1,3) === 3) } }

Example 15

Project: scalajs-frogger   Author: wjsrobertson   File: TiledLayerTest.scala View Source Project (license)

5 votes

package net.xylophones.frogger import org.junit.runner.RunWith import org.scalajs.dom.raw.HTMLImageElement import org.scalatest.junit.JUnitRunner import org.scalatest.mockito.MockitoSugar import org.scalatest.{BeforeAndAfterEach, FunSuite, Matchers} import org.mockito.Mockito._ @RunWith(classOf[JUnitRunner]) class TiledLayerTest extends FunSuite with Matchers with MockitoSugar with BeforeAndAfterEach { val htmlImage = mock[HTMLImageElement] val image = new Image(htmlImage) when(htmlImage.width).thenReturn(20) when(htmlImage.height).thenReturn(10) val tiledImage = new TiledImage(image, 10, 10) val tiles = Array(Array(Tile(0, 0, CellType.Deadly), Tile(1, 0, CellType.Deadly))) val underTest = new TiledLayer(tiledImage, 1, 2, tiles) test("TiledLayer contains Rectangles with correct local offset") { val rects = underTest.rectangles rects.size shouldBe 2 rects.head.x shouldBe 0 rects.head.y shouldBe 0 rects.last.x shouldBe 10 rects.last.y shouldBe 0 } }

Example 16

Project: markovMovieCritic   Author: tammosminia   File: TokensTest.scala View Source Project(license)

5 votes

package markov import org.scalatest.FunSuite import Tokens._ class TokensTest extends FunSuite { val helloTokens = List(StartToken, WordToken("hello"), EndSentence, EndToken) val helloWorldTokens = List(StartToken, WordToken("hello"), WordToken("world"), EndSentence, EndToken) val endWithDot = List(StartToken, WordToken("end"), WordToken("with"), WordToken("dot"), EndSentence, EndToken) val twoLinesTokens = List(StartToken, WordToken("first"), WordToken("line"), EndSentence, WordToken("second"), WordToken("line"), EndSentence, EndToken) test("tokenize") { assert(tokenize("hello") === helloTokens) assert(tokenize("Hello world!") === helloWorldTokens) assert(tokenize("End with dot.") === endWithDot) assert(tokenize("First line. Second line.") === twoLinesTokens) assert(tokenize("First line.\n Second line.\n") === twoLinesTokens) } test("tokensToString") { assert(tokensToString(helloTokens) === "Hello.") assert(tokensToString(helloWorldTokens) === "Hello world.") assert(tokensToString(endWithDot) === "End with dot.") assert(tokensToString(twoLinesTokens) === "First line. Second line.") } test("multiple dots") { assert(tokenize("first line .. second line") === twoLinesTokens) assert(tokenize("first line ..... second line......") === twoLinesTokens) } test("weird spacing") { assert(tokenize("hello ") === helloTokens) assert(tokenize("hello ") === helloTokens) assert(tokenize(" hello") === helloTokens) assert(tokenize(" hello") === helloTokens) assert(tokenize(" hello ") === helloTokens) assert(tokenize(" ") === List(StartToken, EndSentence, EndToken)) assert(tokenize(" ") === List(StartToken, EndSentence, EndToken)) assert(tokenize(" . ") === List(StartToken, EndSentence, EndToken)) assert(tokenize("first line . . second line") === twoLinesTokens) } }

Example 17

Project: ToSidewalk   Author: kotarohara   File: StreetNodeTableTest.scala View Source Project(license)

5 votes

package tosidewalk.model import org.scalatest.FunSuite import tosidewalk.model.connection.H2DBComponent import org.scalatest.concurrent.ScalaFutures import org.scalatest.time.{Millis, Seconds, Span} import geotrellis.vector.Point import slick.lifted.TableQuery class StreetNodeTableTest extends FunSuite with StreetNodeRepository with H2DBComponent with ScalaFutures { implicit val defaultPatience = PatienceConfig(timeout = Span(5, Seconds), interval = Span(500, Millis)) test("Add new street node") { val node = StreetNode(1, Point(1.0, 1.0).jtsGeom) var response = insertStreetNode(node) whenReady(response) { nodeId => assert(nodeId === 2) } } }

Example 18

Project: scalatour   Author: bobxwang   File: ConfigTest.scala View Source Project (license)

5 votes

package com.bob.scalatour.configs import com.typesafe.config._ import org.scalatest.FunSuite class ConfigTest extends FunSuite { test("load config") { val config = ConfigFactory.load("config.conf") assert(config.getString("app.name") == "scalatour") assert(config.getString("app.db.url") == "jdbc:h2:mem:test;INIT=bbtest FROM 'classpath:ddl.sql") assert(config.getString("app.db.driver") == "org.h2.Driver") assert(config.getString("app.http.host") == "0.0.0.0") assert(config.getInt("app.http.port") == 9999) } }

Example 19

Project: scalatour   Author: bobxwang   File: AsyncTest.scala View Source Project (license)

5 votes

package com.bob.scalatour.futures import org.scalatest.FunSuite import scala.async.Async._ import scala.concurrent.ExecutionContext import scala.util.{Failure, Success} class AsyncTest extends FunSuite { implicit val ec = ExecutionContext.global test("sequential") { val future = async { val futureOne = async { 1 } val futureTwo = async { 2 } await(futureOne) + await(futureTwo) } future onComplete { case Success(result) => assert(result == 3) case Failure(failure) => throw failure } } test("parallel") { val futureOne = async { 1 } val futureTwo = async { 2 } val futureThree = async { await(futureOne) + await(futureTwo) } futureThree onComplete { case Success(result) => assert(result == 3) case Failure(failure) => throw failure } } }

Example 20

Project: graphic-calculator   Author: typeness   File: LexerTest.scala View Source Project (license)

5 votes

package io.github.typeness.graphiccalculator import org.scalatest.FunSuite class LexerTest extends FunSuite { test("Tokenize 2x") { val f = "2x" val lexer = new Lexer(f) assert(lexer.tokenize == List(NumberToken(2.0), LiteralToken('x'), EOFToken)) } test("Tokenize x + x") { val f = "x + x" val lexer = new Lexer(f) assert(lexer.tokenize == List(LiteralToken('x'), PlusToken, LiteralToken('x'), EOFToken)) } test("Tokenize x*x*x") { val f = "x*x*x" val lexer = new Lexer(f) assert(lexer.tokenize == List( LiteralToken('x'), MultiplicationToken, LiteralToken('x'), MultiplicationToken, LiteralToken('x'), EOFToken) ) } test("Tokenize x ^ 2+2x+ 1") { val f = "x ^ 2+2x+ 1" val lexer = new Lexer(f) assert(lexer.tokenize == List( LiteralToken('x'), PowerToken, NumberToken(2.0), PlusToken, NumberToken(2.0), LiteralToken('x'), PlusToken, NumberToken(1.0), EOFToken )) } }

Example 21

Project: coursera   Author: syhan   File: VisualizationTest.scala View Source Project (license)

5 votes

package observatory import org.junit.runner.RunWith import org.scalatest.FunSuite import org.scalatest.junit.JUnitRunner import org.scalatest.prop.Checkers import observatory.Visualization._ import observatory.Extraction._ @RunWith(classOf[JUnitRunner]) class VisualizationTest extends FunSuite with Checkers { test("should interpolate color correctly") { val c = interpolateColor(List((0.0, Color(255, 0, 0)), (2.147483647E9, Color(0, 0, 255))), 5.3687091175E8) assert(c.red === 191) assert(c.green === 0) assert(c.blue === 64) } test("exceeding the greatest value of a color scale should return the color associated with the greatest value") { val c = interpolateColor(List((-1.0,Color(255, 0, 0)), (15.39640384017234, Color(0,0,255))), 25.39640384017234) assert(c.red === 0) assert(c.green === 0) assert(c.blue === 255) } test("should predicate temperature correctly") { val t1 = predictTemperature(List((Location(0, 0), 10), (Location(-45, 90), 40)), Location(0, 0.001)) val t2 = predictTemperature(List((Location(0, 0), 10), (Location(-45, 90), 40)), Location(-45, 90.001)) val t3 = predictTemperature(List((Location(0, 0), 10), (Location(-45, 90), 40)), Location(-45, 90)) println(t1) println(t2) assert(t3 === 40) } test("should output a image by given year correctly") { val colors: List[(Double, Color)] = List((60.0, Color(255, 255, 255)), (32.0, Color(255, 0, 0)), (12.0, Color(255, 255, 0)), (0, Color(0, 255, 255)), (-15.0, Color(0, 0, 255)), (-27.0, Color(255, 0, 255)), (-50.0, Color(33, 0, 107)), (-60.0, Color(0, 0, 0))) val locations = locationYearlyAverageRecords(locateTemperatures(1986, "/stations.csv", "/1986.csv")) //val locations = List((Location(0, 0), 10d), (Location(-45, 90), 40d)) val img = visualize(locations, colors) img.output(new java.io.File("output.png"))}}

Example 22

Project: coursera   Author: syhan   File: ExtractionTest.scala View Source Project (license)

5 votes

package observatory import org.junit.runner.RunWith import org.scalatest.FunSuite import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class ExtractionTest extends FunSuite { test("locateTemperature should work with given year") { val temp = Extraction.locateTemperatures(1986, "/stations.csv", "/1986.csv") assert(temp.size == 2429828) } test("locationYearlyAverageRecords should work with given year") { val temp = Extraction.locateTemperatures(1986, "/stations.csv", "/1986.csv") val avg = Extraction.locationYearlyAverageRecords(temp) assert(avg.size == 8755) } }

Example 23

Project: coursera   Author: syhan   File: StackOverflowSuite.scala View Source Project (license)

5 votes

package stackoverflow import org.scalatest.{FunSuite, BeforeAndAfterAll} import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.SparkContext._ import org.apache.spark.rdd.RDD import java.io.File @RunWith(classOf[JUnitRunner]) class StackOverflowSuite extends FunSuite with BeforeAndAfterAll { lazy val testObject = new StackOverflow { override val langs = List( "JavaScript", "Java", "PHP", "Python", "C#", "C++", "Ruby", "CSS", "Objective-C", "Perl", "Scala", "Haskell", "MATLAB", "Clojure", "Groovy") override def langSpread = 50000 override def kmeansKernels = 45 override def kmeansEta: Double = 20.0D override def kmeansMaxIterations = 120 } test("testObject can be instantiated") { val instantiatable = try { testObject true } catch { case _: Throwable => false } assert(instantiatable, "Can't instantiate a StackOverflow object") } }

Example 24

Project: EnterpriseStreamingBenchmark   Author: BenReissaus   File: Statistics$Test.scala View Source Project (license)

5 votes

package org.hpi.esb.flink.utils import org.scalatest.{BeforeAndAfter, FunSuite} class Statistics$Test extends FunSuite with BeforeAndAfter { test("testFold - Happy List") { val elements: Seq[Long] = Seq(1,2,3,8,9) val results = elements.foldLeft(new Statistics())(Statistics.fold) assert(results.min === 1) assert(results.max === 9) assert(results.avg === 4.6) assert(results.sum === 23) assert(results.count === 5) } test("testFold - Empty List") { val elements: Seq[Long] = Seq() val results = elements.foldLeft(new Statistics())(Statistics.fold) assert(results.min === Long.MaxValue) assert(results.max === Long.MinValue) assert(results.avg === 0) assert(results.sum === 0) assert(results.count === 0) } test("testFold - One element list") { val elements: Seq[Long] = Seq(0, 0, 0, 0) val results = elements.foldLeft(new Statistics())(Statistics.fold) assert(results.min === 0) assert(results.max === 0) assert(results.avg === 0) assert(results.sum === 0) assert(results.count === 4) } }

Example 25

Project: EnterpriseStreamingBenchmark   Author: BenReissaus   File: TopicManagementTest.scalaView Source Project (license)

5 votes

package org.hpi.esb.util import org.scalatest.FunSuite import org.scalatest.mockito.MockitoSugar import scala.collection.mutable class TopicManagementTest extends FunSuite with MockitoSugar { test("testGetMatchingTopics") { val topicsToDelete = mutable.Buffer("ESB_IN_0", "ESB_OUT_O", "ESB_STATISTICS_0") val topicsToKeep = mutable.Buffer("esb_new_IN_0", "esb_new_OUT_0", "esb_new_STATISTICS_0", "topic1", "topic2") val allTopics = topicsToDelete ++ topicsToKeep val prefix = "ESB_" assert(allTopics.containsSlice(topicsToDelete)) assert(allTopics.containsSlice(topicsToKeep)) assert(allTopics.size == topicsToDelete.size + topicsToKeep.size) assert(TopicManagement.getMatchingTopics(allTopics, prefix) == topicsToDelete) } }

Example 26

Project: ScalaJSWithXML   Author: sonumehrotra   File: ApplicationTest.scala View Source Project(license)

5 votes

import controllers.Application import org.scalatest.FunSuite class ApplicationTest extends FunSuite { val testObject = new Application test("correct number of warnings") { val result = testObject.findScalastyleWarnings("/home/knoldus/WebPage") assert(result === "20") } test("File not found") { val result = testObject.findScalastyleWarnings("/home/knoldus/WebPag") assert("N/A" === result) } test("Paths exist in app.conf") { val result = testObject.findProjectPathsFromConfig assert(result === Array("/home/knoldus/WebPage", "/home/knoldus/Desktop/PlayScalaJsShowcase/play-scalajs-showcase", "/home/knoldus/Desktop/PlayScalaJsShowcase/play-scalajs-showcas", "/home/knoldus/RahulSonuPlayTest")) } test("Code analysis details") { val result = testObject.findScapegoatWarnings("/home/knoldus/WebPage") assert(List("warns = 12", "errors = 3", "infos = 23") === result) } test("Test coverage details") { val result = testObject.findScoverageReport("/home/knoldus/WebPage") assert("Statement Coverage = 73.08, Branch Coverage = 41.46" === result) } test("Copy Paste Detector details") { val result = testObject.findCopyPasteDetectorReport("/home/knoldus/WebPage") assert("17 Files" === result) } }

Example 27

Project: SANSA-OWL   Author: SANSA-Stack   File: FunctionalSyntaxOWLExpressionsRDDBuilderTest.scala View Source Project (license)

5 votes

package net.sansa_stack.owl.spark.rdd import com.holdenkarau.spark.testing.SharedSparkContext import org.scalatest.FunSuite class FunctionalSyntaxOWLExpressionsRDDBuilderTest extends FunSuite with SharedSparkContext { var _rdd: OWLExpressionsRDD = null def rdd = { if (_rdd == null) { _rdd = FunctionalSyntaxOWLExpressionsRDDBuilder.build( sc, "src/test/resources/ont_functional.owl") _rdd.cache() } _rdd } test("There should be three annotation lines with full URIs") { val res = rdd.filter(line => line.startsWith("Annotation(")).collect() val expected = List( "Annotation(<http://ex.com/foo#hasName> \"Name\")", "Annotation(<http://ex.com/bar#hasTitle> \"Title\")", """Annotation(<http://ex.com/default#description> "A longer description running over several lines")""") assert(res.length == 3) for (e <- expected) { assert(res.contains(e)) } } // test("There should be an import statement") { // val res = rdd.filter(line => line.startsWith("Import")).collect() // assert(res.length == 1) // assert(res(0) == "Import(<http://www.example.com/my/2.0>)") // } test("There should not be any empty lines") { val res = rdd.filter(line => line.trim.isEmpty).collect() assert(res.length == 0) } test("There should not be any comment lines") { val res = rdd.filter(line => line.trim.startsWith("#")).collect() assert(res.length == 0) } test("There should be a DisjointObjectProperties axiom") { val res = rdd.filter(line => line.trim.startsWith("DisjointObjectProperties")).collect() assert(res.length == 1) } test("The total number of axioms should be correct") { val total = 70 // = 71 - uncommented Import(...) assert(rdd.count() == total) } }

Example 28

Project: openhub-source-search-engine   Author: mendozagabe1618   File: ParseTest.scala View Source Project (license)

5 votes

package cloud.hw.util import org.scalatest.FunSuite class ParseTest extends FunSuite { test("A parser must extract a download URL") { val correctMeta = Map( "downloadUrl" -> "http://github.com/vslavik/xmlwrapp/downloads", "projectName" -> "xmlwrapp", "tags" -> "c++,xslt,xml") assertResult(correctMeta) { OpenHubMetadataFetcher.forUrl("file:src/test/resources/response.xml") } } }

Example 29

Project: coursera-parprog1   Author: federicobozzini   File: ParallelParenthesesBalancingSuite.scalaView Source Project (license)

5 votes

package reductions import java.util.concurrent._ import scala.collection._ import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner import common._ import ParallelParenthesesBalancing._ @RunWith(classOf[JUnitRunner]) class ParallelParenthesesBalancingSuite extends FunSuite { test("balance should work for empty string") { def check(input: String, expected: Boolean) = assert(balance(input.toArray) == expected, s"balance($input) should be $expected") check("", true) } test("balance should work for string of length 1") { def check(input: String, expected: Boolean) = assert(balance(input.toArray) == expected, s"balance($input) should be $expected") check("(", false) check(")", false) check(".", true) } test("balance should work for string of length 2") { def check(input: String, expected: Boolean) = assert(balance(input.toArray) == expected, s"balance($input) should be $expected") check("()", true) check(")(", false) check("((", false) check("))", false) check(".)", false) check(".(", false) check("(.", false) check(").", false) check("(((()()())).", false) check("(())))(()()())).", false) check("(())(()()()).", true) check("(((())()()()())).", true) check("(((((()()()())))()())).", true) } }

Example 30

Project: high-performance-spark   Author: gourimahapatra   File: DStreamSuite.scala View Source Project (license)

5 votes

package com.highperformancespark.examples.streaming import org.apache.spark.streaming._ import java.lang.Thread import com.holdenkarau.spark.testing._ import org.scalatest.FunSuite class DStreamExamplesSuite extends FunSuite with SharedSparkContext { test("simple set up") { val ssc = DStreamExamples.makeStreamingContext(sc) val inputStream = DStreamExamples.fileAPIExample(ssc, "./") val repartitioned = DStreamExamples.repartition(inputStream) repartitioned.foreachRDD(rdd => assert(rdd.partitioner.get.numPartitions == 20) ) ssc.start() // This is bad don't do this - but we don't have the full test tools here Thread.sleep(100) ssc.stop() } }

Example 31

Project: high-performance-spark   Author: gourimahapatra   File: NativeExample.scala View Source Project (license)

5 votes

package com.highperformancespark.examples.ffi import com.holdenkarau.spark.testing._ import org.scalacheck.{Arbitrary, Gen} import org.scalacheck.Prop.forAll import org.scalatest.FunSuite import org.scalatest.prop.Checkers import org.scalatest.Matchers._ class NativeExampleSuite extends FunSuite with SharedSparkContext with Checkers with RDDComparisons { test("local sum") { val input = Array(1, 2, 3) val sumMagic = new SumJNI() val result = sumMagic.sum(input) val expected = 6 assert(result === expected) } test("super simple test") { val input = sc.parallelize(List(("hi", Array(1, 2, 3)))) val result = NativeExample.jniSum(input).collect() val expected = List(("hi", 6)) assert(result === expected) } test("native call should find sum correctly") { val property = forAll( RDDGenerator.genRDD[(String, Array[Int])](sc)( Arbitrary.arbitrary[(String, Array[Int])])) { rdd => val expected = rdd.mapValues(_.sum) val result = NativeExample.jniSum(rdd) compareRDDWithOrder(expected, result).isEmpty } check(property) } test("JNA support") { val input = Array(1, 2, 3) assert(6 === SumJNA.sum(input, input.size)) } test("JNA Fortran support") { val input = Array(1, 2, 3) assert(6 === SumFJNA.easySum(input.size, input)) } }

Example 32

Project: high-performance-spark   Author: gourimahapatra   File: FilterInvalidPandasSuite.scala View Source Project (license)

5 votes

package com.highperformancespark.examples.tools import com.highperformancespark.examples.dataframe.RawPanda import com.holdenkarau.spark.testing._ import org.scalatest.FunSuite class FilterInvalidPandasSuite extends FunSuite with SharedSparkContext { test("simple filter") { val invalidPandas = List(1L, 2L) val inputPandas = List( RawPanda(1L, "94110", "giant", true, Array(0.0)), RawPanda(3L, "94110", "giant", true, Array(0.0))) val input = sc.parallelize(inputPandas) val result1 = FilterInvalidPandas.filterInvalidPandas(sc, invalidPandas, input) val result2 = FilterInvalidPandas.filterInvalidPandasWithLogs(sc, invalidPandas, input) assert(result1.collect() === result2.collect()) assert(result1.count() === 1) } }

Example 33

Project: high-performance-spark   Author: gourimahapatra   File: GenerateScalingDataSuite.scala View Source Project (license)

5 votes

package com.highperformancespark.examples.tools import com.highperformancespark.examples.dataframe.RawPanda import com.holdenkarau.spark.testing._ import org.scalatest.FunSuite class GeneratescalaingDataSuite extends FunSuite with SharedSparkContext { // The number of entries depends somewhat on the partition split because we // zip multiple separate RDDs so its more of a "request" test("expected num entries") { val result = GenerateScalingData.generateFullGoldilocks(sc, 10L, 20) assert(result.count() <= 10) assert(result.count() > 5) assert(result.map(_.id).distinct().count() > 1) } test("expected num entries same id") { val result = GenerateScalingData.generateGoldilocks(sc, 5L, 20) assert(result.count() <= 5) assert(result.count() >= 2) assert(result.map(_.id).distinct().count() == 1) } test("mini scale data") { val result = GenerateScalingData.generateMiniScale(sc, 20L, 1) assert(result.count() <= 20) assert(result.count() > 5) assert(result.map(_._1).distinct().count() > 1) } test("mini scale rows") { val result = GenerateScalingData.generateMiniScaleRows(sc, 20L, 1) assert(result.count() <= 20) assert(result.count() > 5) assert(result.map(_(0)).distinct().count() > 1) } }

Example 34

Project: high-performance-spark   Author: gourimahapatra   File: GoldilocksMLlibSuite.scala View Source Project (license)

5 votes

package com.highperformancespark.examples.mllib import com.highperformancespark.examples.dataframe.RawPanda import com.holdenkarau.spark.testing._ import org.scalatest.FunSuite import org.apache.spark.mllib.linalg.{Vector => SparkVector} class GoldilocksMLlibSuite extends FunSuite with SharedSparkContext { val rps = List( RawPanda(1L, "94110", "giant", true, Array(0.0, 0.0)), RawPanda(2L, "94110", "giant", false, Array(0.0, 3.0)), RawPanda(3L, "94110", "giant", true, Array(0.0, 2.0))) test("boolean to double") { assert(1.0 === GoldilocksMLlib.booleanToDouble(true)) assert(0.0 === GoldilocksMLlib.booleanToDouble(false)) } test("encoding") { val input = sc.parallelize(rps) val points = GoldilocksMLlib.toLabeledPointDense(input) assert(points.count() == 3) assert(points.filter(_.label != 0.0).count() == 2) } test("lookup table") { val input = sc.parallelize(List("hi", "bye", "coffee", "hi")) val table = GoldilocksMLlib.createLabelLookup(input) assert(table.size == 3) } }

Example 35

Project: parprog   Author: TraitRDS   File: ParallelParenthesesBalancingSuite.scala View Source Project(license)

5 votes

package reductions import java.util.concurrent._ import scala.collection._ import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner import common._ import ParallelParenthesesBalancing._ @RunWith(classOf[JUnitRunner]) class ParallelParenthesesBalancingSuite extends FunSuite { test("balance should work for empty string") { def check(input: String, expected: Boolean) = assert(balance(input.toArray) == expected, s"balance($input) should be $expected") check("", true) } test("balance should work for string of length 1") { def check(input: String, expected: Boolean) = assert(balance(input.toArray) == expected, s"balance($input) should be $expected") check("(", false) check(")", false) check(".", true) } test("balance should work for string of length 2") { def check(input: String, expected: Boolean) = assert(balance(input.toArray) == expected, s"balance($input) should be $expected") check("()", true) check(")(", false) check("((", false) check("))", false) check(".)", false) check(".(", false) check("(.", false) check(").", false) } }

Example 36

Project: my-scala-playground   Author: rysh   File: MyS3ObjectTest.scala View Source Project (license)

5 votes

package example import better.files.File import org.scalatest.{BeforeAndAfterAll, FunSuite} class MyS3ObjectTest extends FunSuite with BeforeAndAfterAll { val s3 = MyS3.create() val bucketName = s"rysh-${localName()}-my-s3-object-test" val file = File("my-s3-object-test").createIfNotExists() override def beforeAll() { val bucket = s3.createBucket(bucketName) } override def afterAll() { file.delete() s3.deleteBucket(bucketName) } test("Upload an Object") { s3.upload(bucketName, "my-s3-object-test", file) } ignore("List Objects") { ??? } ignore("Download an Object") { ??? } ignore("Copy, Move, or Rename Objects") { ??? } ignore("Delete an Object") { ??? } ignore("Delete Multiple Objects at Once") { ??? } }

Example 37

Project: coursera-scala   Author: tklo   File: CountChangeSuite.scala View Source Project (license)

5 votes

package recfun import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class CountChangeSuite extends FunSuite { import Main.countChange test("countChange: example given in instructions") { assert(countChange(4,List(1,2)) === 3) } test("countChange: sorted CHF") { assert(countChange(300,List(5,10,20,50,100,200,500)) === 1022) } test("countChange: no pennies") { assert(countChange(301,List(5,10,20,50,100,200,500)) === 0) } test("countChange: unsorted CHF") { assert(countChange(300,List(500,5,50,100,20,200,10)) === 1022) } }

Example 38

Project: newts   Author: julien-truffaut   File: NewtsSuite.scala View Source Project (license)

5 votes

package newts import cats.instances.AllInstances import newts.syntax.AllSyntax import org.scalacheck.{Arbitrary, Cogen} import org.scalacheck.Arbitrary.arbitrary import org.scalatest.prop.GeneratorDrivenPropertyChecks import org.scalatest.{FunSuite, Matchers} import org.typelevel.discipline.scalatest.Discipline trait NewtsSuite extends FunSuite with Matchers with GeneratorDrivenPropertyChecks with Discipline with AllSyntax with AllInstances with cats.syntax.AllSyntax with ArbitraryInstances trait ArbitraryInstances { def arbNewtype[S, A: Arbitrary](implicit newtype: Newtype.Aux[S, A]): Arbitrary[S] = Arbitrary(arbitrary[A].map(newtype.wrap)) def cogenNewtype[S, A: Cogen](implicit newtype: Newtype.Aux[S, A]): Cogen[S] = Cogen[A].contramap(newtype.unwrap) implicit val allArbitrary: Arbitrary[All] = arbNewtype[All, Boolean] implicit val anyArbitrary: Arbitrary[Any] = arbNewtype[Any, Boolean] implicit def multArbitrary[A:Arbitrary]: Arbitrary[Mult[A]] = arbNewtype[Mult[A], A] implicit def dualArbitrary[A: Arbitrary]: Arbitrary[Dual[A]] = arbNewtype[Dual[A], A] implicit def firstArbitrary[A: Arbitrary]: Arbitrary[First[A]] = arbNewtype[First[A], A] implicit def lastArbitrary[A: Arbitrary]: Arbitrary[Last[A]] = arbNewtype[Last[A], A] implicit def firstOptionArbitrary[A: Arbitrary]: Arbitrary[FirstOption[A]] = arbNewtype[FirstOption[A], Option[A]] implicit def lastOptionArbitrary[A: Arbitrary]: Arbitrary[LastOption[A]] = arbNewtype[LastOption[A], Option[A]] implicit def minArbitrary[A: Arbitrary]: Arbitrary[Min[A]] = arbNewtype[Min[A], A] implicit def maxArbitrary[A: Arbitrary]: Arbitrary[Max[A]] = arbNewtype[Max[A], A] implicit def zipListArbitrary[A: Arbitrary]: Arbitrary[ZipList[A]] = arbNewtype[ZipList[A], List[A]] implicit val allCogen: Cogen[All] = cogenNewtype[All, Boolean]implicit val anyCogen:Cogen[Any]= cogenNewtype[Any,Boolean]implicitdef multCogen[A:Cogen]:Cogen[Mult[A]]= cogenNewtype[Mult[A], A]implicitdef dualCogen[A:Cogen]:Cogen[Dual[A]]= cogenNewtype[Dual[A], A]implicitdef firstCogen[A:Cogen]:Cogen[First[A]]= cogenNewtype[First[A], A]implicitdef lastCogen[A:Cogen]:Cogen[Last[A]]= cogenNewtype[Last[A], A]implicitdef firstOptionCogen[A:Cogen]:Cogen[FirstOption[A]]= cogenNewtype[FirstOption[A],Option[A]]implicitdef lastOptionCogen[A:Cogen]:Cogen[LastOption[A]]= cogenNewtype[LastOption[A],Option[A]]implicitdef minOptionCogen[A:Cogen]:Cogen[Min[A]]= cogenNewtype[Min[A], A]implicitdef maxOptionCogen[A:Cogen]:Cogen[Max[A]]= cogenNewtype[Max[A], A]implicitdef zipListCogen[A:Cogen]:Cogen[ZipList[A]]= cogenNewtype[ZipList[A],List[A]]}

Example 39

Project: bittorrent   Author: zpooky   File: TorrentFileManager_LargeFile.scala View Source Project(license)

5 votes

package com.spooky.bittorrent.l.file import org.scalatest.FunSuite import java.io.File import com.spooky.bittorrent.metainfo.Torrents import java.nio.file.Paths class TorrentFileManagerTest_LargeFile extends FunSuite { val file = new File("O:\\tmp\\file.dump.torrent") val torrent = Torrents(file) val root = Paths.get("O:\\tmp") lazy val stat = new FileInitiator2(torrent, root).state() test("xx") { val fm = TorrentFileManager(torrent, root, stat) } } object TorrentFileManagerTest_LargeFilex { val file = new File("O:\\tmp\\file.dump.torrent") val torrent = Torrents(file) val root = Paths.get("O:\\tmp") lazy val stat = new FileInitiator2(torrent, root).state() def main(args: Array[String]) { val fm = TorrentFileManager(torrent, root, stat) assert(fm.complete) } }

Example 40

Project: bittorrent   Author: zpooky   File: QueueTest.scala View Source Project (license)

5 votes

package com.spooky.bittorrent import org.scalatest.FunSuite import scala.collection.mutable.Queue class QueueTest extends FunSuite { test("t") { val q = Queue[Int]() q += 1 q += 2 q += 3 q += 4 q += 5 Range(0, q.length).foreach { _ => q.dequeue() } println("size:" + q.size) } }

Example 41

Project: bittorrent   Author: zpooky   File: MonadTest.scala View Source Project (license)

5 votes

package com.spooky.bittorrent import org.scalatest.FunSuite class MonadTest extends FunSuite { implicit def toOption[T](any: T): Option[T] = Option(any) var c = 0 def func: Option[String] = c match { case 0 => { c = c + 1 "0" } case 1 => { c = c + 1 "1" } case 2 => { c = c + 1 "2" } case _ => None } test("") { val xsss = for { x <- func } yield x println(xsss) } }

Example 42

Project: bittorrent   Author: zpooky   File: BencodeMarshallTest.scala View Source Project (license)

5 votes

package com.spooky.bencode import org.scalatest.FunSuite class BencodeMarshallTest extends FunSuite { case class Tttt(s: String, i: Int) val m = new BencodeMarshall test("dd"){ val t = Tttt("ss",112) println(m.marshall(t)) } test("null"){ // println(m.marshall(null)) } }

Example 43

Project: bittorrent   Author: zpooky   File: RequestTest.scala View Source Project (license)

5 votes

package com.spooky import org.scalatest.FunSuite import com.spooky.DHT.PingQuery import com.spooky.bittorrent.InfoHash import com.spooky.bencode.BencodeMarshall class RequestTest extends FunSuite { //{"t":"aa", "y":"q", "q":"ping", "a":{"id":"abcdefghij0123456789"}} val m = new BencodeMarshall test("PingQuery") { val pingQuery = PingQuery(InfoHash.hex("abcdef0123456789"),"aa") val pq = m.marshall(pingQuery) println(pq) println(pq.toBencode) println(pingQuery.nodeId) } //{"t":"aa", "y":"r", "r": {"id":"mnopqrstuvwxyz123456"}} test("PingResponse") { } test("FindNodeQuery") { } test("FindNodeResponse") { } test("") { } test("GetPeersQuery") { } test("GetPeersResponse") { } test("AnnouncePeersQuery") { } test("AnnoucePeersResponse") { } test("ErrorResponse") { } }

Example 44

Project: coursera-funprog-scala-recursion-assignment   Author: jdehlinger   File: CountChangeSuite.scalaView Source Project (license)

5 votes

package recfun import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class CountChangeSuite extends FunSuite { import Main.countChange test("countChange: example given in instructions") { assert(countChange(4,List(1,2)) === 3) } test("countChange: sorted CHF") { assert(countChange(300,List(5,10,20,50,100,200,500)) === 1022) } test("countChange: no pennies") { assert(countChange(301,List(5,10,20,50,100,200,500)) === 0) } test("countChange: unsorted CHF") { assert(countChange(300,List(500,5,50,100,20,200,10)) === 1022) } }

Example 45

Project: scala-ing   Author: vr1090   File: ComplexProperties.scala View Source Project (license)

5 votes

// src/main/scala/progscala2/toolslibs/toolslibs/ComplexProperties.scala package progscala2.toolslibs import org.scalatest.FunSuite import org.scalatest.prop.PropertyChecks class ComplexProperties extends FunSuite with PropertyChecks { def additionTest(a: Complex, b: Complex) = { assert( (a + b).real === (a.real + b.real) ) assert( (a + b).imaginary === (a.imaginary + b.imaginary) ) } def subtractionTest(a: Complex, b: Complex) = { assert( (a - b).real === (a.real - b.real) ) assert( (a - b).imaginary === (a.imaginary - b.imaginary) ) } val zero = Complex(0.0, 0.0) test ("Complex addition with the identity element (zero)") { forAll { (real: Double, imag: Double) => val c = Complex(real, imag) additionTest(zero, c) additionTest(c, zero) } } test ("Complex subtraction with the identity element (zero)") { forAll { (real: Double, imag: Double) => val c = Complex(real, imag) subtractionTest(zero, c) subtractionTest(c, zero) } } test ("Complex addition with two values") { forAll { (real1: Double, imag1: Double, real2: Double, imag2: Double) => val c1 = Complex(real1, imag1) val c2 = Complex(real2, imag2) additionTest(c1, c2) } } test ("Complex subtraction with two values") { forAll { (real1: Double, imag1: Double, real2: Double, imag2: Double) => val c1 = Complex(real1, imag1) val c2 = Complex(real2, imag2) subtractionTest(c1, c2) } } }

Example 46

Project: sourceCode   Author: RominYue   File: CountChangeSuite.scala View Source Project (license)

5 votes

package recfun import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class CountChangeSuite extends FunSuite { import Main.countChange test("countChange: example given in instructions") { assert(countChange(4,List(1,2)) === 3) } test("countChange: sorted CHF") { assert(countChange(300,List(5,10,20,50,100,200,500)) === 1022) } test("countChange: no pennies") { assert(countChange(301,List(5,10,20,50,100,200,500)) === 0) } test("countChange: unsorted CHF") { assert(countChange(300,List(500,5,50,100,20,200,10)) === 1022) } }

Example 47

Project: CodeJam   Author: javathought   File: PancakeTest.scala View Source Project (license)

5 votes

package puzzle2016.q import org.junit.runner.RunWith import org.scalatest.FunSuite import org.scalatest.junit.JUnitRunner import Pancake._ @RunWith(classOf[JUnitRunner]) class PancakeTest extends FunSuite { test("Count Pankcake Jam is ok") { assert( ln(("-" toList) reverse) === 1, "solution for '-' is KO") assert( ln(("-+" toList) reverse) === 1, "solution for '-+' is KO") assert( ln(("+-" toList) reverse) === 2, "solution for '+-' is KO") assert( ln(("+++" toList) reverse) === 0, "solution for '+++' is KO") assert( ln(("--+-" toList) reverse) === 3, "solution for '--+-' is KO") } }

Example 48

Project: Parallelism-and-Concurrency-Assignments   Author: vincenzobaz   File: BoundedBufferSuite.scala View Source Project (license)

5 votes

package pubsub import scala.concurrent._ import scala.concurrent.duration._ import scala.concurrent.ExecutionContext.Implicits.global import scala.collection.mutable.HashMap import org.junit.runner.RunWith import org.scalatest.FunSuite import org.scalatest.junit.JUnitRunner import instrumentation._ import instrumentation.Stats._ import pubsub.collection._ @RunWith(classOf[JUnitRunner]) class BoundedBufferSuite extends FunSuite { import TestHelper._ import TestUtils._ test("Should work in a sequential setting") { val buffer = new BoundedBuffer[Int](4); buffer.put(1) buffer.put(2) buffer.put(3) buffer.put(4) assert(buffer.take() == 1) assert(buffer.take() == 2) assert(buffer.take() == 3) assert(buffer.take() == 4) } test("Should work when Thread 1: `put(1)`, Thread 2: `take` and a buffer of size 1") { testManySchedules(2, sched => { val prodCons = new SchedulableBoundedBuffer[Int](1, sched) List(() => prodCons.put(1), () => prodCons.take()) }, args => (args(1) == 1, s"expected 1 your `take` implementation returned ${args(1)}")) } } object TestUtils { def failsOrTimesOut[T](action: => T): Boolean = { val asyncAction = future { action } try { Await.result(asyncAction, 2000.millisecond) } catch { case _: Throwable => return true } return false } }

Example 49

Project: Parallelism-and-Concurrency-Assignments   Author: vincenzobaz   File: StackOverflowSuite.scala View Source Project (license)

5 votes

package stackoverflow import org.scalatest.{FunSuite, BeforeAndAfterAll} import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner import org.apache.spark.SparkConf import org.apache.spark.SparkContext import org.apache.spark.SparkContext._ import org.apache.spark.rdd.RDD import java.net.URL import java.nio.channels.Channels import java.io.File import java.io.FileOutputStream @RunWith(classOf[JUnitRunner]) class StackOverflowSuite extends FunSuite with BeforeAndAfterAll { lazy val testObject = new StackOverflow { override val langs = List( "JavaScript", "Java", "PHP", "Python", "C#", "C++", "Ruby", "CSS", "Objective-C", "Perl", "Scala", "Haskell", "MATLAB", "Clojure", "Groovy") override def langSpread = 50000 override def kmeansKernels = 45 override def kmeansEta: Double = 20.0D override def kmeansMaxIterations = 120 } test("testObject can be instantiated") { val instantiatable = try { testObject true } catch { case _: Throwable => false } assert(instantiatable, "Can't instantiate a StackOverflow object") } }

Example 50

Project: CakePatternPractise   Author: johnnyqian   File: UserServiceSuite.scala View Source Project(license)

5 votes

package CakePattern import org.scalatest.FunSuite import org.specs2.mock.Mockito class UserServiceSuite extends FunSuite with Mockito with UserServiceComponent with UserRepositoryComponent { lazy val userRepository = mock[UserRepository] lazy val userService = mock[UserService] val user = new User("test", "test") userRepository.authenticate(any[User]) returns user test("testAuthenticate") { assert(userRepository.authenticate(user) == user) } }

Example 51

Project: vo-ss-extractor   Author: oginskis   File: FlatRepoTest.scala View Source Project (license)

5 votes

package org.oginskis.ss.repo import org.bson.Document import org.junit.runner.RunWith import org.oginskis.ss.model.Flat import org.scalatest.FunSuite import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class FlatRepoTest extends FunSuite{ test("flat find filter test: All fields are set") { val flat = new Flat(Option("Caka 95"),Option("4"),Option(55), Option("1/5"),Option(30000),Option("link")) val doc: Document = FlatRepo.findFilter(flat) assert("Caka 95" === doc.get("address")) assert("4" === doc.get("rooms")) assert("55" === doc.get("size")) assert("1/5" === doc.get("floor")) assert("30000" === doc.get("price")) assert("link" === doc.get("link")) } test("flat find filter test: price and link are missing") { val flat = new Flat(Option("Caka 95"),Option("4"),Option(55), Option("1/5")) val doc: Document = FlatRepo.findFilter(flat) assert("Caka 95" === doc.get("address")) assert("4" === doc.get("rooms")) assert("55" === doc.get("size")) assert("1/5" === doc.get("floor")) assert(doc.get("price") === null) assert(doc.get("link") === null) } test("historic flats") { val flats : List[Flat] = FlatRepo.findHistoricAdds(new Flat(Option("Artil?rijas 46"),Option("1"), Option(29),Option("2/4"))) } }

Example 52

Project: pacttests   Author: PawelWlodarski   File: FirstPactExample.scala View Source Project (license)

5 votes

package com.wlodar.pactexample.first import com.wlodar.jug.pacttest.client.ServiceClient import org.scalatest.{FunSpec, FunSuite, Matchers} import scalaj.http.HttpResponse class FirstPactExample extends FunSuite with Matchers { import com.itv.scalapact.ScalaPactForger._ test("Pierwszy przyk?ad na demo") { forgePact .between("tenTutajKonsument") .and("uslugaZewnetrzna") .addInteraction( interaction .description("Prosty get bez parametrów") .uponReceiving("/apiUslugi") .willRespondWith(200, "Pact dzia?a!!!") ).runConsumerTest{config=> //pokaza? kod val result: HttpResponse[String] =ServiceClient.call(config.baseUrl,"apiUslugi") result.code shouldBe 200 result.body shouldBe "Pact dzia?a!!!" // result.body shouldBe "B??d" } } }

Example 53

Project: scala_specialization_coursera   Author: alvsanand   File: LineOfSightSuite.scala View Source Project (license)

5 votes

package reductions import java.util.concurrent._ import scala.collection._ import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner import common._ import java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory @RunWith(classOf[JUnitRunner]) class LineOfSightSuite extends FunSuite { import LineOfSight._ test("lineOfSight should correctly handle an array of size 4") { val output = new Array[Float](4) lineOfSight(Array[Float](0f, 1f, 8f, 9f), output) assert(output.toList == List(0f, 1f, 4f, 4f)) } test("upsweepSequential should correctly handle the chunk 1 until 4 of an array of 4 elements") { val res = upsweepSequential(Array[Float](0f, 1f, 8f, 9f), 1, 4) assert(res == 4f) } test("downsweepSequential should correctly handle a 4 element array when the starting angle is zero") { val output = new Array[Float](4) downsweepSequential(Array[Float](0f, 1f, 8f, 9f), output, 0f, 1, 4) assert(output.toList == List(0f, 1f, 4f, 4f)) } test("parLineOfSight should correctly handle an array of size 4") { val output = new Array[Float](4) parLineOfSight(Array[Float](0f, 1f, 8f, 9f), output, 1) assert(output.toList == List(0f, 1f, 4f, 4f)) } }

Example 54

Project: scala_specialization_coursera   Author: alvsanand   File: CountChangeSuite.scala View Source Project (license)

5 votes

package recfun import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class CountChangeSuite extends FunSuite { import Main.countChange test("countChange: example given in instructions") { assert(countChange(4,List(1,2)) === 3) } test("countChange: sorted CHF") { assert(countChange(300,List(5,10,20,50,100,200,500)) === 1022) } test("countChange: no pennies") { assert(countChange(301,List(5,10,20,50,100,200,500)) === 0) } test("countChange: unsorted CHF") { assert(countChange(300,List(500,5,50,100,20,200,10)) === 1022) } }

Example 55

Project: BigDataMaker   Author: dondrake   File: TestColumns.scala View Source Project (license)

5 votes

package com.drakeconsulting.big_data_maker import org.scalatest.FunSuite import com.holdenkarau.spark.testing.SharedSparkContext import org.apache.spark.sql.SQLContext import org.apache.spark.sql.types.{StructField, StringType, LongType, DoubleType} class ColumnsTest extends FunSuite with SharedSparkContext { val numLoops = 100 test("test StringConstant") { val s1 = new StringConstant("f1", "abc") assert("abc" === s1.getValue(1)) assert(StructField("f1", StringType, false) == s1.getStructField) } test("test RandomLong") { val s1 = new RandomLong("f1", 666666L) for (x <- 1 to numLoops) { assert(s1.getValue(1) >= 0) assert(s1.getValue(1) <= 666666L) } assert(StructField("f1", LongType, false) == s1.getStructField) } test("test RandomDouble") { val s1 = new RandomDouble("f1", 666666.00) for (x <- 1 to numLoops) { assert(s1.getValue(1) >= 0) assert(s1.getValue(1) <= 666666.00) } assert(StructField("f1", DoubleType, false) == s1.getStructField) } test("test Categorical") { val list = List("a", "b", "c", "d") val s1 = new Categorical("f1", list) for (x <- 1 to numLoops) { val v = s1.getValue(1) assert(list.exists(key => v.contains(key))) } assert(StructField("f1", StringType, false) == s1.getStructField) } }

Example 56

Project: BigDataMaker   Author: dondrake   File: TestBigDataMaker.scala View Source Project (license)

5 votes

package com.drakeconsulting.big_data_maker import org.scalatest.FunSuite import com.holdenkarau.spark.testing.SharedSparkContext import org.apache.spark.sql.SQLContext class BigDataMakerTest extends FunSuite with SharedSparkContext { test("first") { val sqlContext = new SQLContext(sc) val bd = new BigData(sqlContext, "/tmp/b", 5, 100) bd.addColumn(new StringConstant("f1", "abc")) bd.addColumn(new StringConstant("f2", "def")) val df = bd._createDataFrame df.show assert(500 === df.count) assert(2 === df.columns.length) } test("col names") { val sqlContext = new SQLContext(sc) val bd = new BigData(sqlContext, "/tmp/b", 5, 100) bd.addColumn(new StringConstant("f1", "abc")) bd.addColumn(new StringConstant("", "def")) assert("f1" === bd.cols(0).name) assert("f_1" === bd.cols(1).name) } }

Example 57

Project: Courses   Author: zearom32   File: SimulationSuite.scala View Source Project (license)

5 votes

package practice import org.junit.runner.RunWith import org.scalatest.FunSuite import org.scalatest.exceptions.{TestCanceledException, TestFailedDueToTimeoutException} import org.scalatest.junit.JUnitRunner import org.scalatest.time.{Millis, Span, Seconds} import org.scalatest.concurrent.Timeouts._ @RunWith(classOf[JUnitRunner]) class SimulationSuite extends FunSuite{ object sim extends Circuits with Parameters import sim._ test("a simple test"){ val in1, in2, sum, carry = new Wire probe("sum", sum) probe("carry", carry) halfAdder(in1, in2, sum, carry) in1.setSignal(true) sim.run() in2.setSignal(true) sim.run() assert(carry.getSignal == true) assert(sum.getSignal == false) } test("will not terminate") { try { cancelAfter(Span(10, Seconds)) { val in3 = new Wire probe("in3", in3) inverter(in3, in3) sim.run() } } catch { case x:TestCanceledException => } } }

Example 58

Project: computation-strategies   Author: socrata-platform   File: GeocodingComputationStrategyTest.scala View Source Project (license)

5 votes

package com.socrata.computation_strategies import com.socrata.computation_strategies.GeocodingComputationStrategy.GeocodingSourcesDoNotMatchSourceColumns import org.scalatest.{ShouldMatchers, FunSuite} class GeocodingComputationStrategyTest extends FunSuite with ShouldMatchers { import TestData._ import TestData.GeocodingData._ def testValidate(definition: StrategyDefinition[String], expected: Option[ValidationError] = None): Unit = { GeocodingComputationStrategy.validate(definition) should be (expected) } def testTransform(definition: StrategyDefinition[String], columns: Map[String, Int], expected: Either[ValidationError, StrategyDefinition[Int]]): Unit = { GeocodingComputationStrategy.transform(definition, columns) should be (expected) } test("Definition with full sources and parameters should be invalid") { testValidate(fullDefinition) } test("Definition with no sources should be invalid") { val expected = Some(GeocodingSourcesDoNotMatchSourceColumns(List(), Some(GeocodingSources(Some(address),Some(city), Some(county),Some(state),Some(zip),Some(country))))) testValidate(noSourcesDefinition, expected) } test("Definition with no parameters should be invalid") { testValidate(noParamsDefinition, Some(MissingParameters(GeocodingParameterSchema))) } test("Definition with an unknown source column should fail to transform") { testTransform(fullDefinition, columnIds - address, Left(UnknownSourceColumn(address))) } }

Example 59

Project: ProgFun1   Author: albertoadami   File: CountChangeSuite.scala View Source Project (license)

5 votes

package recfun import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class CountChangeSuite extends FunSuite { import Main.countChange test("countChange: example given in instructions") { assert(countChange(4,List(1,2)) === 3) } test("countChange: sorted CHF") { assert(countChange(300,List(5,10,20,50,100,200,500)) === 1022) } test("countChange: no pennies") { assert(countChange(301,List(5,10,20,50,100,200,500)) === 0) } test("countChange: unsorted CHF") { assert(countChange(300,List(500,5,50,100,20,200,10)) === 1022) } }

Example 60

Project: spark-wilcoxon   Author: robert-dodier   File: wilcoxonSuite.scala View Source Project (license)

5 votes

package org.robertdodier import org.scalatest.{BeforeAndAfterAll, FunSuite} import org.apache.spark.{SparkConf, SparkContext} class wilcoxonSuite extends FunSuite with BeforeAndAfterAll { @transient var sc: SparkContext = _ override def beforeAll() { val conf = new SparkConf() .setMaster("local") .setAppName("test") sc = new SparkContext(conf) super.beforeAll() } override def afterAll() { if (sc != null) { sc.stop() } super.afterAll() } test("compute scaled rank sum with made-up data") { val scoresAndLabels = Seq((0.6, 1), (0.9, 1), (0.3, 1), (0.2, 0), (0.1, 0), (0.5, 0)) val U = wilcoxon.U (sc.parallelize (scoresAndLabels)) val expected_U = 8.0/9.0 assert (Math.abs (U - expected_U) <= 1e-12) } }

Example 61

Project: sclib   Author: j-keck   File: EitherOpsSuite.scala View Source Project (license)

5 votes

package sclib.ops import org.scalatest.{FunSuite, Matchers} class EitherOpsSuite extends FunSuite with Matchers { import sclib.ops.either._ test("sequence with Right values"){ val l: List[Either[String, Int]] = List.range(1, 10).map(_.right[String]) val e: Either[String, List[Int]] = l.sequence e should be(Right(List.range(1, 10))) } test("sequence with one Left"){ val l: List[Either[String, Int]] = List.range(1, 10).map(Right.apply).updated(6, Left("BOOM")) val e: Either[String, Seq[Int]] = l.sequence e should be(Left("BOOM")) } test("right biased map / flatMap"){ val res1 = for { a <- 1.right b <- "BOOM".left[Int] } yield a + b res1 should be(Left("BOOM")) val res2 = for{ a <- 1.right b <- 2.right } yield a + b res2 should be(Right(3)) } }

Example 62

Project: sclib   Author: j-keck   File: ListOpsSuite.scala View Source Project (license)

5 votes

package sclib.ops import org.scalatest.{FunSuite, Matchers} import sclib.ops.list._ class ListOpsSuite extends FunSuite with Matchers { test("unfoldRight") { ListOps.unfoldRight(0) { i => if (i > 5) None else Some((i, i + 1)) } should be(List(0, 1, 2, 3, 4, 5)) } test("unfoldLeft") { ListOps.unfoldLeft(0) { i => if (i > 5) None else Some((i + 1, i)) } should be(List(5, 4, 3, 2, 1, 0)) } }

Example 63

Project: sclib   Author: j-keck   File: FSPermSuite.scala View Source Project (license)

5 votes

package sclib.io.fs import java.nio.file.attribute.PosixFilePermission import java.nio.file.attribute.PosixFilePermission._ import org.scalatest.{FunSuite, Matchers} import sclib.ops.all._ class FSPermSuite extends FunSuite with Matchers { import FSPerm._ test("calc: valid") { calc(731) should be( Seq(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE, GROUP_WRITE, GROUP_EXECUTE, OTHERS_EXECUTE).success) } test("calc: invalid"){ calc(738).fold(_.getMessage)(_ => "Failure expected!") should be("Invalid file mode: 738") } test("mod: valid"){ def check(s1: Seq[PosixFilePermission], mode: String, s2: Seq[PosixFilePermission]) = { mod(s1, mode).map(_.sorted) should be(s2.sorted.success) } check(Seq(OWNER_READ), "a+x", Seq(OWNER_READ, OWNER_EXECUTE, GROUP_EXECUTE, OTHERS_EXECUTE)) check(Seq(OWNER_READ), "a+r", Seq(OWNER_READ, GROUP_READ, OTHERS_READ)) check(Seq(OWNER_READ, GROUP_READ), "u+wx", Seq(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE, GROUP_READ)) check(Seq(OWNER_EXECUTE, GROUP_EXECUTE), "u=rw", Seq(OWNER_READ, OWNER_WRITE, GROUP_EXECUTE)) check(Seq(), "u+r,g+w,o+x", Seq(OWNER_READ, GROUP_WRITE, OTHERS_EXECUTE)) } test("mod: invalid"){ def check(mode: String, expected: String) = { mod(Seq(), mode).fold(_.getMessage)(x => s"Failure expected for mode: ${mode} - received: ${x}") should be(expected) } check("arwx", "operator [+|-|=] not found") check("a/rwx", "operator [+|-|=] not found") check("+rwx", "who ([a|u|g|o]+) not found") check("a+", "perm ([r|w|x]+) not found") } }

Example 64

Project: wartremover-contrib   Author: wartremover   File: UnsafeInheritanceTest.scala View Source Project (license)

5 votes

package org.wartremover package contrib.test import org.scalatest.FunSuite import org.wartremover.contrib.warts.UnsafeInheritance import org.wartremover.test.WartTestTraverser class UnsafeInheritanceTest extends FunSuite with ResultAssertions { test("Method must be final or abstract") { val result = WartTestTraverser(UnsafeInheritance) { trait T { def m() = {} } } assertError(result)("Method must be final or abstract") } test("Final and abstract, private, object methods are allowed") { val result = WartTestTraverser(UnsafeInheritance) { trait T { final def m2() = {} def m1(): Unit private def m3() = {} } final class C1 { def m() = {} } sealed class C2 { def m() = {} } object O { def m() = {} } case class CC(i: Int) } assertEmpty(result) } test("UnsafeInheritance wart obeys SuppressWarnings") { val result = WartTestTraverser(UnsafeInheritance) { trait T { @SuppressWarnings(Array("org.wartremover.contrib.warts.UnsafeInheritance")) def m() = {} } } assertEmpty(result) } }

Example 65

Project: wartremover-contrib   Author: wartremover   File: SomeApplyTest.scala View Source Project(license)

5 votes

package org.wartremover package contrib.test import org.scalatest.FunSuite import org.wartremover.contrib.warts.SomeApply import org.wartremover.test.WartTestTraverser class SomeApplyTest extends FunSuite with ResultAssertions { test("can't use Some.apply with null") { val result = WartTestTraverser(SomeApply) { Some(null) } assertError(result)("Some.apply is disabled - use Option.apply instead") } test("can't use Some.apply with a literal") { val result = WartTestTraverser(SomeApply) { Some(1) } assertError(result)("Some.apply is disabled - use Option.apply instead") } test("can't use Some.apply with an identifier") { val result = WartTestTraverser(SomeApply) { val x = 1 Some(x) } assertError(result)("Some.apply is disabled - use Option.apply instead") } test("can use Some.unapply in pattern matching") { val result = WartTestTraverser(SomeApply) { Option("test") match { case Some(test) => println(test) case None => println("not gonna happen") } } assertEmpty(result) } test("obeys SuppressWarnings") { val result = WartTestTraverser(SomeApply) { @SuppressWarnings(Array("org.wartremover.contrib.warts.SomeApply")) val x = Some(null) } assertEmpty(result) } }

Example 66

Project: phone-guide   Author: videlalvaro   File: EncoderDecoderTest.scala View Source Project(license)

5 votes

package org.videlalvaro.phoneguide.netty import io.netty.channel.embedded.EmbeddedChannel import org.scalatest.prop.GeneratorDrivenPropertyChecks import org.scalatest.{FunSuite, Matchers} import org.videlalvaro.phoneguide.PhoneNumber import org.videlalvaro.phoneguide.generators.Generators._ class EncoderDecoderTest extends FunSuite with GeneratorDrivenPropertyChecks with Matchers { test("netty encode/decode message") { forAll { (phoneNumber: PhoneNumber) => val channel = new EmbeddedChannel(new MessageEncoder(), new MessageDecoder()) channel.writeOutbound(phoneNumber) channel.writeInbound(channel.readOutbound()) val readPhoneNumber = channel.readInbound(); readPhoneNumber should not be (null) readPhoneNumber.equals(phoneNumber) should be (true) phoneNumber.equals(readPhoneNumber) should be (true) } } }

Example 67

Project: marathon   Author: xiaozai512   File: ReadinessCheckSerializerTest.scala View Source Project(license)

5 votes

package mesosphere.marathon.state import mesosphere.marathon.core.readiness.ReadinessCheckTestHelper import org.scalatest.{ GivenWhenThen, Matchers, FunSuite } import mesosphere.marathon.Protos class ReadinessCheckSerializerTest extends FunSuite with Matchers with GivenWhenThen { test("get defaultHttp for empty protobuf") { Given("an empty protobuf") val proto = Protos.ReadinessCheckDefinition.getDefaultInstance When("reading it") val check = ReadinessCheckSerializer.fromProto(proto) Then("we get the defaults") check should equal(ReadinessCheckTestHelper.defaultHttp) } test("defaultHttp example serialized/deserializes") { Given("a defaultHttp readinessCheck") val defaultHttp = ReadinessCheckTestHelper.defaultHttp When("serializing it to a proto") val proto = ReadinessCheckSerializer.toProto(defaultHttp) And("deserializing it again") val reread = ReadinessCheckSerializer.fromProto(proto) Then("we get the original check back") reread should equal(defaultHttp) } test("alternativeHttps example serialized/deserializes") { Given("a alternativeHttps readinessCheck") val alternativeHttps = ReadinessCheckTestHelper.alternativeHttps When("serializing it to a proto") val proto = ReadinessCheckSerializer.toProto(alternativeHttps) And("deserializing it again") val reread = ReadinessCheckSerializer.fromProto(proto) Then("we get the original check back") reread should equal(alternativeHttps) } }

Example 68

Project: marathon   Author: xiaozai512   File: InstanceIdTest.scala View Source Project (license)

5 votes

package mesosphere.marathon.instance import mesosphere.marathon.core.instance.Instance import mesosphere.marathon.core.pod.MesosContainer import mesosphere.marathon.core.task.Task import mesosphere.marathon.raml.Resources import mesosphere.marathon.state.PathId._ import org.scalatest.{ FunSuite, Matchers } class InstanceIdTest extends FunSuite with Matchers { test("AppIds can be converted to InstanceIds and back to AppIds") { val appId = "/test/foo/bla/rest".toPath val instanceId = Instance.Id.forRunSpec(appId) instanceId.runSpecId should equal(appId) } test("InstanceIds can be converted to TaskIds without container name") { val appId = "/test/foo/bla/rest".toPath val instanceId = Instance.Id.forRunSpec(appId) val taskId = Task.Id.forInstanceId(instanceId, container = None) taskId.idString should be(instanceId.idString + ".$anon") } test("InstanceIds can be converted to TaskIds with container name") { val appId = "/test/foo/bla/rest".toPath val instanceId = Instance.Id.forRunSpec(appId) val container = MesosContainer("firstOne", resources = Resources()) val taskId = Task.Id.forInstanceId(instanceId, Some(container)) taskId.idString should be(instanceId.idString + ".firstOne") } test("InstanceIds can be converted from TaskIds with container name") { val appId = "/test/foo/bla/rest".toPath val parsedTaskId = Task.Id("test_foo_bla_rest.instance-myinstance.someContainerName") parsedTaskId.runSpecId should be(appId) parsedTaskId.instanceId should be(Instance.Id("test_foo_bla_rest.instance-myinstance")) parsedTaskId.containerName should be('nonEmpty) parsedTaskId.containerName should be(Some("someContainerName")) } test("InstanceIds can be converted from TaskIds without a container name") { val appId = "/test/foo/bla/rest".toPath val parsedTaskId = Task.Id("test_foo_bla_rest.instance-myinstance.$anon") parsedTaskId.runSpecId should be(appId) parsedTaskId.instanceId should be(Instance.Id("test_foo_bla_rest.instance-myinstance")) parsedTaskId.containerName should be('empty) } test("InstanceIds should be created by static string") { val idString = "app.marathon-task" val instanceId = Instance.Id(idString) instanceId.idString should be(idString) instanceId.runSpecId.safePath should be("app") val taskId = Task.Id(idString + ".app") taskId.instanceId should be(instanceId) } }

Example 69

Project: marathon   Author: xiaozai512   File: TaskIdTest.scala View Source Project (license)

5 votes

package mesosphere.marathon.tasks import mesosphere.marathon.core.task.Task import org.apache.mesos.Protos.TaskID import org.scalatest.{ FunSuite, Matchers } import mesosphere.marathon.state.PathId._ class TaskIdTest extends FunSuite with Matchers { test("AppIds can be converted to TaskIds and back to AppIds") { val appId = "/test/foo/bla/rest".toPath val taskId = Task.Id.forRunSpec(appId) taskId.runSpecId should equal(appId) } test("Old TaskIds can be converted") { val taskId = Task.Id(TaskID.newBuilder().setValue("app_682ebe64-0771-11e4-b05d-e0f84720c54e").build) taskId.runSpecId should equal("app".toRootPath) } test("Old TaskIds can be converted even if they have dots in them") { val taskId = Task.Id(TaskID.newBuilder().setValue("app.foo.bar_682ebe64-0771-11e4-b05d-e0f84720c54e").build) taskId.runSpecId should equal("app.foo.bar".toRootPath) } test("Old TaskIds can be converted even if they have underscores in them") { val taskId = Task.Id(TaskID.newBuilder().setValue("app_foo_bar_0-12345678").build) taskId.runSpecId should equal("/app/foo/bar".toRootPath) } test("TaskIds with encoded InstanceIds could be encoded") { val taskId = Task.Id(TaskID.newBuilder().setValue("test_foo_bla_rest.instance-instance1.62d0f03f-79aa-11e6-a1a0-660c139c5e15").build) taskId.runSpecId should equal("/test/foo/bla/rest".toRootPath) taskId.instanceId.idString should equal("test_foo_bla_rest.instance-instance1") } test("TaskIds with encoded InstanceIds could be encoded even with crucial path ids") { val taskId = Task.Id(TaskID.newBuilder().setValue("test_foo.instance-_bla_rest.instance-instance1.62d0f03f-79aa-11e6-a1a0-660c139c5e15").build) taskId.runSpecId should equal("/test/foo.instance-/bla/rest".toRootPath) taskId.instanceId.idString should equal("test_foo.instance-_bla_rest.instance-instance1") } test("TaskIds without specific instanceId should use taskId as instanceId") { val taskId = Task.Id(TaskID.newBuilder().setValue("test_foo_bla_rest.62d0f03f-79aa-11e6-a1a0-660c139c5e15").build) taskId.runSpecId should equal("/test/foo/bla/rest".toRootPath) taskId.instanceId.idString should equal("test_foo_bla_rest.marathon-62d0f03f-79aa-11e6-a1a0-660c139c5e15") } }

Example 70

Project: marathon   Author: xiaozai512   File: ResourceMatchTest.scala View Source Project (license)

5 votes

package mesosphere.mesos import mesosphere.marathon.tasks.{ PortsMatch, PortsMatcher } import mesosphere.marathon.test.MarathonTestHelper import org.scalatest.{ FunSuite, GivenWhenThen, Matchers } import scala.collection.immutable.Seq class ResourceMatchTest extends FunSuite with GivenWhenThen with Matchers { test("resources include all matched reservations") { Given("a resource match with reservations") val memReservation = MarathonTestHelper.reservation(principal = "memPrincipal", labels = Map("resource" -> "mem")) val portReservation = MarathonTestHelper.reservation(principal = "portPrincipal", labels = Map("resource" -> "ports")) val resourceMatch = ResourceMatcher.ResourceMatch( scalarMatches = Seq( GeneralScalarMatch( "mem", 128.0, consumed = Seq(GeneralScalarMatch.Consumption(128.0, "role1", reservation = Some(memReservation))), scope = ScalarMatchResult.Scope.NoneDisk ) ), portsMatch = PortsMatch(Seq(Some(PortsMatcher.PortWithRole("role2", 80, reservation = Some(portReservation))))) ) When("converting it to resources") val resources = resourceMatch.resources Then("the resources should refer to the reservations") resources should equal( Seq( MarathonTestHelper.scalarResource("mem", 128, "role1", reservation = Some(memReservation)), MarathonTestHelper.portsResource(80, 80, "role2", reservation = Some(portReservation)) ) ) } }

Example 71

Project: functional-structures-refactoring-kata   Author: matteobaglini   File: AppTests.scala View Source Project (license)

5 votes

import App._ import Models._ import org.scalatest.FunSuite class AppTests extends FunSuite { test("happy path") { val cartId = CartId("some-gold-cart") val storage = new SpyStorage applyDiscount(cartId, storage) assert(storage.saved.get == Cart(CartId("some-gold-cart"),CustomerId("gold-customer"),50.0) ) } test("no discount") { val cartId = CartId("some-normal-cart") val storage = new SpyStorage applyDiscount(cartId, storage) assert(storage.saved.isEmpty) } test("missing cart") { val cartId = CartId("missing-cart") val storage = new SpyStorage applyDiscount(cartId, storage) assert(storage.saved.isEmpty) } class SpyStorage extends Storage[Cart] { var saved: Option[Cart] = None override def flush(value: Cart): Unit = saved = Some(value) } }

Example 72

Project: data.ncbitaxonomy   Author: bio4j   File: parseNodes.scala View Source Project (license)

5 votes

package com.bio4j.data.ncbitaxonomy.test import org.scalatest.FunSuite import com.bio4j.data.ncbitaxonomy._, dmp._ class ParseNodes extends FunSuite { val nodeLines: Seq[String] = Seq( """318 | 29438 | no rank | | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | |""", """319 | 29438 | no rank | | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | |""", """321 | 317 | no rank | | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | |""", """322 | 47877 | no rank | | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | |""", """323 | 251701 | no rank | | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | |""", """329 | 48736 | species | RP | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | |""", """330 | 1232139 | species | PP | 0 | 1 | 11 | 1 | 0 | 1 | 1 | 0 | |""" ) test("parse several nodes") { val nodes = dmp.nodes.fromLines(nodeLines.toIterator).toSeq val firstNode = nodes.head val lastNode = nodes.last assert { (firstNode.ID === "318" ) && (firstNode.parentID === "29438" ) && (firstNode.rank === "no rank" ) } assert { (lastNode.ID === "330" ) && (lastNode.parentID === "1232139" ) && (lastNode.rank === "species" ) } } }

Example 73

Project: func-programming-scala-coursera   Author: andrei-l   File: PascalSuite.scala View Source Project (license)

5 votes

package org.coursera.progfun.recfun import org.junit.runner.RunWith import org.scalatest.FunSuite import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class PascalSuite extends FunSuite { import Main.pascal test("pascal: col=0,row=2") { assert(pascal(0,2) === 1) } test("pascal: col=1,row=2") { assert(pascal(1,2) === 2) } test("pascal: col=1,row=3") { assert(pascal(1,3) === 3) } }

Example 74

Project: functional-programming-principles-scala   Author: filslo   File: CountChangeSuite.scala View Source Project (license)

5 votes

package recfun import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class CountChangeSuite extends FunSuite { import Main.countChange test("countChange: example given in instructions") { assert(countChange(4,List(1,2)) === 3) } test("countChange: sorted CHF") { assert(countChange(300,List(5,10,20,50,100,200,500)) === 1022) } test("countChange: no pennies") { assert(countChange(301,List(5,10,20,50,100,200,500)) === 0) } test("countChange: unsorted CHF") { assert(countChange(300,List(500,5,50,100,20,200,10)) === 1022) } }

Example 75

Project: oanda-scala-api   Author: cnnickolay   File: ApiModelGeneratorUnitTest.scala View Source Project (license)

5 votes

package org.nikosoft.oanda.generator import org.nikosoft.oanda.generator.ApiModelGeneratorParsers.ParameterTable import org.scalatest.{FunSuite, Matchers} class ApiModelGeneratorUnitTest extends FunSuite with Matchers { test("generate enumeration") { val inputTitle = "TradeState" val inputDefinition = "The current state of the Trade." val inputParameters = ParameterTable("Value", "Description", Map( "OPEN" -> "The Trade is currently open", "CLOSED" -> "The Trade has been fully closed", "CLOSE_WHEN_TRADEABLE" -> "The Trade will be closed as soon as the trade’s instrument becomes tradeable" )) val expectedOutput = """ |case class TradeSpecifier(value: String) extends AnyVal""".stripMargin val actualOutput = ApiModelGenerator.generateCaseClass(inputTitle, inputDefinition, inputParameters) actualOutput shouldBe expectedOutput } }

Example 76

Project: oanda-scala-api   Author: cnnickolay   File: ApiImplUnitTest.scala View Source Project (license)

5 votes

package org.nikosoft.oanda.api.remove import org.json4s.Formats import org.json4s.jackson.JsonMethods._ import org.nikosoft.oanda.api.JsonSerializers import org.nikosoft.oanda.api.`def`.AccountsApi.AccountsResponse import org.scalatest.FunSuite class ApiImplUnitTest extends FunSuite { implicit val formats: Formats = JsonSerializers.formats test("parse account json") { val json = """{"account":{"id":"001-004-XXXXXXX-003","createdTime":"2017-05-30T07:11:30.656911765Z","currency":"EUR","createdByUserID":1442547,"alias":"MT4","marginRate":"0.02","hedgingEnabled":false,"lastTransactionID":"87","balance":"77.0033","openTradeCount":1,"openPositionCount":1,"pendingOrderCount":2,"pl":"-0.9954","resettablePL":"-0.9954","financing":"-0.0013","commission":"0.0000", |"orders":[ | {"id":"85","createTime":"2017-06-15T09:08:02.732786641Z","type":"STOP_LOSS","tradeID":"82","clientTradeID":"72179822","price":"1.11000","timeInForce":"GTC","triggerCondition":"DEFAULT","state":"PENDING"}, | {"id":"87","createTime":"2017-06-15T09:13:56.368495444Z","replacesOrderID":"84","type":"TAKE_PROFIT","tradeID":"82","clientTradeID":"72179822","price":"1.11850","timeInForce":"GTC","triggerCondition":"DEFAULT","state":"PENDING"} |], |"positions":[ | {"instrument":"EUR_USD", | "long":{"units":"5000","averagePrice":"1.11810","pl":"0.3444","resettablePL":"0.3444","financing":"-0.0024","tradeIDs":["82"],"unrealizedPL":"-2.4386"}, | "short":{"units":"0","pl":"-1.3398","resettablePL":"-1.3398","financing":"0.0011","unrealizedPL":"0.0000"}, | "pl":"-0.9954","resettablePL":"-0.9954","financing":"-0.0013","commission":"0.0000","unrealizedPL":"-2.4386"}], |"trades":[{"id":"82","instrument":"EUR_USD","price":"1.11810","openTime":"2017-06-15T09:07:28.287005040Z","initialUnits":"1000","state":"OPEN","currentUnits":"1000","realizedPL":"0.0000","financing":"0.0000", | "clientExtensions":{"id":"72179822","tag":"0"},"takeProfitOrderID":"87","stopLossOrderID":"85","unrealizedPL":"-2.4386"}], |"unrealizedPL":"-2.4386","NAV":"74.5647","marginUsed":"20.0022","marginAvailable":"54.5625","positionValue":"1000.1076","marginCloseoutUnrealizedPL":"-2.3847","marginCloseoutNAV":"74.6186","marginCloseoutMarginUsed":"20.0000","marginCloseoutPositionValue":"1000.0000","marginCloseoutPercent":"0.13401","withdrawalLimit":"54.5625","marginCallMarginUsed":"20.0000","marginCallPercent":"0.26803"}, |"lastTransactionID":"87"}""".stripMargin println(parse(json).children.head.extract[AccountsResponse]) } }

Example 77

Project: scalasom   Author: dyamah   File: CellTest.scala View Source Project (license)

5 votes

package com.github.dyamah.scalasom import org.scalatest.FunSuite class CellTest extends FunSuite { val cell1 = Cell(1, 1, new VectorImpl(List(1, 1, 1))) val cell2 = Cell(1, 1, new VectorImpl(List(1, 1, 1))) val cell3 = Cell(1, 1, new VectorImpl(List(2, 2, 2))) val cell4 = Cell(1, 2, new VectorImpl(List(1, 1, 1))) val cell5 = Cell(2, 1, new VectorImpl(List(1, 1, 1))) val cell6 = Cell(2, 2, new VectorImpl(List(1, 1, 1))) test("testEquals") { assert(cell1 == cell2) assert(cell1 != cell3) assert(cell1 != cell4) assert(cell1 != cell5) assert(cell1 != cell6) } test("testDistance") { assert(cell1.distance(cell1) == 0) assert(cell1.distance(cell2) == 0) assert(cell1.distance(cell3) == 0) assert(cell1.distance(cell4) == 1) assert(cell1.distance(cell5) == 1) assert(cell1.distance(cell6) == math.pow(2, 0.5)) } }

Example 78

Project: Scala-Machine-Learning   Author: Wei-1   File: DBSCANTest.scala View Source Project(license)

5 votes

// Wei Chen - DBSCAN Test // 2016-11-10 import org.scalatest.FunSuite import ght.mi.TestData._ import ght.mi.general.MatrixFunc._ import ght.mi.algorithm.DBSCAN class DBSCANSuite extends FunSuite { val dbscan = new DBSCAN() test("DBSCAN Test : Clustering Tiny Data") { val result = dbscan.cluster(UNLABELED_TINY_DATA, 2) assert(arrayequal(result, LABEL_TINY_DATA)) } test("DBSCAN Test : Clustering Small Data") { val result = dbscan.cluster(UNLABELED_SMALL_DATA, 2) assert(arrayequal(result, LABEL_SMALL_DATA)) } test("DBSCAN Test : Clustering Large Data") { val result = dbscan.cluster(UNLABELED_LARGE_DATA, 3) assert(arrayequal(result, LABEL_LARGE_DATA)) } }

Example 79

Project: Scala-Machine-Learning   Author: Wei-1   File: LinearSVMTest.scala View Source Project(license)

5 votes

// Wei Chen - Linear SVM Test // 2016-06-03 import org.scalatest.FunSuite import ght.mi.TestData._ import ght.mi.general.MatrixFunc._ import ght.mi.algorithm.LinearSVM class LinearSVMSuite extends FunSuite { val linearsvm = new LinearSVM() test("LinearSVM Test : Initialization") { assert(linearsvm.projector.isEmpty) } test("LinearSVM Test : Linear Train") { val cost = Map(-1 -> 1.0, 1 -> 1.0) val limit = 1000 val err = 1e-1 linearsvm.train(LABELED_LINEAR_DATA, cost, limit, err) assert(!linearsvm.projector.isEmpty) } test("LinearSVM Test : Linear Predict") { val result = linearsvm.predict(UNLABELED_LINEAR_DATA) assert(arrayequal(result, LABEL_LINEAR_DATA)) } test("LinearSVM Test : Clear") { linearsvm.clear() assert(linearsvm.projector.isEmpty) } test("LinearSVM Test : Nonlinear Train") { val cost = Map(1 -> 1.0, 2 -> 1.0) val limit = 1000 val err = 1e-1 linearsvm.train(LABELED_NONLINEAR_DATA, cost, limit, err) assert(!linearsvm.projector.isEmpty) } test("LinearSVM Test : Nonlinear Predict - WRONG") { val result = linearsvm.predict(UNLABELED_NONLINEAR_DATA) assert(!arrayequal(result, LABEL_NONLINEAR_DATA)) } }

Example 80

Project: Scala-Machine-Learning   Author: Wei-1   File: GaussianProcessTest.scala View Source Project(license)

5 votes

// Wei Chen - Gaussian Process Test // 2016-11-24 import org.scalatest.FunSuite import ght.mi.TestData._ import ght.mi.general.MatrixFunc._ import ght.mi.algorithm.GaussianProcess class GaussianProcessSuite extends FunSuite { val gp = new GaussianProcess() test("GaussianProcess Test : Initialization") { assert(gp.pointGroups.isEmpty) } test("GaussianProcess Test : Linear Train") { gp.train(LABELED_LINEAR_DATA) assert(gp.pointGroups.size == 2) } test("GaussianProcess Test : Linear Predict") { val result = gp.predict(UNLABELED_LINEAR_DATA, 3) assert(arrayequal(result, LABEL_LINEAR_DATA)) } test("GaussianProcess Test : Nonlinear Train") { gp.train(LABELED_NONLINEAR_DATA) assert(gp.pointGroups.size == 2) } test("GaussianProcess Test : Nonlinear Predict") { val result = gp.predict(UNLABELED_NONLINEAR_DATA, 3) assert(arrayequal(result, LABEL_NONLINEAR_DATA)) } test("GaussianProcess Test : Clear") { gp.clear() assert(gp.pointGroups.isEmpty) } }

Example 81

Project: Scala-Machine-Learning   Author: Wei-1   File: RandomForestTest.scala View Source Project(license)

5 votes

// Wei Chen - Random Forest Test // 2016-11-29 import org.scalatest.FunSuite import ght.mi.TestData._ import ght.mi.general.MatrixFunc._ import ght.mi.algorithm.RandomForest class RandomForestSuite extends FunSuite { val rf = new RandomForest() test("RandomForest Test : Initialization") { assert(rf.trees.isEmpty) } test("RandomForest Test : Linear Train") { rf.train(LABELED_LINEAR_DATA, 5, 4) assert(!rf.trees.isEmpty) } test("RandomForest Test : Linear Predict") { val result = rf.predict(UNLABELED_LINEAR_DATA) assert(arrayequal(result, LABEL_LINEAR_DATA)) } test("RandomForest Test : Nonlinear Train") { rf.train(LABELED_NONLINEAR_DATA, 5, 4) assert(!rf.trees.isEmpty) } test("RandomForest Test : Nonlinear Predict - WRONG") { val result = rf.predict(UNLABELED_NONLINEAR_DATA) assert(!arrayequal(result, LABEL_NONLINEAR_DATA)) } test("RandomForest Test : Clear") { rf.clear() assert(rf.trees.isEmpty) } }

Example 82

Project: Scala-Machine-Learning   Author: Wei-1   File: LinearRegressionTest.scala View Source Project(license)

5 votes

// Wei Chen - Linear Regression Test // 2016-06-04 import org.scalatest.FunSuite import ght.mi.TestData._ import ght.mi.general.MatrixFunc._ import ght.mi.algorithm.LinearRegression class LinearRegressionSuite extends FunSuite { val linearregression = new LinearRegression() test("LinearRegression Test : Initialization") { assert(linearregression.projector.isEmpty) } test("LinearRegression Test : Linear Train") { linearregression.train(LABELED_LINEAR_DATA) assert(linearregression.projector(0)._1 == -1) assert(linearregression.projector(0)._2 == 1) } test("LinearRegression Test : Linear Predict") { val result = linearregression.predict(UNLABELED_LINEAR_DATA) assert(arrayequal(result, LABEL_LINEAR_DATA)) } test("LinearRegression Test : Clear") { linearregression.clear() assert(linearregression.projector.isEmpty) } test("LinearRegression Test : Nonlinear Train") { linearregression.train(LABELED_NONLINEAR_DATA) assert(linearregression.projector(0)._1 == 1) assert(linearregression.projector(0)._2 == 2) } test("LinearRegression Test : Nonlinear Predict - WRONG") { val result = linearregression.predict(UNLABELED_NONLINEAR_DATA) assert(!arrayequal(result, LABEL_NONLINEAR_DATA)) } }

Example 83

Project: Scala-Machine-Learning   Author: Wei-1   File: GeneAlgorithmTest.scala View Source Project(license)

5 votes

// Wei Chen - Gene Algorithm Test // 2017-07-22 import org.scalatest.FunSuite import ght.mi.general.MatrixFunc._ import ght.mi.algorithm.GeneAlgorithm class GeneAlgorithmSuite extends FunSuite { val ga = new GeneAlgorithm() val initseeds = Array(Array(0.0), Array(1.0)) def evaluation(arr: Array[Double]): Double = - (arr.head - 0.7).abs def breeding(pa: Array[Double], pb: Array[Double]): Array[Double] = pa.zip(pb).map { case (a, b) => if (scala.util.Random.nextDouble > 0.1) (a + b) / 2 else scala.util.Random.nextDouble } val generationsize: Int = 100 val elitesize: Int = 3 test("GeneAlgorithm Test : Initial") { assert(ga.seeds == null) ga.setSeeds(initseeds) assert(matrixequal(ga.seeds, initseeds)) } test("GeneAlgorithm Test : Evolve") { for (i <- 0 until 10) ga.evolve(evaluation, breeding, generationsize, elitesize) assert(ga.seeds.size == generationsize) val best = ga.evolve(evaluation, breeding, generationsize, elitesize) assert((best.head - 0.7).abs < 0.05) } }

Example 84

Project: Scala-Machine-Learning   Author: Wei-1   File: QLearningTest.scala View Source Project(license)

5 votes

// Wei Chen - Q-Learning Test // 2017-07-28 import org.scalatest.FunSuite import ght.mi.TestData._ import ght.mi.algorithm.QLearning class QLearningSuite extends FunSuite { val learning_rate = 0.1 val scale = 1 val limit = 10000 val epoch = 100 val statenumber = 5 val scores = Map(2 -> 10.0, 3 -> 0.0, 4 -> 100.0) val links = Map(0 -> Array(1, 2), 1 -> Array(3, 4)) val ql = new QLearning(statenumber) ql.addScores(scores) ql.addLinks(links) test("QLearning Test : Iterate") { ql.iterate(limit, learning_rate, scale, epoch) assert(true) } test("QLearning Test : Result") { val result = ql.result(epoch) assert(result.size == 3) assert(result.last.id == 4) } }

Example 85

Project: Scala-Machine-Learning   Author: Wei-1   File: NeuralNetworkTest.scala View Source Project(license)

5 votes

// Wei Chen - Neural Network Test // 2016-11-06 import org.scalatest.FunSuite import ght.mi.TestData._ import ght.mi.general.MatrixFunc._ import ght.mi.algorithm.NeuralNetwork class NeuralNetworkSuite extends FunSuite { val layer_neurons = Array(5, 4) val input_column = UNLABELED_LARGE_HIGH_DIM_DATA.head.size val output_column = TARGET_LARGE_HIGH_DIM_DATA.head.size val limit = 1000 val nn = new NeuralNetwork(layer_neurons, input_column, output_column) test("NeuralNetwork Test : Initialization") { assert(nn.syns(0).size == input_column) assert(nn.syns(layer_neurons.size).head.size == output_column) } test("NeuralNetwork Test : Train") { nn.train(UNLABELED_LARGE_HIGH_DIM_DATA, TARGET_LARGE_HIGH_DIM_DATA, limit) assert(!nn.syns.isEmpty) } test("NeuralNetwork Test : Predict") { val result = nn.predict(UNLABELED_SMALL_HIGH_DIM_DATA) assert(matrixsimilar(result, TARGET_SMALL_HIGH_DIM_DATA, 0.2)) } }

Example 86

Project: reactiveinflux   Author: pygmalios   File: ExampleApplication.scala View Source Project(license)

5 votes

package com.example import java.net.URI import com.pygmalios.reactiveinflux.ReactiveInfluxDbName import com.pygmalios.reactiveinflux.command.query.BaseQueryCommand import com.pygmalios.reactiveinflux.itest.ITestConfig import com.pygmalios.reactiveinflux.response.EmptyJsonResponse import com.pygmalios.reactiveinflux.{ReactiveInflux, ReactiveInfluxCore} import org.scalatest.FunSuite import org.scalatest.concurrent.{IntegrationPatience, ScalaFutures} import play.api.libs.ws.{WSClient, WSResponse} class ExampleApplication extends FunSuite with ScalaFutures with IntegrationPatience { test("Execute custom command") { val reactiveInflux = ReactiveInflux(config = Some(ITestConfig.config)) try { implicit val dbName = ReactiveInfluxDbName("ExampleApplicatixon") val db = reactiveInflux.database try { val core = reactiveInflux.asInstanceOf[ReactiveInfluxCore] whenReady(core.execute(new CustomQueryCommand(core.config.url)).failed) { ex => } } finally { db.drop() } } finally { reactiveInflux.close() } } } class CustomQueryCommand(baseUri: URI) extends BaseQueryCommand(baseUri) { override type TResult = Unit override protected def responseFactory(wsResponse: WSResponse) = new CustomQueryCommandResponse(wsResponse) override def httpRequest(ws: WSClient) = ws.url(qUri("WHATEVER").toString) } class CustomQueryCommandResponse(wsResponse: WSResponse) extends EmptyJsonResponse(wsResponse)

Example 87

Project: functional-programming-scala   Author: borgees   File: CountChangeSuite.scala View Source Project (license)

5 votes

package recfun import org.scalatest.FunSuite import org.junit.runner.RunWith import org.scalatest.junit.JUnitRunner @RunWith(classOf[JUnitRunner]) class CountChangeSuite extends FunSuite { import Main.countChange test("countChange: example given in instructions") { assert(countChange(4,List(1,2)) === 3) } test("countChange: sorted CHF") { assert(countChange(300,List(5,10,20,50,100,200,500)) === 1022) } test("countChange: no pennies") { assert(countChange(301,List(5,10,20,50,100,200,500)) === 0) } test("countChange: unsorted CHF") { assert(countChange(300,List(500,5,50,100,20,200,10)) === 1022) } }

Example 88

Project: backprop   Author: andrisak   File: NetworkTest.scala View Source Project (license)

5 votes

package se.andrisak.backprop.algo import org.mockito.Mockito.when import org.scalatest.mock.MockitoSugar import org.scalatest.{BeforeAndAfterEach, FunSuite, Matchers} import scala.util.Random class NetworkTest extends FunSuite with BeforeAndAfterEach with Matchers with MockitoSugar { val RANDOM_VALUE = 0.2 val INPUT_LAYER_NEURON_COUNT = 1 val HIDDEN_LAYER_NEURON_COUNT = 1 val INPUT = 0.528593 val random = mock[Random] when(random.nextDouble()).thenReturn(RANDOM_VALUE) test("test that clearInput clears all node input") { val network = new Network(INPUT_LAYER_NEURON_COUNT, HIDDEN_LAYER_NEURON_COUNT, random) network.getInputLayer.neurons.head.addInput(0.534543) network.getHiddenLayer.neurons.head.addInput(0.6854543) network.clearInputs() network.getInputLayer.neurons.head.getInput should equal(0.0) network.getHiddenLayer.neurons.head.getInput should equal(0.0) } test("init of input layer should add the input to input neurons") { val network = new Network(INPUT_LAYER_NEURON_COUNT, HIDDEN_LAYER_NEURON_COUNT, random) network.initInputLayer(List(INPUT)) network.getInputLayer.neurons.head.getInput should equal(INPUT) } test("adding more input values than input neurons should throw an exception") { val network = new Network(INPUT_LAYER_NEURON_COUNT, HIDDEN_LAYER_NEURON_COUNT, random) intercept[IllegalArgumentException] { network.initInputLayer(List(INPUT, INPUT)) } } }

Example 89

Project: backprop   Author: andrisak   File: NeuronTest.scala View Source Project (license)

5 votes

package se.andrisak.backprop.algo import org.mockito.Mockito.when import org.scalatest.mock.MockitoSugar import org.scalatest.{BeforeAndAfterEach, FunSuite, Matchers} import scala.util.Random class NeuronTest extends FunSuite with BeforeAndAfterEach with Matchers with MockitoSugar { val NEURON_NAME = "neuron" val NEURON_NAME2 = "neuron2" val RANDOM_VALUE = 0.53 val random = mock[Random] when(random.nextDouble()).thenReturn(RANDOM_VALUE) val neuron = new Neuron(NEURON_NAME, random) test("input should be stored and be cleared") { val input = 0.543 neuron.addInput(input) neuron.getInput should equal (input) neuron.clearInput() neuron.getInput should equal (0) } test("neurons should be connected with a ForwardLink") { val neuron2 = new Neuron(NEURON_NAME2, random) neuron.connectToNeuronsInLayer(List(neuron2)) val link = neuron.getLinkTo(neuron2) link.to should equal(neuron2) link.weight should equal(RANDOM_VALUE) link should equal(neuron.getNextLayerLinks.head) } test("neurons should be connected with a ReverseLink") { val neuron2 = new Neuron(NEURON_NAME2, random) neuron.connectToNeuronsInPreviousLayer(List(neuron2)) neuron.getPreviousLayerNeurons.head should equal(neuron2) } test("test the sigmoid computation") { neuron.output should equal(0.5) } }

Example 90

Project: backprop   Author: andrisak   File: BackPropagationAlgoTest.scala View Source Project(license)

5 votes

package se.andrisak.backprop.algo import org.mockito.Mockito._ import org.scalatest.mock.MockitoSugar import org.scalatest.{BeforeAndAfterEach, FunSuite, Matchers} import se.andrisak.backprop.rest.model.ClassificationRequest.TrainingDataItem import scala.util.Random class BackPropagationAlgoTest extends FunSuite with BeforeAndAfterEach with Matchers with MockitoSugar { val ITERATIONS = 1 val TRAINING_DATA_FIRST_INPUT: Double = 1.0 val TRAINING_DATA_SECOND_INPUT: Double = 1.0 val TARGET: Double = 1.0 val RANDOM = 0.5 val EXPECTED_OUTPUT = 0.9439400108508628 var trainingData: TrainingDataItem = null override protected def beforeEach(): Unit = { trainingData = TrainingDataItem(TRAINING_DATA_FIRST_INPUT, TRAINING_DATA_SECOND_INPUT, TARGET) } test("test classify") { val random = mock[Random] when(random.nextDouble()).thenReturn(RANDOM) val bp = new BackPropagationAlgo(random) val output = bp.classify(ITERATIONS, Seq(trainingData), List(1.0, 1.0)) output should equal(EXPECTED_OUTPUT) } }

Example 91

Project: train-stamp-rally   Author: ponkotuy   File: TrainTimeSuite.scala View Source Project (license)

5 votes

package utils import org.scalatest.FunSuite class TrainTimeSuite extends FunSuite { test("TrainTime.addMinutes") { assert(TrainTime(6, 1).addMinutes(15) === TrainTime(6, 16)) assert(TrainTime(6, 23).addMinutes(-10) === TrainTime(6, 13)) } test("TrainTime.addMinutes if carry") { assert(TrainTime(6, 59).addMinutes(3) === TrainTime(7, 2)) assert(TrainTime(7, 3).addMinutes(-5) === TrainTime(6, 58)) } test("TrainTime.addMinutes if over hour") { assert(TrainTime(23, 44).addMinutes(25) === TrainTime(0, 9)) assert(TrainTime(0, 15).addMinutes(-18) === TrainTime(23, 57)) } }

Example 92

Project: scala_test   Author: oops   File: ComplexProperties.scala View Source Project (license)

5 votes

// src/main/scala/progscala2/toolslibs/toolslibs/ComplexProperties.scala package progscala2.toolslibs import org.scalatest.FunSuite import org.scalatest.prop.PropertyChecks class ComplexProperties extends FunSuite with PropertyChecks { def additionTest(a: Complex, b: Complex) = { assert( (a + b).real === (a.real + b.real) ) assert( (a + b).imaginary === (a.imaginary + b.imaginary) ) } def subtractionTest(a: Complex, b: Complex) = { assert( (a - b).real === (a.real - b.real) ) assert( (a - b).imaginary === (a.imaginary - b.imaginary) ) } val zero = Complex(0.0, 0.0) test ("Complex addition with the identity element (zero)") { forAll { (real: Double, imag: Double) => val c = Complex(real, imag) additionTest(zero, c) additionTest(c, zero) } } test ("Complex subtraction with the identity element (zero)") { forAll { (real: Double, imag: Double) => val c = Complex(real, imag) subtractionTest(zero, c) subtractionTest(c, zero) } } test ("Complex addition with two values") { forAll { (real1: Double, imag1: Double, real2: Double, imag2: Double) => val c1 = Complex(real1, imag1) val c2 = Complex(real2, imag2) additionTest(c1, c2) } } test ("Complex subtraction with two values") { forAll { (real1: Double, imag1: Double, real2: Double, imag2: Double) => val c1 = Complex(real1, imag1) val c2 = Complex(real2, imag2) subtractionTest(c1, c2) } } }

Example 93

Project: scala_test   Author: oops   File: ComplexSuite.scala View Source Project (license)

5 votes

// src/test/scala/progscala2/toolslibs/ComplexSuite.scala package progscala2.toolslibs import org.scalatest.FunSuite class ComplexSuite extends FunSuite { val c1 = Complex(1.2, 3.4) val c2 = Complex(5.6, 7.8) test("addition with (0, 0)") { assert(c1 + Complex(0.0, 0.0) === c1) } test("subtraction with (0, 0)") { assert(c1 - Complex(0.0, 0.0) === c1) } test("addition") { assert((c1 + c2).real === (c1.real + c2.real)) assert((c1 + c2).imaginary === (c1.imaginary + c2.imaginary)) } test("subtraction") { assert((c1 - c2).real === (c1.real - c2.real)) assert((c1 - c2).imaginary === (c1.imaginary - c2.imaginary)) } }

Example 94

Project: Scala-and-Spark-for-Big-Data-Analytics   Author: PacktPublishing   File: TransformationTestWithSparkTestingBase.scala View Source Project (license)

5 votes

package com.chapter16.SparkTesting import org.scalatest.Assertions._ import org.apache.spark.rdd.RDD import com.holdenkarau.spark.testing.SharedSparkContext import org.scalatest.FunSuite class TransformationTestWithSparkTestingBase extends FunSuite with SharedSparkContext { def tokenize(line: RDD[String]) = { line.map(x => x.split(' ')).collect() } test("works, obviously!") { assert(1 == 1) } test("Words counting") { assert(sc.parallelize("Hello world My name is Reza".split("\\W")).map(_ + 1).count == 6) } test("Testing RDD transformations using a shared Spark Context") { val input = List("Testing", "RDD transformations", "using a shared", "Spark Context") val expected = Array(Array("Testing"), Array("RDD", "transformations"), Array("using", "a", "shared"), Array("Spark", "Context")) val transformed = tokenize(sc.parallelize(input)) assert(transformed === expected) } }

Example 95

Project: practical-logic-handbook   Author: inpefess   File: TokenTypeTest.scala View Source Project(license)

5 votes

package chapter1 import org.scalatest.FunSuite import scala.util.{Failure, Success, Try} class TokenTypeTest extends FunSuite { test("testCharType") { assert(TokenType.charType('+') == TokenType.Symbolic) assert(TokenType.charType('1') == TokenType.Numeric) assert(TokenType.charType('A') == TokenType.Alphanumeric) assert(TokenType.charType(' ') == TokenType.Space) assert(TokenType.charType(',') == TokenType.Punctuation) // this character is Cyrillic Try(TokenType.charType('?')) match { case Success(_) => fail() case Failure(e) => assert(e.getMessage == "Unknown character: ?") } } }

Example 96

Project: practical-logic-handbook   Author: inpefess   File: LexerTest.scala View Source Project (license)

5 votes

package chapter1 import org.scalatest.{BeforeAndAfter, FunSuite} class LexerTest extends FunSuite with BeforeAndAfter { test("tokenize simple math") { assert( Lexer.toTokens("2*((var_1 + x’) + 11) ") == Vector("2", "*", "(", "(", "var_1", "+", "x’", ")", "+", "11", ")") ) } test("tokenize C++ like code") { assert( Lexer.toTokens("if (*p1-- == *p2++) then f() else g()") == Vector("if", "(", "*", "p1", "--", "==", "*", "p2", "++", ")", "then", "f", "(", ")", "else", "g", "(", ")") ) } test("empty line - no terms") { assert(Lexer.toTokens("") == Vector()) } }

Example 97

Project: practical-logic-handbook   Author: inpefess   File: PropositionalFormulaTest.scala View Source Project (license)

5 votes

package chapter2 import org.scalatest.FunSuite class PropositionalFormulaTest extends FunSuite { test("someImportantTautologies") { val p = Atom("p") val q = Atom("q") val r = Atom("r") assert(Iff(Not(True), False).isTautology) assert(Iff(Not(False), True).isTautology) assert(Iff(Not(Not(p)), p).isTautology) assert(Iff(And(p, False), False).isTautology) assert(Iff(And(p, True), p).isTautology) assert(Iff(And(p, p), p).isTautology) assert(Iff(And(p, Not(p)), False).isTautology) assert(Iff(And(p, q), And(q, p)).isTautology) assert(Iff(And(And(p, q), r), And(p, And(q, r))).isTautology) assert(Iff(Or(p, False), p).isTautology) assert(Iff(Or(p, True), True).isTautology) assert(Iff(Or(p, p), p).isTautology) assert(Iff(Or(p, Not(p)), True).isTautology) assert(Iff(Or(p, q), Or(q, p)).isTautology) assert(Iff(Or(Or(p, q), r), Or(p, Or(q, r))).isTautology) assert(Iff(And(p, Or(q, r)), Or(And(p, q), And(p, r))).isTautology) assert(Iff(Or(p, And(q, r)), And(Or(p, q), Or(p, r))).isTautology) assert(Iff(Imp(False, p), True).isTautology) assert(Iff(Imp(p, True), True).isTautology) assert(Iff(Imp(p, False), Not(p)).isTautology) assert(Iff(Imp(p, p), True).isTautology) assert(Iff(Imp(p, q), Imp(Not(q), Not(p))).isTautology) assert(Iff(Imp(p, q), Iff(p, And(p, q))).isTautology)assert(Iff(Imp(p, q),Iff(q,Or(q, p))).isTautology)assert(Iff(Iff(p, q),Iff(q, p)).isTautology)assert(Iff(Iff(Iff(p, q), r),Iff(p,Iff(q, r))).isTautology)}}

Example 98

Project: reactive.queue.router   Author: objektwerks   File: QueueRouterTest.scala View Source Project(license)

5 votes

package reactive.queue.router import com.typesafe.config.ConfigFactory import io.scalac.amqp.Connection import org.scalatest.{BeforeAndAfterAll, FunSuite} import scala.concurrent.Await import scala.concurrent.duration._ class QueueRouterTest extends FunSuite with BeforeAndAfterAll with QueueRouterSubscriber { implicit val ec = system.dispatcher override protected def beforeAll(): Unit = { server map { binding => val connection = Connection(ConfigFactory.load("test.reactive.queue.conf")) val subscription = QueueSubscription("test.reactive.queue", s"http://127.0.0.1:${binding.localAddress.getPort}/message") val prefetch = 10 system.actorOf(QueueRouter.props(connection, subscription, prefetch), name = "queue-router") } } override protected def afterAll(): Unit = { server map { binding => binding.unbind.onComplete { _ => Await.result(system.terminate(), 1 second) } } } test("router conf") { import net.ceedubs.ficus.Ficus._ import net.ceedubs.ficus.readers.ArbitraryTypeReader._ val conf = ConfigFactory.load("test.queue.router.conf").as[QueueRouterConf]("router") assert(conf.queueSubscriptions.nonEmpty) } test("router") { val count = 10 QueueLoader.load(source = "/test.json", total = count) while (counter.intValue != count) { Thread.sleep(500) } assert(counter.intValue == count) } }

Example 99

Project: typelevel   Author: objektwerks   File: ShowTest.scala View Source Project (license)

5 votes

package objektwerks.cats import org.scalatest.{FunSuite, Matchers} case class Actor(name: String) object Actor { import cats.Show implicit val actorShow: Show[Actor] = Show.show[Actor](_.name) } class ShowTest extends FunSuite with Matchers { test("instances") { import cats.Show import cats.instances.int._ val showInt = Show[Int] showInt.show(1) shouldEqual "1" } test("syntax") { import cats.instances.int._ import cats.syntax.show._ 1.show shouldEqual "1" } test("custom") { import cats.syntax.show._ val actor = Actor("Fred Flintstone") actor.show shouldEqual "Fred Flintstone" } }

Example 100

Project: spark-netsuite   Author: springml   File: TestCSVUtil.scala View Source Project (license)

4 votes

package com.springml.spark.netsuite.util import org.scalatest.{BeforeAndAfterEach, FunSuite} import org.scalatest.mock.MockitoSugar class TestCSVUtil extends FunSuite with MockitoSugar with BeforeAndAfterEach { test("Successfully reading CSV file") { val csvURL= getClass.getResource("/xpath.csv") val csvContent = CSVUtil.readCSV(csvURL.getPath) assert(csvContent.size == 6) assert(csvContent("Id").equals("string(/platformCore:record/@internalId)")) assert(csvContent("Entity").equals("/platformCore:record/listRel:entityId/text()")) assert(csvContent("Status").equals("/platformCore:record/listRel:entityStatus[@internalId=\"13\"]/platformCore:name/text()")) } }

https://www.programcreek.com/scala/org.scalatest.FunSuite