add pattern match to scala.js enum test

Author: bishabosha

tests/sjs-junit/test/org/scalajs/testsuite/compiler/EnumTestScala3.scala

@@ -3,22 +3,23 @@ package org.scalajs.testsuite.compiler
 import org.junit.Assert._
 import org.junit.Test
 
-object EnumTestScala3:
+class EnumTestScala3:
+  import EnumTestScala3._
 
-  enum Color1 derives Eql:
-    case Red, Green, Blue
+  @Test def testColor1(): Unit =
+    import EnumTestScala3.{Color1 => Color}
 
-  enum Color2 extends java.lang.Enum[Color2] derives Eql:
-    case Red, Green, Blue
+    def code(c: Color): Character = c match
+      case Color.Red   => 'R'
+      case Color.Green => 'G'
+      case Color.Blue  => 'B'
 
-  def color1(): Unit =
-    import EnumTestScala3.{Color1 => Color}
     assert(Color.Red.ordinal == 0)
     assert(Color.Green.ordinal == 1)
     assert(Color.Blue.ordinal == 2)
-    assert(Color.Red.enumLabel == "Red")
-    assert(Color.Green.enumLabel == "Green")
-    assert(Color.Blue.enumLabel == "Blue")
+    assert(Color.Red.productPrefix == "Red")
+    assert(Color.Green.productPrefix == "Green")
+    assert(Color.Blue.productPrefix == "Blue")
     assert(Color.valueOf("Red") == Color.Red)
     assert(Color.valueOf("Green") == Color.Green)
     assert(Color.valueOf("Blue") == Color.Blue)
@@ -27,16 +28,26 @@ object EnumTestScala3:
     assert(Color.values(0) == Color.Red)
     assert(Color.values(1) == Color.Green)
     assert(Color.values(2) == Color.Blue)
-  end color1
+    assert(code(Color.Red)   == 'R')
+    assert(code(Color.Green) == 'G')
+    assert(code(Color.Blue)  == 'B')
+
+  end testColor1
 
-  def color2(): Unit = // copied from `color1`
+  @Test def testColor2(): Unit =  // copied from `color1`
     import EnumTestScala3.{Color2 => Color}
+
+    def code(c: Color): Character = c match
+      case Color.Red   => 'R'
+      case Color.Green => 'G'
+      case Color.Blue  => 'B'
+
     assert(Color.Red.ordinal == 0)
     assert(Color.Green.ordinal == 1)
     assert(Color.Blue.ordinal == 2)
-    assert(Color.Red.enumLabel == "Red")
-    assert(Color.Green.enumLabel == "Green")
-    assert(Color.Blue.enumLabel == "Blue")
+    assert(Color.Red.productPrefix == "Red")
+    assert(Color.Green.productPrefix == "Green")
+    assert(Color.Blue.productPrefix == "Blue")
     assert(Color.valueOf("Red") == Color.Red)
     assert(Color.valueOf("Green") == Color.Green)
     assert(Color.valueOf("Blue") == Color.Blue)
@@ -45,27 +56,26 @@ object EnumTestScala3:
     assert(Color.values(0) == Color.Red)
     assert(Color.values(1) == Color.Green)
     assert(Color.values(2) == Color.Blue)
-  end color2
-
-  // test "non-simple" cases with anonymous subclasses
-  enum Currency1(val dollarValue: Double) derives Eql:
-    case Dollar    extends Currency1(1.0)
-    case SwissFanc extends Currency1(1.09)
-    case Euro      extends Currency1(1.18)
+    assert(code(Color.Red)   == 'R')
+    assert(code(Color.Green) == 'G')
+    assert(code(Color.Blue)  == 'B')
 
-  enum Currency2(val dollarValue: Double) extends java.lang.Enum[Currency2] derives Eql:
-    case Dollar    extends Currency2(1.0)
-    case SwissFanc extends Currency2(1.09)
-    case Euro      extends Currency2(1.18)
+  end testColor2
 
-  def currency1(): Unit =
+  @Test def testCurrency1(): Unit =
     import EnumTestScala3.{Currency1 => Currency}
+
+    def code(c: Currency): String = c match
+      case Currency.Dollar    => "USD"
+      case Currency.SwissFanc => "CHF"
+      case Currency.Euro      => "EUR"
+
     assert(Currency.Dollar.ordinal == 0)
     assert(Currency.SwissFanc.ordinal == 1)
     assert(Currency.Euro.ordinal == 2)
-    assert(Currency.Dollar.enumLabel == "Dollar")
-    assert(Currency.SwissFanc.enumLabel == "SwissFanc")
-    assert(Currency.Euro.enumLabel == "Euro")
+    assert(Currency.Dollar.productPrefix == "Dollar")
+    assert(Currency.SwissFanc.productPrefix == "SwissFanc")
+    assert(Currency.Euro.productPrefix == "Euro")
     assert(Currency.valueOf("Dollar") == Currency.Dollar)
     assert(Currency.valueOf("SwissFanc") == Currency.SwissFanc)
     assert(Currency.valueOf("Euro") == Currency.Euro)
@@ -77,16 +87,27 @@ object EnumTestScala3:
     assert(Currency.Dollar.dollarValue == 1.00)
     assert(Currency.SwissFanc.dollarValue == 1.09)
     assert(Currency.Euro.dollarValue == 1.18)
-  end currency1
+    assert(code(Currency.Dollar)    == "USD")
+    assert(code(Currency.SwissFanc) == "CHF")
+    assert(code(Currency.Euro)      == "EUR")
+
 
-  def currency2(): Unit = // copied from `currency1`
+  end testCurrency1
+
+  @Test def testCurrency2(): Unit = // copied from `testCurrency1`
     import EnumTestScala3.{Currency2 => Currency}
+
+    def code(c: Currency): String = c match
+      case Currency.Dollar    => "USD"
+      case Currency.SwissFanc => "CHF"
+      case Currency.Euro      => "EUR"
+
     assert(Currency.Dollar.ordinal == 0)
     assert(Currency.SwissFanc.ordinal == 1)
     assert(Currency.Euro.ordinal == 2)
-    assert(Currency.Dollar.enumLabel == "Dollar")
-    assert(Currency.SwissFanc.enumLabel == "SwissFanc")
-    assert(Currency.Euro.enumLabel == "Euro")
+    assert(Currency.Dollar.productPrefix == "Dollar")
+    assert(Currency.SwissFanc.productPrefix == "SwissFanc")
+    assert(Currency.Euro.productPrefix == "Euro")
     assert(Currency.valueOf("Dollar") == Currency.Dollar)
     assert(Currency.valueOf("SwissFanc") == Currency.SwissFanc)
     assert(Currency.valueOf("Euro") == Currency.Euro)
@@ -98,26 +119,51 @@ object EnumTestScala3:
     assert(Currency.Dollar.dollarValue == 1.00)
     assert(Currency.SwissFanc.dollarValue == 1.09)
     assert(Currency.Euro.dollarValue == 1.18)
-  end currency2
+    assert(code(Currency.Dollar)    == "USD")
+    assert(code(Currency.SwissFanc) == "CHF")
+    assert(code(Currency.Euro)      == "EUR")
 
-  enum Opt[+T]:
-    case Sm[+T1](value: T1) extends Opt[T1]
-    case Nn                 extends Opt[Nothing]
+  end testCurrency2
+
+  @Test def testOpt(): Unit =
+
+    def encode[T <: AnyVal](t: Opt[T]): T | Null = t match
+      case Opt.Sm(t) => t
+      case Opt.Nn    => null
 
-  def opt(): Unit =
     assert(Opt.Sm(1).ordinal == 0)
     assert(Opt.Nn.ordinal == 1)
-    assert(Opt.Sm(1).enumLabel == "Sm")
-    assert(Opt.Nn.enumLabel == "Nn")
+    assert(Opt.Sm(1).productPrefix == "Sm")
+    assert(Opt.Nn.productPrefix == "Nn")
     assert(Opt.valueOf("Nn") == Opt.Nn)
     assert(Opt.values(0) == Opt.Nn)
     assert(Opt.Sm("hello").value == "hello")
-  end opt
+    assert(encode(Opt.Sm(23)) == 23)
+    assert(encode(Opt.Nn)     == null)
 
-class EnumTestScala3:
-  import EnumTestScala3._
-  @Test def testColor1(): Unit = color1()
-  @Test def testColor2(): Unit = color2()
-  @Test def testCurrency1(): Unit = currency1()
-  @Test def testCurrency2(): Unit = currency2()
-  @Test def testOpt(): Unit = opt()
+  end testOpt
+
+object EnumTestScala3:
+
+  enum Color1 derives Eql:
+    case Red, Green, Blue
+
+  enum Color2 extends java.lang.Enum[Color2] derives Eql:
+    case Red, Green, Blue
+
+  // test "non-simple" cases with anonymous subclasses
+  enum Currency1(val dollarValue: Double) derives Eql:
+    case Dollar    extends Currency1(1.0)
+    case SwissFanc extends Currency1(1.09)
+    case Euro      extends Currency1(1.18)
+
+  enum Currency2(val dollarValue: Double) extends java.lang.Enum[Currency2] derives Eql:
+    case Dollar    extends Currency2(1.0)
+    case SwissFanc extends Currency2(1.09)
+    case Euro      extends Currency2(1.18)
+
+  enum Opt[+T]:
+    case Sm[+T1](value: T1) extends Opt[T1]
+    case Nn                 extends Opt[Nothing]
+
+end EnumTestScala3