Comment écrire un ScalaTest pour une méthode de correspondance de motif qui utilise une collection Carte

Question

Je suis en train d'écrire mon premier ensemble de tests ScalaTest pour l'objet Scala suivant qui convertit le temps en format 24 heures (00:00 à 24:00) dans le temps comme des mots (huit heures avant midi, huit heures et demie avant midi, quart à neuf heures avant midi). Je cherche un point de départ dans la façon d'écrire des tests pour hourFmt, minutesFmt et Fmt qui utilisent la correspondance de modèle et une collection de cartes pour retourner le mot approprié pour une valeur entière pour les heures et les minutes.

J'ai lu la plupart des ScalaTest Documentation Guide de l'utilisateur, mais n'a pas pu trouver de la documentation sur le modèle des méthodes d'appariement ou collections Carte. Je cherche juste un point de départ ou des exemples que la communauté est au courant car ce qui suit sera la première fois que j'écris des tests unitaires.

Je joins mon code ci-dessous pour clarifier les trois méthodes que j'ai parlé.

object TimeAsWords extends App { 
    def parseTime(hhmm: String): (Int, Int) = { 
    """^([01]\d|2[0-4]):([0-5]\d)$""".r.findAllIn(hhmm).matchData foreach { 
     md => return (md.group(1).toInt, md.group(2).toInt) 
    } 
    throw new IllegalArgumentException("Input string doesn't match required format: 00:00 - 24:00") 
    } 

    def formatTime(hhmm: (Int, Int)): String = { 
    val englishNum = Map(
     1 -> "one", 2 -> "two", 3 -> "three", 4 -> "four", 5 -> "five", 
     6 -> "six", 7 -> "seven", 8 -> "eight", 9 -> "nine", 10 -> "ten", 
     11 -> "eleven", 12 -> "twelve", 13 -> "thirteen", 14 -> "fourteen", 
     16 -> "sixteen", 17 -> "seventeen", 18 -> "eighteen", 19 -> "nineteen", 
     20 -> "twenty", 21 -> "twenty-one", 22 -> "twenty-two", 
     23 -> "twenty-three", 24 -> "twenty-four", 25 -> "twenty-five", 
     26 -> "twenty-six", 27 -> "twenty-seven", 28 -> "twenty-eight", 
     29 -> "twenty-nine" 
    ) 

    def hourFmt(h: Int): String = h match { 
     case 0 | 24  => "midnight" 
     case 12   => "noon" 
     case _ if h < 12 => englishNum(h) + " o'clock before midday" 
     case _   => englishNum(h - 12) + " o'clock after midday" 
    } 

    def minuteFmt(m: Int): String = "%s %s".format(
     englishNum(m), 
     if (m == 1) "minute" else "minutes" 
    ) 

    def fmt(m: Int): (Int => String) = m match { 
     case 0   => hourFmt 
     case 15   => "quarter past " + hourFmt(_) 
     case 30   => "half past " + hourFmt(_) 
     case 45   => h => "quarter to " + hourFmt(h + 1) 
     case _ if m < 30 => h => "%s past %s".format(minuteFmt(m), hourFmt(h)) 
     case _   => h => "%s to %s".format(minuteFmt(60 - m), hourFmt(h + 1)) 
    } 

    val (hh, mm) = hhmm 
    fmt(mm)(hh).capitalize 
    } 

    try { 
    println(formatTime(parseTime(args(0)))) 
    } catch { 
    case e: IllegalArgumentException => System.err.println(e.getMessage) 
     System.exit(1) 
    } 
} 

Answer 1

Je souhaite publier la réponse à ma propre question, mais voudrais trouver une meilleure façon de tests unitaires d'écriture pour une fmt fonction qui utilise la correspondance de modèles qui est tributaire de deux autres fonctions hourFmt et minutesFmt.

ScalaTest actuel que j'ai écrit:

package time 

import TimeAsWords._ 
import org.scalatest.FunSuite 

/** 
    * Created by PeterW on 6/18/2017. 
    */ 
class TimeAsWordsTest extends FunSuite { 
    test("testParseTime - 00:00") { 
    assert(parseTime("00:00") == (0,0)) 
    } 
    test("testParseTime - IllegalArgumentException") { 
    val thrown = intercept[Exception] { 
     parseTime("25:00") 
    } 
    assert(thrown.getMessage == "Input string doesn't match required format: 00:00 - 24:00") 
    } 
    test("testFormatTime - Midnight") { 
    assert(formatTime((0,0)) == "Midnight") 
    } 
    test("testFormatTime - Noon") { 
    assert(formatTime((12,0)) == "Noon") 
    } 
    test("testFormatTime - o'clock before midday") { 
    assert(formatTime((8,0)) == "Eight o'clock before midday") 
    } 
    test("testFormatTime - o'clock after midday") { 
    assert(formatTime((13,0)) == "One o'clock after midday") 
    } 
    test("testFormatTime - Quater past") { 
    assert(formatTime((13,15)) == "Quarter past one after midday") 
    } 
    test("testFormatTime - Half past") { 
    assert(formatTime((13,30)) == "Half past one after midday") 
    } 
    test("testFormatTime - Quarter to") { 
    assert(formatTime((13,45)) == "Quarter to two after midday") 
    } 
    test("testFormatTime - Minutes past hour") { 
    assert(formatTime((13,25)) == "Twenty-five minutes past one after midday") 
    } 
    test("testFormatTime - Minutes to hour") { 
    assert(formatTime((13,35)) == "Twenty-five minutes to two after midday") 
    } 
    test("testFormatTime - Minute singular") { 
    assert(formatTime((13,1)) == "One minute past one after midday") 
    } 
    test("testFormatTime - Minutes plural") { 
    assert(formatTime((13,2)) == "Two minutes past one after midday") 
    } 
}