From 277f3b77e29610f6e569cb7ce962bc74b2957e6a Mon Sep 17 00:00:00 2001 From: Martijn Hoekstra Date: Wed, 3 Jun 2020 22:43:17 +0200 Subject: [PATCH] work around incorrectly unexpanded names --- .../tools/nsc/transform/Constructors.scala | 22 +- .../scala/reflect/internal/StdNames.scala | 3 + test/files/run/t10625.check | 3 + test/files/run/t10625.scala | 4 + test/files/run/t8831_many/Classes_1.scala | 2577 ++++++----------- test/files/run/t8831_many/Tests_2.scala | 2199 +++++--------- test/files/run/t8831_many/generator.scala | 12 +- 7 files changed, 1643 insertions(+), 3177 deletions(-) create mode 100644 test/files/run/t10625.check create mode 100644 test/files/run/t10625.scala diff --git a/src/compiler/scala/tools/nsc/transform/Constructors.scala b/src/compiler/scala/tools/nsc/transform/Constructors.scala index 5cb6955a0bc5..8b80df2b247c 100644 --- a/src/compiler/scala/tools/nsc/transform/Constructors.scala +++ b/src/compiler/scala/tools/nsc/transform/Constructors.scala @@ -474,15 +474,21 @@ abstract class Constructors extends Statics with Transform with TypingTransforme def usesSpecializedField = intoConstructor.usesSpecializedField // The constructor parameter corresponding to an accessor - def parameter(acc: Symbol): Symbol = parameterNamed(acc.unexpandedName.getterName) + def parameter(acc: Symbol): Symbol = { + import scala.util.Try + //works around the edge case where unexpandedName over-unexpands shenanigans like literal $$ or `$#` + def unexpanded = parameterNamed(acc.unexpandedName.getterName) + def expanded = parameterNamed(acc.getterName) + unexpanded.orElse(expanded).swap.map(abort).merge + } - // The constructor parameter with given name. This means the parameter - // has given name, or starts with given name, and continues with a `$` afterwards. - def parameterNamed(name: Name): Symbol = + // The constructor parameter with given getter name. This means the parameter name + // decodes to the same name that the getter decodes to + def parameterNamed(name: Name): Either[String, Symbol] = primaryConstrParams.filter(_.name.decodedName == name.decodedName) match { - case List(p) => p - case Nil => abort(s"$name not in $primaryConstrParams") - case ps => abort(s"$name matches multiple constructor paramters $ps") + case List(p) => Right(p) + case Nil => Left(s"No constructor parameter named $name (decoded to ${name.decodedName}) found in list of constructor parameters $primaryConstrParams (decoded to ${primaryConstrParams.map(_.decodedName)})") + case ps => Left(s"$name matches multiple constructor parameters $ps") } // A transformer for expressions that go into the constructor @@ -529,7 +535,7 @@ abstract class Constructors extends Statics with Transform with TypingTransforme else if (canBeSupplanted(tree.symbol)) gen.mkAttributedIdent(parameter(tree.symbol)) setPos tree.pos else if (tree.symbol.outerSource == clazz && !isDelayedInitSubclass) - gen.mkAttributedIdent(parameterNamed(nme.OUTER)) setPos tree.pos + gen.mkAttributedIdent(parameterNamed(nme.OUTER).fold(abort, identity)).setPos(tree.pos) else super.transform(tree) diff --git a/src/reflect/scala/reflect/internal/StdNames.scala b/src/reflect/scala/reflect/internal/StdNames.scala index f29e8046379b..213a2738bf1a 100644 --- a/src/reflect/scala/reflect/internal/StdNames.scala +++ b/src/reflect/scala/reflect/internal/StdNames.scala @@ -437,6 +437,9 @@ trait StdNames { * Look backward from the end of the string for "$$", and take the * part of the string after that; but if the string is "$$$" or longer, * be sure to retain the extra dollars. + * If the name happens to be a back quoted name containing literal $$ + * or $ followed by an operator that gets encoded, go directly to compiler + * crash. Do not pass go and don't even think about collecting any $$ */ def unexpandedName(name: Name): Name = name lastIndexOf "$$" match { case 0 | -1 => name diff --git a/test/files/run/t10625.check b/test/files/run/t10625.check new file mode 100644 index 000000000000..a65cf05470e7 --- /dev/null +++ b/test/files/run/t10625.check @@ -0,0 +1,3 @@ +1 +1 +Some(1) diff --git a/test/files/run/t10625.scala b/test/files/run/t10625.scala new file mode 100644 index 000000000000..a7263dc05d77 --- /dev/null +++ b/test/files/run/t10625.scala @@ -0,0 +1,4 @@ +case class WhyNot(`^$#`: Int) +object Test extends App { + val wn = WhyNot(1) +} diff --git a/test/files/run/t8831_many/Classes_1.scala b/test/files/run/t8831_many/Classes_1.scala index 1f10723e8898..e75474b447bc 100644 --- a/test/files/run/t8831_many/Classes_1.scala +++ b/test/files/run/t8831_many/Classes_1.scala @@ -1,2011 +1,1120 @@ -case class Ctpvtpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ +case class Cpvt_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ val p1 = `a b` val p2 = a } -case class Ctpvtpvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ +case class Cpvt_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ val p1 = `a b` } -case class Ctpvtvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ +case class Cpvt_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ val p1 = `a b` val p2 = a } -case class Ctpvtvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ +case class Cpvt_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ val p1 = `a b` } -case class Ctpvtnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ +case class Cpvt_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ val p1 = `a b` val p2 = a } -case class Ctpvtnf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ +case class Cpvt_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ val p1 = `a b` } -case class Ctpvfpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ +case class Cpvf_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ val p2 = a } -case class Ctpvfvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ - val p2 = a - - } -case class Ctpvfnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ - val p2 = a - - } -case class Ctvtpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ - val p1 = `a b` -val p2 = a - - } -case class Ctvtpvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ - val p1 = `a b` - - } -case class Ctvtvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ - val p1 = `a b` -val p2 = a - - } -case class Ctvtvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ - val p1 = `a b` - - } -case class Ctvtnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ - val p1 = `a b` -val p2 = a - - } -case class Ctvtnf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ - val p1 = `a b` - - } -case class Ctvfpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ - val p2 = a - - } -case class Ctvfvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ - val p2 = a - - } -case class Ctvfnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ - val p2 = a - - } -case class Ctntpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ - val p1 = `a b` -val p2 = a - - } -case class Ctntpvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ - val p1 = `a b` - - } -case class Ctntvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ - val p1 = `a b` -val p2 = a - - } -case class Ctntvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ - val p1 = `a b` - - } -case class Ctntnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ - val p1 = `a b` -val p2 = a - - } -case class Ctntnf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ - val p1 = `a b` - - } -case class Ctnfpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ - val p2 = a - - } -case class Ctnfvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ - val p2 = a - - } -case class Ctnfnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ - val p2 = a - - } -case class Cfpvtpvt[A, B](private val `a b`: A, private val a: B){ - val p1 = `a b` -val p2 = a - - } -case class Cfpvtpvf[A, B](private val `a b`: A, private val a: B){ - val p1 = `a b` - - } -case class Cfpvtvt[A, B](private val `a b`: A, val a: B){ - val p1 = `a b` -val p2 = a - - } -case class Cfpvtvf[A, B](private val `a b`: A, val a: B){ - val p1 = `a b` - - } -case class Cfpvtnt[A, B](private val `a b`: A, a: B){ - val p1 = `a b` -val p2 = a - - } -case class Cfpvtnf[A, B](private val `a b`: A, a: B){ - val p1 = `a b` - - } -case class Cfpvfpvt[A, B](private val `a b`: A, private val a: B){ - val p2 = a - - } -case class Cfpvfpvf[A, B](private val `a b`: A, private val a: B){ +case class Cpvf_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ } -case class Cfpvfvt[A, B](private val `a b`: A, val a: B){ +case class Cpvf_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ val p2 = a } -case class Cfpvfvf[A, B](private val `a b`: A, val a: B){ +case class Cpvf_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ } -case class Cfpvfnt[A, B](private val `a b`: A, a: B){ +case class Cpvf_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ val p2 = a } -case class Cfpvfnf[A, B](private val `a b`: A, a: B){ +case class Cpvf_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ } -case class Cfvtpvt[A, B](val `a b`: A, private val a: B){ +case class Cvt_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ val p1 = `a b` val p2 = a } -case class Cfvtpvf[A, B](val `a b`: A, private val a: B){ +case class Cvt_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ val p1 = `a b` } -case class Cfvtvt[A, B](val `a b`: A, val a: B){ +case class Cvt_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ val p1 = `a b` val p2 = a } -case class Cfvtvf[A, B](val `a b`: A, val a: B){ +case class Cvt_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ val p1 = `a b` } -case class Cfvtnt[A, B](val `a b`: A, a: B){ +case class Cvt_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ val p1 = `a b` val p2 = a } -case class Cfvtnf[A, B](val `a b`: A, a: B){ +case class Cvt_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ val p1 = `a b` } -case class Cfvfpvt[A, B](val `a b`: A, private val a: B){ +case class Cvf_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ val p2 = a } -case class Cfvfpvf[A, B](val `a b`: A, private val a: B){ +case class Cvf_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ } -case class Cfvfvt[A, B](val `a b`: A, val a: B){ +case class Cvf_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ val p2 = a } -case class Cfvfvf[A, B](val `a b`: A, val a: B){ +case class Cvf_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ } -case class Cfvfnt[A, B](val `a b`: A, a: B){ +case class Cvf_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ val p2 = a } -case class Cfvfnf[A, B](val `a b`: A, a: B){ +case class Cvf_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ } -case class Cfntpvt[A, B]( `a b`: A, private val a: B){ +case class Cnt_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ val p1 = `a b` val p2 = a } -case class Cfntpvf[A, B]( `a b`: A, private val a: B){ +case class Cnt_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ val p1 = `a b` } -case class Cfntvt[A, B]( `a b`: A, val a: B){ +case class Cnt_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ val p1 = `a b` val p2 = a } -case class Cfntvf[A, B]( `a b`: A, val a: B){ +case class Cnt_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ val p1 = `a b` } -case class Cfntnt[A, B]( `a b`: A, a: B){ +case class Cnt_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ val p1 = `a b` val p2 = a } -case class Cfntnf[A, B]( `a b`: A, a: B){ +case class Cnt_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ val p1 = `a b` } -case class Cfnfpvt[A, B]( `a b`: A, private val a: B){ +case class Cnf_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ val p2 = a } -case class Cfnfpvf[A, B]( `a b`: A, private val a: B){ +case class Cnf_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ } -case class Cfnfvt[A, B]( `a b`: A, val a: B){ +case class Cnf_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ val p2 = a } -case class Cfnfvf[A, B]( `a b`: A, val a: B){ +case class Cnf_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ } -case class Cfnfnt[A, B]( `a b`: A, a: B){ +case class Cnf_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ val p2 = a } -case class Cfnfnf[A, B]( `a b`: A, a: B){ +case class Cnf_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ } - class Rtpvtpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ + class Rpvt_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ val p1 = `a b` val p2 = a } - class Rtpvtpvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ + class Rpvt_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ val p1 = `a b` } - class Rtpvtvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ + class Rpvt_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ val p1 = `a b` val p2 = a } - class Rtpvtvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ + class Rpvt_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ val p1 = `a b` } - class Rtpvtnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ + class Rpvt_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ val p1 = `a b` val p2 = a } - class Rtpvtnf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ + class Rpvt_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ val p1 = `a b` } - class Rtpvfpvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ - val p2 = a - - } - class Rtpvfvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ - val p2 = a - - } - class Rtpvfnt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ + class Rpvf_pvt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ val p2 = a } - class Rtvtpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ - val p1 = `a b` -val p2 = a - - } - class Rtvtpvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ - val p1 = `a b` - - } - class Rtvtvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ - val p1 = `a b` -val p2 = a - - } - class Rtvtvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ - val p1 = `a b` - - } - class Rtvtnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ - val p1 = `a b` -val p2 = a - - } - class Rtvtnf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ - val p1 = `a b` - - } - class Rtvfpvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ - val p2 = a - - } - class Rtvfvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ - val p2 = a - - } - class Rtvfnt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ - val p2 = a - - } - class Rtntpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ - val p1 = `a b` -val p2 = a - - } - class Rtntpvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ - val p1 = `a b` - - } - class Rtntvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ - val p1 = `a b` -val p2 = a - - } - class Rtntvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ - val p1 = `a b` - - } - class Rtntnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ - val p1 = `a b` -val p2 = a - - } - class Rtntnf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ - val p1 = `a b` - - } - class Rtnfpvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ - val p2 = a - - } - class Rtnfvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ - val p2 = a - - } - class Rtnfnt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ - val p2 = a - - } - class Rfpvtpvt[A, B](private val `a b`: A, private val a: B){ - val p1 = `a b` -val p2 = a - - } - class Rfpvtpvf[A, B](private val `a b`: A, private val a: B){ - val p1 = `a b` - - } - class Rfpvtvt[A, B](private val `a b`: A, val a: B){ - val p1 = `a b` -val p2 = a - - } - class Rfpvtvf[A, B](private val `a b`: A, val a: B){ - val p1 = `a b` - - } - class Rfpvtnt[A, B](private val `a b`: A, a: B){ - val p1 = `a b` -val p2 = a - - } - class Rfpvtnf[A, B](private val `a b`: A, a: B){ - val p1 = `a b` - - } - class Rfpvfpvt[A, B](private val `a b`: A, private val a: B){ - val p2 = a - - } - class Rfpvfpvf[A, B](private val `a b`: A, private val a: B){ + class Rpvf_pvf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, private val a: B){ } - class Rfpvfvt[A, B](private val `a b`: A, val a: B){ + class Rpvf_vt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ val p2 = a } - class Rfpvfvf[A, B](private val `a b`: A, val a: B){ + class Rpvf_vf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, val a: B){ } - class Rfpvfnt[A, B](private val `a b`: A, a: B){ + class Rpvf_nt[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ val p2 = a } - class Rfpvfnf[A, B](private val `a b`: A, a: B){ + class Rpvf_nf[@specialized(Int) A, @specialized(Int) B](private val `a b`: A, a: B){ } - class Rfvtpvt[A, B](val `a b`: A, private val a: B){ + class Rvt_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ val p1 = `a b` val p2 = a } - class Rfvtpvf[A, B](val `a b`: A, private val a: B){ + class Rvt_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ val p1 = `a b` } - class Rfvtvt[A, B](val `a b`: A, val a: B){ + class Rvt_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ val p1 = `a b` val p2 = a } - class Rfvtvf[A, B](val `a b`: A, val a: B){ + class Rvt_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ val p1 = `a b` } - class Rfvtnt[A, B](val `a b`: A, a: B){ + class Rvt_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ val p1 = `a b` val p2 = a } - class Rfvtnf[A, B](val `a b`: A, a: B){ + class Rvt_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ val p1 = `a b` } - class Rfvfpvt[A, B](val `a b`: A, private val a: B){ + class Rvf_pvt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ val p2 = a } - class Rfvfpvf[A, B](val `a b`: A, private val a: B){ + class Rvf_pvf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, private val a: B){ } - class Rfvfvt[A, B](val `a b`: A, val a: B){ + class Rvf_vt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ val p2 = a } - class Rfvfvf[A, B](val `a b`: A, val a: B){ + class Rvf_vf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, val a: B){ } - class Rfvfnt[A, B](val `a b`: A, a: B){ + class Rvf_nt[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ val p2 = a } - class Rfvfnf[A, B](val `a b`: A, a: B){ + class Rvf_nf[@specialized(Int) A, @specialized(Int) B](val `a b`: A, a: B){ } - class Rfntpvt[A, B]( `a b`: A, private val a: B){ + class Rnt_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ val p1 = `a b` val p2 = a } - class Rfntpvf[A, B]( `a b`: A, private val a: B){ + class Rnt_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ val p1 = `a b` } - class Rfntvt[A, B]( `a b`: A, val a: B){ + class Rnt_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ val p1 = `a b` val p2 = a } - class Rfntvf[A, B]( `a b`: A, val a: B){ + class Rnt_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ val p1 = `a b` } - class Rfntnt[A, B]( `a b`: A, a: B){ + class Rnt_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ val p1 = `a b` val p2 = a } - class Rfntnf[A, B]( `a b`: A, a: B){ + class Rnt_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ val p1 = `a b` } - class Rfnfpvt[A, B]( `a b`: A, private val a: B){ + class Rnf_pvt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ val p2 = a } - class Rfnfpvf[A, B]( `a b`: A, private val a: B){ + class Rnf_pvf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, private val a: B){ } - class Rfnfvt[A, B]( `a b`: A, val a: B){ + class Rnf_vt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ val p2 = a } - class Rfnfvf[A, B]( `a b`: A, val a: B){ + class Rnf_vf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, val a: B){ } - class Rfnfnt[A, B]( `a b`: A, a: B){ + class Rnf_nt[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ val p2 = a } - class Rfnfnf[A, B]( `a b`: A, a: B){ + class Rnf_nf[@specialized(Int) A, @specialized(Int) B]( `a b`: A, a: B){ } object TestJoint { def joint(): Unit = { -val ch_Ctpvtpvt = new Ctpvtpvt('a', 'b') -val i_Ctpvtpvt = new Ctpvtpvt(1, 2) -val Ctpvtpvt(extracted1i_Ctpvtpvt, extracted2i_Ctpvtpvt) = i_Ctpvtpvt -val Ctpvtpvt(extracted1ch_Ctpvtpvt, extracted2ch_Ctpvtpvt) = ch_Ctpvtpvt -assert(1 == extracted1i_Ctpvtpvt) -assert(2 == extracted2i_Ctpvtpvt) -assert('a' == extracted1ch_Ctpvtpvt) -assert('b' == extracted2ch_Ctpvtpvt) - -assert(1 == i_Ctpvtpvt.p1) -assert(2 == i_Ctpvtpvt.p2) -assert('a' == ch_Ctpvtpvt.p1) -assert('b' == ch_Ctpvtpvt.p2) - - -val ch_Ctpvtpvf = new Ctpvtpvf('a', 'b') -val i_Ctpvtpvf = new Ctpvtpvf(1, 2) -val Ctpvtpvf(extracted1i_Ctpvtpvf, extracted2i_Ctpvtpvf) = i_Ctpvtpvf -val Ctpvtpvf(extracted1ch_Ctpvtpvf, extracted2ch_Ctpvtpvf) = ch_Ctpvtpvf -assert(1 == extracted1i_Ctpvtpvf) -assert(2 == extracted2i_Ctpvtpvf) -assert('a' == extracted1ch_Ctpvtpvf) -assert('b' == extracted2ch_Ctpvtpvf) - -assert(1 == i_Ctpvtpvf.p1) -assert('a' == ch_Ctpvtpvf.p1) - - -val ch_Ctpvtvt = new Ctpvtvt('a', 'b') -val i_Ctpvtvt = new Ctpvtvt(1, 2) -val Ctpvtvt(extracted1i_Ctpvtvt, extracted2i_Ctpvtvt) = i_Ctpvtvt -val Ctpvtvt(extracted1ch_Ctpvtvt, extracted2ch_Ctpvtvt) = ch_Ctpvtvt -assert(1 == extracted1i_Ctpvtvt) -assert(2 == extracted2i_Ctpvtvt) -assert('a' == extracted1ch_Ctpvtvt) -assert('b' == extracted2ch_Ctpvtvt) - -assert(2 == i_Ctpvtvt.a) -assert('b' == ch_Ctpvtvt.a) -assert(1 == i_Ctpvtvt.p1) -assert(2 == i_Ctpvtvt.p2) -assert('a' == ch_Ctpvtvt.p1) -assert('b' == ch_Ctpvtvt.p2) - - -val ch_Ctpvtvf = new Ctpvtvf('a', 'b') -val i_Ctpvtvf = new Ctpvtvf(1, 2) -val Ctpvtvf(extracted1i_Ctpvtvf, extracted2i_Ctpvtvf) = i_Ctpvtvf -val Ctpvtvf(extracted1ch_Ctpvtvf, extracted2ch_Ctpvtvf) = ch_Ctpvtvf -assert(1 == extracted1i_Ctpvtvf) -assert(2 == extracted2i_Ctpvtvf) -assert('a' == extracted1ch_Ctpvtvf) -assert('b' == extracted2ch_Ctpvtvf) - -assert(2 == i_Ctpvtvf.a) -assert('b' == ch_Ctpvtvf.a) -assert(1 == i_Ctpvtvf.p1) -assert('a' == ch_Ctpvtvf.p1) - - -val ch_Ctpvtnt = new Ctpvtnt('a', 'b') -val i_Ctpvtnt = new Ctpvtnt(1, 2) -val Ctpvtnt(extracted1i_Ctpvtnt, extracted2i_Ctpvtnt) = i_Ctpvtnt -val Ctpvtnt(extracted1ch_Ctpvtnt, extracted2ch_Ctpvtnt) = ch_Ctpvtnt -assert(1 == extracted1i_Ctpvtnt) -assert(2 == extracted2i_Ctpvtnt) -assert('a' == extracted1ch_Ctpvtnt) -assert('b' == extracted2ch_Ctpvtnt) - -assert(2 == i_Ctpvtnt.a) -assert('b' == ch_Ctpvtnt.a) -assert(1 == i_Ctpvtnt.p1) -assert(2 == i_Ctpvtnt.p2) -assert('a' == ch_Ctpvtnt.p1) -assert('b' == ch_Ctpvtnt.p2) - - -val ch_Ctpvtnf = new Ctpvtnf('a', 'b') -val i_Ctpvtnf = new Ctpvtnf(1, 2) -val Ctpvtnf(extracted1i_Ctpvtnf, extracted2i_Ctpvtnf) = i_Ctpvtnf -val Ctpvtnf(extracted1ch_Ctpvtnf, extracted2ch_Ctpvtnf) = ch_Ctpvtnf -assert(1 == extracted1i_Ctpvtnf) -assert(2 == extracted2i_Ctpvtnf) -assert('a' == extracted1ch_Ctpvtnf) -assert('b' == extracted2ch_Ctpvtnf) - -assert(2 == i_Ctpvtnf.a) -assert('b' == ch_Ctpvtnf.a) -assert(1 == i_Ctpvtnf.p1) -assert('a' == ch_Ctpvtnf.p1) - - -val ch_Ctpvfpvt = new Ctpvfpvt('a', 'b') -val i_Ctpvfpvt = new Ctpvfpvt(1, 2) -val Ctpvfpvt(extracted1i_Ctpvfpvt, extracted2i_Ctpvfpvt) = i_Ctpvfpvt -val Ctpvfpvt(extracted1ch_Ctpvfpvt, extracted2ch_Ctpvfpvt) = ch_Ctpvfpvt -assert(1 == extracted1i_Ctpvfpvt) -assert(2 == extracted2i_Ctpvfpvt) -assert('a' == extracted1ch_Ctpvfpvt) -assert('b' == extracted2ch_Ctpvfpvt) - -assert(2 == i_Ctpvfpvt.p2) -assert('b' == ch_Ctpvfpvt.p2) - - -val ch_Ctpvfvt = new Ctpvfvt('a', 'b') -val i_Ctpvfvt = new Ctpvfvt(1, 2) -val Ctpvfvt(extracted1i_Ctpvfvt, extracted2i_Ctpvfvt) = i_Ctpvfvt -val Ctpvfvt(extracted1ch_Ctpvfvt, extracted2ch_Ctpvfvt) = ch_Ctpvfvt -assert(1 == extracted1i_Ctpvfvt) -assert(2 == extracted2i_Ctpvfvt) -assert('a' == extracted1ch_Ctpvfvt) -assert('b' == extracted2ch_Ctpvfvt) - -assert(2 == i_Ctpvfvt.a) -assert('b' == ch_Ctpvfvt.a) -assert(2 == i_Ctpvfvt.p2) -assert('b' == ch_Ctpvfvt.p2) - - -val ch_Ctpvfnt = new Ctpvfnt('a', 'b') -val i_Ctpvfnt = new Ctpvfnt(1, 2) -val Ctpvfnt(extracted1i_Ctpvfnt, extracted2i_Ctpvfnt) = i_Ctpvfnt -val Ctpvfnt(extracted1ch_Ctpvfnt, extracted2ch_Ctpvfnt) = ch_Ctpvfnt -assert(1 == extracted1i_Ctpvfnt) -assert(2 == extracted2i_Ctpvfnt) -assert('a' == extracted1ch_Ctpvfnt) -assert('b' == extracted2ch_Ctpvfnt) - -assert(2 == i_Ctpvfnt.a) -assert('b' == ch_Ctpvfnt.a) -assert(2 == i_Ctpvfnt.p2) -assert('b' == ch_Ctpvfnt.p2) - - -val ch_Ctvtpvt = new Ctvtpvt('a', 'b') -val i_Ctvtpvt = new Ctvtpvt(1, 2) -val Ctvtpvt(extracted1i_Ctvtpvt, extracted2i_Ctvtpvt) = i_Ctvtpvt -val Ctvtpvt(extracted1ch_Ctvtpvt, extracted2ch_Ctvtpvt) = ch_Ctvtpvt -assert(1 == extracted1i_Ctvtpvt) -assert(2 == extracted2i_Ctvtpvt) -assert('a' == extracted1ch_Ctvtpvt) -assert('b' == extracted2ch_Ctvtpvt) - -assert(1 == i_Ctvtpvt.`a b`) -assert('a' == ch_Ctvtpvt.`a b`) -assert(1 == i_Ctvtpvt.p1) -assert(2 == i_Ctvtpvt.p2) -assert('a' == ch_Ctvtpvt.p1) -assert('b' == ch_Ctvtpvt.p2) - - -val ch_Ctvtpvf = new Ctvtpvf('a', 'b') -val i_Ctvtpvf = new Ctvtpvf(1, 2) -val Ctvtpvf(extracted1i_Ctvtpvf, extracted2i_Ctvtpvf) = i_Ctvtpvf -val Ctvtpvf(extracted1ch_Ctvtpvf, extracted2ch_Ctvtpvf) = ch_Ctvtpvf -assert(1 == extracted1i_Ctvtpvf) -assert(2 == extracted2i_Ctvtpvf) -assert('a' == extracted1ch_Ctvtpvf) -assert('b' == extracted2ch_Ctvtpvf) - -assert(1 == i_Ctvtpvf.`a b`) -assert('a' == ch_Ctvtpvf.`a b`) -assert(1 == i_Ctvtpvf.p1) -assert('a' == ch_Ctvtpvf.p1) - - -val ch_Ctvtvt = new Ctvtvt('a', 'b') -val i_Ctvtvt = new Ctvtvt(1, 2) -val Ctvtvt(extracted1i_Ctvtvt, extracted2i_Ctvtvt) = i_Ctvtvt -val Ctvtvt(extracted1ch_Ctvtvt, extracted2ch_Ctvtvt) = ch_Ctvtvt -assert(1 == extracted1i_Ctvtvt) -assert(2 == extracted2i_Ctvtvt) -assert('a' == extracted1ch_Ctvtvt) -assert('b' == extracted2ch_Ctvtvt) - -assert(1 == i_Ctvtvt.`a b`) -assert(2 == i_Ctvtvt.a) -assert('a' == ch_Ctvtvt.`a b`) -assert('b' == ch_Ctvtvt.a) -assert(1 == i_Ctvtvt.p1) -assert(2 == i_Ctvtvt.p2) -assert('a' == ch_Ctvtvt.p1) -assert('b' == ch_Ctvtvt.p2) - - -val ch_Ctvtvf = new Ctvtvf('a', 'b') -val i_Ctvtvf = new Ctvtvf(1, 2) -val Ctvtvf(extracted1i_Ctvtvf, extracted2i_Ctvtvf) = i_Ctvtvf -val Ctvtvf(extracted1ch_Ctvtvf, extracted2ch_Ctvtvf) = ch_Ctvtvf -assert(1 == extracted1i_Ctvtvf) -assert(2 == extracted2i_Ctvtvf) -assert('a' == extracted1ch_Ctvtvf) -assert('b' == extracted2ch_Ctvtvf) - -assert(1 == i_Ctvtvf.`a b`) -assert(2 == i_Ctvtvf.a) -assert('a' == ch_Ctvtvf.`a b`) -assert('b' == ch_Ctvtvf.a) -assert(1 == i_Ctvtvf.p1) -assert('a' == ch_Ctvtvf.p1) - - -val ch_Ctvtnt = new Ctvtnt('a', 'b') -val i_Ctvtnt = new Ctvtnt(1, 2) -val Ctvtnt(extracted1i_Ctvtnt, extracted2i_Ctvtnt) = i_Ctvtnt -val Ctvtnt(extracted1ch_Ctvtnt, extracted2ch_Ctvtnt) = ch_Ctvtnt -assert(1 == extracted1i_Ctvtnt) -assert(2 == extracted2i_Ctvtnt) -assert('a' == extracted1ch_Ctvtnt) -assert('b' == extracted2ch_Ctvtnt) - -assert(1 == i_Ctvtnt.`a b`) -assert(2 == i_Ctvtnt.a) -assert('a' == ch_Ctvtnt.`a b`) -assert('b' == ch_Ctvtnt.a) -assert(1 == i_Ctvtnt.p1) -assert(2 == i_Ctvtnt.p2) -assert('a' == ch_Ctvtnt.p1) -assert('b' == ch_Ctvtnt.p2) - - -val ch_Ctvtnf = new Ctvtnf('a', 'b') -val i_Ctvtnf = new Ctvtnf(1, 2) -val Ctvtnf(extracted1i_Ctvtnf, extracted2i_Ctvtnf) = i_Ctvtnf -val Ctvtnf(extracted1ch_Ctvtnf, extracted2ch_Ctvtnf) = ch_Ctvtnf -assert(1 == extracted1i_Ctvtnf) -assert(2 == extracted2i_Ctvtnf) -assert('a' == extracted1ch_Ctvtnf) -assert('b' == extracted2ch_Ctvtnf) - -assert(1 == i_Ctvtnf.`a b`) -assert(2 == i_Ctvtnf.a) -assert('a' == ch_Ctvtnf.`a b`) -assert('b' == ch_Ctvtnf.a) -assert(1 == i_Ctvtnf.p1) -assert('a' == ch_Ctvtnf.p1) - - -val ch_Ctvfpvt = new Ctvfpvt('a', 'b') -val i_Ctvfpvt = new Ctvfpvt(1, 2) -val Ctvfpvt(extracted1i_Ctvfpvt, extracted2i_Ctvfpvt) = i_Ctvfpvt -val Ctvfpvt(extracted1ch_Ctvfpvt, extracted2ch_Ctvfpvt) = ch_Ctvfpvt -assert(1 == extracted1i_Ctvfpvt) -assert(2 == extracted2i_Ctvfpvt) -assert('a' == extracted1ch_Ctvfpvt) -assert('b' == extracted2ch_Ctvfpvt) - -assert(1 == i_Ctvfpvt.`a b`) -assert('a' == ch_Ctvfpvt.`a b`) -assert(2 == i_Ctvfpvt.p2) -assert('b' == ch_Ctvfpvt.p2) - - -val ch_Ctvfvt = new Ctvfvt('a', 'b') -val i_Ctvfvt = new Ctvfvt(1, 2) -val Ctvfvt(extracted1i_Ctvfvt, extracted2i_Ctvfvt) = i_Ctvfvt -val Ctvfvt(extracted1ch_Ctvfvt, extracted2ch_Ctvfvt) = ch_Ctvfvt -assert(1 == extracted1i_Ctvfvt) -assert(2 == extracted2i_Ctvfvt) -assert('a' == extracted1ch_Ctvfvt) -assert('b' == extracted2ch_Ctvfvt) - -assert(1 == i_Ctvfvt.`a b`) -assert(2 == i_Ctvfvt.a) -assert('a' == ch_Ctvfvt.`a b`) -assert('b' == ch_Ctvfvt.a) -assert(2 == i_Ctvfvt.p2) -assert('b' == ch_Ctvfvt.p2) - - -val ch_Ctvfnt = new Ctvfnt('a', 'b') -val i_Ctvfnt = new Ctvfnt(1, 2) -val Ctvfnt(extracted1i_Ctvfnt, extracted2i_Ctvfnt) = i_Ctvfnt -val Ctvfnt(extracted1ch_Ctvfnt, extracted2ch_Ctvfnt) = ch_Ctvfnt -assert(1 == extracted1i_Ctvfnt) -assert(2 == extracted2i_Ctvfnt) -assert('a' == extracted1ch_Ctvfnt) -assert('b' == extracted2ch_Ctvfnt) - -assert(1 == i_Ctvfnt.`a b`) -assert(2 == i_Ctvfnt.a) -assert('a' == ch_Ctvfnt.`a b`) -assert('b' == ch_Ctvfnt.a) -assert(2 == i_Ctvfnt.p2) -assert('b' == ch_Ctvfnt.p2) - - -val ch_Ctntpvt = new Ctntpvt('a', 'b') -val i_Ctntpvt = new Ctntpvt(1, 2) -val Ctntpvt(extracted1i_Ctntpvt, extracted2i_Ctntpvt) = i_Ctntpvt -val Ctntpvt(extracted1ch_Ctntpvt, extracted2ch_Ctntpvt) = ch_Ctntpvt -assert(1 == extracted1i_Ctntpvt) -assert(2 == extracted2i_Ctntpvt) -assert('a' == extracted1ch_Ctntpvt) -assert('b' == extracted2ch_Ctntpvt) - -assert(1 == i_Ctntpvt.`a b`) -assert('a' == ch_Ctntpvt.`a b`) -assert(1 == i_Ctntpvt.p1) -assert(2 == i_Ctntpvt.p2) -assert('a' == ch_Ctntpvt.p1) -assert('b' == ch_Ctntpvt.p2) - - -val ch_Ctntpvf = new Ctntpvf('a', 'b') -val i_Ctntpvf = new Ctntpvf(1, 2) -val Ctntpvf(extracted1i_Ctntpvf, extracted2i_Ctntpvf) = i_Ctntpvf -val Ctntpvf(extracted1ch_Ctntpvf, extracted2ch_Ctntpvf) = ch_Ctntpvf -assert(1 == extracted1i_Ctntpvf) -assert(2 == extracted2i_Ctntpvf) -assert('a' == extracted1ch_Ctntpvf) -assert('b' == extracted2ch_Ctntpvf) - -assert(1 == i_Ctntpvf.`a b`) -assert('a' == ch_Ctntpvf.`a b`) -assert(1 == i_Ctntpvf.p1) -assert('a' == ch_Ctntpvf.p1) - - -val ch_Ctntvt = new Ctntvt('a', 'b') -val i_Ctntvt = new Ctntvt(1, 2) -val Ctntvt(extracted1i_Ctntvt, extracted2i_Ctntvt) = i_Ctntvt -val Ctntvt(extracted1ch_Ctntvt, extracted2ch_Ctntvt) = ch_Ctntvt -assert(1 == extracted1i_Ctntvt) -assert(2 == extracted2i_Ctntvt) -assert('a' == extracted1ch_Ctntvt) -assert('b' == extracted2ch_Ctntvt) - -assert(1 == i_Ctntvt.`a b`) -assert(2 == i_Ctntvt.a) -assert('a' == ch_Ctntvt.`a b`) -assert('b' == ch_Ctntvt.a) -assert(1 == i_Ctntvt.p1) -assert(2 == i_Ctntvt.p2) -assert('a' == ch_Ctntvt.p1) -assert('b' == ch_Ctntvt.p2) - - -val ch_Ctntvf = new Ctntvf('a', 'b') -val i_Ctntvf = new Ctntvf(1, 2) -val Ctntvf(extracted1i_Ctntvf, extracted2i_Ctntvf) = i_Ctntvf -val Ctntvf(extracted1ch_Ctntvf, extracted2ch_Ctntvf) = ch_Ctntvf -assert(1 == extracted1i_Ctntvf) -assert(2 == extracted2i_Ctntvf) -assert('a' == extracted1ch_Ctntvf) -assert('b' == extracted2ch_Ctntvf) - -assert(1 == i_Ctntvf.`a b`) -assert(2 == i_Ctntvf.a) -assert('a' == ch_Ctntvf.`a b`) -assert('b' == ch_Ctntvf.a) -assert(1 == i_Ctntvf.p1) -assert('a' == ch_Ctntvf.p1) - - -val ch_Ctntnt = new Ctntnt('a', 'b') -val i_Ctntnt = new Ctntnt(1, 2) -val Ctntnt(extracted1i_Ctntnt, extracted2i_Ctntnt) = i_Ctntnt -val Ctntnt(extracted1ch_Ctntnt, extracted2ch_Ctntnt) = ch_Ctntnt -assert(1 == extracted1i_Ctntnt) -assert(2 == extracted2i_Ctntnt) -assert('a' == extracted1ch_Ctntnt) -assert('b' == extracted2ch_Ctntnt) - -assert(1 == i_Ctntnt.`a b`) -assert(2 == i_Ctntnt.a) -assert('a' == ch_Ctntnt.`a b`) -assert('b' == ch_Ctntnt.a) -assert(1 == i_Ctntnt.p1) -assert(2 == i_Ctntnt.p2) -assert('a' == ch_Ctntnt.p1) -assert('b' == ch_Ctntnt.p2) - - -val ch_Ctntnf = new Ctntnf('a', 'b') -val i_Ctntnf = new Ctntnf(1, 2) -val Ctntnf(extracted1i_Ctntnf, extracted2i_Ctntnf) = i_Ctntnf -val Ctntnf(extracted1ch_Ctntnf, extracted2ch_Ctntnf) = ch_Ctntnf -assert(1 == extracted1i_Ctntnf) -assert(2 == extracted2i_Ctntnf) -assert('a' == extracted1ch_Ctntnf) -assert('b' == extracted2ch_Ctntnf) - -assert(1 == i_Ctntnf.`a b`) -assert(2 == i_Ctntnf.a) -assert('a' == ch_Ctntnf.`a b`) -assert('b' == ch_Ctntnf.a) -assert(1 == i_Ctntnf.p1) -assert('a' == ch_Ctntnf.p1) - - -val ch_Ctnfpvt = new Ctnfpvt('a', 'b') -val i_Ctnfpvt = new Ctnfpvt(1, 2) -val Ctnfpvt(extracted1i_Ctnfpvt, extracted2i_Ctnfpvt) = i_Ctnfpvt -val Ctnfpvt(extracted1ch_Ctnfpvt, extracted2ch_Ctnfpvt) = ch_Ctnfpvt -assert(1 == extracted1i_Ctnfpvt) -assert(2 == extracted2i_Ctnfpvt) -assert('a' == extracted1ch_Ctnfpvt) -assert('b' == extracted2ch_Ctnfpvt) - -assert(1 == i_Ctnfpvt.`a b`) -assert('a' == ch_Ctnfpvt.`a b`) -assert(2 == i_Ctnfpvt.p2) -assert('b' == ch_Ctnfpvt.p2) - - -val ch_Ctnfvt = new Ctnfvt('a', 'b') -val i_Ctnfvt = new Ctnfvt(1, 2) -val Ctnfvt(extracted1i_Ctnfvt, extracted2i_Ctnfvt) = i_Ctnfvt -val Ctnfvt(extracted1ch_Ctnfvt, extracted2ch_Ctnfvt) = ch_Ctnfvt -assert(1 == extracted1i_Ctnfvt) -assert(2 == extracted2i_Ctnfvt) -assert('a' == extracted1ch_Ctnfvt) -assert('b' == extracted2ch_Ctnfvt) - -assert(1 == i_Ctnfvt.`a b`) -assert(2 == i_Ctnfvt.a) -assert('a' == ch_Ctnfvt.`a b`) -assert('b' == ch_Ctnfvt.a) -assert(2 == i_Ctnfvt.p2) -assert('b' == ch_Ctnfvt.p2) - - -val ch_Ctnfnt = new Ctnfnt('a', 'b') -val i_Ctnfnt = new Ctnfnt(1, 2) -val Ctnfnt(extracted1i_Ctnfnt, extracted2i_Ctnfnt) = i_Ctnfnt -val Ctnfnt(extracted1ch_Ctnfnt, extracted2ch_Ctnfnt) = ch_Ctnfnt -assert(1 == extracted1i_Ctnfnt) -assert(2 == extracted2i_Ctnfnt) -assert('a' == extracted1ch_Ctnfnt) -assert('b' == extracted2ch_Ctnfnt) - -assert(1 == i_Ctnfnt.`a b`) -assert(2 == i_Ctnfnt.a) -assert('a' == ch_Ctnfnt.`a b`) -assert('b' == ch_Ctnfnt.a) -assert(2 == i_Ctnfnt.p2) -assert('b' == ch_Ctnfnt.p2) - - -val ch_Cfpvtpvt = new Cfpvtpvt('a', 'b') -val i_Cfpvtpvt = new Cfpvtpvt(1, 2) -val Cfpvtpvt(extracted1i_Cfpvtpvt, extracted2i_Cfpvtpvt) = i_Cfpvtpvt -val Cfpvtpvt(extracted1ch_Cfpvtpvt, extracted2ch_Cfpvtpvt) = ch_Cfpvtpvt -assert(1 == extracted1i_Cfpvtpvt) -assert(2 == extracted2i_Cfpvtpvt) -assert('a' == extracted1ch_Cfpvtpvt) -assert('b' == extracted2ch_Cfpvtpvt) - -assert(1 == i_Cfpvtpvt.p1) -assert(2 == i_Cfpvtpvt.p2) -assert('a' == ch_Cfpvtpvt.p1) -assert('b' == ch_Cfpvtpvt.p2) - - -val ch_Cfpvtpvf = new Cfpvtpvf('a', 'b') -val i_Cfpvtpvf = new Cfpvtpvf(1, 2) -val Cfpvtpvf(extracted1i_Cfpvtpvf, extracted2i_Cfpvtpvf) = i_Cfpvtpvf -val Cfpvtpvf(extracted1ch_Cfpvtpvf, extracted2ch_Cfpvtpvf) = ch_Cfpvtpvf -assert(1 == extracted1i_Cfpvtpvf) -assert(2 == extracted2i_Cfpvtpvf) -assert('a' == extracted1ch_Cfpvtpvf) -assert('b' == extracted2ch_Cfpvtpvf) - -assert(1 == i_Cfpvtpvf.p1) -assert('a' == ch_Cfpvtpvf.p1) - - -val ch_Cfpvtvt = new Cfpvtvt('a', 'b') -val i_Cfpvtvt = new Cfpvtvt(1, 2) -val Cfpvtvt(extracted1i_Cfpvtvt, extracted2i_Cfpvtvt) = i_Cfpvtvt -val Cfpvtvt(extracted1ch_Cfpvtvt, extracted2ch_Cfpvtvt) = ch_Cfpvtvt -assert(1 == extracted1i_Cfpvtvt) -assert(2 == extracted2i_Cfpvtvt) -assert('a' == extracted1ch_Cfpvtvt) -assert('b' == extracted2ch_Cfpvtvt) - -assert(2 == i_Cfpvtvt.a) -assert('b' == ch_Cfpvtvt.a) -assert(1 == i_Cfpvtvt.p1) -assert(2 == i_Cfpvtvt.p2) -assert('a' == ch_Cfpvtvt.p1) -assert('b' == ch_Cfpvtvt.p2) - - -val ch_Cfpvtvf = new Cfpvtvf('a', 'b') -val i_Cfpvtvf = new Cfpvtvf(1, 2) -val Cfpvtvf(extracted1i_Cfpvtvf, extracted2i_Cfpvtvf) = i_Cfpvtvf -val Cfpvtvf(extracted1ch_Cfpvtvf, extracted2ch_Cfpvtvf) = ch_Cfpvtvf -assert(1 == extracted1i_Cfpvtvf) -assert(2 == extracted2i_Cfpvtvf) -assert('a' == extracted1ch_Cfpvtvf) -assert('b' == extracted2ch_Cfpvtvf) - -assert(2 == i_Cfpvtvf.a) -assert('b' == ch_Cfpvtvf.a) -assert(1 == i_Cfpvtvf.p1) -assert('a' == ch_Cfpvtvf.p1) - - -val ch_Cfpvtnt = new Cfpvtnt('a', 'b') -val i_Cfpvtnt = new Cfpvtnt(1, 2) -val Cfpvtnt(extracted1i_Cfpvtnt, extracted2i_Cfpvtnt) = i_Cfpvtnt -val Cfpvtnt(extracted1ch_Cfpvtnt, extracted2ch_Cfpvtnt) = ch_Cfpvtnt -assert(1 == extracted1i_Cfpvtnt) -assert(2 == extracted2i_Cfpvtnt) -assert('a' == extracted1ch_Cfpvtnt) -assert('b' == extracted2ch_Cfpvtnt) - -assert(2 == i_Cfpvtnt.a) -assert('b' == ch_Cfpvtnt.a) -assert(1 == i_Cfpvtnt.p1) -assert(2 == i_Cfpvtnt.p2) -assert('a' == ch_Cfpvtnt.p1) -assert('b' == ch_Cfpvtnt.p2) - - -val ch_Cfpvtnf = new Cfpvtnf('a', 'b') -val i_Cfpvtnf = new Cfpvtnf(1, 2) -val Cfpvtnf(extracted1i_Cfpvtnf, extracted2i_Cfpvtnf) = i_Cfpvtnf -val Cfpvtnf(extracted1ch_Cfpvtnf, extracted2ch_Cfpvtnf) = ch_Cfpvtnf -assert(1 == extracted1i_Cfpvtnf) -assert(2 == extracted2i_Cfpvtnf) -assert('a' == extracted1ch_Cfpvtnf) -assert('b' == extracted2ch_Cfpvtnf) - -assert(2 == i_Cfpvtnf.a) -assert('b' == ch_Cfpvtnf.a) -assert(1 == i_Cfpvtnf.p1) -assert('a' == ch_Cfpvtnf.p1) - - -val ch_Cfpvfpvt = new Cfpvfpvt('a', 'b') -val i_Cfpvfpvt = new Cfpvfpvt(1, 2) -val Cfpvfpvt(extracted1i_Cfpvfpvt, extracted2i_Cfpvfpvt) = i_Cfpvfpvt -val Cfpvfpvt(extracted1ch_Cfpvfpvt, extracted2ch_Cfpvfpvt) = ch_Cfpvfpvt -assert(1 == extracted1i_Cfpvfpvt) -assert(2 == extracted2i_Cfpvfpvt) -assert('a' == extracted1ch_Cfpvfpvt) -assert('b' == extracted2ch_Cfpvfpvt) - -assert(2 == i_Cfpvfpvt.p2) -assert('b' == ch_Cfpvfpvt.p2) - - -val ch_Cfpvfpvf = new Cfpvfpvf('a', 'b') -val i_Cfpvfpvf = new Cfpvfpvf(1, 2) -val Cfpvfpvf(extracted1i_Cfpvfpvf, extracted2i_Cfpvfpvf) = i_Cfpvfpvf -val Cfpvfpvf(extracted1ch_Cfpvfpvf, extracted2ch_Cfpvfpvf) = ch_Cfpvfpvf -assert(1 == extracted1i_Cfpvfpvf) -assert(2 == extracted2i_Cfpvfpvf) -assert('a' == extracted1ch_Cfpvfpvf) -assert('b' == extracted2ch_Cfpvfpvf) - - - -val ch_Cfpvfvt = new Cfpvfvt('a', 'b') -val i_Cfpvfvt = new Cfpvfvt(1, 2) -val Cfpvfvt(extracted1i_Cfpvfvt, extracted2i_Cfpvfvt) = i_Cfpvfvt -val Cfpvfvt(extracted1ch_Cfpvfvt, extracted2ch_Cfpvfvt) = ch_Cfpvfvt -assert(1 == extracted1i_Cfpvfvt) -assert(2 == extracted2i_Cfpvfvt) -assert('a' == extracted1ch_Cfpvfvt) -assert('b' == extracted2ch_Cfpvfvt) - -assert(2 == i_Cfpvfvt.a) -assert('b' == ch_Cfpvfvt.a) -assert(2 == i_Cfpvfvt.p2) -assert('b' == ch_Cfpvfvt.p2) - - -val ch_Cfpvfvf = new Cfpvfvf('a', 'b') -val i_Cfpvfvf = new Cfpvfvf(1, 2) -val Cfpvfvf(extracted1i_Cfpvfvf, extracted2i_Cfpvfvf) = i_Cfpvfvf -val Cfpvfvf(extracted1ch_Cfpvfvf, extracted2ch_Cfpvfvf) = ch_Cfpvfvf -assert(1 == extracted1i_Cfpvfvf) -assert(2 == extracted2i_Cfpvfvf) -assert('a' == extracted1ch_Cfpvfvf) -assert('b' == extracted2ch_Cfpvfvf) - -assert(2 == i_Cfpvfvf.a) -assert('b' == ch_Cfpvfvf.a) - - -val ch_Cfpvfnt = new Cfpvfnt('a', 'b') -val i_Cfpvfnt = new Cfpvfnt(1, 2) -val Cfpvfnt(extracted1i_Cfpvfnt, extracted2i_Cfpvfnt) = i_Cfpvfnt -val Cfpvfnt(extracted1ch_Cfpvfnt, extracted2ch_Cfpvfnt) = ch_Cfpvfnt -assert(1 == extracted1i_Cfpvfnt) -assert(2 == extracted2i_Cfpvfnt) -assert('a' == extracted1ch_Cfpvfnt) -assert('b' == extracted2ch_Cfpvfnt) - -assert(2 == i_Cfpvfnt.a) -assert('b' == ch_Cfpvfnt.a) -assert(2 == i_Cfpvfnt.p2) -assert('b' == ch_Cfpvfnt.p2) - - -val ch_Cfpvfnf = new Cfpvfnf('a', 'b') -val i_Cfpvfnf = new Cfpvfnf(1, 2) -val Cfpvfnf(extracted1i_Cfpvfnf, extracted2i_Cfpvfnf) = i_Cfpvfnf -val Cfpvfnf(extracted1ch_Cfpvfnf, extracted2ch_Cfpvfnf) = ch_Cfpvfnf -assert(1 == extracted1i_Cfpvfnf) -assert(2 == extracted2i_Cfpvfnf) -assert('a' == extracted1ch_Cfpvfnf) -assert('b' == extracted2ch_Cfpvfnf) - -assert(2 == i_Cfpvfnf.a) -assert('b' == ch_Cfpvfnf.a) - - -val ch_Cfvtpvt = new Cfvtpvt('a', 'b') -val i_Cfvtpvt = new Cfvtpvt(1, 2) -val Cfvtpvt(extracted1i_Cfvtpvt, extracted2i_Cfvtpvt) = i_Cfvtpvt -val Cfvtpvt(extracted1ch_Cfvtpvt, extracted2ch_Cfvtpvt) = ch_Cfvtpvt -assert(1 == extracted1i_Cfvtpvt) -assert(2 == extracted2i_Cfvtpvt) -assert('a' == extracted1ch_Cfvtpvt) -assert('b' == extracted2ch_Cfvtpvt) - -assert(1 == i_Cfvtpvt.`a b`) -assert('a' == ch_Cfvtpvt.`a b`) -assert(1 == i_Cfvtpvt.p1) -assert(2 == i_Cfvtpvt.p2) -assert('a' == ch_Cfvtpvt.p1) -assert('b' == ch_Cfvtpvt.p2) - - -val ch_Cfvtpvf = new Cfvtpvf('a', 'b') -val i_Cfvtpvf = new Cfvtpvf(1, 2) -val Cfvtpvf(extracted1i_Cfvtpvf, extracted2i_Cfvtpvf) = i_Cfvtpvf -val Cfvtpvf(extracted1ch_Cfvtpvf, extracted2ch_Cfvtpvf) = ch_Cfvtpvf -assert(1 == extracted1i_Cfvtpvf) -assert(2 == extracted2i_Cfvtpvf) -assert('a' == extracted1ch_Cfvtpvf) -assert('b' == extracted2ch_Cfvtpvf) - -assert(1 == i_Cfvtpvf.`a b`) -assert('a' == ch_Cfvtpvf.`a b`) -assert(1 == i_Cfvtpvf.p1) -assert('a' == ch_Cfvtpvf.p1) - - -val ch_Cfvtvt = new Cfvtvt('a', 'b') -val i_Cfvtvt = new Cfvtvt(1, 2) -val Cfvtvt(extracted1i_Cfvtvt, extracted2i_Cfvtvt) = i_Cfvtvt -val Cfvtvt(extracted1ch_Cfvtvt, extracted2ch_Cfvtvt) = ch_Cfvtvt -assert(1 == extracted1i_Cfvtvt) -assert(2 == extracted2i_Cfvtvt) -assert('a' == extracted1ch_Cfvtvt) -assert('b' == extracted2ch_Cfvtvt) - -assert(1 == i_Cfvtvt.`a b`) -assert(2 == i_Cfvtvt.a) -assert('a' == ch_Cfvtvt.`a b`) -assert('b' == ch_Cfvtvt.a) -assert(1 == i_Cfvtvt.p1) -assert(2 == i_Cfvtvt.p2) -assert('a' == ch_Cfvtvt.p1) -assert('b' == ch_Cfvtvt.p2) - - -val ch_Cfvtvf = new Cfvtvf('a', 'b') -val i_Cfvtvf = new Cfvtvf(1, 2) -val Cfvtvf(extracted1i_Cfvtvf, extracted2i_Cfvtvf) = i_Cfvtvf -val Cfvtvf(extracted1ch_Cfvtvf, extracted2ch_Cfvtvf) = ch_Cfvtvf -assert(1 == extracted1i_Cfvtvf) -assert(2 == extracted2i_Cfvtvf) -assert('a' == extracted1ch_Cfvtvf) -assert('b' == extracted2ch_Cfvtvf) - -assert(1 == i_Cfvtvf.`a b`) -assert(2 == i_Cfvtvf.a) -assert('a' == ch_Cfvtvf.`a b`) -assert('b' == ch_Cfvtvf.a) -assert(1 == i_Cfvtvf.p1) -assert('a' == ch_Cfvtvf.p1) - - -val ch_Cfvtnt = new Cfvtnt('a', 'b') -val i_Cfvtnt = new Cfvtnt(1, 2) -val Cfvtnt(extracted1i_Cfvtnt, extracted2i_Cfvtnt) = i_Cfvtnt -val Cfvtnt(extracted1ch_Cfvtnt, extracted2ch_Cfvtnt) = ch_Cfvtnt -assert(1 == extracted1i_Cfvtnt) -assert(2 == extracted2i_Cfvtnt) -assert('a' == extracted1ch_Cfvtnt) -assert('b' == extracted2ch_Cfvtnt) - -assert(1 == i_Cfvtnt.`a b`) -assert(2 == i_Cfvtnt.a) -assert('a' == ch_Cfvtnt.`a b`) -assert('b' == ch_Cfvtnt.a) -assert(1 == i_Cfvtnt.p1) -assert(2 == i_Cfvtnt.p2) -assert('a' == ch_Cfvtnt.p1) -assert('b' == ch_Cfvtnt.p2) - - -val ch_Cfvtnf = new Cfvtnf('a', 'b') -val i_Cfvtnf = new Cfvtnf(1, 2) -val Cfvtnf(extracted1i_Cfvtnf, extracted2i_Cfvtnf) = i_Cfvtnf -val Cfvtnf(extracted1ch_Cfvtnf, extracted2ch_Cfvtnf) = ch_Cfvtnf -assert(1 == extracted1i_Cfvtnf) -assert(2 == extracted2i_Cfvtnf) -assert('a' == extracted1ch_Cfvtnf) -assert('b' == extracted2ch_Cfvtnf) - -assert(1 == i_Cfvtnf.`a b`) -assert(2 == i_Cfvtnf.a) -assert('a' == ch_Cfvtnf.`a b`) -assert('b' == ch_Cfvtnf.a) -assert(1 == i_Cfvtnf.p1) -assert('a' == ch_Cfvtnf.p1) - - -val ch_Cfvfpvt = new Cfvfpvt('a', 'b') -val i_Cfvfpvt = new Cfvfpvt(1, 2) -val Cfvfpvt(extracted1i_Cfvfpvt, extracted2i_Cfvfpvt) = i_Cfvfpvt -val Cfvfpvt(extracted1ch_Cfvfpvt, extracted2ch_Cfvfpvt) = ch_Cfvfpvt -assert(1 == extracted1i_Cfvfpvt) -assert(2 == extracted2i_Cfvfpvt) -assert('a' == extracted1ch_Cfvfpvt) -assert('b' == extracted2ch_Cfvfpvt) - -assert(1 == i_Cfvfpvt.`a b`) -assert('a' == ch_Cfvfpvt.`a b`) -assert(2 == i_Cfvfpvt.p2) -assert('b' == ch_Cfvfpvt.p2) - - -val ch_Cfvfpvf = new Cfvfpvf('a', 'b') -val i_Cfvfpvf = new Cfvfpvf(1, 2) -val Cfvfpvf(extracted1i_Cfvfpvf, extracted2i_Cfvfpvf) = i_Cfvfpvf -val Cfvfpvf(extracted1ch_Cfvfpvf, extracted2ch_Cfvfpvf) = ch_Cfvfpvf -assert(1 == extracted1i_Cfvfpvf) -assert(2 == extracted2i_Cfvfpvf) -assert('a' == extracted1ch_Cfvfpvf) -assert('b' == extracted2ch_Cfvfpvf) - -assert(1 == i_Cfvfpvf.`a b`) -assert('a' == ch_Cfvfpvf.`a b`) - - -val ch_Cfvfvt = new Cfvfvt('a', 'b') -val i_Cfvfvt = new Cfvfvt(1, 2) -val Cfvfvt(extracted1i_Cfvfvt, extracted2i_Cfvfvt) = i_Cfvfvt -val Cfvfvt(extracted1ch_Cfvfvt, extracted2ch_Cfvfvt) = ch_Cfvfvt -assert(1 == extracted1i_Cfvfvt) -assert(2 == extracted2i_Cfvfvt) -assert('a' == extracted1ch_Cfvfvt) -assert('b' == extracted2ch_Cfvfvt) - -assert(1 == i_Cfvfvt.`a b`) -assert(2 == i_Cfvfvt.a) -assert('a' == ch_Cfvfvt.`a b`) -assert('b' == ch_Cfvfvt.a) -assert(2 == i_Cfvfvt.p2) -assert('b' == ch_Cfvfvt.p2) - - -val ch_Cfvfvf = new Cfvfvf('a', 'b') -val i_Cfvfvf = new Cfvfvf(1, 2) -val Cfvfvf(extracted1i_Cfvfvf, extracted2i_Cfvfvf) = i_Cfvfvf -val Cfvfvf(extracted1ch_Cfvfvf, extracted2ch_Cfvfvf) = ch_Cfvfvf -assert(1 == extracted1i_Cfvfvf) -assert(2 == extracted2i_Cfvfvf) -assert('a' == extracted1ch_Cfvfvf) -assert('b' == extracted2ch_Cfvfvf) - -assert(1 == i_Cfvfvf.`a b`) -assert(2 == i_Cfvfvf.a) -assert('a' == ch_Cfvfvf.`a b`) -assert('b' == ch_Cfvfvf.a) - - -val ch_Cfvfnt = new Cfvfnt('a', 'b') -val i_Cfvfnt = new Cfvfnt(1, 2) -val Cfvfnt(extracted1i_Cfvfnt, extracted2i_Cfvfnt) = i_Cfvfnt -val Cfvfnt(extracted1ch_Cfvfnt, extracted2ch_Cfvfnt) = ch_Cfvfnt -assert(1 == extracted1i_Cfvfnt) -assert(2 == extracted2i_Cfvfnt) -assert('a' == extracted1ch_Cfvfnt) -assert('b' == extracted2ch_Cfvfnt) - -assert(1 == i_Cfvfnt.`a b`) -assert(2 == i_Cfvfnt.a) -assert('a' == ch_Cfvfnt.`a b`) -assert('b' == ch_Cfvfnt.a) -assert(2 == i_Cfvfnt.p2) -assert('b' == ch_Cfvfnt.p2) - - -val ch_Cfvfnf = new Cfvfnf('a', 'b') -val i_Cfvfnf = new Cfvfnf(1, 2) -val Cfvfnf(extracted1i_Cfvfnf, extracted2i_Cfvfnf) = i_Cfvfnf -val Cfvfnf(extracted1ch_Cfvfnf, extracted2ch_Cfvfnf) = ch_Cfvfnf -assert(1 == extracted1i_Cfvfnf) -assert(2 == extracted2i_Cfvfnf) -assert('a' == extracted1ch_Cfvfnf) -assert('b' == extracted2ch_Cfvfnf) - -assert(1 == i_Cfvfnf.`a b`) -assert(2 == i_Cfvfnf.a) -assert('a' == ch_Cfvfnf.`a b`) -assert('b' == ch_Cfvfnf.a) - - -val ch_Cfntpvt = new Cfntpvt('a', 'b') -val i_Cfntpvt = new Cfntpvt(1, 2) -val Cfntpvt(extracted1i_Cfntpvt, extracted2i_Cfntpvt) = i_Cfntpvt -val Cfntpvt(extracted1ch_Cfntpvt, extracted2ch_Cfntpvt) = ch_Cfntpvt -assert(1 == extracted1i_Cfntpvt) -assert(2 == extracted2i_Cfntpvt) -assert('a' == extracted1ch_Cfntpvt) -assert('b' == extracted2ch_Cfntpvt) - -assert(1 == i_Cfntpvt.`a b`) -assert('a' == ch_Cfntpvt.`a b`) -assert(1 == i_Cfntpvt.p1) -assert(2 == i_Cfntpvt.p2) -assert('a' == ch_Cfntpvt.p1) -assert('b' == ch_Cfntpvt.p2) - - -val ch_Cfntpvf = new Cfntpvf('a', 'b') -val i_Cfntpvf = new Cfntpvf(1, 2) -val Cfntpvf(extracted1i_Cfntpvf, extracted2i_Cfntpvf) = i_Cfntpvf -val Cfntpvf(extracted1ch_Cfntpvf, extracted2ch_Cfntpvf) = ch_Cfntpvf -assert(1 == extracted1i_Cfntpvf) -assert(2 == extracted2i_Cfntpvf) -assert('a' == extracted1ch_Cfntpvf) -assert('b' == extracted2ch_Cfntpvf) - -assert(1 == i_Cfntpvf.`a b`) -assert('a' == ch_Cfntpvf.`a b`) -assert(1 == i_Cfntpvf.p1) -assert('a' == ch_Cfntpvf.p1) - - -val ch_Cfntvt = new Cfntvt('a', 'b') -val i_Cfntvt = new Cfntvt(1, 2) -val Cfntvt(extracted1i_Cfntvt, extracted2i_Cfntvt) = i_Cfntvt -val Cfntvt(extracted1ch_Cfntvt, extracted2ch_Cfntvt) = ch_Cfntvt -assert(1 == extracted1i_Cfntvt) -assert(2 == extracted2i_Cfntvt) -assert('a' == extracted1ch_Cfntvt) -assert('b' == extracted2ch_Cfntvt) - -assert(1 == i_Cfntvt.`a b`) -assert(2 == i_Cfntvt.a) -assert('a' == ch_Cfntvt.`a b`) -assert('b' == ch_Cfntvt.a) -assert(1 == i_Cfntvt.p1) -assert(2 == i_Cfntvt.p2) -assert('a' == ch_Cfntvt.p1) -assert('b' == ch_Cfntvt.p2) - - -val ch_Cfntvf = new Cfntvf('a', 'b') -val i_Cfntvf = new Cfntvf(1, 2) -val Cfntvf(extracted1i_Cfntvf, extracted2i_Cfntvf) = i_Cfntvf -val Cfntvf(extracted1ch_Cfntvf, extracted2ch_Cfntvf) = ch_Cfntvf -assert(1 == extracted1i_Cfntvf) -assert(2 == extracted2i_Cfntvf) -assert('a' == extracted1ch_Cfntvf) -assert('b' == extracted2ch_Cfntvf) - -assert(1 == i_Cfntvf.`a b`) -assert(2 == i_Cfntvf.a) -assert('a' == ch_Cfntvf.`a b`) -assert('b' == ch_Cfntvf.a) -assert(1 == i_Cfntvf.p1) -assert('a' == ch_Cfntvf.p1) - - -val ch_Cfntnt = new Cfntnt('a', 'b') -val i_Cfntnt = new Cfntnt(1, 2) -val Cfntnt(extracted1i_Cfntnt, extracted2i_Cfntnt) = i_Cfntnt -val Cfntnt(extracted1ch_Cfntnt, extracted2ch_Cfntnt) = ch_Cfntnt -assert(1 == extracted1i_Cfntnt) -assert(2 == extracted2i_Cfntnt) -assert('a' == extracted1ch_Cfntnt) -assert('b' == extracted2ch_Cfntnt) - -assert(1 == i_Cfntnt.`a b`) -assert(2 == i_Cfntnt.a) -assert('a' == ch_Cfntnt.`a b`) -assert('b' == ch_Cfntnt.a) -assert(1 == i_Cfntnt.p1) -assert(2 == i_Cfntnt.p2) -assert('a' == ch_Cfntnt.p1) -assert('b' == ch_Cfntnt.p2) - - -val ch_Cfntnf = new Cfntnf('a', 'b') -val i_Cfntnf = new Cfntnf(1, 2) -val Cfntnf(extracted1i_Cfntnf, extracted2i_Cfntnf) = i_Cfntnf -val Cfntnf(extracted1ch_Cfntnf, extracted2ch_Cfntnf) = ch_Cfntnf -assert(1 == extracted1i_Cfntnf) -assert(2 == extracted2i_Cfntnf) -assert('a' == extracted1ch_Cfntnf) -assert('b' == extracted2ch_Cfntnf) - -assert(1 == i_Cfntnf.`a b`) -assert(2 == i_Cfntnf.a) -assert('a' == ch_Cfntnf.`a b`) -assert('b' == ch_Cfntnf.a) -assert(1 == i_Cfntnf.p1) -assert('a' == ch_Cfntnf.p1) - - -val ch_Cfnfpvt = new Cfnfpvt('a', 'b') -val i_Cfnfpvt = new Cfnfpvt(1, 2) -val Cfnfpvt(extracted1i_Cfnfpvt, extracted2i_Cfnfpvt) = i_Cfnfpvt -val Cfnfpvt(extracted1ch_Cfnfpvt, extracted2ch_Cfnfpvt) = ch_Cfnfpvt -assert(1 == extracted1i_Cfnfpvt) -assert(2 == extracted2i_Cfnfpvt) -assert('a' == extracted1ch_Cfnfpvt) -assert('b' == extracted2ch_Cfnfpvt) - -assert(1 == i_Cfnfpvt.`a b`) -assert('a' == ch_Cfnfpvt.`a b`) -assert(2 == i_Cfnfpvt.p2) -assert('b' == ch_Cfnfpvt.p2) - - -val ch_Cfnfpvf = new Cfnfpvf('a', 'b') -val i_Cfnfpvf = new Cfnfpvf(1, 2) -val Cfnfpvf(extracted1i_Cfnfpvf, extracted2i_Cfnfpvf) = i_Cfnfpvf -val Cfnfpvf(extracted1ch_Cfnfpvf, extracted2ch_Cfnfpvf) = ch_Cfnfpvf -assert(1 == extracted1i_Cfnfpvf) -assert(2 == extracted2i_Cfnfpvf) -assert('a' == extracted1ch_Cfnfpvf) -assert('b' == extracted2ch_Cfnfpvf) - -assert(1 == i_Cfnfpvf.`a b`) -assert('a' == ch_Cfnfpvf.`a b`) - - -val ch_Cfnfvt = new Cfnfvt('a', 'b') -val i_Cfnfvt = new Cfnfvt(1, 2) -val Cfnfvt(extracted1i_Cfnfvt, extracted2i_Cfnfvt) = i_Cfnfvt -val Cfnfvt(extracted1ch_Cfnfvt, extracted2ch_Cfnfvt) = ch_Cfnfvt -assert(1 == extracted1i_Cfnfvt) -assert(2 == extracted2i_Cfnfvt) -assert('a' == extracted1ch_Cfnfvt) -assert('b' == extracted2ch_Cfnfvt) - -assert(1 == i_Cfnfvt.`a b`) -assert(2 == i_Cfnfvt.a) -assert('a' == ch_Cfnfvt.`a b`) -assert('b' == ch_Cfnfvt.a) -assert(2 == i_Cfnfvt.p2) -assert('b' == ch_Cfnfvt.p2) - - -val ch_Cfnfvf = new Cfnfvf('a', 'b') -val i_Cfnfvf = new Cfnfvf(1, 2) -val Cfnfvf(extracted1i_Cfnfvf, extracted2i_Cfnfvf) = i_Cfnfvf -val Cfnfvf(extracted1ch_Cfnfvf, extracted2ch_Cfnfvf) = ch_Cfnfvf -assert(1 == extracted1i_Cfnfvf) -assert(2 == extracted2i_Cfnfvf) -assert('a' == extracted1ch_Cfnfvf) -assert('b' == extracted2ch_Cfnfvf) - -assert(1 == i_Cfnfvf.`a b`) -assert(2 == i_Cfnfvf.a) -assert('a' == ch_Cfnfvf.`a b`) -assert('b' == ch_Cfnfvf.a) - - -val ch_Cfnfnt = new Cfnfnt('a', 'b') -val i_Cfnfnt = new Cfnfnt(1, 2) -val Cfnfnt(extracted1i_Cfnfnt, extracted2i_Cfnfnt) = i_Cfnfnt -val Cfnfnt(extracted1ch_Cfnfnt, extracted2ch_Cfnfnt) = ch_Cfnfnt -assert(1 == extracted1i_Cfnfnt) -assert(2 == extracted2i_Cfnfnt) -assert('a' == extracted1ch_Cfnfnt) -assert('b' == extracted2ch_Cfnfnt) - -assert(1 == i_Cfnfnt.`a b`) -assert(2 == i_Cfnfnt.a) -assert('a' == ch_Cfnfnt.`a b`) -assert('b' == ch_Cfnfnt.a) -assert(2 == i_Cfnfnt.p2) -assert('b' == ch_Cfnfnt.p2) - - -val ch_Cfnfnf = new Cfnfnf('a', 'b') -val i_Cfnfnf = new Cfnfnf(1, 2) -val Cfnfnf(extracted1i_Cfnfnf, extracted2i_Cfnfnf) = i_Cfnfnf -val Cfnfnf(extracted1ch_Cfnfnf, extracted2ch_Cfnfnf) = ch_Cfnfnf -assert(1 == extracted1i_Cfnfnf) -assert(2 == extracted2i_Cfnfnf) -assert('a' == extracted1ch_Cfnfnf) -assert('b' == extracted2ch_Cfnfnf) - -assert(1 == i_Cfnfnf.`a b`) -assert(2 == i_Cfnfnf.a) -assert('a' == ch_Cfnfnf.`a b`) -assert('b' == ch_Cfnfnf.a) - - -val ch_Rtpvtpvt = new Rtpvtpvt('a', 'b') -val i_Rtpvtpvt = new Rtpvtpvt(1, 2) -assert(1 == i_Rtpvtpvt.p1) -assert(2 == i_Rtpvtpvt.p2) -assert('a' == ch_Rtpvtpvt.p1) -assert('b' == ch_Rtpvtpvt.p2) - - -val ch_Rtpvtpvf = new Rtpvtpvf('a', 'b') -val i_Rtpvtpvf = new Rtpvtpvf(1, 2) -assert(1 == i_Rtpvtpvf.p1) -assert('a' == ch_Rtpvtpvf.p1) - - -val ch_Rtpvtvt = new Rtpvtvt('a', 'b') -val i_Rtpvtvt = new Rtpvtvt(1, 2) -assert(2 == i_Rtpvtvt.a) -assert('b' == ch_Rtpvtvt.a) -assert(1 == i_Rtpvtvt.p1) -assert(2 == i_Rtpvtvt.p2) -assert('a' == ch_Rtpvtvt.p1) -assert('b' == ch_Rtpvtvt.p2) - - -val ch_Rtpvtvf = new Rtpvtvf('a', 'b') -val i_Rtpvtvf = new Rtpvtvf(1, 2) -assert(2 == i_Rtpvtvf.a) -assert('b' == ch_Rtpvtvf.a) -assert(1 == i_Rtpvtvf.p1) -assert('a' == ch_Rtpvtvf.p1) - - -val ch_Rtpvtnt = new Rtpvtnt('a', 'b') -val i_Rtpvtnt = new Rtpvtnt(1, 2) -assert(1 == i_Rtpvtnt.p1) -assert(2 == i_Rtpvtnt.p2) -assert('a' == ch_Rtpvtnt.p1) -assert('b' == ch_Rtpvtnt.p2) - - -val ch_Rtpvtnf = new Rtpvtnf('a', 'b') -val i_Rtpvtnf = new Rtpvtnf(1, 2) -assert(1 == i_Rtpvtnf.p1) -assert('a' == ch_Rtpvtnf.p1) - - -val ch_Rtpvfpvt = new Rtpvfpvt('a', 'b') -val i_Rtpvfpvt = new Rtpvfpvt(1, 2) -assert(2 == i_Rtpvfpvt.p2) -assert('b' == ch_Rtpvfpvt.p2) - - -val ch_Rtpvfvt = new Rtpvfvt('a', 'b') -val i_Rtpvfvt = new Rtpvfvt(1, 2) -assert(2 == i_Rtpvfvt.a) -assert('b' == ch_Rtpvfvt.a) -assert(2 == i_Rtpvfvt.p2) -assert('b' == ch_Rtpvfvt.p2) - - -val ch_Rtpvfnt = new Rtpvfnt('a', 'b') -val i_Rtpvfnt = new Rtpvfnt(1, 2) -assert(2 == i_Rtpvfnt.p2) -assert('b' == ch_Rtpvfnt.p2) - - -val ch_Rtvtpvt = new Rtvtpvt('a', 'b') -val i_Rtvtpvt = new Rtvtpvt(1, 2) -assert(1 == i_Rtvtpvt.`a b`) -assert('a' == ch_Rtvtpvt.`a b`) -assert(1 == i_Rtvtpvt.p1) -assert(2 == i_Rtvtpvt.p2) -assert('a' == ch_Rtvtpvt.p1) -assert('b' == ch_Rtvtpvt.p2) - - -val ch_Rtvtpvf = new Rtvtpvf('a', 'b') -val i_Rtvtpvf = new Rtvtpvf(1, 2) -assert(1 == i_Rtvtpvf.`a b`) -assert('a' == ch_Rtvtpvf.`a b`) -assert(1 == i_Rtvtpvf.p1) -assert('a' == ch_Rtvtpvf.p1) - - -val ch_Rtvtvt = new Rtvtvt('a', 'b') -val i_Rtvtvt = new Rtvtvt(1, 2) -assert(1 == i_Rtvtvt.`a b`) -assert(2 == i_Rtvtvt.a) -assert('a' == ch_Rtvtvt.`a b`) -assert('b' == ch_Rtvtvt.a) -assert(1 == i_Rtvtvt.p1) -assert(2 == i_Rtvtvt.p2) -assert('a' == ch_Rtvtvt.p1) -assert('b' == ch_Rtvtvt.p2) - - -val ch_Rtvtvf = new Rtvtvf('a', 'b') -val i_Rtvtvf = new Rtvtvf(1, 2) -assert(1 == i_Rtvtvf.`a b`) -assert(2 == i_Rtvtvf.a) -assert('a' == ch_Rtvtvf.`a b`) -assert('b' == ch_Rtvtvf.a) -assert(1 == i_Rtvtvf.p1) -assert('a' == ch_Rtvtvf.p1) - - -val ch_Rtvtnt = new Rtvtnt('a', 'b') -val i_Rtvtnt = new Rtvtnt(1, 2) -assert(1 == i_Rtvtnt.`a b`) -assert('a' == ch_Rtvtnt.`a b`) -assert(1 == i_Rtvtnt.p1) -assert(2 == i_Rtvtnt.p2) -assert('a' == ch_Rtvtnt.p1) -assert('b' == ch_Rtvtnt.p2) - - -val ch_Rtvtnf = new Rtvtnf('a', 'b') -val i_Rtvtnf = new Rtvtnf(1, 2) -assert(1 == i_Rtvtnf.`a b`) -assert('a' == ch_Rtvtnf.`a b`) -assert(1 == i_Rtvtnf.p1) -assert('a' == ch_Rtvtnf.p1) - - -val ch_Rtvfpvt = new Rtvfpvt('a', 'b') -val i_Rtvfpvt = new Rtvfpvt(1, 2) -assert(1 == i_Rtvfpvt.`a b`) -assert('a' == ch_Rtvfpvt.`a b`) -assert(2 == i_Rtvfpvt.p2) -assert('b' == ch_Rtvfpvt.p2) - - -val ch_Rtvfvt = new Rtvfvt('a', 'b') -val i_Rtvfvt = new Rtvfvt(1, 2) -assert(1 == i_Rtvfvt.`a b`) -assert(2 == i_Rtvfvt.a) -assert('a' == ch_Rtvfvt.`a b`) -assert('b' == ch_Rtvfvt.a) -assert(2 == i_Rtvfvt.p2) -assert('b' == ch_Rtvfvt.p2) - - -val ch_Rtvfnt = new Rtvfnt('a', 'b') -val i_Rtvfnt = new Rtvfnt(1, 2) -assert(1 == i_Rtvfnt.`a b`) -assert('a' == ch_Rtvfnt.`a b`) -assert(2 == i_Rtvfnt.p2) -assert('b' == ch_Rtvfnt.p2) - - -val ch_Rtntpvt = new Rtntpvt('a', 'b') -val i_Rtntpvt = new Rtntpvt(1, 2) -assert(1 == i_Rtntpvt.p1) -assert(2 == i_Rtntpvt.p2) -assert('a' == ch_Rtntpvt.p1) -assert('b' == ch_Rtntpvt.p2) - - -val ch_Rtntpvf = new Rtntpvf('a', 'b') -val i_Rtntpvf = new Rtntpvf(1, 2) -assert(1 == i_Rtntpvf.p1) -assert('a' == ch_Rtntpvf.p1) - - -val ch_Rtntvt = new Rtntvt('a', 'b') -val i_Rtntvt = new Rtntvt(1, 2) -assert(2 == i_Rtntvt.a) -assert('b' == ch_Rtntvt.a) -assert(1 == i_Rtntvt.p1) -assert(2 == i_Rtntvt.p2) -assert('a' == ch_Rtntvt.p1) -assert('b' == ch_Rtntvt.p2) - - -val ch_Rtntvf = new Rtntvf('a', 'b') -val i_Rtntvf = new Rtntvf(1, 2) -assert(2 == i_Rtntvf.a) -assert('b' == ch_Rtntvf.a) -assert(1 == i_Rtntvf.p1) -assert('a' == ch_Rtntvf.p1) - - -val ch_Rtntnt = new Rtntnt('a', 'b') -val i_Rtntnt = new Rtntnt(1, 2) -assert(1 == i_Rtntnt.p1) -assert(2 == i_Rtntnt.p2) -assert('a' == ch_Rtntnt.p1) -assert('b' == ch_Rtntnt.p2) - - -val ch_Rtntnf = new Rtntnf('a', 'b') -val i_Rtntnf = new Rtntnf(1, 2) -assert(1 == i_Rtntnf.p1) -assert('a' == ch_Rtntnf.p1) - - -val ch_Rtnfpvt = new Rtnfpvt('a', 'b') -val i_Rtnfpvt = new Rtnfpvt(1, 2) -assert(2 == i_Rtnfpvt.p2) -assert('b' == ch_Rtnfpvt.p2) - - -val ch_Rtnfvt = new Rtnfvt('a', 'b') -val i_Rtnfvt = new Rtnfvt(1, 2) -assert(2 == i_Rtnfvt.a) -assert('b' == ch_Rtnfvt.a) -assert(2 == i_Rtnfvt.p2) -assert('b' == ch_Rtnfvt.p2) - - -val ch_Rtnfnt = new Rtnfnt('a', 'b') -val i_Rtnfnt = new Rtnfnt(1, 2) -assert(2 == i_Rtnfnt.p2) -assert('b' == ch_Rtnfnt.p2) - - -val ch_Rfpvtpvt = new Rfpvtpvt('a', 'b') -val i_Rfpvtpvt = new Rfpvtpvt(1, 2) -assert(1 == i_Rfpvtpvt.p1) -assert(2 == i_Rfpvtpvt.p2) -assert('a' == ch_Rfpvtpvt.p1) -assert('b' == ch_Rfpvtpvt.p2) - - -val ch_Rfpvtpvf = new Rfpvtpvf('a', 'b') -val i_Rfpvtpvf = new Rfpvtpvf(1, 2) -assert(1 == i_Rfpvtpvf.p1) -assert('a' == ch_Rfpvtpvf.p1) - - -val ch_Rfpvtvt = new Rfpvtvt('a', 'b') -val i_Rfpvtvt = new Rfpvtvt(1, 2) -assert(2 == i_Rfpvtvt.a) -assert('b' == ch_Rfpvtvt.a) -assert(1 == i_Rfpvtvt.p1) -assert(2 == i_Rfpvtvt.p2) -assert('a' == ch_Rfpvtvt.p1) -assert('b' == ch_Rfpvtvt.p2) - - -val ch_Rfpvtvf = new Rfpvtvf('a', 'b') -val i_Rfpvtvf = new Rfpvtvf(1, 2) -assert(2 == i_Rfpvtvf.a) -assert('b' == ch_Rfpvtvf.a) -assert(1 == i_Rfpvtvf.p1) -assert('a' == ch_Rfpvtvf.p1) - - -val ch_Rfpvtnt = new Rfpvtnt('a', 'b') -val i_Rfpvtnt = new Rfpvtnt(1, 2) -assert(1 == i_Rfpvtnt.p1) -assert(2 == i_Rfpvtnt.p2) -assert('a' == ch_Rfpvtnt.p1) -assert('b' == ch_Rfpvtnt.p2) - - -val ch_Rfpvtnf = new Rfpvtnf('a', 'b') -val i_Rfpvtnf = new Rfpvtnf(1, 2) -assert(1 == i_Rfpvtnf.p1) -assert('a' == ch_Rfpvtnf.p1) - - -val ch_Rfpvfpvt = new Rfpvfpvt('a', 'b') -val i_Rfpvfpvt = new Rfpvfpvt(1, 2) -assert(2 == i_Rfpvfpvt.p2) -assert('b' == ch_Rfpvfpvt.p2) - - -val ch_Rfpvfpvf = new Rfpvfpvf('a', 'b') -val i_Rfpvfpvf = new Rfpvfpvf(1, 2) - +val ch_Cpvt_pvt = new Cpvt_pvt('a', 'b') +val i_Cpvt_pvt = new Cpvt_pvt(1, 2) +val Cpvt_pvt(extracted1i_Cpvt_pvt, extracted2i_Cpvt_pvt) = i_Cpvt_pvt +val Cpvt_pvt(extracted1ch_Cpvt_pvt, extracted2ch_Cpvt_pvt) = ch_Cpvt_pvt +assert(1 == extracted1i_Cpvt_pvt) +assert(2 == extracted2i_Cpvt_pvt) +assert('a' == extracted1ch_Cpvt_pvt) +assert('b' == extracted2ch_Cpvt_pvt) + +assert(1 == i_Cpvt_pvt.p1) +assert(2 == i_Cpvt_pvt.p2) +assert('a' == ch_Cpvt_pvt.p1) +assert('b' == ch_Cpvt_pvt.p2) + + +val ch_Cpvt_pvf = new Cpvt_pvf('a', 'b') +val i_Cpvt_pvf = new Cpvt_pvf(1, 2) +val Cpvt_pvf(extracted1i_Cpvt_pvf, extracted2i_Cpvt_pvf) = i_Cpvt_pvf +val Cpvt_pvf(extracted1ch_Cpvt_pvf, extracted2ch_Cpvt_pvf) = ch_Cpvt_pvf +assert(1 == extracted1i_Cpvt_pvf) +assert(2 == extracted2i_Cpvt_pvf) +assert('a' == extracted1ch_Cpvt_pvf) +assert('b' == extracted2ch_Cpvt_pvf) + +assert(1 == i_Cpvt_pvf.p1) +assert('a' == ch_Cpvt_pvf.p1) + + +val ch_Cpvt_vt = new Cpvt_vt('a', 'b') +val i_Cpvt_vt = new Cpvt_vt(1, 2) +val Cpvt_vt(extracted1i_Cpvt_vt, extracted2i_Cpvt_vt) = i_Cpvt_vt +val Cpvt_vt(extracted1ch_Cpvt_vt, extracted2ch_Cpvt_vt) = ch_Cpvt_vt +assert(1 == extracted1i_Cpvt_vt) +assert(2 == extracted2i_Cpvt_vt) +assert('a' == extracted1ch_Cpvt_vt) +assert('b' == extracted2ch_Cpvt_vt) + +assert(2 == i_Cpvt_vt.a) +assert('b' == ch_Cpvt_vt.a) +assert(1 == i_Cpvt_vt.p1) +assert(2 == i_Cpvt_vt.p2) +assert('a' == ch_Cpvt_vt.p1) +assert('b' == ch_Cpvt_vt.p2) + + +val ch_Cpvt_vf = new Cpvt_vf('a', 'b') +val i_Cpvt_vf = new Cpvt_vf(1, 2) +val Cpvt_vf(extracted1i_Cpvt_vf, extracted2i_Cpvt_vf) = i_Cpvt_vf +val Cpvt_vf(extracted1ch_Cpvt_vf, extracted2ch_Cpvt_vf) = ch_Cpvt_vf +assert(1 == extracted1i_Cpvt_vf) +assert(2 == extracted2i_Cpvt_vf) +assert('a' == extracted1ch_Cpvt_vf) +assert('b' == extracted2ch_Cpvt_vf) + +assert(2 == i_Cpvt_vf.a) +assert('b' == ch_Cpvt_vf.a) +assert(1 == i_Cpvt_vf.p1) +assert('a' == ch_Cpvt_vf.p1) + + +val ch_Cpvt_nt = new Cpvt_nt('a', 'b') +val i_Cpvt_nt = new Cpvt_nt(1, 2) +val Cpvt_nt(extracted1i_Cpvt_nt, extracted2i_Cpvt_nt) = i_Cpvt_nt +val Cpvt_nt(extracted1ch_Cpvt_nt, extracted2ch_Cpvt_nt) = ch_Cpvt_nt +assert(1 == extracted1i_Cpvt_nt) +assert(2 == extracted2i_Cpvt_nt) +assert('a' == extracted1ch_Cpvt_nt) +assert('b' == extracted2ch_Cpvt_nt) + +assert(2 == i_Cpvt_nt.a) +assert('b' == ch_Cpvt_nt.a) +assert(1 == i_Cpvt_nt.p1) +assert(2 == i_Cpvt_nt.p2) +assert('a' == ch_Cpvt_nt.p1) +assert('b' == ch_Cpvt_nt.p2) + + +val ch_Cpvt_nf = new Cpvt_nf('a', 'b') +val i_Cpvt_nf = new Cpvt_nf(1, 2) +val Cpvt_nf(extracted1i_Cpvt_nf, extracted2i_Cpvt_nf) = i_Cpvt_nf +val Cpvt_nf(extracted1ch_Cpvt_nf, extracted2ch_Cpvt_nf) = ch_Cpvt_nf +assert(1 == extracted1i_Cpvt_nf) +assert(2 == extracted2i_Cpvt_nf) +assert('a' == extracted1ch_Cpvt_nf) +assert('b' == extracted2ch_Cpvt_nf) + +assert(2 == i_Cpvt_nf.a) +assert('b' == ch_Cpvt_nf.a) +assert(1 == i_Cpvt_nf.p1) +assert('a' == ch_Cpvt_nf.p1) + + +val ch_Cpvf_pvt = new Cpvf_pvt('a', 'b') +val i_Cpvf_pvt = new Cpvf_pvt(1, 2) +val Cpvf_pvt(extracted1i_Cpvf_pvt, extracted2i_Cpvf_pvt) = i_Cpvf_pvt +val Cpvf_pvt(extracted1ch_Cpvf_pvt, extracted2ch_Cpvf_pvt) = ch_Cpvf_pvt +assert(1 == extracted1i_Cpvf_pvt) +assert(2 == extracted2i_Cpvf_pvt) +assert('a' == extracted1ch_Cpvf_pvt) +assert('b' == extracted2ch_Cpvf_pvt) + +assert(2 == i_Cpvf_pvt.p2) +assert('b' == ch_Cpvf_pvt.p2) + + +val ch_Cpvf_pvf = new Cpvf_pvf('a', 'b') +val i_Cpvf_pvf = new Cpvf_pvf(1, 2) +val Cpvf_pvf(extracted1i_Cpvf_pvf, extracted2i_Cpvf_pvf) = i_Cpvf_pvf +val Cpvf_pvf(extracted1ch_Cpvf_pvf, extracted2ch_Cpvf_pvf) = ch_Cpvf_pvf +assert(1 == extracted1i_Cpvf_pvf) +assert(2 == extracted2i_Cpvf_pvf) +assert('a' == extracted1ch_Cpvf_pvf) +assert('b' == extracted2ch_Cpvf_pvf) + + + +val ch_Cpvf_vt = new Cpvf_vt('a', 'b') +val i_Cpvf_vt = new Cpvf_vt(1, 2) +val Cpvf_vt(extracted1i_Cpvf_vt, extracted2i_Cpvf_vt) = i_Cpvf_vt +val Cpvf_vt(extracted1ch_Cpvf_vt, extracted2ch_Cpvf_vt) = ch_Cpvf_vt +assert(1 == extracted1i_Cpvf_vt) +assert(2 == extracted2i_Cpvf_vt) +assert('a' == extracted1ch_Cpvf_vt) +assert('b' == extracted2ch_Cpvf_vt) + +assert(2 == i_Cpvf_vt.a) +assert('b' == ch_Cpvf_vt.a) +assert(2 == i_Cpvf_vt.p2) +assert('b' == ch_Cpvf_vt.p2) + + +val ch_Cpvf_vf = new Cpvf_vf('a', 'b') +val i_Cpvf_vf = new Cpvf_vf(1, 2) +val Cpvf_vf(extracted1i_Cpvf_vf, extracted2i_Cpvf_vf) = i_Cpvf_vf +val Cpvf_vf(extracted1ch_Cpvf_vf, extracted2ch_Cpvf_vf) = ch_Cpvf_vf +assert(1 == extracted1i_Cpvf_vf) +assert(2 == extracted2i_Cpvf_vf) +assert('a' == extracted1ch_Cpvf_vf) +assert('b' == extracted2ch_Cpvf_vf) + +assert(2 == i_Cpvf_vf.a) +assert('b' == ch_Cpvf_vf.a) + + +val ch_Cpvf_nt = new Cpvf_nt('a', 'b') +val i_Cpvf_nt = new Cpvf_nt(1, 2) +val Cpvf_nt(extracted1i_Cpvf_nt, extracted2i_Cpvf_nt) = i_Cpvf_nt +val Cpvf_nt(extracted1ch_Cpvf_nt, extracted2ch_Cpvf_nt) = ch_Cpvf_nt +assert(1 == extracted1i_Cpvf_nt) +assert(2 == extracted2i_Cpvf_nt) +assert('a' == extracted1ch_Cpvf_nt) +assert('b' == extracted2ch_Cpvf_nt) + +assert(2 == i_Cpvf_nt.a) +assert('b' == ch_Cpvf_nt.a) +assert(2 == i_Cpvf_nt.p2) +assert('b' == ch_Cpvf_nt.p2) + + +val ch_Cpvf_nf = new Cpvf_nf('a', 'b') +val i_Cpvf_nf = new Cpvf_nf(1, 2) +val Cpvf_nf(extracted1i_Cpvf_nf, extracted2i_Cpvf_nf) = i_Cpvf_nf +val Cpvf_nf(extracted1ch_Cpvf_nf, extracted2ch_Cpvf_nf) = ch_Cpvf_nf +assert(1 == extracted1i_Cpvf_nf) +assert(2 == extracted2i_Cpvf_nf) +assert('a' == extracted1ch_Cpvf_nf) +assert('b' == extracted2ch_Cpvf_nf) + +assert(2 == i_Cpvf_nf.a) +assert('b' == ch_Cpvf_nf.a) + + +val ch_Cvt_pvt = new Cvt_pvt('a', 'b') +val i_Cvt_pvt = new Cvt_pvt(1, 2) +val Cvt_pvt(extracted1i_Cvt_pvt, extracted2i_Cvt_pvt) = i_Cvt_pvt +val Cvt_pvt(extracted1ch_Cvt_pvt, extracted2ch_Cvt_pvt) = ch_Cvt_pvt +assert(1 == extracted1i_Cvt_pvt) +assert(2 == extracted2i_Cvt_pvt) +assert('a' == extracted1ch_Cvt_pvt) +assert('b' == extracted2ch_Cvt_pvt) + +assert(1 == i_Cvt_pvt.`a b`) +assert('a' == ch_Cvt_pvt.`a b`) +assert(1 == i_Cvt_pvt.p1) +assert(2 == i_Cvt_pvt.p2) +assert('a' == ch_Cvt_pvt.p1) +assert('b' == ch_Cvt_pvt.p2) + + +val ch_Cvt_pvf = new Cvt_pvf('a', 'b') +val i_Cvt_pvf = new Cvt_pvf(1, 2) +val Cvt_pvf(extracted1i_Cvt_pvf, extracted2i_Cvt_pvf) = i_Cvt_pvf +val Cvt_pvf(extracted1ch_Cvt_pvf, extracted2ch_Cvt_pvf) = ch_Cvt_pvf +assert(1 == extracted1i_Cvt_pvf) +assert(2 == extracted2i_Cvt_pvf) +assert('a' == extracted1ch_Cvt_pvf) +assert('b' == extracted2ch_Cvt_pvf) + +assert(1 == i_Cvt_pvf.`a b`) +assert('a' == ch_Cvt_pvf.`a b`) +assert(1 == i_Cvt_pvf.p1) +assert('a' == ch_Cvt_pvf.p1) + + +val ch_Cvt_vt = new Cvt_vt('a', 'b') +val i_Cvt_vt = new Cvt_vt(1, 2) +val Cvt_vt(extracted1i_Cvt_vt, extracted2i_Cvt_vt) = i_Cvt_vt +val Cvt_vt(extracted1ch_Cvt_vt, extracted2ch_Cvt_vt) = ch_Cvt_vt +assert(1 == extracted1i_Cvt_vt) +assert(2 == extracted2i_Cvt_vt) +assert('a' == extracted1ch_Cvt_vt) +assert('b' == extracted2ch_Cvt_vt) + +assert(1 == i_Cvt_vt.`a b`) +assert(2 == i_Cvt_vt.a) +assert('a' == ch_Cvt_vt.`a b`) +assert('b' == ch_Cvt_vt.a) +assert(1 == i_Cvt_vt.p1) +assert(2 == i_Cvt_vt.p2) +assert('a' == ch_Cvt_vt.p1) +assert('b' == ch_Cvt_vt.p2) + + +val ch_Cvt_vf = new Cvt_vf('a', 'b') +val i_Cvt_vf = new Cvt_vf(1, 2) +val Cvt_vf(extracted1i_Cvt_vf, extracted2i_Cvt_vf) = i_Cvt_vf +val Cvt_vf(extracted1ch_Cvt_vf, extracted2ch_Cvt_vf) = ch_Cvt_vf +assert(1 == extracted1i_Cvt_vf) +assert(2 == extracted2i_Cvt_vf) +assert('a' == extracted1ch_Cvt_vf) +assert('b' == extracted2ch_Cvt_vf) + +assert(1 == i_Cvt_vf.`a b`) +assert(2 == i_Cvt_vf.a) +assert('a' == ch_Cvt_vf.`a b`) +assert('b' == ch_Cvt_vf.a) +assert(1 == i_Cvt_vf.p1) +assert('a' == ch_Cvt_vf.p1) + + +val ch_Cvt_nt = new Cvt_nt('a', 'b') +val i_Cvt_nt = new Cvt_nt(1, 2) +val Cvt_nt(extracted1i_Cvt_nt, extracted2i_Cvt_nt) = i_Cvt_nt +val Cvt_nt(extracted1ch_Cvt_nt, extracted2ch_Cvt_nt) = ch_Cvt_nt +assert(1 == extracted1i_Cvt_nt) +assert(2 == extracted2i_Cvt_nt) +assert('a' == extracted1ch_Cvt_nt) +assert('b' == extracted2ch_Cvt_nt) + +assert(1 == i_Cvt_nt.`a b`) +assert(2 == i_Cvt_nt.a) +assert('a' == ch_Cvt_nt.`a b`) +assert('b' == ch_Cvt_nt.a) +assert(1 == i_Cvt_nt.p1) +assert(2 == i_Cvt_nt.p2) +assert('a' == ch_Cvt_nt.p1) +assert('b' == ch_Cvt_nt.p2) + + +val ch_Cvt_nf = new Cvt_nf('a', 'b') +val i_Cvt_nf = new Cvt_nf(1, 2) +val Cvt_nf(extracted1i_Cvt_nf, extracted2i_Cvt_nf) = i_Cvt_nf +val Cvt_nf(extracted1ch_Cvt_nf, extracted2ch_Cvt_nf) = ch_Cvt_nf +assert(1 == extracted1i_Cvt_nf) +assert(2 == extracted2i_Cvt_nf) +assert('a' == extracted1ch_Cvt_nf) +assert('b' == extracted2ch_Cvt_nf) + +assert(1 == i_Cvt_nf.`a b`) +assert(2 == i_Cvt_nf.a) +assert('a' == ch_Cvt_nf.`a b`) +assert('b' == ch_Cvt_nf.a) +assert(1 == i_Cvt_nf.p1) +assert('a' == ch_Cvt_nf.p1) + + +val ch_Cvf_pvt = new Cvf_pvt('a', 'b') +val i_Cvf_pvt = new Cvf_pvt(1, 2) +val Cvf_pvt(extracted1i_Cvf_pvt, extracted2i_Cvf_pvt) = i_Cvf_pvt +val Cvf_pvt(extracted1ch_Cvf_pvt, extracted2ch_Cvf_pvt) = ch_Cvf_pvt +assert(1 == extracted1i_Cvf_pvt) +assert(2 == extracted2i_Cvf_pvt) +assert('a' == extracted1ch_Cvf_pvt) +assert('b' == extracted2ch_Cvf_pvt) + +assert(1 == i_Cvf_pvt.`a b`) +assert('a' == ch_Cvf_pvt.`a b`) +assert(2 == i_Cvf_pvt.p2) +assert('b' == ch_Cvf_pvt.p2) + + +val ch_Cvf_pvf = new Cvf_pvf('a', 'b') +val i_Cvf_pvf = new Cvf_pvf(1, 2) +val Cvf_pvf(extracted1i_Cvf_pvf, extracted2i_Cvf_pvf) = i_Cvf_pvf +val Cvf_pvf(extracted1ch_Cvf_pvf, extracted2ch_Cvf_pvf) = ch_Cvf_pvf +assert(1 == extracted1i_Cvf_pvf) +assert(2 == extracted2i_Cvf_pvf) +assert('a' == extracted1ch_Cvf_pvf) +assert('b' == extracted2ch_Cvf_pvf) + +assert(1 == i_Cvf_pvf.`a b`) +assert('a' == ch_Cvf_pvf.`a b`) + + +val ch_Cvf_vt = new Cvf_vt('a', 'b') +val i_Cvf_vt = new Cvf_vt(1, 2) +val Cvf_vt(extracted1i_Cvf_vt, extracted2i_Cvf_vt) = i_Cvf_vt +val Cvf_vt(extracted1ch_Cvf_vt, extracted2ch_Cvf_vt) = ch_Cvf_vt +assert(1 == extracted1i_Cvf_vt) +assert(2 == extracted2i_Cvf_vt) +assert('a' == extracted1ch_Cvf_vt) +assert('b' == extracted2ch_Cvf_vt) + +assert(1 == i_Cvf_vt.`a b`) +assert(2 == i_Cvf_vt.a) +assert('a' == ch_Cvf_vt.`a b`) +assert('b' == ch_Cvf_vt.a) +assert(2 == i_Cvf_vt.p2) +assert('b' == ch_Cvf_vt.p2) + + +val ch_Cvf_vf = new Cvf_vf('a', 'b') +val i_Cvf_vf = new Cvf_vf(1, 2) +val Cvf_vf(extracted1i_Cvf_vf, extracted2i_Cvf_vf) = i_Cvf_vf +val Cvf_vf(extracted1ch_Cvf_vf, extracted2ch_Cvf_vf) = ch_Cvf_vf +assert(1 == extracted1i_Cvf_vf) +assert(2 == extracted2i_Cvf_vf) +assert('a' == extracted1ch_Cvf_vf) +assert('b' == extracted2ch_Cvf_vf) + +assert(1 == i_Cvf_vf.`a b`) +assert(2 == i_Cvf_vf.a) +assert('a' == ch_Cvf_vf.`a b`) +assert('b' == ch_Cvf_vf.a) + + +val ch_Cvf_nt = new Cvf_nt('a', 'b') +val i_Cvf_nt = new Cvf_nt(1, 2) +val Cvf_nt(extracted1i_Cvf_nt, extracted2i_Cvf_nt) = i_Cvf_nt +val Cvf_nt(extracted1ch_Cvf_nt, extracted2ch_Cvf_nt) = ch_Cvf_nt +assert(1 == extracted1i_Cvf_nt) +assert(2 == extracted2i_Cvf_nt) +assert('a' == extracted1ch_Cvf_nt) +assert('b' == extracted2ch_Cvf_nt) + +assert(1 == i_Cvf_nt.`a b`) +assert(2 == i_Cvf_nt.a) +assert('a' == ch_Cvf_nt.`a b`) +assert('b' == ch_Cvf_nt.a) +assert(2 == i_Cvf_nt.p2) +assert('b' == ch_Cvf_nt.p2) + + +val ch_Cvf_nf = new Cvf_nf('a', 'b') +val i_Cvf_nf = new Cvf_nf(1, 2) +val Cvf_nf(extracted1i_Cvf_nf, extracted2i_Cvf_nf) = i_Cvf_nf +val Cvf_nf(extracted1ch_Cvf_nf, extracted2ch_Cvf_nf) = ch_Cvf_nf +assert(1 == extracted1i_Cvf_nf) +assert(2 == extracted2i_Cvf_nf) +assert('a' == extracted1ch_Cvf_nf) +assert('b' == extracted2ch_Cvf_nf) + +assert(1 == i_Cvf_nf.`a b`) +assert(2 == i_Cvf_nf.a) +assert('a' == ch_Cvf_nf.`a b`) +assert('b' == ch_Cvf_nf.a) + + +val ch_Cnt_pvt = new Cnt_pvt('a', 'b') +val i_Cnt_pvt = new Cnt_pvt(1, 2) +val Cnt_pvt(extracted1i_Cnt_pvt, extracted2i_Cnt_pvt) = i_Cnt_pvt +val Cnt_pvt(extracted1ch_Cnt_pvt, extracted2ch_Cnt_pvt) = ch_Cnt_pvt +assert(1 == extracted1i_Cnt_pvt) +assert(2 == extracted2i_Cnt_pvt) +assert('a' == extracted1ch_Cnt_pvt) +assert('b' == extracted2ch_Cnt_pvt) + +assert(1 == i_Cnt_pvt.`a b`) +assert('a' == ch_Cnt_pvt.`a b`) +assert(1 == i_Cnt_pvt.p1) +assert(2 == i_Cnt_pvt.p2) +assert('a' == ch_Cnt_pvt.p1) +assert('b' == ch_Cnt_pvt.p2) + + +val ch_Cnt_pvf = new Cnt_pvf('a', 'b') +val i_Cnt_pvf = new Cnt_pvf(1, 2) +val Cnt_pvf(extracted1i_Cnt_pvf, extracted2i_Cnt_pvf) = i_Cnt_pvf +val Cnt_pvf(extracted1ch_Cnt_pvf, extracted2ch_Cnt_pvf) = ch_Cnt_pvf +assert(1 == extracted1i_Cnt_pvf) +assert(2 == extracted2i_Cnt_pvf) +assert('a' == extracted1ch_Cnt_pvf) +assert('b' == extracted2ch_Cnt_pvf) + +assert(1 == i_Cnt_pvf.`a b`) +assert('a' == ch_Cnt_pvf.`a b`) +assert(1 == i_Cnt_pvf.p1) +assert('a' == ch_Cnt_pvf.p1) + + +val ch_Cnt_vt = new Cnt_vt('a', 'b') +val i_Cnt_vt = new Cnt_vt(1, 2) +val Cnt_vt(extracted1i_Cnt_vt, extracted2i_Cnt_vt) = i_Cnt_vt +val Cnt_vt(extracted1ch_Cnt_vt, extracted2ch_Cnt_vt) = ch_Cnt_vt +assert(1 == extracted1i_Cnt_vt) +assert(2 == extracted2i_Cnt_vt) +assert('a' == extracted1ch_Cnt_vt) +assert('b' == extracted2ch_Cnt_vt) + +assert(1 == i_Cnt_vt.`a b`) +assert(2 == i_Cnt_vt.a) +assert('a' == ch_Cnt_vt.`a b`) +assert('b' == ch_Cnt_vt.a) +assert(1 == i_Cnt_vt.p1) +assert(2 == i_Cnt_vt.p2) +assert('a' == ch_Cnt_vt.p1) +assert('b' == ch_Cnt_vt.p2) + + +val ch_Cnt_vf = new Cnt_vf('a', 'b') +val i_Cnt_vf = new Cnt_vf(1, 2) +val Cnt_vf(extracted1i_Cnt_vf, extracted2i_Cnt_vf) = i_Cnt_vf +val Cnt_vf(extracted1ch_Cnt_vf, extracted2ch_Cnt_vf) = ch_Cnt_vf +assert(1 == extracted1i_Cnt_vf) +assert(2 == extracted2i_Cnt_vf) +assert('a' == extracted1ch_Cnt_vf) +assert('b' == extracted2ch_Cnt_vf) + +assert(1 == i_Cnt_vf.`a b`) +assert(2 == i_Cnt_vf.a) +assert('a' == ch_Cnt_vf.`a b`) +assert('b' == ch_Cnt_vf.a) +assert(1 == i_Cnt_vf.p1) +assert('a' == ch_Cnt_vf.p1) + + +val ch_Cnt_nt = new Cnt_nt('a', 'b') +val i_Cnt_nt = new Cnt_nt(1, 2) +val Cnt_nt(extracted1i_Cnt_nt, extracted2i_Cnt_nt) = i_Cnt_nt +val Cnt_nt(extracted1ch_Cnt_nt, extracted2ch_Cnt_nt) = ch_Cnt_nt +assert(1 == extracted1i_Cnt_nt) +assert(2 == extracted2i_Cnt_nt) +assert('a' == extracted1ch_Cnt_nt) +assert('b' == extracted2ch_Cnt_nt) + +assert(1 == i_Cnt_nt.`a b`) +assert(2 == i_Cnt_nt.a) +assert('a' == ch_Cnt_nt.`a b`) +assert('b' == ch_Cnt_nt.a) +assert(1 == i_Cnt_nt.p1) +assert(2 == i_Cnt_nt.p2) +assert('a' == ch_Cnt_nt.p1) +assert('b' == ch_Cnt_nt.p2) + + +val ch_Cnt_nf = new Cnt_nf('a', 'b') +val i_Cnt_nf = new Cnt_nf(1, 2) +val Cnt_nf(extracted1i_Cnt_nf, extracted2i_Cnt_nf) = i_Cnt_nf +val Cnt_nf(extracted1ch_Cnt_nf, extracted2ch_Cnt_nf) = ch_Cnt_nf +assert(1 == extracted1i_Cnt_nf) +assert(2 == extracted2i_Cnt_nf) +assert('a' == extracted1ch_Cnt_nf) +assert('b' == extracted2ch_Cnt_nf) + +assert(1 == i_Cnt_nf.`a b`) +assert(2 == i_Cnt_nf.a) +assert('a' == ch_Cnt_nf.`a b`) +assert('b' == ch_Cnt_nf.a) +assert(1 == i_Cnt_nf.p1) +assert('a' == ch_Cnt_nf.p1) + + +val ch_Cnf_pvt = new Cnf_pvt('a', 'b') +val i_Cnf_pvt = new Cnf_pvt(1, 2) +val Cnf_pvt(extracted1i_Cnf_pvt, extracted2i_Cnf_pvt) = i_Cnf_pvt +val Cnf_pvt(extracted1ch_Cnf_pvt, extracted2ch_Cnf_pvt) = ch_Cnf_pvt +assert(1 == extracted1i_Cnf_pvt) +assert(2 == extracted2i_Cnf_pvt) +assert('a' == extracted1ch_Cnf_pvt) +assert('b' == extracted2ch_Cnf_pvt) + +assert(1 == i_Cnf_pvt.`a b`) +assert('a' == ch_Cnf_pvt.`a b`) +assert(2 == i_Cnf_pvt.p2) +assert('b' == ch_Cnf_pvt.p2) + + +val ch_Cnf_pvf = new Cnf_pvf('a', 'b') +val i_Cnf_pvf = new Cnf_pvf(1, 2) +val Cnf_pvf(extracted1i_Cnf_pvf, extracted2i_Cnf_pvf) = i_Cnf_pvf +val Cnf_pvf(extracted1ch_Cnf_pvf, extracted2ch_Cnf_pvf) = ch_Cnf_pvf +assert(1 == extracted1i_Cnf_pvf) +assert(2 == extracted2i_Cnf_pvf) +assert('a' == extracted1ch_Cnf_pvf) +assert('b' == extracted2ch_Cnf_pvf) + +assert(1 == i_Cnf_pvf.`a b`) +assert('a' == ch_Cnf_pvf.`a b`) + + +val ch_Cnf_vt = new Cnf_vt('a', 'b') +val i_Cnf_vt = new Cnf_vt(1, 2) +val Cnf_vt(extracted1i_Cnf_vt, extracted2i_Cnf_vt) = i_Cnf_vt +val Cnf_vt(extracted1ch_Cnf_vt, extracted2ch_Cnf_vt) = ch_Cnf_vt +assert(1 == extracted1i_Cnf_vt) +assert(2 == extracted2i_Cnf_vt) +assert('a' == extracted1ch_Cnf_vt) +assert('b' == extracted2ch_Cnf_vt) + +assert(1 == i_Cnf_vt.`a b`) +assert(2 == i_Cnf_vt.a) +assert('a' == ch_Cnf_vt.`a b`) +assert('b' == ch_Cnf_vt.a) +assert(2 == i_Cnf_vt.p2) +assert('b' == ch_Cnf_vt.p2) + + +val ch_Cnf_vf = new Cnf_vf('a', 'b') +val i_Cnf_vf = new Cnf_vf(1, 2) +val Cnf_vf(extracted1i_Cnf_vf, extracted2i_Cnf_vf) = i_Cnf_vf +val Cnf_vf(extracted1ch_Cnf_vf, extracted2ch_Cnf_vf) = ch_Cnf_vf +assert(1 == extracted1i_Cnf_vf) +assert(2 == extracted2i_Cnf_vf) +assert('a' == extracted1ch_Cnf_vf) +assert('b' == extracted2ch_Cnf_vf) + +assert(1 == i_Cnf_vf.`a b`) +assert(2 == i_Cnf_vf.a) +assert('a' == ch_Cnf_vf.`a b`) +assert('b' == ch_Cnf_vf.a) + + +val ch_Cnf_nt = new Cnf_nt('a', 'b') +val i_Cnf_nt = new Cnf_nt(1, 2) +val Cnf_nt(extracted1i_Cnf_nt, extracted2i_Cnf_nt) = i_Cnf_nt +val Cnf_nt(extracted1ch_Cnf_nt, extracted2ch_Cnf_nt) = ch_Cnf_nt +assert(1 == extracted1i_Cnf_nt) +assert(2 == extracted2i_Cnf_nt) +assert('a' == extracted1ch_Cnf_nt) +assert('b' == extracted2ch_Cnf_nt) + +assert(1 == i_Cnf_nt.`a b`) +assert(2 == i_Cnf_nt.a) +assert('a' == ch_Cnf_nt.`a b`) +assert('b' == ch_Cnf_nt.a) +assert(2 == i_Cnf_nt.p2) +assert('b' == ch_Cnf_nt.p2) + + +val ch_Cnf_nf = new Cnf_nf('a', 'b') +val i_Cnf_nf = new Cnf_nf(1, 2) +val Cnf_nf(extracted1i_Cnf_nf, extracted2i_Cnf_nf) = i_Cnf_nf +val Cnf_nf(extracted1ch_Cnf_nf, extracted2ch_Cnf_nf) = ch_Cnf_nf +assert(1 == extracted1i_Cnf_nf) +assert(2 == extracted2i_Cnf_nf) +assert('a' == extracted1ch_Cnf_nf) +assert('b' == extracted2ch_Cnf_nf) + +assert(1 == i_Cnf_nf.`a b`) +assert(2 == i_Cnf_nf.a) +assert('a' == ch_Cnf_nf.`a b`) +assert('b' == ch_Cnf_nf.a) + + +val ch_Rpvt_pvt = new Rpvt_pvt('a', 'b') +val i_Rpvt_pvt = new Rpvt_pvt(1, 2) +assert(1 == i_Rpvt_pvt.p1) +assert(2 == i_Rpvt_pvt.p2) +assert('a' == ch_Rpvt_pvt.p1) +assert('b' == ch_Rpvt_pvt.p2) + + +val ch_Rpvt_pvf = new Rpvt_pvf('a', 'b') +val i_Rpvt_pvf = new Rpvt_pvf(1, 2) +assert(1 == i_Rpvt_pvf.p1) +assert('a' == ch_Rpvt_pvf.p1) + + +val ch_Rpvt_vt = new Rpvt_vt('a', 'b') +val i_Rpvt_vt = new Rpvt_vt(1, 2) +assert(2 == i_Rpvt_vt.a) +assert('b' == ch_Rpvt_vt.a) +assert(1 == i_Rpvt_vt.p1) +assert(2 == i_Rpvt_vt.p2) +assert('a' == ch_Rpvt_vt.p1) +assert('b' == ch_Rpvt_vt.p2) + + +val ch_Rpvt_vf = new Rpvt_vf('a', 'b') +val i_Rpvt_vf = new Rpvt_vf(1, 2) +assert(2 == i_Rpvt_vf.a) +assert('b' == ch_Rpvt_vf.a) +assert(1 == i_Rpvt_vf.p1) +assert('a' == ch_Rpvt_vf.p1) + + +val ch_Rpvt_nt = new Rpvt_nt('a', 'b') +val i_Rpvt_nt = new Rpvt_nt(1, 2) +assert(1 == i_Rpvt_nt.p1) +assert(2 == i_Rpvt_nt.p2) +assert('a' == ch_Rpvt_nt.p1) +assert('b' == ch_Rpvt_nt.p2) + + +val ch_Rpvt_nf = new Rpvt_nf('a', 'b') +val i_Rpvt_nf = new Rpvt_nf(1, 2) +assert(1 == i_Rpvt_nf.p1) +assert('a' == ch_Rpvt_nf.p1) + + +val ch_Rpvf_pvt = new Rpvf_pvt('a', 'b') +val i_Rpvf_pvt = new Rpvf_pvt(1, 2) +assert(2 == i_Rpvf_pvt.p2) +assert('b' == ch_Rpvf_pvt.p2) -val ch_Rfpvfvt = new Rfpvfvt('a', 'b') -val i_Rfpvfvt = new Rfpvfvt(1, 2) -assert(2 == i_Rfpvfvt.a) -assert('b' == ch_Rfpvfvt.a) -assert(2 == i_Rfpvfvt.p2) -assert('b' == ch_Rfpvfvt.p2) +val ch_Rpvf_pvf = new Rpvf_pvf('a', 'b') +val i_Rpvf_pvf = new Rpvf_pvf(1, 2) + + +val ch_Rpvf_vt = new Rpvf_vt('a', 'b') +val i_Rpvf_vt = new Rpvf_vt(1, 2) +assert(2 == i_Rpvf_vt.a) +assert('b' == ch_Rpvf_vt.a) +assert(2 == i_Rpvf_vt.p2) +assert('b' == ch_Rpvf_vt.p2) -val ch_Rfpvfvf = new Rfpvfvf('a', 'b') -val i_Rfpvfvf = new Rfpvfvf(1, 2) -assert(2 == i_Rfpvfvf.a) -assert('b' == ch_Rfpvfvf.a) + +val ch_Rpvf_vf = new Rpvf_vf('a', 'b') +val i_Rpvf_vf = new Rpvf_vf(1, 2) +assert(2 == i_Rpvf_vf.a) +assert('b' == ch_Rpvf_vf.a) -val ch_Rfpvfnt = new Rfpvfnt('a', 'b') -val i_Rfpvfnt = new Rfpvfnt(1, 2) -assert(2 == i_Rfpvfnt.p2) -assert('b' == ch_Rfpvfnt.p2) +val ch_Rpvf_nt = new Rpvf_nt('a', 'b') +val i_Rpvf_nt = new Rpvf_nt(1, 2) +assert(2 == i_Rpvf_nt.p2) +assert('b' == ch_Rpvf_nt.p2) -val ch_Rfpvfnf = new Rfpvfnf('a', 'b') -val i_Rfpvfnf = new Rfpvfnf(1, 2) +val ch_Rpvf_nf = new Rpvf_nf('a', 'b') +val i_Rpvf_nf = new Rpvf_nf(1, 2) -val ch_Rfvtpvt = new Rfvtpvt('a', 'b') -val i_Rfvtpvt = new Rfvtpvt(1, 2) -assert(1 == i_Rfvtpvt.`a b`) -assert('a' == ch_Rfvtpvt.`a b`) -assert(1 == i_Rfvtpvt.p1) -assert(2 == i_Rfvtpvt.p2) -assert('a' == ch_Rfvtpvt.p1) -assert('b' == ch_Rfvtpvt.p2) +val ch_Rvt_pvt = new Rvt_pvt('a', 'b') +val i_Rvt_pvt = new Rvt_pvt(1, 2) +assert(1 == i_Rvt_pvt.`a b`) +assert('a' == ch_Rvt_pvt.`a b`) +assert(1 == i_Rvt_pvt.p1) +assert(2 == i_Rvt_pvt.p2) +assert('a' == ch_Rvt_pvt.p1) +assert('b' == ch_Rvt_pvt.p2) -val ch_Rfvtpvf = new Rfvtpvf('a', 'b') -val i_Rfvtpvf = new Rfvtpvf(1, 2) -assert(1 == i_Rfvtpvf.`a b`) -assert('a' == ch_Rfvtpvf.`a b`) -assert(1 == i_Rfvtpvf.p1) -assert('a' == ch_Rfvtpvf.p1) +val ch_Rvt_pvf = new Rvt_pvf('a', 'b') +val i_Rvt_pvf = new Rvt_pvf(1, 2) +assert(1 == i_Rvt_pvf.`a b`) +assert('a' == ch_Rvt_pvf.`a b`) +assert(1 == i_Rvt_pvf.p1) +assert('a' == ch_Rvt_pvf.p1) -val ch_Rfvtvt = new Rfvtvt('a', 'b') -val i_Rfvtvt = new Rfvtvt(1, 2) -assert(1 == i_Rfvtvt.`a b`) -assert(2 == i_Rfvtvt.a) -assert('a' == ch_Rfvtvt.`a b`) -assert('b' == ch_Rfvtvt.a) -assert(1 == i_Rfvtvt.p1) -assert(2 == i_Rfvtvt.p2) -assert('a' == ch_Rfvtvt.p1) -assert('b' == ch_Rfvtvt.p2) +val ch_Rvt_vt = new Rvt_vt('a', 'b') +val i_Rvt_vt = new Rvt_vt(1, 2) +assert(1 == i_Rvt_vt.`a b`) +assert(2 == i_Rvt_vt.a) +assert('a' == ch_Rvt_vt.`a b`) +assert('b' == ch_Rvt_vt.a) +assert(1 == i_Rvt_vt.p1) +assert(2 == i_Rvt_vt.p2) +assert('a' == ch_Rvt_vt.p1) +assert('b' == ch_Rvt_vt.p2) -val ch_Rfvtvf = new Rfvtvf('a', 'b') -val i_Rfvtvf = new Rfvtvf(1, 2) -assert(1 == i_Rfvtvf.`a b`) -assert(2 == i_Rfvtvf.a) -assert('a' == ch_Rfvtvf.`a b`) -assert('b' == ch_Rfvtvf.a) -assert(1 == i_Rfvtvf.p1) -assert('a' == ch_Rfvtvf.p1) +val ch_Rvt_vf = new Rvt_vf('a', 'b') +val i_Rvt_vf = new Rvt_vf(1, 2) +assert(1 == i_Rvt_vf.`a b`) +assert(2 == i_Rvt_vf.a) +assert('a' == ch_Rvt_vf.`a b`) +assert('b' == ch_Rvt_vf.a) +assert(1 == i_Rvt_vf.p1) +assert('a' == ch_Rvt_vf.p1) -val ch_Rfvtnt = new Rfvtnt('a', 'b') -val i_Rfvtnt = new Rfvtnt(1, 2) -assert(1 == i_Rfvtnt.`a b`) -assert('a' == ch_Rfvtnt.`a b`) -assert(1 == i_Rfvtnt.p1) -assert(2 == i_Rfvtnt.p2) -assert('a' == ch_Rfvtnt.p1) -assert('b' == ch_Rfvtnt.p2) +val ch_Rvt_nt = new Rvt_nt('a', 'b') +val i_Rvt_nt = new Rvt_nt(1, 2) +assert(1 == i_Rvt_nt.`a b`) +assert('a' == ch_Rvt_nt.`a b`) +assert(1 == i_Rvt_nt.p1) +assert(2 == i_Rvt_nt.p2) +assert('a' == ch_Rvt_nt.p1) +assert('b' == ch_Rvt_nt.p2) -val ch_Rfvtnf = new Rfvtnf('a', 'b') -val i_Rfvtnf = new Rfvtnf(1, 2) -assert(1 == i_Rfvtnf.`a b`) -assert('a' == ch_Rfvtnf.`a b`) -assert(1 == i_Rfvtnf.p1) -assert('a' == ch_Rfvtnf.p1) +val ch_Rvt_nf = new Rvt_nf('a', 'b') +val i_Rvt_nf = new Rvt_nf(1, 2) +assert(1 == i_Rvt_nf.`a b`) +assert('a' == ch_Rvt_nf.`a b`) +assert(1 == i_Rvt_nf.p1) +assert('a' == ch_Rvt_nf.p1) -val ch_Rfvfpvt = new Rfvfpvt('a', 'b') -val i_Rfvfpvt = new Rfvfpvt(1, 2) -assert(1 == i_Rfvfpvt.`a b`) -assert('a' == ch_Rfvfpvt.`a b`) -assert(2 == i_Rfvfpvt.p2) -assert('b' == ch_Rfvfpvt.p2) +val ch_Rvf_pvt = new Rvf_pvt('a', 'b') +val i_Rvf_pvt = new Rvf_pvt(1, 2) +assert(1 == i_Rvf_pvt.`a b`) +assert('a' == ch_Rvf_pvt.`a b`) +assert(2 == i_Rvf_pvt.p2) +assert('b' == ch_Rvf_pvt.p2) -val ch_Rfvfpvf = new Rfvfpvf('a', 'b') -val i_Rfvfpvf = new Rfvfpvf(1, 2) -assert(1 == i_Rfvfpvf.`a b`) -assert('a' == ch_Rfvfpvf.`a b`) +val ch_Rvf_pvf = new Rvf_pvf('a', 'b') +val i_Rvf_pvf = new Rvf_pvf(1, 2) +assert(1 == i_Rvf_pvf.`a b`) +assert('a' == ch_Rvf_pvf.`a b`) -val ch_Rfvfvt = new Rfvfvt('a', 'b') -val i_Rfvfvt = new Rfvfvt(1, 2) -assert(1 == i_Rfvfvt.`a b`) -assert(2 == i_Rfvfvt.a) -assert('a' == ch_Rfvfvt.`a b`) -assert('b' == ch_Rfvfvt.a) -assert(2 == i_Rfvfvt.p2) -assert('b' == ch_Rfvfvt.p2) +val ch_Rvf_vt = new Rvf_vt('a', 'b') +val i_Rvf_vt = new Rvf_vt(1, 2) +assert(1 == i_Rvf_vt.`a b`) +assert(2 == i_Rvf_vt.a) +assert('a' == ch_Rvf_vt.`a b`) +assert('b' == ch_Rvf_vt.a) +assert(2 == i_Rvf_vt.p2) +assert('b' == ch_Rvf_vt.p2) -val ch_Rfvfvf = new Rfvfvf('a', 'b') -val i_Rfvfvf = new Rfvfvf(1, 2) -assert(1 == i_Rfvfvf.`a b`) -assert(2 == i_Rfvfvf.a) -assert('a' == ch_Rfvfvf.`a b`) -assert('b' == ch_Rfvfvf.a) +val ch_Rvf_vf = new Rvf_vf('a', 'b') +val i_Rvf_vf = new Rvf_vf(1, 2) +assert(1 == i_Rvf_vf.`a b`) +assert(2 == i_Rvf_vf.a) +assert('a' == ch_Rvf_vf.`a b`) +assert('b' == ch_Rvf_vf.a) -val ch_Rfvfnt = new Rfvfnt('a', 'b') -val i_Rfvfnt = new Rfvfnt(1, 2) -assert(1 == i_Rfvfnt.`a b`) -assert('a' == ch_Rfvfnt.`a b`) -assert(2 == i_Rfvfnt.p2) -assert('b' == ch_Rfvfnt.p2) +val ch_Rvf_nt = new Rvf_nt('a', 'b') +val i_Rvf_nt = new Rvf_nt(1, 2) +assert(1 == i_Rvf_nt.`a b`) +assert('a' == ch_Rvf_nt.`a b`) +assert(2 == i_Rvf_nt.p2) +assert('b' == ch_Rvf_nt.p2) -val ch_Rfvfnf = new Rfvfnf('a', 'b') -val i_Rfvfnf = new Rfvfnf(1, 2) -assert(1 == i_Rfvfnf.`a b`) -assert('a' == ch_Rfvfnf.`a b`) +val ch_Rvf_nf = new Rvf_nf('a', 'b') +val i_Rvf_nf = new Rvf_nf(1, 2) +assert(1 == i_Rvf_nf.`a b`) +assert('a' == ch_Rvf_nf.`a b`) -val ch_Rfntpvt = new Rfntpvt('a', 'b') -val i_Rfntpvt = new Rfntpvt(1, 2) -assert(1 == i_Rfntpvt.p1) -assert(2 == i_Rfntpvt.p2) -assert('a' == ch_Rfntpvt.p1) -assert('b' == ch_Rfntpvt.p2) +val ch_Rnt_pvt = new Rnt_pvt('a', 'b') +val i_Rnt_pvt = new Rnt_pvt(1, 2) +assert(1 == i_Rnt_pvt.p1) +assert(2 == i_Rnt_pvt.p2) +assert('a' == ch_Rnt_pvt.p1) +assert('b' == ch_Rnt_pvt.p2) -val ch_Rfntpvf = new Rfntpvf('a', 'b') -val i_Rfntpvf = new Rfntpvf(1, 2) -assert(1 == i_Rfntpvf.p1) -assert('a' == ch_Rfntpvf.p1) +val ch_Rnt_pvf = new Rnt_pvf('a', 'b') +val i_Rnt_pvf = new Rnt_pvf(1, 2) +assert(1 == i_Rnt_pvf.p1) +assert('a' == ch_Rnt_pvf.p1) -val ch_Rfntvt = new Rfntvt('a', 'b') -val i_Rfntvt = new Rfntvt(1, 2) -assert(2 == i_Rfntvt.a) -assert('b' == ch_Rfntvt.a) -assert(1 == i_Rfntvt.p1) -assert(2 == i_Rfntvt.p2) -assert('a' == ch_Rfntvt.p1) -assert('b' == ch_Rfntvt.p2) +val ch_Rnt_vt = new Rnt_vt('a', 'b') +val i_Rnt_vt = new Rnt_vt(1, 2) +assert(2 == i_Rnt_vt.a) +assert('b' == ch_Rnt_vt.a) +assert(1 == i_Rnt_vt.p1) +assert(2 == i_Rnt_vt.p2) +assert('a' == ch_Rnt_vt.p1) +assert('b' == ch_Rnt_vt.p2) -val ch_Rfntvf = new Rfntvf('a', 'b') -val i_Rfntvf = new Rfntvf(1, 2) -assert(2 == i_Rfntvf.a) -assert('b' == ch_Rfntvf.a) -assert(1 == i_Rfntvf.p1) -assert('a' == ch_Rfntvf.p1) +val ch_Rnt_vf = new Rnt_vf('a', 'b') +val i_Rnt_vf = new Rnt_vf(1, 2) +assert(2 == i_Rnt_vf.a) +assert('b' == ch_Rnt_vf.a) +assert(1 == i_Rnt_vf.p1) +assert('a' == ch_Rnt_vf.p1) -val ch_Rfntnt = new Rfntnt('a', 'b') -val i_Rfntnt = new Rfntnt(1, 2) -assert(1 == i_Rfntnt.p1) -assert(2 == i_Rfntnt.p2) -assert('a' == ch_Rfntnt.p1) -assert('b' == ch_Rfntnt.p2) +val ch_Rnt_nt = new Rnt_nt('a', 'b') +val i_Rnt_nt = new Rnt_nt(1, 2) +assert(1 == i_Rnt_nt.p1) +assert(2 == i_Rnt_nt.p2) +assert('a' == ch_Rnt_nt.p1) +assert('b' == ch_Rnt_nt.p2) -val ch_Rfntnf = new Rfntnf('a', 'b') -val i_Rfntnf = new Rfntnf(1, 2) -assert(1 == i_Rfntnf.p1) -assert('a' == ch_Rfntnf.p1) +val ch_Rnt_nf = new Rnt_nf('a', 'b') +val i_Rnt_nf = new Rnt_nf(1, 2) +assert(1 == i_Rnt_nf.p1) +assert('a' == ch_Rnt_nf.p1) -val ch_Rfnfpvt = new Rfnfpvt('a', 'b') -val i_Rfnfpvt = new Rfnfpvt(1, 2) -assert(2 == i_Rfnfpvt.p2) -assert('b' == ch_Rfnfpvt.p2) +val ch_Rnf_pvt = new Rnf_pvt('a', 'b') +val i_Rnf_pvt = new Rnf_pvt(1, 2) +assert(2 == i_Rnf_pvt.p2) +assert('b' == ch_Rnf_pvt.p2) -val ch_Rfnfpvf = new Rfnfpvf('a', 'b') -val i_Rfnfpvf = new Rfnfpvf(1, 2) +val ch_Rnf_pvf = new Rnf_pvf('a', 'b') +val i_Rnf_pvf = new Rnf_pvf(1, 2) -val ch_Rfnfvt = new Rfnfvt('a', 'b') -val i_Rfnfvt = new Rfnfvt(1, 2) -assert(2 == i_Rfnfvt.a) -assert('b' == ch_Rfnfvt.a) -assert(2 == i_Rfnfvt.p2) -assert('b' == ch_Rfnfvt.p2) +val ch_Rnf_vt = new Rnf_vt('a', 'b') +val i_Rnf_vt = new Rnf_vt(1, 2) +assert(2 == i_Rnf_vt.a) +assert('b' == ch_Rnf_vt.a) +assert(2 == i_Rnf_vt.p2) +assert('b' == ch_Rnf_vt.p2) -val ch_Rfnfvf = new Rfnfvf('a', 'b') -val i_Rfnfvf = new Rfnfvf(1, 2) -assert(2 == i_Rfnfvf.a) -assert('b' == ch_Rfnfvf.a) +val ch_Rnf_vf = new Rnf_vf('a', 'b') +val i_Rnf_vf = new Rnf_vf(1, 2) +assert(2 == i_Rnf_vf.a) +assert('b' == ch_Rnf_vf.a) -val ch_Rfnfnt = new Rfnfnt('a', 'b') -val i_Rfnfnt = new Rfnfnt(1, 2) -assert(2 == i_Rfnfnt.p2) -assert('b' == ch_Rfnfnt.p2) +val ch_Rnf_nt = new Rnf_nt('a', 'b') +val i_Rnf_nt = new Rnf_nt(1, 2) +assert(2 == i_Rnf_nt.p2) +assert('b' == ch_Rnf_nt.p2) -val ch_Rfnfnf = new Rfnfnf('a', 'b') -val i_Rfnfnf = new Rfnfnf(1, 2) +val ch_Rnf_nf = new Rnf_nf('a', 'b') +val i_Rnf_nf = new Rnf_nf(1, 2) }} diff --git a/test/files/run/t8831_many/Tests_2.scala b/test/files/run/t8831_many/Tests_2.scala index fba69ecabe56..65ff1f0bbab2 100644 --- a/test/files/run/t8831_many/Tests_2.scala +++ b/test/files/run/t8831_many/Tests_2.scala @@ -1,1488 +1,831 @@ object Test extends App { -val ch_Ctpvtpvt = new Ctpvtpvt('a', 'b') -val i_Ctpvtpvt = new Ctpvtpvt(1, 2) -val Ctpvtpvt(extracted1i_Ctpvtpvt, extracted2i_Ctpvtpvt) = i_Ctpvtpvt -val Ctpvtpvt(extracted1ch_Ctpvtpvt, extracted2ch_Ctpvtpvt) = ch_Ctpvtpvt -assert(1 == extracted1i_Ctpvtpvt) -assert(2 == extracted2i_Ctpvtpvt) -assert('a' == extracted1ch_Ctpvtpvt) -assert('b' == extracted2ch_Ctpvtpvt) - -assert(1 == i_Ctpvtpvt.p1) -assert(2 == i_Ctpvtpvt.p2) -assert('a' == ch_Ctpvtpvt.p1) -assert('b' == ch_Ctpvtpvt.p2) - - -val ch_Ctpvtpvf = new Ctpvtpvf('a', 'b') -val i_Ctpvtpvf = new Ctpvtpvf(1, 2) -val Ctpvtpvf(extracted1i_Ctpvtpvf, extracted2i_Ctpvtpvf) = i_Ctpvtpvf -val Ctpvtpvf(extracted1ch_Ctpvtpvf, extracted2ch_Ctpvtpvf) = ch_Ctpvtpvf -assert(1 == extracted1i_Ctpvtpvf) -assert(2 == extracted2i_Ctpvtpvf) -assert('a' == extracted1ch_Ctpvtpvf) -assert('b' == extracted2ch_Ctpvtpvf) - -assert(1 == i_Ctpvtpvf.p1) -assert('a' == ch_Ctpvtpvf.p1) - - -val ch_Ctpvtvt = new Ctpvtvt('a', 'b') -val i_Ctpvtvt = new Ctpvtvt(1, 2) -val Ctpvtvt(extracted1i_Ctpvtvt, extracted2i_Ctpvtvt) = i_Ctpvtvt -val Ctpvtvt(extracted1ch_Ctpvtvt, extracted2ch_Ctpvtvt) = ch_Ctpvtvt -assert(1 == extracted1i_Ctpvtvt) -assert(2 == extracted2i_Ctpvtvt) -assert('a' == extracted1ch_Ctpvtvt) -assert('b' == extracted2ch_Ctpvtvt) - -assert(2 == i_Ctpvtvt.a) -assert('b' == ch_Ctpvtvt.a) -assert(1 == i_Ctpvtvt.p1) -assert(2 == i_Ctpvtvt.p2) -assert('a' == ch_Ctpvtvt.p1) -assert('b' == ch_Ctpvtvt.p2) - - -val ch_Ctpvtvf = new Ctpvtvf('a', 'b') -val i_Ctpvtvf = new Ctpvtvf(1, 2) -val Ctpvtvf(extracted1i_Ctpvtvf, extracted2i_Ctpvtvf) = i_Ctpvtvf -val Ctpvtvf(extracted1ch_Ctpvtvf, extracted2ch_Ctpvtvf) = ch_Ctpvtvf -assert(1 == extracted1i_Ctpvtvf) -assert(2 == extracted2i_Ctpvtvf) -assert('a' == extracted1ch_Ctpvtvf) -assert('b' == extracted2ch_Ctpvtvf) - -assert(2 == i_Ctpvtvf.a) -assert('b' == ch_Ctpvtvf.a) -assert(1 == i_Ctpvtvf.p1) -assert('a' == ch_Ctpvtvf.p1) - - -val ch_Ctpvtnt = new Ctpvtnt('a', 'b') -val i_Ctpvtnt = new Ctpvtnt(1, 2) -val Ctpvtnt(extracted1i_Ctpvtnt, extracted2i_Ctpvtnt) = i_Ctpvtnt -val Ctpvtnt(extracted1ch_Ctpvtnt, extracted2ch_Ctpvtnt) = ch_Ctpvtnt -assert(1 == extracted1i_Ctpvtnt) -assert(2 == extracted2i_Ctpvtnt) -assert('a' == extracted1ch_Ctpvtnt) -assert('b' == extracted2ch_Ctpvtnt) - -assert(2 == i_Ctpvtnt.a) -assert('b' == ch_Ctpvtnt.a) -assert(1 == i_Ctpvtnt.p1) -assert(2 == i_Ctpvtnt.p2) -assert('a' == ch_Ctpvtnt.p1) -assert('b' == ch_Ctpvtnt.p2) - - -val ch_Ctpvtnf = new Ctpvtnf('a', 'b') -val i_Ctpvtnf = new Ctpvtnf(1, 2) -val Ctpvtnf(extracted1i_Ctpvtnf, extracted2i_Ctpvtnf) = i_Ctpvtnf -val Ctpvtnf(extracted1ch_Ctpvtnf, extracted2ch_Ctpvtnf) = ch_Ctpvtnf -assert(1 == extracted1i_Ctpvtnf) -assert(2 == extracted2i_Ctpvtnf) -assert('a' == extracted1ch_Ctpvtnf) -assert('b' == extracted2ch_Ctpvtnf) - -assert(2 == i_Ctpvtnf.a) -assert('b' == ch_Ctpvtnf.a) -assert(1 == i_Ctpvtnf.p1) -assert('a' == ch_Ctpvtnf.p1) - - -val ch_Ctpvfpvt = new Ctpvfpvt('a', 'b') -val i_Ctpvfpvt = new Ctpvfpvt(1, 2) -val Ctpvfpvt(extracted1i_Ctpvfpvt, extracted2i_Ctpvfpvt) = i_Ctpvfpvt -val Ctpvfpvt(extracted1ch_Ctpvfpvt, extracted2ch_Ctpvfpvt) = ch_Ctpvfpvt -assert(1 == extracted1i_Ctpvfpvt) -assert(2 == extracted2i_Ctpvfpvt) -assert('a' == extracted1ch_Ctpvfpvt) -assert('b' == extracted2ch_Ctpvfpvt) - -assert(2 == i_Ctpvfpvt.p2) -assert('b' == ch_Ctpvfpvt.p2) - - -val ch_Ctpvfvt = new Ctpvfvt('a', 'b') -val i_Ctpvfvt = new Ctpvfvt(1, 2) -val Ctpvfvt(extracted1i_Ctpvfvt, extracted2i_Ctpvfvt) = i_Ctpvfvt -val Ctpvfvt(extracted1ch_Ctpvfvt, extracted2ch_Ctpvfvt) = ch_Ctpvfvt -assert(1 == extracted1i_Ctpvfvt) -assert(2 == extracted2i_Ctpvfvt) -assert('a' == extracted1ch_Ctpvfvt) -assert('b' == extracted2ch_Ctpvfvt) - -assert(2 == i_Ctpvfvt.a) -assert('b' == ch_Ctpvfvt.a) -assert(2 == i_Ctpvfvt.p2) -assert('b' == ch_Ctpvfvt.p2) - - -val ch_Ctpvfnt = new Ctpvfnt('a', 'b') -val i_Ctpvfnt = new Ctpvfnt(1, 2) -val Ctpvfnt(extracted1i_Ctpvfnt, extracted2i_Ctpvfnt) = i_Ctpvfnt -val Ctpvfnt(extracted1ch_Ctpvfnt, extracted2ch_Ctpvfnt) = ch_Ctpvfnt -assert(1 == extracted1i_Ctpvfnt) -assert(2 == extracted2i_Ctpvfnt) -assert('a' == extracted1ch_Ctpvfnt) -assert('b' == extracted2ch_Ctpvfnt) - -assert(2 == i_Ctpvfnt.a) -assert('b' == ch_Ctpvfnt.a) -assert(2 == i_Ctpvfnt.p2) -assert('b' == ch_Ctpvfnt.p2) - - -val ch_Ctvtpvt = new Ctvtpvt('a', 'b') -val i_Ctvtpvt = new Ctvtpvt(1, 2) -val Ctvtpvt(extracted1i_Ctvtpvt, extracted2i_Ctvtpvt) = i_Ctvtpvt -val Ctvtpvt(extracted1ch_Ctvtpvt, extracted2ch_Ctvtpvt) = ch_Ctvtpvt -assert(1 == extracted1i_Ctvtpvt) -assert(2 == extracted2i_Ctvtpvt) -assert('a' == extracted1ch_Ctvtpvt) -assert('b' == extracted2ch_Ctvtpvt) - -assert(1 == i_Ctvtpvt.`a b`) -assert('a' == ch_Ctvtpvt.`a b`) -assert(1 == i_Ctvtpvt.p1) -assert(2 == i_Ctvtpvt.p2) -assert('a' == ch_Ctvtpvt.p1) -assert('b' == ch_Ctvtpvt.p2) - - -val ch_Ctvtpvf = new Ctvtpvf('a', 'b') -val i_Ctvtpvf = new Ctvtpvf(1, 2) -val Ctvtpvf(extracted1i_Ctvtpvf, extracted2i_Ctvtpvf) = i_Ctvtpvf -val Ctvtpvf(extracted1ch_Ctvtpvf, extracted2ch_Ctvtpvf) = ch_Ctvtpvf -assert(1 == extracted1i_Ctvtpvf) -assert(2 == extracted2i_Ctvtpvf) -assert('a' == extracted1ch_Ctvtpvf) -assert('b' == extracted2ch_Ctvtpvf) - -assert(1 == i_Ctvtpvf.`a b`) -assert('a' == ch_Ctvtpvf.`a b`) -assert(1 == i_Ctvtpvf.p1) -assert('a' == ch_Ctvtpvf.p1) - - -val ch_Ctvtvt = new Ctvtvt('a', 'b') -val i_Ctvtvt = new Ctvtvt(1, 2) -val Ctvtvt(extracted1i_Ctvtvt, extracted2i_Ctvtvt) = i_Ctvtvt -val Ctvtvt(extracted1ch_Ctvtvt, extracted2ch_Ctvtvt) = ch_Ctvtvt -assert(1 == extracted1i_Ctvtvt) -assert(2 == extracted2i_Ctvtvt) -assert('a' == extracted1ch_Ctvtvt) -assert('b' == extracted2ch_Ctvtvt) - -assert(1 == i_Ctvtvt.`a b`) -assert(2 == i_Ctvtvt.a) -assert('a' == ch_Ctvtvt.`a b`) -assert('b' == ch_Ctvtvt.a) -assert(1 == i_Ctvtvt.p1) -assert(2 == i_Ctvtvt.p2) -assert('a' == ch_Ctvtvt.p1) -assert('b' == ch_Ctvtvt.p2) - - -val ch_Ctvtvf = new Ctvtvf('a', 'b') -val i_Ctvtvf = new Ctvtvf(1, 2) -val Ctvtvf(extracted1i_Ctvtvf, extracted2i_Ctvtvf) = i_Ctvtvf -val Ctvtvf(extracted1ch_Ctvtvf, extracted2ch_Ctvtvf) = ch_Ctvtvf -assert(1 == extracted1i_Ctvtvf) -assert(2 == extracted2i_Ctvtvf) -assert('a' == extracted1ch_Ctvtvf) -assert('b' == extracted2ch_Ctvtvf) - -assert(1 == i_Ctvtvf.`a b`) -assert(2 == i_Ctvtvf.a) -assert('a' == ch_Ctvtvf.`a b`) -assert('b' == ch_Ctvtvf.a) -assert(1 == i_Ctvtvf.p1) -assert('a' == ch_Ctvtvf.p1) - - -val ch_Ctvtnt = new Ctvtnt('a', 'b') -val i_Ctvtnt = new Ctvtnt(1, 2) -val Ctvtnt(extracted1i_Ctvtnt, extracted2i_Ctvtnt) = i_Ctvtnt -val Ctvtnt(extracted1ch_Ctvtnt, extracted2ch_Ctvtnt) = ch_Ctvtnt -assert(1 == extracted1i_Ctvtnt) -assert(2 == extracted2i_Ctvtnt) -assert('a' == extracted1ch_Ctvtnt) -assert('b' == extracted2ch_Ctvtnt) - -assert(1 == i_Ctvtnt.`a b`) -assert(2 == i_Ctvtnt.a) -assert('a' == ch_Ctvtnt.`a b`) -assert('b' == ch_Ctvtnt.a) -assert(1 == i_Ctvtnt.p1) -assert(2 == i_Ctvtnt.p2) -assert('a' == ch_Ctvtnt.p1) -assert('b' == ch_Ctvtnt.p2) - - -val ch_Ctvtnf = new Ctvtnf('a', 'b') -val i_Ctvtnf = new Ctvtnf(1, 2) -val Ctvtnf(extracted1i_Ctvtnf, extracted2i_Ctvtnf) = i_Ctvtnf -val Ctvtnf(extracted1ch_Ctvtnf, extracted2ch_Ctvtnf) = ch_Ctvtnf -assert(1 == extracted1i_Ctvtnf) -assert(2 == extracted2i_Ctvtnf) -assert('a' == extracted1ch_Ctvtnf) -assert('b' == extracted2ch_Ctvtnf) - -assert(1 == i_Ctvtnf.`a b`) -assert(2 == i_Ctvtnf.a) -assert('a' == ch_Ctvtnf.`a b`) -assert('b' == ch_Ctvtnf.a) -assert(1 == i_Ctvtnf.p1) -assert('a' == ch_Ctvtnf.p1) - - -val ch_Ctvfpvt = new Ctvfpvt('a', 'b') -val i_Ctvfpvt = new Ctvfpvt(1, 2) -val Ctvfpvt(extracted1i_Ctvfpvt, extracted2i_Ctvfpvt) = i_Ctvfpvt -val Ctvfpvt(extracted1ch_Ctvfpvt, extracted2ch_Ctvfpvt) = ch_Ctvfpvt -assert(1 == extracted1i_Ctvfpvt) -assert(2 == extracted2i_Ctvfpvt) -assert('a' == extracted1ch_Ctvfpvt) -assert('b' == extracted2ch_Ctvfpvt) - -assert(1 == i_Ctvfpvt.`a b`) -assert('a' == ch_Ctvfpvt.`a b`) -assert(2 == i_Ctvfpvt.p2) -assert('b' == ch_Ctvfpvt.p2) - - -val ch_Ctvfvt = new Ctvfvt('a', 'b') -val i_Ctvfvt = new Ctvfvt(1, 2) -val Ctvfvt(extracted1i_Ctvfvt, extracted2i_Ctvfvt) = i_Ctvfvt -val Ctvfvt(extracted1ch_Ctvfvt, extracted2ch_Ctvfvt) = ch_Ctvfvt -assert(1 == extracted1i_Ctvfvt) -assert(2 == extracted2i_Ctvfvt) -assert('a' == extracted1ch_Ctvfvt) -assert('b' == extracted2ch_Ctvfvt) - -assert(1 == i_Ctvfvt.`a b`) -assert(2 == i_Ctvfvt.a) -assert('a' == ch_Ctvfvt.`a b`) -assert('b' == ch_Ctvfvt.a) -assert(2 == i_Ctvfvt.p2) -assert('b' == ch_Ctvfvt.p2) - - -val ch_Ctvfnt = new Ctvfnt('a', 'b') -val i_Ctvfnt = new Ctvfnt(1, 2) -val Ctvfnt(extracted1i_Ctvfnt, extracted2i_Ctvfnt) = i_Ctvfnt -val Ctvfnt(extracted1ch_Ctvfnt, extracted2ch_Ctvfnt) = ch_Ctvfnt -assert(1 == extracted1i_Ctvfnt) -assert(2 == extracted2i_Ctvfnt) -assert('a' == extracted1ch_Ctvfnt) -assert('b' == extracted2ch_Ctvfnt) - -assert(1 == i_Ctvfnt.`a b`) -assert(2 == i_Ctvfnt.a) -assert('a' == ch_Ctvfnt.`a b`) -assert('b' == ch_Ctvfnt.a) -assert(2 == i_Ctvfnt.p2) -assert('b' == ch_Ctvfnt.p2) - - -val ch_Ctntpvt = new Ctntpvt('a', 'b') -val i_Ctntpvt = new Ctntpvt(1, 2) -val Ctntpvt(extracted1i_Ctntpvt, extracted2i_Ctntpvt) = i_Ctntpvt -val Ctntpvt(extracted1ch_Ctntpvt, extracted2ch_Ctntpvt) = ch_Ctntpvt -assert(1 == extracted1i_Ctntpvt) -assert(2 == extracted2i_Ctntpvt) -assert('a' == extracted1ch_Ctntpvt) -assert('b' == extracted2ch_Ctntpvt) - -assert(1 == i_Ctntpvt.`a b`) -assert('a' == ch_Ctntpvt.`a b`) -assert(1 == i_Ctntpvt.p1) -assert(2 == i_Ctntpvt.p2) -assert('a' == ch_Ctntpvt.p1) -assert('b' == ch_Ctntpvt.p2) - - -val ch_Ctntpvf = new Ctntpvf('a', 'b') -val i_Ctntpvf = new Ctntpvf(1, 2) -val Ctntpvf(extracted1i_Ctntpvf, extracted2i_Ctntpvf) = i_Ctntpvf -val Ctntpvf(extracted1ch_Ctntpvf, extracted2ch_Ctntpvf) = ch_Ctntpvf -assert(1 == extracted1i_Ctntpvf) -assert(2 == extracted2i_Ctntpvf) -assert('a' == extracted1ch_Ctntpvf) -assert('b' == extracted2ch_Ctntpvf) - -assert(1 == i_Ctntpvf.`a b`) -assert('a' == ch_Ctntpvf.`a b`) -assert(1 == i_Ctntpvf.p1) -assert('a' == ch_Ctntpvf.p1) - - -val ch_Ctntvt = new Ctntvt('a', 'b') -val i_Ctntvt = new Ctntvt(1, 2) -val Ctntvt(extracted1i_Ctntvt, extracted2i_Ctntvt) = i_Ctntvt -val Ctntvt(extracted1ch_Ctntvt, extracted2ch_Ctntvt) = ch_Ctntvt -assert(1 == extracted1i_Ctntvt) -assert(2 == extracted2i_Ctntvt) -assert('a' == extracted1ch_Ctntvt) -assert('b' == extracted2ch_Ctntvt) - -assert(1 == i_Ctntvt.`a b`) -assert(2 == i_Ctntvt.a) -assert('a' == ch_Ctntvt.`a b`) -assert('b' == ch_Ctntvt.a) -assert(1 == i_Ctntvt.p1) -assert(2 == i_Ctntvt.p2) -assert('a' == ch_Ctntvt.p1) -assert('b' == ch_Ctntvt.p2) - - -val ch_Ctntvf = new Ctntvf('a', 'b') -val i_Ctntvf = new Ctntvf(1, 2) -val Ctntvf(extracted1i_Ctntvf, extracted2i_Ctntvf) = i_Ctntvf -val Ctntvf(extracted1ch_Ctntvf, extracted2ch_Ctntvf) = ch_Ctntvf -assert(1 == extracted1i_Ctntvf) -assert(2 == extracted2i_Ctntvf) -assert('a' == extracted1ch_Ctntvf) -assert('b' == extracted2ch_Ctntvf) - -assert(1 == i_Ctntvf.`a b`) -assert(2 == i_Ctntvf.a) -assert('a' == ch_Ctntvf.`a b`) -assert('b' == ch_Ctntvf.a) -assert(1 == i_Ctntvf.p1) -assert('a' == ch_Ctntvf.p1) - - -val ch_Ctntnt = new Ctntnt('a', 'b') -val i_Ctntnt = new Ctntnt(1, 2) -val Ctntnt(extracted1i_Ctntnt, extracted2i_Ctntnt) = i_Ctntnt -val Ctntnt(extracted1ch_Ctntnt, extracted2ch_Ctntnt) = ch_Ctntnt -assert(1 == extracted1i_Ctntnt) -assert(2 == extracted2i_Ctntnt) -assert('a' == extracted1ch_Ctntnt) -assert('b' == extracted2ch_Ctntnt) - -assert(1 == i_Ctntnt.`a b`) -assert(2 == i_Ctntnt.a) -assert('a' == ch_Ctntnt.`a b`) -assert('b' == ch_Ctntnt.a) -assert(1 == i_Ctntnt.p1) -assert(2 == i_Ctntnt.p2) -assert('a' == ch_Ctntnt.p1) -assert('b' == ch_Ctntnt.p2) - - -val ch_Ctntnf = new Ctntnf('a', 'b') -val i_Ctntnf = new Ctntnf(1, 2) -val Ctntnf(extracted1i_Ctntnf, extracted2i_Ctntnf) = i_Ctntnf -val Ctntnf(extracted1ch_Ctntnf, extracted2ch_Ctntnf) = ch_Ctntnf -assert(1 == extracted1i_Ctntnf) -assert(2 == extracted2i_Ctntnf) -assert('a' == extracted1ch_Ctntnf) -assert('b' == extracted2ch_Ctntnf) - -assert(1 == i_Ctntnf.`a b`) -assert(2 == i_Ctntnf.a) -assert('a' == ch_Ctntnf.`a b`) -assert('b' == ch_Ctntnf.a) -assert(1 == i_Ctntnf.p1) -assert('a' == ch_Ctntnf.p1) - - -val ch_Ctnfpvt = new Ctnfpvt('a', 'b') -val i_Ctnfpvt = new Ctnfpvt(1, 2) -val Ctnfpvt(extracted1i_Ctnfpvt, extracted2i_Ctnfpvt) = i_Ctnfpvt -val Ctnfpvt(extracted1ch_Ctnfpvt, extracted2ch_Ctnfpvt) = ch_Ctnfpvt -assert(1 == extracted1i_Ctnfpvt) -assert(2 == extracted2i_Ctnfpvt) -assert('a' == extracted1ch_Ctnfpvt) -assert('b' == extracted2ch_Ctnfpvt) - -assert(1 == i_Ctnfpvt.`a b`) -assert('a' == ch_Ctnfpvt.`a b`) -assert(2 == i_Ctnfpvt.p2) -assert('b' == ch_Ctnfpvt.p2) - - -val ch_Ctnfvt = new Ctnfvt('a', 'b') -val i_Ctnfvt = new Ctnfvt(1, 2) -val Ctnfvt(extracted1i_Ctnfvt, extracted2i_Ctnfvt) = i_Ctnfvt -val Ctnfvt(extracted1ch_Ctnfvt, extracted2ch_Ctnfvt) = ch_Ctnfvt -assert(1 == extracted1i_Ctnfvt) -assert(2 == extracted2i_Ctnfvt) -assert('a' == extracted1ch_Ctnfvt) -assert('b' == extracted2ch_Ctnfvt) - -assert(1 == i_Ctnfvt.`a b`) -assert(2 == i_Ctnfvt.a) -assert('a' == ch_Ctnfvt.`a b`) -assert('b' == ch_Ctnfvt.a) -assert(2 == i_Ctnfvt.p2) -assert('b' == ch_Ctnfvt.p2) - - -val ch_Ctnfnt = new Ctnfnt('a', 'b') -val i_Ctnfnt = new Ctnfnt(1, 2) -val Ctnfnt(extracted1i_Ctnfnt, extracted2i_Ctnfnt) = i_Ctnfnt -val Ctnfnt(extracted1ch_Ctnfnt, extracted2ch_Ctnfnt) = ch_Ctnfnt -assert(1 == extracted1i_Ctnfnt) -assert(2 == extracted2i_Ctnfnt) -assert('a' == extracted1ch_Ctnfnt) -assert('b' == extracted2ch_Ctnfnt) - -assert(1 == i_Ctnfnt.`a b`) -assert(2 == i_Ctnfnt.a) -assert('a' == ch_Ctnfnt.`a b`) -assert('b' == ch_Ctnfnt.a) -assert(2 == i_Ctnfnt.p2) -assert('b' == ch_Ctnfnt.p2) - - -val ch_Cfpvtpvt = new Cfpvtpvt('a', 'b') -val i_Cfpvtpvt = new Cfpvtpvt(1, 2) -val Cfpvtpvt(extracted1i_Cfpvtpvt, extracted2i_Cfpvtpvt) = i_Cfpvtpvt -val Cfpvtpvt(extracted1ch_Cfpvtpvt, extracted2ch_Cfpvtpvt) = ch_Cfpvtpvt -assert(1 == extracted1i_Cfpvtpvt) -assert(2 == extracted2i_Cfpvtpvt) -assert('a' == extracted1ch_Cfpvtpvt) -assert('b' == extracted2ch_Cfpvtpvt) - -assert(1 == i_Cfpvtpvt.p1) -assert(2 == i_Cfpvtpvt.p2) -assert('a' == ch_Cfpvtpvt.p1) -assert('b' == ch_Cfpvtpvt.p2) - - -val ch_Cfpvtpvf = new Cfpvtpvf('a', 'b') -val i_Cfpvtpvf = new Cfpvtpvf(1, 2) -val Cfpvtpvf(extracted1i_Cfpvtpvf, extracted2i_Cfpvtpvf) = i_Cfpvtpvf -val Cfpvtpvf(extracted1ch_Cfpvtpvf, extracted2ch_Cfpvtpvf) = ch_Cfpvtpvf -assert(1 == extracted1i_Cfpvtpvf) -assert(2 == extracted2i_Cfpvtpvf) -assert('a' == extracted1ch_Cfpvtpvf) -assert('b' == extracted2ch_Cfpvtpvf) - -assert(1 == i_Cfpvtpvf.p1) -assert('a' == ch_Cfpvtpvf.p1) - - -val ch_Cfpvtvt = new Cfpvtvt('a', 'b') -val i_Cfpvtvt = new Cfpvtvt(1, 2) -val Cfpvtvt(extracted1i_Cfpvtvt, extracted2i_Cfpvtvt) = i_Cfpvtvt -val Cfpvtvt(extracted1ch_Cfpvtvt, extracted2ch_Cfpvtvt) = ch_Cfpvtvt -assert(1 == extracted1i_Cfpvtvt) -assert(2 == extracted2i_Cfpvtvt) -assert('a' == extracted1ch_Cfpvtvt) -assert('b' == extracted2ch_Cfpvtvt) - -assert(2 == i_Cfpvtvt.a) -assert('b' == ch_Cfpvtvt.a) -assert(1 == i_Cfpvtvt.p1) -assert(2 == i_Cfpvtvt.p2) -assert('a' == ch_Cfpvtvt.p1) -assert('b' == ch_Cfpvtvt.p2) - - -val ch_Cfpvtvf = new Cfpvtvf('a', 'b') -val i_Cfpvtvf = new Cfpvtvf(1, 2) -val Cfpvtvf(extracted1i_Cfpvtvf, extracted2i_Cfpvtvf) = i_Cfpvtvf -val Cfpvtvf(extracted1ch_Cfpvtvf, extracted2ch_Cfpvtvf) = ch_Cfpvtvf -assert(1 == extracted1i_Cfpvtvf) -assert(2 == extracted2i_Cfpvtvf) -assert('a' == extracted1ch_Cfpvtvf) -assert('b' == extracted2ch_Cfpvtvf) - -assert(2 == i_Cfpvtvf.a) -assert('b' == ch_Cfpvtvf.a) -assert(1 == i_Cfpvtvf.p1) -assert('a' == ch_Cfpvtvf.p1) - - -val ch_Cfpvtnt = new Cfpvtnt('a', 'b') -val i_Cfpvtnt = new Cfpvtnt(1, 2) -val Cfpvtnt(extracted1i_Cfpvtnt, extracted2i_Cfpvtnt) = i_Cfpvtnt -val Cfpvtnt(extracted1ch_Cfpvtnt, extracted2ch_Cfpvtnt) = ch_Cfpvtnt -assert(1 == extracted1i_Cfpvtnt) -assert(2 == extracted2i_Cfpvtnt) -assert('a' == extracted1ch_Cfpvtnt) -assert('b' == extracted2ch_Cfpvtnt) - -assert(2 == i_Cfpvtnt.a) -assert('b' == ch_Cfpvtnt.a) -assert(1 == i_Cfpvtnt.p1) -assert(2 == i_Cfpvtnt.p2) -assert('a' == ch_Cfpvtnt.p1) -assert('b' == ch_Cfpvtnt.p2) - - -val ch_Cfpvtnf = new Cfpvtnf('a', 'b') -val i_Cfpvtnf = new Cfpvtnf(1, 2) -val Cfpvtnf(extracted1i_Cfpvtnf, extracted2i_Cfpvtnf) = i_Cfpvtnf -val Cfpvtnf(extracted1ch_Cfpvtnf, extracted2ch_Cfpvtnf) = ch_Cfpvtnf -assert(1 == extracted1i_Cfpvtnf) -assert(2 == extracted2i_Cfpvtnf) -assert('a' == extracted1ch_Cfpvtnf) -assert('b' == extracted2ch_Cfpvtnf) - -assert(2 == i_Cfpvtnf.a) -assert('b' == ch_Cfpvtnf.a) -assert(1 == i_Cfpvtnf.p1) -assert('a' == ch_Cfpvtnf.p1) - - -val ch_Cfpvfpvt = new Cfpvfpvt('a', 'b') -val i_Cfpvfpvt = new Cfpvfpvt(1, 2) -val Cfpvfpvt(extracted1i_Cfpvfpvt, extracted2i_Cfpvfpvt) = i_Cfpvfpvt -val Cfpvfpvt(extracted1ch_Cfpvfpvt, extracted2ch_Cfpvfpvt) = ch_Cfpvfpvt -assert(1 == extracted1i_Cfpvfpvt) -assert(2 == extracted2i_Cfpvfpvt) -assert('a' == extracted1ch_Cfpvfpvt) -assert('b' == extracted2ch_Cfpvfpvt) - -assert(2 == i_Cfpvfpvt.p2) -assert('b' == ch_Cfpvfpvt.p2) - - -val ch_Cfpvfpvf = new Cfpvfpvf('a', 'b') -val i_Cfpvfpvf = new Cfpvfpvf(1, 2) -val Cfpvfpvf(extracted1i_Cfpvfpvf, extracted2i_Cfpvfpvf) = i_Cfpvfpvf -val Cfpvfpvf(extracted1ch_Cfpvfpvf, extracted2ch_Cfpvfpvf) = ch_Cfpvfpvf -assert(1 == extracted1i_Cfpvfpvf) -assert(2 == extracted2i_Cfpvfpvf) -assert('a' == extracted1ch_Cfpvfpvf) -assert('b' == extracted2ch_Cfpvfpvf) - - - -val ch_Cfpvfvt = new Cfpvfvt('a', 'b') -val i_Cfpvfvt = new Cfpvfvt(1, 2) -val Cfpvfvt(extracted1i_Cfpvfvt, extracted2i_Cfpvfvt) = i_Cfpvfvt -val Cfpvfvt(extracted1ch_Cfpvfvt, extracted2ch_Cfpvfvt) = ch_Cfpvfvt -assert(1 == extracted1i_Cfpvfvt) -assert(2 == extracted2i_Cfpvfvt) -assert('a' == extracted1ch_Cfpvfvt) -assert('b' == extracted2ch_Cfpvfvt) - -assert(2 == i_Cfpvfvt.a) -assert('b' == ch_Cfpvfvt.a) -assert(2 == i_Cfpvfvt.p2) -assert('b' == ch_Cfpvfvt.p2) - - -val ch_Cfpvfvf = new Cfpvfvf('a', 'b') -val i_Cfpvfvf = new Cfpvfvf(1, 2) -val Cfpvfvf(extracted1i_Cfpvfvf, extracted2i_Cfpvfvf) = i_Cfpvfvf -val Cfpvfvf(extracted1ch_Cfpvfvf, extracted2ch_Cfpvfvf) = ch_Cfpvfvf -assert(1 == extracted1i_Cfpvfvf) -assert(2 == extracted2i_Cfpvfvf) -assert('a' == extracted1ch_Cfpvfvf) -assert('b' == extracted2ch_Cfpvfvf) - -assert(2 == i_Cfpvfvf.a) -assert('b' == ch_Cfpvfvf.a) - - -val ch_Cfpvfnt = new Cfpvfnt('a', 'b') -val i_Cfpvfnt = new Cfpvfnt(1, 2) -val Cfpvfnt(extracted1i_Cfpvfnt, extracted2i_Cfpvfnt) = i_Cfpvfnt -val Cfpvfnt(extracted1ch_Cfpvfnt, extracted2ch_Cfpvfnt) = ch_Cfpvfnt -assert(1 == extracted1i_Cfpvfnt) -assert(2 == extracted2i_Cfpvfnt) -assert('a' == extracted1ch_Cfpvfnt) -assert('b' == extracted2ch_Cfpvfnt) - -assert(2 == i_Cfpvfnt.a) -assert('b' == ch_Cfpvfnt.a) -assert(2 == i_Cfpvfnt.p2) -assert('b' == ch_Cfpvfnt.p2) - - -val ch_Cfpvfnf = new Cfpvfnf('a', 'b') -val i_Cfpvfnf = new Cfpvfnf(1, 2) -val Cfpvfnf(extracted1i_Cfpvfnf, extracted2i_Cfpvfnf) = i_Cfpvfnf -val Cfpvfnf(extracted1ch_Cfpvfnf, extracted2ch_Cfpvfnf) = ch_Cfpvfnf -assert(1 == extracted1i_Cfpvfnf) -assert(2 == extracted2i_Cfpvfnf) -assert('a' == extracted1ch_Cfpvfnf) -assert('b' == extracted2ch_Cfpvfnf) - -assert(2 == i_Cfpvfnf.a) -assert('b' == ch_Cfpvfnf.a) - - -val ch_Cfvtpvt = new Cfvtpvt('a', 'b') -val i_Cfvtpvt = new Cfvtpvt(1, 2) -val Cfvtpvt(extracted1i_Cfvtpvt, extracted2i_Cfvtpvt) = i_Cfvtpvt -val Cfvtpvt(extracted1ch_Cfvtpvt, extracted2ch_Cfvtpvt) = ch_Cfvtpvt -assert(1 == extracted1i_Cfvtpvt) -assert(2 == extracted2i_Cfvtpvt) -assert('a' == extracted1ch_Cfvtpvt) -assert('b' == extracted2ch_Cfvtpvt) - -assert(1 == i_Cfvtpvt.`a b`) -assert('a' == ch_Cfvtpvt.`a b`) -assert(1 == i_Cfvtpvt.p1) -assert(2 == i_Cfvtpvt.p2) -assert('a' == ch_Cfvtpvt.p1) -assert('b' == ch_Cfvtpvt.p2) - - -val ch_Cfvtpvf = new Cfvtpvf('a', 'b') -val i_Cfvtpvf = new Cfvtpvf(1, 2) -val Cfvtpvf(extracted1i_Cfvtpvf, extracted2i_Cfvtpvf) = i_Cfvtpvf -val Cfvtpvf(extracted1ch_Cfvtpvf, extracted2ch_Cfvtpvf) = ch_Cfvtpvf -assert(1 == extracted1i_Cfvtpvf) -assert(2 == extracted2i_Cfvtpvf) -assert('a' == extracted1ch_Cfvtpvf) -assert('b' == extracted2ch_Cfvtpvf) - -assert(1 == i_Cfvtpvf.`a b`) -assert('a' == ch_Cfvtpvf.`a b`) -assert(1 == i_Cfvtpvf.p1) -assert('a' == ch_Cfvtpvf.p1) - - -val ch_Cfvtvt = new Cfvtvt('a', 'b') -val i_Cfvtvt = new Cfvtvt(1, 2) -val Cfvtvt(extracted1i_Cfvtvt, extracted2i_Cfvtvt) = i_Cfvtvt -val Cfvtvt(extracted1ch_Cfvtvt, extracted2ch_Cfvtvt) = ch_Cfvtvt -assert(1 == extracted1i_Cfvtvt) -assert(2 == extracted2i_Cfvtvt) -assert('a' == extracted1ch_Cfvtvt) -assert('b' == extracted2ch_Cfvtvt) - -assert(1 == i_Cfvtvt.`a b`) -assert(2 == i_Cfvtvt.a) -assert('a' == ch_Cfvtvt.`a b`) -assert('b' == ch_Cfvtvt.a) -assert(1 == i_Cfvtvt.p1) -assert(2 == i_Cfvtvt.p2) -assert('a' == ch_Cfvtvt.p1) -assert('b' == ch_Cfvtvt.p2) - - -val ch_Cfvtvf = new Cfvtvf('a', 'b') -val i_Cfvtvf = new Cfvtvf(1, 2) -val Cfvtvf(extracted1i_Cfvtvf, extracted2i_Cfvtvf) = i_Cfvtvf -val Cfvtvf(extracted1ch_Cfvtvf, extracted2ch_Cfvtvf) = ch_Cfvtvf -assert(1 == extracted1i_Cfvtvf) -assert(2 == extracted2i_Cfvtvf) -assert('a' == extracted1ch_Cfvtvf) -assert('b' == extracted2ch_Cfvtvf) - -assert(1 == i_Cfvtvf.`a b`) -assert(2 == i_Cfvtvf.a) -assert('a' == ch_Cfvtvf.`a b`) -assert('b' == ch_Cfvtvf.a) -assert(1 == i_Cfvtvf.p1) -assert('a' == ch_Cfvtvf.p1) - - -val ch_Cfvtnt = new Cfvtnt('a', 'b') -val i_Cfvtnt = new Cfvtnt(1, 2) -val Cfvtnt(extracted1i_Cfvtnt, extracted2i_Cfvtnt) = i_Cfvtnt -val Cfvtnt(extracted1ch_Cfvtnt, extracted2ch_Cfvtnt) = ch_Cfvtnt -assert(1 == extracted1i_Cfvtnt) -assert(2 == extracted2i_Cfvtnt) -assert('a' == extracted1ch_Cfvtnt) -assert('b' == extracted2ch_Cfvtnt) - -assert(1 == i_Cfvtnt.`a b`) -assert(2 == i_Cfvtnt.a) -assert('a' == ch_Cfvtnt.`a b`) -assert('b' == ch_Cfvtnt.a) -assert(1 == i_Cfvtnt.p1) -assert(2 == i_Cfvtnt.p2) -assert('a' == ch_Cfvtnt.p1) -assert('b' == ch_Cfvtnt.p2) - - -val ch_Cfvtnf = new Cfvtnf('a', 'b') -val i_Cfvtnf = new Cfvtnf(1, 2) -val Cfvtnf(extracted1i_Cfvtnf, extracted2i_Cfvtnf) = i_Cfvtnf -val Cfvtnf(extracted1ch_Cfvtnf, extracted2ch_Cfvtnf) = ch_Cfvtnf -assert(1 == extracted1i_Cfvtnf) -assert(2 == extracted2i_Cfvtnf) -assert('a' == extracted1ch_Cfvtnf) -assert('b' == extracted2ch_Cfvtnf) - -assert(1 == i_Cfvtnf.`a b`) -assert(2 == i_Cfvtnf.a) -assert('a' == ch_Cfvtnf.`a b`) -assert('b' == ch_Cfvtnf.a) -assert(1 == i_Cfvtnf.p1) -assert('a' == ch_Cfvtnf.p1) - - -val ch_Cfvfpvt = new Cfvfpvt('a', 'b') -val i_Cfvfpvt = new Cfvfpvt(1, 2) -val Cfvfpvt(extracted1i_Cfvfpvt, extracted2i_Cfvfpvt) = i_Cfvfpvt -val Cfvfpvt(extracted1ch_Cfvfpvt, extracted2ch_Cfvfpvt) = ch_Cfvfpvt -assert(1 == extracted1i_Cfvfpvt) -assert(2 == extracted2i_Cfvfpvt) -assert('a' == extracted1ch_Cfvfpvt) -assert('b' == extracted2ch_Cfvfpvt) - -assert(1 == i_Cfvfpvt.`a b`) -assert('a' == ch_Cfvfpvt.`a b`) -assert(2 == i_Cfvfpvt.p2) -assert('b' == ch_Cfvfpvt.p2) - - -val ch_Cfvfpvf = new Cfvfpvf('a', 'b') -val i_Cfvfpvf = new Cfvfpvf(1, 2) -val Cfvfpvf(extracted1i_Cfvfpvf, extracted2i_Cfvfpvf) = i_Cfvfpvf -val Cfvfpvf(extracted1ch_Cfvfpvf, extracted2ch_Cfvfpvf) = ch_Cfvfpvf -assert(1 == extracted1i_Cfvfpvf) -assert(2 == extracted2i_Cfvfpvf) -assert('a' == extracted1ch_Cfvfpvf) -assert('b' == extracted2ch_Cfvfpvf) - -assert(1 == i_Cfvfpvf.`a b`) -assert('a' == ch_Cfvfpvf.`a b`) - - -val ch_Cfvfvt = new Cfvfvt('a', 'b') -val i_Cfvfvt = new Cfvfvt(1, 2) -val Cfvfvt(extracted1i_Cfvfvt, extracted2i_Cfvfvt) = i_Cfvfvt -val Cfvfvt(extracted1ch_Cfvfvt, extracted2ch_Cfvfvt) = ch_Cfvfvt -assert(1 == extracted1i_Cfvfvt) -assert(2 == extracted2i_Cfvfvt) -assert('a' == extracted1ch_Cfvfvt) -assert('b' == extracted2ch_Cfvfvt) - -assert(1 == i_Cfvfvt.`a b`) -assert(2 == i_Cfvfvt.a) -assert('a' == ch_Cfvfvt.`a b`) -assert('b' == ch_Cfvfvt.a) -assert(2 == i_Cfvfvt.p2) -assert('b' == ch_Cfvfvt.p2) - - -val ch_Cfvfvf = new Cfvfvf('a', 'b') -val i_Cfvfvf = new Cfvfvf(1, 2) -val Cfvfvf(extracted1i_Cfvfvf, extracted2i_Cfvfvf) = i_Cfvfvf -val Cfvfvf(extracted1ch_Cfvfvf, extracted2ch_Cfvfvf) = ch_Cfvfvf -assert(1 == extracted1i_Cfvfvf) -assert(2 == extracted2i_Cfvfvf) -assert('a' == extracted1ch_Cfvfvf) -assert('b' == extracted2ch_Cfvfvf) - -assert(1 == i_Cfvfvf.`a b`) -assert(2 == i_Cfvfvf.a) -assert('a' == ch_Cfvfvf.`a b`) -assert('b' == ch_Cfvfvf.a) - - -val ch_Cfvfnt = new Cfvfnt('a', 'b') -val i_Cfvfnt = new Cfvfnt(1, 2) -val Cfvfnt(extracted1i_Cfvfnt, extracted2i_Cfvfnt) = i_Cfvfnt -val Cfvfnt(extracted1ch_Cfvfnt, extracted2ch_Cfvfnt) = ch_Cfvfnt -assert(1 == extracted1i_Cfvfnt) -assert(2 == extracted2i_Cfvfnt) -assert('a' == extracted1ch_Cfvfnt) -assert('b' == extracted2ch_Cfvfnt) - -assert(1 == i_Cfvfnt.`a b`) -assert(2 == i_Cfvfnt.a) -assert('a' == ch_Cfvfnt.`a b`) -assert('b' == ch_Cfvfnt.a) -assert(2 == i_Cfvfnt.p2) -assert('b' == ch_Cfvfnt.p2) - - -val ch_Cfvfnf = new Cfvfnf('a', 'b') -val i_Cfvfnf = new Cfvfnf(1, 2) -val Cfvfnf(extracted1i_Cfvfnf, extracted2i_Cfvfnf) = i_Cfvfnf -val Cfvfnf(extracted1ch_Cfvfnf, extracted2ch_Cfvfnf) = ch_Cfvfnf -assert(1 == extracted1i_Cfvfnf) -assert(2 == extracted2i_Cfvfnf) -assert('a' == extracted1ch_Cfvfnf) -assert('b' == extracted2ch_Cfvfnf) - -assert(1 == i_Cfvfnf.`a b`) -assert(2 == i_Cfvfnf.a) -assert('a' == ch_Cfvfnf.`a b`) -assert('b' == ch_Cfvfnf.a) - - -val ch_Cfntpvt = new Cfntpvt('a', 'b') -val i_Cfntpvt = new Cfntpvt(1, 2) -val Cfntpvt(extracted1i_Cfntpvt, extracted2i_Cfntpvt) = i_Cfntpvt -val Cfntpvt(extracted1ch_Cfntpvt, extracted2ch_Cfntpvt) = ch_Cfntpvt -assert(1 == extracted1i_Cfntpvt) -assert(2 == extracted2i_Cfntpvt) -assert('a' == extracted1ch_Cfntpvt) -assert('b' == extracted2ch_Cfntpvt) - -assert(1 == i_Cfntpvt.`a b`) -assert('a' == ch_Cfntpvt.`a b`) -assert(1 == i_Cfntpvt.p1) -assert(2 == i_Cfntpvt.p2) -assert('a' == ch_Cfntpvt.p1) -assert('b' == ch_Cfntpvt.p2) - - -val ch_Cfntpvf = new Cfntpvf('a', 'b') -val i_Cfntpvf = new Cfntpvf(1, 2) -val Cfntpvf(extracted1i_Cfntpvf, extracted2i_Cfntpvf) = i_Cfntpvf -val Cfntpvf(extracted1ch_Cfntpvf, extracted2ch_Cfntpvf) = ch_Cfntpvf -assert(1 == extracted1i_Cfntpvf) -assert(2 == extracted2i_Cfntpvf) -assert('a' == extracted1ch_Cfntpvf) -assert('b' == extracted2ch_Cfntpvf) - -assert(1 == i_Cfntpvf.`a b`) -assert('a' == ch_Cfntpvf.`a b`) -assert(1 == i_Cfntpvf.p1) -assert('a' == ch_Cfntpvf.p1) - - -val ch_Cfntvt = new Cfntvt('a', 'b') -val i_Cfntvt = new Cfntvt(1, 2) -val Cfntvt(extracted1i_Cfntvt, extracted2i_Cfntvt) = i_Cfntvt -val Cfntvt(extracted1ch_Cfntvt, extracted2ch_Cfntvt) = ch_Cfntvt -assert(1 == extracted1i_Cfntvt) -assert(2 == extracted2i_Cfntvt) -assert('a' == extracted1ch_Cfntvt) -assert('b' == extracted2ch_Cfntvt) - -assert(1 == i_Cfntvt.`a b`) -assert(2 == i_Cfntvt.a) -assert('a' == ch_Cfntvt.`a b`) -assert('b' == ch_Cfntvt.a) -assert(1 == i_Cfntvt.p1) -assert(2 == i_Cfntvt.p2) -assert('a' == ch_Cfntvt.p1) -assert('b' == ch_Cfntvt.p2) - - -val ch_Cfntvf = new Cfntvf('a', 'b') -val i_Cfntvf = new Cfntvf(1, 2) -val Cfntvf(extracted1i_Cfntvf, extracted2i_Cfntvf) = i_Cfntvf -val Cfntvf(extracted1ch_Cfntvf, extracted2ch_Cfntvf) = ch_Cfntvf -assert(1 == extracted1i_Cfntvf) -assert(2 == extracted2i_Cfntvf) -assert('a' == extracted1ch_Cfntvf) -assert('b' == extracted2ch_Cfntvf) - -assert(1 == i_Cfntvf.`a b`) -assert(2 == i_Cfntvf.a) -assert('a' == ch_Cfntvf.`a b`) -assert('b' == ch_Cfntvf.a) -assert(1 == i_Cfntvf.p1) -assert('a' == ch_Cfntvf.p1) - - -val ch_Cfntnt = new Cfntnt('a', 'b') -val i_Cfntnt = new Cfntnt(1, 2) -val Cfntnt(extracted1i_Cfntnt, extracted2i_Cfntnt) = i_Cfntnt -val Cfntnt(extracted1ch_Cfntnt, extracted2ch_Cfntnt) = ch_Cfntnt -assert(1 == extracted1i_Cfntnt) -assert(2 == extracted2i_Cfntnt) -assert('a' == extracted1ch_Cfntnt) -assert('b' == extracted2ch_Cfntnt) - -assert(1 == i_Cfntnt.`a b`) -assert(2 == i_Cfntnt.a) -assert('a' == ch_Cfntnt.`a b`) -assert('b' == ch_Cfntnt.a) -assert(1 == i_Cfntnt.p1) -assert(2 == i_Cfntnt.p2) -assert('a' == ch_Cfntnt.p1) -assert('b' == ch_Cfntnt.p2) - - -val ch_Cfntnf = new Cfntnf('a', 'b') -val i_Cfntnf = new Cfntnf(1, 2) -val Cfntnf(extracted1i_Cfntnf, extracted2i_Cfntnf) = i_Cfntnf -val Cfntnf(extracted1ch_Cfntnf, extracted2ch_Cfntnf) = ch_Cfntnf -assert(1 == extracted1i_Cfntnf) -assert(2 == extracted2i_Cfntnf) -assert('a' == extracted1ch_Cfntnf) -assert('b' == extracted2ch_Cfntnf) - -assert(1 == i_Cfntnf.`a b`) -assert(2 == i_Cfntnf.a) -assert('a' == ch_Cfntnf.`a b`) -assert('b' == ch_Cfntnf.a) -assert(1 == i_Cfntnf.p1) -assert('a' == ch_Cfntnf.p1) - - -val ch_Cfnfpvt = new Cfnfpvt('a', 'b') -val i_Cfnfpvt = new Cfnfpvt(1, 2) -val Cfnfpvt(extracted1i_Cfnfpvt, extracted2i_Cfnfpvt) = i_Cfnfpvt -val Cfnfpvt(extracted1ch_Cfnfpvt, extracted2ch_Cfnfpvt) = ch_Cfnfpvt -assert(1 == extracted1i_Cfnfpvt) -assert(2 == extracted2i_Cfnfpvt) -assert('a' == extracted1ch_Cfnfpvt) -assert('b' == extracted2ch_Cfnfpvt) - -assert(1 == i_Cfnfpvt.`a b`) -assert('a' == ch_Cfnfpvt.`a b`) -assert(2 == i_Cfnfpvt.p2) -assert('b' == ch_Cfnfpvt.p2) - - -val ch_Cfnfpvf = new Cfnfpvf('a', 'b') -val i_Cfnfpvf = new Cfnfpvf(1, 2) -val Cfnfpvf(extracted1i_Cfnfpvf, extracted2i_Cfnfpvf) = i_Cfnfpvf -val Cfnfpvf(extracted1ch_Cfnfpvf, extracted2ch_Cfnfpvf) = ch_Cfnfpvf -assert(1 == extracted1i_Cfnfpvf) -assert(2 == extracted2i_Cfnfpvf) -assert('a' == extracted1ch_Cfnfpvf) -assert('b' == extracted2ch_Cfnfpvf) - -assert(1 == i_Cfnfpvf.`a b`) -assert('a' == ch_Cfnfpvf.`a b`) - - -val ch_Cfnfvt = new Cfnfvt('a', 'b') -val i_Cfnfvt = new Cfnfvt(1, 2) -val Cfnfvt(extracted1i_Cfnfvt, extracted2i_Cfnfvt) = i_Cfnfvt -val Cfnfvt(extracted1ch_Cfnfvt, extracted2ch_Cfnfvt) = ch_Cfnfvt -assert(1 == extracted1i_Cfnfvt) -assert(2 == extracted2i_Cfnfvt) -assert('a' == extracted1ch_Cfnfvt) -assert('b' == extracted2ch_Cfnfvt) - -assert(1 == i_Cfnfvt.`a b`) -assert(2 == i_Cfnfvt.a) -assert('a' == ch_Cfnfvt.`a b`) -assert('b' == ch_Cfnfvt.a) -assert(2 == i_Cfnfvt.p2) -assert('b' == ch_Cfnfvt.p2) - - -val ch_Cfnfvf = new Cfnfvf('a', 'b') -val i_Cfnfvf = new Cfnfvf(1, 2) -val Cfnfvf(extracted1i_Cfnfvf, extracted2i_Cfnfvf) = i_Cfnfvf -val Cfnfvf(extracted1ch_Cfnfvf, extracted2ch_Cfnfvf) = ch_Cfnfvf -assert(1 == extracted1i_Cfnfvf) -assert(2 == extracted2i_Cfnfvf) -assert('a' == extracted1ch_Cfnfvf) -assert('b' == extracted2ch_Cfnfvf) - -assert(1 == i_Cfnfvf.`a b`) -assert(2 == i_Cfnfvf.a) -assert('a' == ch_Cfnfvf.`a b`) -assert('b' == ch_Cfnfvf.a) - - -val ch_Cfnfnt = new Cfnfnt('a', 'b') -val i_Cfnfnt = new Cfnfnt(1, 2) -val Cfnfnt(extracted1i_Cfnfnt, extracted2i_Cfnfnt) = i_Cfnfnt -val Cfnfnt(extracted1ch_Cfnfnt, extracted2ch_Cfnfnt) = ch_Cfnfnt -assert(1 == extracted1i_Cfnfnt) -assert(2 == extracted2i_Cfnfnt) -assert('a' == extracted1ch_Cfnfnt) -assert('b' == extracted2ch_Cfnfnt) - -assert(1 == i_Cfnfnt.`a b`) -assert(2 == i_Cfnfnt.a) -assert('a' == ch_Cfnfnt.`a b`) -assert('b' == ch_Cfnfnt.a) -assert(2 == i_Cfnfnt.p2) -assert('b' == ch_Cfnfnt.p2) - - -val ch_Cfnfnf = new Cfnfnf('a', 'b') -val i_Cfnfnf = new Cfnfnf(1, 2) -val Cfnfnf(extracted1i_Cfnfnf, extracted2i_Cfnfnf) = i_Cfnfnf -val Cfnfnf(extracted1ch_Cfnfnf, extracted2ch_Cfnfnf) = ch_Cfnfnf -assert(1 == extracted1i_Cfnfnf) -assert(2 == extracted2i_Cfnfnf) -assert('a' == extracted1ch_Cfnfnf) -assert('b' == extracted2ch_Cfnfnf) - -assert(1 == i_Cfnfnf.`a b`) -assert(2 == i_Cfnfnf.a) -assert('a' == ch_Cfnfnf.`a b`) -assert('b' == ch_Cfnfnf.a) - - -val ch_Rtpvtpvt = new Rtpvtpvt('a', 'b') -val i_Rtpvtpvt = new Rtpvtpvt(1, 2) -assert(1 == i_Rtpvtpvt.p1) -assert(2 == i_Rtpvtpvt.p2) -assert('a' == ch_Rtpvtpvt.p1) -assert('b' == ch_Rtpvtpvt.p2) - - -val ch_Rtpvtpvf = new Rtpvtpvf('a', 'b') -val i_Rtpvtpvf = new Rtpvtpvf(1, 2) -assert(1 == i_Rtpvtpvf.p1) -assert('a' == ch_Rtpvtpvf.p1) - - -val ch_Rtpvtvt = new Rtpvtvt('a', 'b') -val i_Rtpvtvt = new Rtpvtvt(1, 2) -assert(2 == i_Rtpvtvt.a) -assert('b' == ch_Rtpvtvt.a) -assert(1 == i_Rtpvtvt.p1) -assert(2 == i_Rtpvtvt.p2) -assert('a' == ch_Rtpvtvt.p1) -assert('b' == ch_Rtpvtvt.p2) - - -val ch_Rtpvtvf = new Rtpvtvf('a', 'b') -val i_Rtpvtvf = new Rtpvtvf(1, 2) -assert(2 == i_Rtpvtvf.a) -assert('b' == ch_Rtpvtvf.a) -assert(1 == i_Rtpvtvf.p1) -assert('a' == ch_Rtpvtvf.p1) - - -val ch_Rtpvtnt = new Rtpvtnt('a', 'b') -val i_Rtpvtnt = new Rtpvtnt(1, 2) -assert(1 == i_Rtpvtnt.p1) -assert(2 == i_Rtpvtnt.p2) -assert('a' == ch_Rtpvtnt.p1) -assert('b' == ch_Rtpvtnt.p2) - - -val ch_Rtpvtnf = new Rtpvtnf('a', 'b') -val i_Rtpvtnf = new Rtpvtnf(1, 2) -assert(1 == i_Rtpvtnf.p1) -assert('a' == ch_Rtpvtnf.p1) - - -val ch_Rtpvfpvt = new Rtpvfpvt('a', 'b') -val i_Rtpvfpvt = new Rtpvfpvt(1, 2) -assert(2 == i_Rtpvfpvt.p2) -assert('b' == ch_Rtpvfpvt.p2) - - -val ch_Rtpvfvt = new Rtpvfvt('a', 'b') -val i_Rtpvfvt = new Rtpvfvt(1, 2) -assert(2 == i_Rtpvfvt.a) -assert('b' == ch_Rtpvfvt.a) -assert(2 == i_Rtpvfvt.p2) -assert('b' == ch_Rtpvfvt.p2) - - -val ch_Rtpvfnt = new Rtpvfnt('a', 'b') -val i_Rtpvfnt = new Rtpvfnt(1, 2) -assert(2 == i_Rtpvfnt.p2) -assert('b' == ch_Rtpvfnt.p2) - - -val ch_Rtvtpvt = new Rtvtpvt('a', 'b') -val i_Rtvtpvt = new Rtvtpvt(1, 2) -assert(1 == i_Rtvtpvt.`a b`) -assert('a' == ch_Rtvtpvt.`a b`) -assert(1 == i_Rtvtpvt.p1) -assert(2 == i_Rtvtpvt.p2) -assert('a' == ch_Rtvtpvt.p1) -assert('b' == ch_Rtvtpvt.p2) - - -val ch_Rtvtpvf = new Rtvtpvf('a', 'b') -val i_Rtvtpvf = new Rtvtpvf(1, 2) -assert(1 == i_Rtvtpvf.`a b`) -assert('a' == ch_Rtvtpvf.`a b`) -assert(1 == i_Rtvtpvf.p1) -assert('a' == ch_Rtvtpvf.p1) - - -val ch_Rtvtvt = new Rtvtvt('a', 'b') -val i_Rtvtvt = new Rtvtvt(1, 2) -assert(1 == i_Rtvtvt.`a b`) -assert(2 == i_Rtvtvt.a) -assert('a' == ch_Rtvtvt.`a b`) -assert('b' == ch_Rtvtvt.a) -assert(1 == i_Rtvtvt.p1) -assert(2 == i_Rtvtvt.p2) -assert('a' == ch_Rtvtvt.p1) -assert('b' == ch_Rtvtvt.p2) - +val ch_Cpvt_pvt = new Cpvt_pvt('a', 'b') +val i_Cpvt_pvt = new Cpvt_pvt(1, 2) +val Cpvt_pvt(extracted1i_Cpvt_pvt, extracted2i_Cpvt_pvt) = i_Cpvt_pvt +val Cpvt_pvt(extracted1ch_Cpvt_pvt, extracted2ch_Cpvt_pvt) = ch_Cpvt_pvt +assert(1 == extracted1i_Cpvt_pvt) +assert(2 == extracted2i_Cpvt_pvt) +assert('a' == extracted1ch_Cpvt_pvt) +assert('b' == extracted2ch_Cpvt_pvt) + +assert(1 == i_Cpvt_pvt.p1) +assert(2 == i_Cpvt_pvt.p2) +assert('a' == ch_Cpvt_pvt.p1) +assert('b' == ch_Cpvt_pvt.p2) + + +val ch_Cpvt_pvf = new Cpvt_pvf('a', 'b') +val i_Cpvt_pvf = new Cpvt_pvf(1, 2) +val Cpvt_pvf(extracted1i_Cpvt_pvf, extracted2i_Cpvt_pvf) = i_Cpvt_pvf +val Cpvt_pvf(extracted1ch_Cpvt_pvf, extracted2ch_Cpvt_pvf) = ch_Cpvt_pvf +assert(1 == extracted1i_Cpvt_pvf) +assert(2 == extracted2i_Cpvt_pvf) +assert('a' == extracted1ch_Cpvt_pvf) +assert('b' == extracted2ch_Cpvt_pvf) + +assert(1 == i_Cpvt_pvf.p1) +assert('a' == ch_Cpvt_pvf.p1) + + +val ch_Cpvt_vt = new Cpvt_vt('a', 'b') +val i_Cpvt_vt = new Cpvt_vt(1, 2) +val Cpvt_vt(extracted1i_Cpvt_vt, extracted2i_Cpvt_vt) = i_Cpvt_vt +val Cpvt_vt(extracted1ch_Cpvt_vt, extracted2ch_Cpvt_vt) = ch_Cpvt_vt +assert(1 == extracted1i_Cpvt_vt) +assert(2 == extracted2i_Cpvt_vt) +assert('a' == extracted1ch_Cpvt_vt) +assert('b' == extracted2ch_Cpvt_vt) + +assert(2 == i_Cpvt_vt.a) +assert('b' == ch_Cpvt_vt.a) +assert(1 == i_Cpvt_vt.p1) +assert(2 == i_Cpvt_vt.p2) +assert('a' == ch_Cpvt_vt.p1) +assert('b' == ch_Cpvt_vt.p2) + + +val ch_Cpvt_vf = new Cpvt_vf('a', 'b') +val i_Cpvt_vf = new Cpvt_vf(1, 2) +val Cpvt_vf(extracted1i_Cpvt_vf, extracted2i_Cpvt_vf) = i_Cpvt_vf +val Cpvt_vf(extracted1ch_Cpvt_vf, extracted2ch_Cpvt_vf) = ch_Cpvt_vf +assert(1 == extracted1i_Cpvt_vf) +assert(2 == extracted2i_Cpvt_vf) +assert('a' == extracted1ch_Cpvt_vf) +assert('b' == extracted2ch_Cpvt_vf) + +assert(2 == i_Cpvt_vf.a) +assert('b' == ch_Cpvt_vf.a) +assert(1 == i_Cpvt_vf.p1) +assert('a' == ch_Cpvt_vf.p1) + + +val ch_Cpvt_nt = new Cpvt_nt('a', 'b') +val i_Cpvt_nt = new Cpvt_nt(1, 2) +val Cpvt_nt(extracted1i_Cpvt_nt, extracted2i_Cpvt_nt) = i_Cpvt_nt +val Cpvt_nt(extracted1ch_Cpvt_nt, extracted2ch_Cpvt_nt) = ch_Cpvt_nt +assert(1 == extracted1i_Cpvt_nt) +assert(2 == extracted2i_Cpvt_nt) +assert('a' == extracted1ch_Cpvt_nt) +assert('b' == extracted2ch_Cpvt_nt) + +assert(2 == i_Cpvt_nt.a) +assert('b' == ch_Cpvt_nt.a) +assert(1 == i_Cpvt_nt.p1) +assert(2 == i_Cpvt_nt.p2) +assert('a' == ch_Cpvt_nt.p1) +assert('b' == ch_Cpvt_nt.p2) + + +val ch_Cpvt_nf = new Cpvt_nf('a', 'b') +val i_Cpvt_nf = new Cpvt_nf(1, 2) +val Cpvt_nf(extracted1i_Cpvt_nf, extracted2i_Cpvt_nf) = i_Cpvt_nf +val Cpvt_nf(extracted1ch_Cpvt_nf, extracted2ch_Cpvt_nf) = ch_Cpvt_nf +assert(1 == extracted1i_Cpvt_nf) +assert(2 == extracted2i_Cpvt_nf) +assert('a' == extracted1ch_Cpvt_nf) +assert('b' == extracted2ch_Cpvt_nf) + +assert(2 == i_Cpvt_nf.a) +assert('b' == ch_Cpvt_nf.a) +assert(1 == i_Cpvt_nf.p1) +assert('a' == ch_Cpvt_nf.p1) + + +val ch_Cpvf_pvt = new Cpvf_pvt('a', 'b') +val i_Cpvf_pvt = new Cpvf_pvt(1, 2) +val Cpvf_pvt(extracted1i_Cpvf_pvt, extracted2i_Cpvf_pvt) = i_Cpvf_pvt +val Cpvf_pvt(extracted1ch_Cpvf_pvt, extracted2ch_Cpvf_pvt) = ch_Cpvf_pvt +assert(1 == extracted1i_Cpvf_pvt) +assert(2 == extracted2i_Cpvf_pvt) +assert('a' == extracted1ch_Cpvf_pvt) +assert('b' == extracted2ch_Cpvf_pvt) + +assert(2 == i_Cpvf_pvt.p2) +assert('b' == ch_Cpvf_pvt.p2) + + +val ch_Cpvf_pvf = new Cpvf_pvf('a', 'b') +val i_Cpvf_pvf = new Cpvf_pvf(1, 2) +val Cpvf_pvf(extracted1i_Cpvf_pvf, extracted2i_Cpvf_pvf) = i_Cpvf_pvf +val Cpvf_pvf(extracted1ch_Cpvf_pvf, extracted2ch_Cpvf_pvf) = ch_Cpvf_pvf +assert(1 == extracted1i_Cpvf_pvf) +assert(2 == extracted2i_Cpvf_pvf) +assert('a' == extracted1ch_Cpvf_pvf) +assert('b' == extracted2ch_Cpvf_pvf) + + + +val ch_Cpvf_vt = new Cpvf_vt('a', 'b') +val i_Cpvf_vt = new Cpvf_vt(1, 2) +val Cpvf_vt(extracted1i_Cpvf_vt, extracted2i_Cpvf_vt) = i_Cpvf_vt +val Cpvf_vt(extracted1ch_Cpvf_vt, extracted2ch_Cpvf_vt) = ch_Cpvf_vt +assert(1 == extracted1i_Cpvf_vt) +assert(2 == extracted2i_Cpvf_vt) +assert('a' == extracted1ch_Cpvf_vt) +assert('b' == extracted2ch_Cpvf_vt) + +assert(2 == i_Cpvf_vt.a) +assert('b' == ch_Cpvf_vt.a) +assert(2 == i_Cpvf_vt.p2) +assert('b' == ch_Cpvf_vt.p2) + + +val ch_Cpvf_vf = new Cpvf_vf('a', 'b') +val i_Cpvf_vf = new Cpvf_vf(1, 2) +val Cpvf_vf(extracted1i_Cpvf_vf, extracted2i_Cpvf_vf) = i_Cpvf_vf +val Cpvf_vf(extracted1ch_Cpvf_vf, extracted2ch_Cpvf_vf) = ch_Cpvf_vf +assert(1 == extracted1i_Cpvf_vf) +assert(2 == extracted2i_Cpvf_vf) +assert('a' == extracted1ch_Cpvf_vf) +assert('b' == extracted2ch_Cpvf_vf) + +assert(2 == i_Cpvf_vf.a) +assert('b' == ch_Cpvf_vf.a) + + +val ch_Cpvf_nt = new Cpvf_nt('a', 'b') +val i_Cpvf_nt = new Cpvf_nt(1, 2) +val Cpvf_nt(extracted1i_Cpvf_nt, extracted2i_Cpvf_nt) = i_Cpvf_nt +val Cpvf_nt(extracted1ch_Cpvf_nt, extracted2ch_Cpvf_nt) = ch_Cpvf_nt +assert(1 == extracted1i_Cpvf_nt) +assert(2 == extracted2i_Cpvf_nt) +assert('a' == extracted1ch_Cpvf_nt) +assert('b' == extracted2ch_Cpvf_nt) + +assert(2 == i_Cpvf_nt.a) +assert('b' == ch_Cpvf_nt.a) +assert(2 == i_Cpvf_nt.p2) +assert('b' == ch_Cpvf_nt.p2) + + +val ch_Cpvf_nf = new Cpvf_nf('a', 'b') +val i_Cpvf_nf = new Cpvf_nf(1, 2) +val Cpvf_nf(extracted1i_Cpvf_nf, extracted2i_Cpvf_nf) = i_Cpvf_nf +val Cpvf_nf(extracted1ch_Cpvf_nf, extracted2ch_Cpvf_nf) = ch_Cpvf_nf +assert(1 == extracted1i_Cpvf_nf) +assert(2 == extracted2i_Cpvf_nf) +assert('a' == extracted1ch_Cpvf_nf) +assert('b' == extracted2ch_Cpvf_nf) + +assert(2 == i_Cpvf_nf.a) +assert('b' == ch_Cpvf_nf.a) + + +val ch_Cvt_pvt = new Cvt_pvt('a', 'b') +val i_Cvt_pvt = new Cvt_pvt(1, 2) +val Cvt_pvt(extracted1i_Cvt_pvt, extracted2i_Cvt_pvt) = i_Cvt_pvt +val Cvt_pvt(extracted1ch_Cvt_pvt, extracted2ch_Cvt_pvt) = ch_Cvt_pvt +assert(1 == extracted1i_Cvt_pvt) +assert(2 == extracted2i_Cvt_pvt) +assert('a' == extracted1ch_Cvt_pvt) +assert('b' == extracted2ch_Cvt_pvt) + +assert(1 == i_Cvt_pvt.`a b`) +assert('a' == ch_Cvt_pvt.`a b`) +assert(1 == i_Cvt_pvt.p1) +assert(2 == i_Cvt_pvt.p2) +assert('a' == ch_Cvt_pvt.p1) +assert('b' == ch_Cvt_pvt.p2) + + +val ch_Cvt_pvf = new Cvt_pvf('a', 'b') +val i_Cvt_pvf = new Cvt_pvf(1, 2) +val Cvt_pvf(extracted1i_Cvt_pvf, extracted2i_Cvt_pvf) = i_Cvt_pvf +val Cvt_pvf(extracted1ch_Cvt_pvf, extracted2ch_Cvt_pvf) = ch_Cvt_pvf +assert(1 == extracted1i_Cvt_pvf) +assert(2 == extracted2i_Cvt_pvf) +assert('a' == extracted1ch_Cvt_pvf) +assert('b' == extracted2ch_Cvt_pvf) + +assert(1 == i_Cvt_pvf.`a b`) +assert('a' == ch_Cvt_pvf.`a b`) +assert(1 == i_Cvt_pvf.p1) +assert('a' == ch_Cvt_pvf.p1) + + +val ch_Cvt_vt = new Cvt_vt('a', 'b') +val i_Cvt_vt = new Cvt_vt(1, 2) +val Cvt_vt(extracted1i_Cvt_vt, extracted2i_Cvt_vt) = i_Cvt_vt +val Cvt_vt(extracted1ch_Cvt_vt, extracted2ch_Cvt_vt) = ch_Cvt_vt +assert(1 == extracted1i_Cvt_vt) +assert(2 == extracted2i_Cvt_vt) +assert('a' == extracted1ch_Cvt_vt) +assert('b' == extracted2ch_Cvt_vt) + +assert(1 == i_Cvt_vt.`a b`) +assert(2 == i_Cvt_vt.a) +assert('a' == ch_Cvt_vt.`a b`) +assert('b' == ch_Cvt_vt.a) +assert(1 == i_Cvt_vt.p1) +assert(2 == i_Cvt_vt.p2) +assert('a' == ch_Cvt_vt.p1) +assert('b' == ch_Cvt_vt.p2) + + +val ch_Cvt_vf = new Cvt_vf('a', 'b') +val i_Cvt_vf = new Cvt_vf(1, 2) +val Cvt_vf(extracted1i_Cvt_vf, extracted2i_Cvt_vf) = i_Cvt_vf +val Cvt_vf(extracted1ch_Cvt_vf, extracted2ch_Cvt_vf) = ch_Cvt_vf +assert(1 == extracted1i_Cvt_vf) +assert(2 == extracted2i_Cvt_vf) +assert('a' == extracted1ch_Cvt_vf) +assert('b' == extracted2ch_Cvt_vf) + +assert(1 == i_Cvt_vf.`a b`) +assert(2 == i_Cvt_vf.a) +assert('a' == ch_Cvt_vf.`a b`) +assert('b' == ch_Cvt_vf.a) +assert(1 == i_Cvt_vf.p1) +assert('a' == ch_Cvt_vf.p1) + + +val ch_Cvt_nt = new Cvt_nt('a', 'b') +val i_Cvt_nt = new Cvt_nt(1, 2) +val Cvt_nt(extracted1i_Cvt_nt, extracted2i_Cvt_nt) = i_Cvt_nt +val Cvt_nt(extracted1ch_Cvt_nt, extracted2ch_Cvt_nt) = ch_Cvt_nt +assert(1 == extracted1i_Cvt_nt) +assert(2 == extracted2i_Cvt_nt) +assert('a' == extracted1ch_Cvt_nt) +assert('b' == extracted2ch_Cvt_nt) + +assert(1 == i_Cvt_nt.`a b`) +assert(2 == i_Cvt_nt.a) +assert('a' == ch_Cvt_nt.`a b`) +assert('b' == ch_Cvt_nt.a) +assert(1 == i_Cvt_nt.p1) +assert(2 == i_Cvt_nt.p2) +assert('a' == ch_Cvt_nt.p1) +assert('b' == ch_Cvt_nt.p2) + + +val ch_Cvt_nf = new Cvt_nf('a', 'b') +val i_Cvt_nf = new Cvt_nf(1, 2) +val Cvt_nf(extracted1i_Cvt_nf, extracted2i_Cvt_nf) = i_Cvt_nf +val Cvt_nf(extracted1ch_Cvt_nf, extracted2ch_Cvt_nf) = ch_Cvt_nf +assert(1 == extracted1i_Cvt_nf) +assert(2 == extracted2i_Cvt_nf) +assert('a' == extracted1ch_Cvt_nf) +assert('b' == extracted2ch_Cvt_nf) + +assert(1 == i_Cvt_nf.`a b`) +assert(2 == i_Cvt_nf.a) +assert('a' == ch_Cvt_nf.`a b`) +assert('b' == ch_Cvt_nf.a) +assert(1 == i_Cvt_nf.p1) +assert('a' == ch_Cvt_nf.p1) + + +val ch_Cvf_pvt = new Cvf_pvt('a', 'b') +val i_Cvf_pvt = new Cvf_pvt(1, 2) +val Cvf_pvt(extracted1i_Cvf_pvt, extracted2i_Cvf_pvt) = i_Cvf_pvt +val Cvf_pvt(extracted1ch_Cvf_pvt, extracted2ch_Cvf_pvt) = ch_Cvf_pvt +assert(1 == extracted1i_Cvf_pvt) +assert(2 == extracted2i_Cvf_pvt) +assert('a' == extracted1ch_Cvf_pvt) +assert('b' == extracted2ch_Cvf_pvt) + +assert(1 == i_Cvf_pvt.`a b`) +assert('a' == ch_Cvf_pvt.`a b`) +assert(2 == i_Cvf_pvt.p2) +assert('b' == ch_Cvf_pvt.p2) + + +val ch_Cvf_pvf = new Cvf_pvf('a', 'b') +val i_Cvf_pvf = new Cvf_pvf(1, 2) +val Cvf_pvf(extracted1i_Cvf_pvf, extracted2i_Cvf_pvf) = i_Cvf_pvf +val Cvf_pvf(extracted1ch_Cvf_pvf, extracted2ch_Cvf_pvf) = ch_Cvf_pvf +assert(1 == extracted1i_Cvf_pvf) +assert(2 == extracted2i_Cvf_pvf) +assert('a' == extracted1ch_Cvf_pvf) +assert('b' == extracted2ch_Cvf_pvf) + +assert(1 == i_Cvf_pvf.`a b`) +assert('a' == ch_Cvf_pvf.`a b`) + + +val ch_Cvf_vt = new Cvf_vt('a', 'b') +val i_Cvf_vt = new Cvf_vt(1, 2) +val Cvf_vt(extracted1i_Cvf_vt, extracted2i_Cvf_vt) = i_Cvf_vt +val Cvf_vt(extracted1ch_Cvf_vt, extracted2ch_Cvf_vt) = ch_Cvf_vt +assert(1 == extracted1i_Cvf_vt) +assert(2 == extracted2i_Cvf_vt) +assert('a' == extracted1ch_Cvf_vt) +assert('b' == extracted2ch_Cvf_vt) + +assert(1 == i_Cvf_vt.`a b`) +assert(2 == i_Cvf_vt.a) +assert('a' == ch_Cvf_vt.`a b`) +assert('b' == ch_Cvf_vt.a) +assert(2 == i_Cvf_vt.p2) +assert('b' == ch_Cvf_vt.p2) + + +val ch_Cvf_vf = new Cvf_vf('a', 'b') +val i_Cvf_vf = new Cvf_vf(1, 2) +val Cvf_vf(extracted1i_Cvf_vf, extracted2i_Cvf_vf) = i_Cvf_vf +val Cvf_vf(extracted1ch_Cvf_vf, extracted2ch_Cvf_vf) = ch_Cvf_vf +assert(1 == extracted1i_Cvf_vf) +assert(2 == extracted2i_Cvf_vf) +assert('a' == extracted1ch_Cvf_vf) +assert('b' == extracted2ch_Cvf_vf) + +assert(1 == i_Cvf_vf.`a b`) +assert(2 == i_Cvf_vf.a) +assert('a' == ch_Cvf_vf.`a b`) +assert('b' == ch_Cvf_vf.a) + + +val ch_Cvf_nt = new Cvf_nt('a', 'b') +val i_Cvf_nt = new Cvf_nt(1, 2) +val Cvf_nt(extracted1i_Cvf_nt, extracted2i_Cvf_nt) = i_Cvf_nt +val Cvf_nt(extracted1ch_Cvf_nt, extracted2ch_Cvf_nt) = ch_Cvf_nt +assert(1 == extracted1i_Cvf_nt) +assert(2 == extracted2i_Cvf_nt) +assert('a' == extracted1ch_Cvf_nt) +assert('b' == extracted2ch_Cvf_nt) + +assert(1 == i_Cvf_nt.`a b`) +assert(2 == i_Cvf_nt.a) +assert('a' == ch_Cvf_nt.`a b`) +assert('b' == ch_Cvf_nt.a) +assert(2 == i_Cvf_nt.p2) +assert('b' == ch_Cvf_nt.p2) + + +val ch_Cvf_nf = new Cvf_nf('a', 'b') +val i_Cvf_nf = new Cvf_nf(1, 2) +val Cvf_nf(extracted1i_Cvf_nf, extracted2i_Cvf_nf) = i_Cvf_nf +val Cvf_nf(extracted1ch_Cvf_nf, extracted2ch_Cvf_nf) = ch_Cvf_nf +assert(1 == extracted1i_Cvf_nf) +assert(2 == extracted2i_Cvf_nf) +assert('a' == extracted1ch_Cvf_nf) +assert('b' == extracted2ch_Cvf_nf) + +assert(1 == i_Cvf_nf.`a b`) +assert(2 == i_Cvf_nf.a) +assert('a' == ch_Cvf_nf.`a b`) +assert('b' == ch_Cvf_nf.a) + + +val ch_Cnt_pvt = new Cnt_pvt('a', 'b') +val i_Cnt_pvt = new Cnt_pvt(1, 2) +val Cnt_pvt(extracted1i_Cnt_pvt, extracted2i_Cnt_pvt) = i_Cnt_pvt +val Cnt_pvt(extracted1ch_Cnt_pvt, extracted2ch_Cnt_pvt) = ch_Cnt_pvt +assert(1 == extracted1i_Cnt_pvt) +assert(2 == extracted2i_Cnt_pvt) +assert('a' == extracted1ch_Cnt_pvt) +assert('b' == extracted2ch_Cnt_pvt) + +assert(1 == i_Cnt_pvt.`a b`) +assert('a' == ch_Cnt_pvt.`a b`) +assert(1 == i_Cnt_pvt.p1) +assert(2 == i_Cnt_pvt.p2) +assert('a' == ch_Cnt_pvt.p1) +assert('b' == ch_Cnt_pvt.p2) + + +val ch_Cnt_pvf = new Cnt_pvf('a', 'b') +val i_Cnt_pvf = new Cnt_pvf(1, 2) +val Cnt_pvf(extracted1i_Cnt_pvf, extracted2i_Cnt_pvf) = i_Cnt_pvf +val Cnt_pvf(extracted1ch_Cnt_pvf, extracted2ch_Cnt_pvf) = ch_Cnt_pvf +assert(1 == extracted1i_Cnt_pvf) +assert(2 == extracted2i_Cnt_pvf) +assert('a' == extracted1ch_Cnt_pvf) +assert('b' == extracted2ch_Cnt_pvf) + +assert(1 == i_Cnt_pvf.`a b`) +assert('a' == ch_Cnt_pvf.`a b`) +assert(1 == i_Cnt_pvf.p1) +assert('a' == ch_Cnt_pvf.p1) + + +val ch_Cnt_vt = new Cnt_vt('a', 'b') +val i_Cnt_vt = new Cnt_vt(1, 2) +val Cnt_vt(extracted1i_Cnt_vt, extracted2i_Cnt_vt) = i_Cnt_vt +val Cnt_vt(extracted1ch_Cnt_vt, extracted2ch_Cnt_vt) = ch_Cnt_vt +assert(1 == extracted1i_Cnt_vt) +assert(2 == extracted2i_Cnt_vt) +assert('a' == extracted1ch_Cnt_vt) +assert('b' == extracted2ch_Cnt_vt) + +assert(1 == i_Cnt_vt.`a b`) +assert(2 == i_Cnt_vt.a) +assert('a' == ch_Cnt_vt.`a b`) +assert('b' == ch_Cnt_vt.a) +assert(1 == i_Cnt_vt.p1) +assert(2 == i_Cnt_vt.p2) +assert('a' == ch_Cnt_vt.p1) +assert('b' == ch_Cnt_vt.p2) + + +val ch_Cnt_vf = new Cnt_vf('a', 'b') +val i_Cnt_vf = new Cnt_vf(1, 2) +val Cnt_vf(extracted1i_Cnt_vf, extracted2i_Cnt_vf) = i_Cnt_vf +val Cnt_vf(extracted1ch_Cnt_vf, extracted2ch_Cnt_vf) = ch_Cnt_vf +assert(1 == extracted1i_Cnt_vf) +assert(2 == extracted2i_Cnt_vf) +assert('a' == extracted1ch_Cnt_vf) +assert('b' == extracted2ch_Cnt_vf) + +assert(1 == i_Cnt_vf.`a b`) +assert(2 == i_Cnt_vf.a) +assert('a' == ch_Cnt_vf.`a b`) +assert('b' == ch_Cnt_vf.a) +assert(1 == i_Cnt_vf.p1) +assert('a' == ch_Cnt_vf.p1) + + +val ch_Cnt_nt = new Cnt_nt('a', 'b') +val i_Cnt_nt = new Cnt_nt(1, 2) +val Cnt_nt(extracted1i_Cnt_nt, extracted2i_Cnt_nt) = i_Cnt_nt +val Cnt_nt(extracted1ch_Cnt_nt, extracted2ch_Cnt_nt) = ch_Cnt_nt +assert(1 == extracted1i_Cnt_nt) +assert(2 == extracted2i_Cnt_nt) +assert('a' == extracted1ch_Cnt_nt) +assert('b' == extracted2ch_Cnt_nt) + +assert(1 == i_Cnt_nt.`a b`) +assert(2 == i_Cnt_nt.a) +assert('a' == ch_Cnt_nt.`a b`) +assert('b' == ch_Cnt_nt.a) +assert(1 == i_Cnt_nt.p1) +assert(2 == i_Cnt_nt.p2) +assert('a' == ch_Cnt_nt.p1) +assert('b' == ch_Cnt_nt.p2) + + +val ch_Cnt_nf = new Cnt_nf('a', 'b') +val i_Cnt_nf = new Cnt_nf(1, 2) +val Cnt_nf(extracted1i_Cnt_nf, extracted2i_Cnt_nf) = i_Cnt_nf +val Cnt_nf(extracted1ch_Cnt_nf, extracted2ch_Cnt_nf) = ch_Cnt_nf +assert(1 == extracted1i_Cnt_nf) +assert(2 == extracted2i_Cnt_nf) +assert('a' == extracted1ch_Cnt_nf) +assert('b' == extracted2ch_Cnt_nf) + +assert(1 == i_Cnt_nf.`a b`) +assert(2 == i_Cnt_nf.a) +assert('a' == ch_Cnt_nf.`a b`) +assert('b' == ch_Cnt_nf.a) +assert(1 == i_Cnt_nf.p1) +assert('a' == ch_Cnt_nf.p1) + + +val ch_Cnf_pvt = new Cnf_pvt('a', 'b') +val i_Cnf_pvt = new Cnf_pvt(1, 2) +val Cnf_pvt(extracted1i_Cnf_pvt, extracted2i_Cnf_pvt) = i_Cnf_pvt +val Cnf_pvt(extracted1ch_Cnf_pvt, extracted2ch_Cnf_pvt) = ch_Cnf_pvt +assert(1 == extracted1i_Cnf_pvt) +assert(2 == extracted2i_Cnf_pvt) +assert('a' == extracted1ch_Cnf_pvt) +assert('b' == extracted2ch_Cnf_pvt) + +assert(1 == i_Cnf_pvt.`a b`) +assert('a' == ch_Cnf_pvt.`a b`) +assert(2 == i_Cnf_pvt.p2) +assert('b' == ch_Cnf_pvt.p2) + + +val ch_Cnf_pvf = new Cnf_pvf('a', 'b') +val i_Cnf_pvf = new Cnf_pvf(1, 2) +val Cnf_pvf(extracted1i_Cnf_pvf, extracted2i_Cnf_pvf) = i_Cnf_pvf +val Cnf_pvf(extracted1ch_Cnf_pvf, extracted2ch_Cnf_pvf) = ch_Cnf_pvf +assert(1 == extracted1i_Cnf_pvf) +assert(2 == extracted2i_Cnf_pvf) +assert('a' == extracted1ch_Cnf_pvf) +assert('b' == extracted2ch_Cnf_pvf) + +assert(1 == i_Cnf_pvf.`a b`) +assert('a' == ch_Cnf_pvf.`a b`) + + +val ch_Cnf_vt = new Cnf_vt('a', 'b') +val i_Cnf_vt = new Cnf_vt(1, 2) +val Cnf_vt(extracted1i_Cnf_vt, extracted2i_Cnf_vt) = i_Cnf_vt +val Cnf_vt(extracted1ch_Cnf_vt, extracted2ch_Cnf_vt) = ch_Cnf_vt +assert(1 == extracted1i_Cnf_vt) +assert(2 == extracted2i_Cnf_vt) +assert('a' == extracted1ch_Cnf_vt) +assert('b' == extracted2ch_Cnf_vt) + +assert(1 == i_Cnf_vt.`a b`) +assert(2 == i_Cnf_vt.a) +assert('a' == ch_Cnf_vt.`a b`) +assert('b' == ch_Cnf_vt.a) +assert(2 == i_Cnf_vt.p2) +assert('b' == ch_Cnf_vt.p2) + + +val ch_Cnf_vf = new Cnf_vf('a', 'b') +val i_Cnf_vf = new Cnf_vf(1, 2) +val Cnf_vf(extracted1i_Cnf_vf, extracted2i_Cnf_vf) = i_Cnf_vf +val Cnf_vf(extracted1ch_Cnf_vf, extracted2ch_Cnf_vf) = ch_Cnf_vf +assert(1 == extracted1i_Cnf_vf) +assert(2 == extracted2i_Cnf_vf) +assert('a' == extracted1ch_Cnf_vf) +assert('b' == extracted2ch_Cnf_vf) + +assert(1 == i_Cnf_vf.`a b`) +assert(2 == i_Cnf_vf.a) +assert('a' == ch_Cnf_vf.`a b`) +assert('b' == ch_Cnf_vf.a) + + +val ch_Cnf_nt = new Cnf_nt('a', 'b') +val i_Cnf_nt = new Cnf_nt(1, 2) +val Cnf_nt(extracted1i_Cnf_nt, extracted2i_Cnf_nt) = i_Cnf_nt +val Cnf_nt(extracted1ch_Cnf_nt, extracted2ch_Cnf_nt) = ch_Cnf_nt +assert(1 == extracted1i_Cnf_nt) +assert(2 == extracted2i_Cnf_nt) +assert('a' == extracted1ch_Cnf_nt) +assert('b' == extracted2ch_Cnf_nt) + +assert(1 == i_Cnf_nt.`a b`) +assert(2 == i_Cnf_nt.a) +assert('a' == ch_Cnf_nt.`a b`) +assert('b' == ch_Cnf_nt.a) +assert(2 == i_Cnf_nt.p2) +assert('b' == ch_Cnf_nt.p2) + + +val ch_Cnf_nf = new Cnf_nf('a', 'b') +val i_Cnf_nf = new Cnf_nf(1, 2) +val Cnf_nf(extracted1i_Cnf_nf, extracted2i_Cnf_nf) = i_Cnf_nf +val Cnf_nf(extracted1ch_Cnf_nf, extracted2ch_Cnf_nf) = ch_Cnf_nf +assert(1 == extracted1i_Cnf_nf) +assert(2 == extracted2i_Cnf_nf) +assert('a' == extracted1ch_Cnf_nf) +assert('b' == extracted2ch_Cnf_nf) + +assert(1 == i_Cnf_nf.`a b`) +assert(2 == i_Cnf_nf.a) +assert('a' == ch_Cnf_nf.`a b`) +assert('b' == ch_Cnf_nf.a) + + +val ch_Rpvt_pvt = new Rpvt_pvt('a', 'b') +val i_Rpvt_pvt = new Rpvt_pvt(1, 2) +assert(1 == i_Rpvt_pvt.p1) +assert(2 == i_Rpvt_pvt.p2) +assert('a' == ch_Rpvt_pvt.p1) +assert('b' == ch_Rpvt_pvt.p2) + + +val ch_Rpvt_pvf = new Rpvt_pvf('a', 'b') +val i_Rpvt_pvf = new Rpvt_pvf(1, 2) +assert(1 == i_Rpvt_pvf.p1) +assert('a' == ch_Rpvt_pvf.p1) + + +val ch_Rpvt_vt = new Rpvt_vt('a', 'b') +val i_Rpvt_vt = new Rpvt_vt(1, 2) +assert(2 == i_Rpvt_vt.a) +assert('b' == ch_Rpvt_vt.a) +assert(1 == i_Rpvt_vt.p1) +assert(2 == i_Rpvt_vt.p2) +assert('a' == ch_Rpvt_vt.p1) +assert('b' == ch_Rpvt_vt.p2) + + +val ch_Rpvt_vf = new Rpvt_vf('a', 'b') +val i_Rpvt_vf = new Rpvt_vf(1, 2) +assert(2 == i_Rpvt_vf.a) +assert('b' == ch_Rpvt_vf.a) +assert(1 == i_Rpvt_vf.p1) +assert('a' == ch_Rpvt_vf.p1) + + +val ch_Rpvt_nt = new Rpvt_nt('a', 'b') +val i_Rpvt_nt = new Rpvt_nt(1, 2) +assert(1 == i_Rpvt_nt.p1) +assert(2 == i_Rpvt_nt.p2) +assert('a' == ch_Rpvt_nt.p1) +assert('b' == ch_Rpvt_nt.p2) + + +val ch_Rpvt_nf = new Rpvt_nf('a', 'b') +val i_Rpvt_nf = new Rpvt_nf(1, 2) +assert(1 == i_Rpvt_nf.p1) +assert('a' == ch_Rpvt_nf.p1) + + +val ch_Rpvf_pvt = new Rpvf_pvt('a', 'b') +val i_Rpvf_pvt = new Rpvf_pvt(1, 2) +assert(2 == i_Rpvf_pvt.p2) +assert('b' == ch_Rpvf_pvt.p2) -val ch_Rtvtvf = new Rtvtvf('a', 'b') -val i_Rtvtvf = new Rtvtvf(1, 2) -assert(1 == i_Rtvtvf.`a b`) -assert(2 == i_Rtvtvf.a) -assert('a' == ch_Rtvtvf.`a b`) -assert('b' == ch_Rtvtvf.a) -assert(1 == i_Rtvtvf.p1) -assert('a' == ch_Rtvtvf.p1) - -val ch_Rtvtnt = new Rtvtnt('a', 'b') -val i_Rtvtnt = new Rtvtnt(1, 2) -assert(1 == i_Rtvtnt.`a b`) -assert('a' == ch_Rtvtnt.`a b`) -assert(1 == i_Rtvtnt.p1) -assert(2 == i_Rtvtnt.p2) -assert('a' == ch_Rtvtnt.p1) -assert('b' == ch_Rtvtnt.p2) +val ch_Rpvf_pvf = new Rpvf_pvf('a', 'b') +val i_Rpvf_pvf = new Rpvf_pvf(1, 2) + + +val ch_Rpvf_vt = new Rpvf_vt('a', 'b') +val i_Rpvf_vt = new Rpvf_vt(1, 2) +assert(2 == i_Rpvf_vt.a) +assert('b' == ch_Rpvf_vt.a) +assert(2 == i_Rpvf_vt.p2) +assert('b' == ch_Rpvf_vt.p2) -val ch_Rtvtnf = new Rtvtnf('a', 'b') -val i_Rtvtnf = new Rtvtnf(1, 2) -assert(1 == i_Rtvtnf.`a b`) -assert('a' == ch_Rtvtnf.`a b`) -assert(1 == i_Rtvtnf.p1) -assert('a' == ch_Rtvtnf.p1) +val ch_Rpvf_vf = new Rpvf_vf('a', 'b') +val i_Rpvf_vf = new Rpvf_vf(1, 2) +assert(2 == i_Rpvf_vf.a) +assert('b' == ch_Rpvf_vf.a) + +val ch_Rpvf_nt = new Rpvf_nt('a', 'b') +val i_Rpvf_nt = new Rpvf_nt(1, 2) +assert(2 == i_Rpvf_nt.p2) +assert('b' == ch_Rpvf_nt.p2) -val ch_Rtvfpvt = new Rtvfpvt('a', 'b') -val i_Rtvfpvt = new Rtvfpvt(1, 2) -assert(1 == i_Rtvfpvt.`a b`) -assert('a' == ch_Rtvfpvt.`a b`) -assert(2 == i_Rtvfpvt.p2) -assert('b' == ch_Rtvfpvt.p2) +val ch_Rpvf_nf = new Rpvf_nf('a', 'b') +val i_Rpvf_nf = new Rpvf_nf(1, 2) -val ch_Rtvfvt = new Rtvfvt('a', 'b') -val i_Rtvfvt = new Rtvfvt(1, 2) -assert(1 == i_Rtvfvt.`a b`) -assert(2 == i_Rtvfvt.a) -assert('a' == ch_Rtvfvt.`a b`) -assert('b' == ch_Rtvfvt.a) -assert(2 == i_Rtvfvt.p2) -assert('b' == ch_Rtvfvt.p2) +val ch_Rvt_pvt = new Rvt_pvt('a', 'b') +val i_Rvt_pvt = new Rvt_pvt(1, 2) +assert(1 == i_Rvt_pvt.`a b`) +assert('a' == ch_Rvt_pvt.`a b`) +assert(1 == i_Rvt_pvt.p1) +assert(2 == i_Rvt_pvt.p2) +assert('a' == ch_Rvt_pvt.p1) +assert('b' == ch_Rvt_pvt.p2) -val ch_Rtvfnt = new Rtvfnt('a', 'b') -val i_Rtvfnt = new Rtvfnt(1, 2) -assert(1 == i_Rtvfnt.`a b`) -assert('a' == ch_Rtvfnt.`a b`) -assert(2 == i_Rtvfnt.p2) -assert('b' == ch_Rtvfnt.p2) +val ch_Rvt_pvf = new Rvt_pvf('a', 'b') +val i_Rvt_pvf = new Rvt_pvf(1, 2) +assert(1 == i_Rvt_pvf.`a b`) +assert('a' == ch_Rvt_pvf.`a b`) +assert(1 == i_Rvt_pvf.p1) +assert('a' == ch_Rvt_pvf.p1) -val ch_Rtntpvt = new Rtntpvt('a', 'b') -val i_Rtntpvt = new Rtntpvt(1, 2) -assert(1 == i_Rtntpvt.p1) -assert(2 == i_Rtntpvt.p2) -assert('a' == ch_Rtntpvt.p1) -assert('b' == ch_Rtntpvt.p2) +val ch_Rvt_vt = new Rvt_vt('a', 'b') +val i_Rvt_vt = new Rvt_vt(1, 2) +assert(1 == i_Rvt_vt.`a b`) +assert(2 == i_Rvt_vt.a) +assert('a' == ch_Rvt_vt.`a b`) +assert('b' == ch_Rvt_vt.a) +assert(1 == i_Rvt_vt.p1) +assert(2 == i_Rvt_vt.p2) +assert('a' == ch_Rvt_vt.p1) +assert('b' == ch_Rvt_vt.p2) -val ch_Rtntpvf = new Rtntpvf('a', 'b') -val i_Rtntpvf = new Rtntpvf(1, 2) -assert(1 == i_Rtntpvf.p1) -assert('a' == ch_Rtntpvf.p1) +val ch_Rvt_vf = new Rvt_vf('a', 'b') +val i_Rvt_vf = new Rvt_vf(1, 2) +assert(1 == i_Rvt_vf.`a b`) +assert(2 == i_Rvt_vf.a) +assert('a' == ch_Rvt_vf.`a b`) +assert('b' == ch_Rvt_vf.a) +assert(1 == i_Rvt_vf.p1) +assert('a' == ch_Rvt_vf.p1) -val ch_Rtntvt = new Rtntvt('a', 'b') -val i_Rtntvt = new Rtntvt(1, 2) -assert(2 == i_Rtntvt.a) -assert('b' == ch_Rtntvt.a) -assert(1 == i_Rtntvt.p1) -assert(2 == i_Rtntvt.p2) -assert('a' == ch_Rtntvt.p1) -assert('b' == ch_Rtntvt.p2) +val ch_Rvt_nt = new Rvt_nt('a', 'b') +val i_Rvt_nt = new Rvt_nt(1, 2) +assert(1 == i_Rvt_nt.`a b`) +assert('a' == ch_Rvt_nt.`a b`) +assert(1 == i_Rvt_nt.p1) +assert(2 == i_Rvt_nt.p2) +assert('a' == ch_Rvt_nt.p1) +assert('b' == ch_Rvt_nt.p2) -val ch_Rtntvf = new Rtntvf('a', 'b') -val i_Rtntvf = new Rtntvf(1, 2) -assert(2 == i_Rtntvf.a) -assert('b' == ch_Rtntvf.a) -assert(1 == i_Rtntvf.p1) -assert('a' == ch_Rtntvf.p1) +val ch_Rvt_nf = new Rvt_nf('a', 'b') +val i_Rvt_nf = new Rvt_nf(1, 2) +assert(1 == i_Rvt_nf.`a b`) +assert('a' == ch_Rvt_nf.`a b`) +assert(1 == i_Rvt_nf.p1) +assert('a' == ch_Rvt_nf.p1) -val ch_Rtntnt = new Rtntnt('a', 'b') -val i_Rtntnt = new Rtntnt(1, 2) -assert(1 == i_Rtntnt.p1) -assert(2 == i_Rtntnt.p2) -assert('a' == ch_Rtntnt.p1) -assert('b' == ch_Rtntnt.p2) +val ch_Rvf_pvt = new Rvf_pvt('a', 'b') +val i_Rvf_pvt = new Rvf_pvt(1, 2) +assert(1 == i_Rvf_pvt.`a b`) +assert('a' == ch_Rvf_pvt.`a b`) +assert(2 == i_Rvf_pvt.p2) +assert('b' == ch_Rvf_pvt.p2) -val ch_Rtntnf = new Rtntnf('a', 'b') -val i_Rtntnf = new Rtntnf(1, 2) -assert(1 == i_Rtntnf.p1) -assert('a' == ch_Rtntnf.p1) +val ch_Rvf_pvf = new Rvf_pvf('a', 'b') +val i_Rvf_pvf = new Rvf_pvf(1, 2) +assert(1 == i_Rvf_pvf.`a b`) +assert('a' == ch_Rvf_pvf.`a b`) -val ch_Rtnfpvt = new Rtnfpvt('a', 'b') -val i_Rtnfpvt = new Rtnfpvt(1, 2) -assert(2 == i_Rtnfpvt.p2) -assert('b' == ch_Rtnfpvt.p2) +val ch_Rvf_vt = new Rvf_vt('a', 'b') +val i_Rvf_vt = new Rvf_vt(1, 2) +assert(1 == i_Rvf_vt.`a b`) +assert(2 == i_Rvf_vt.a) +assert('a' == ch_Rvf_vt.`a b`) +assert('b' == ch_Rvf_vt.a) +assert(2 == i_Rvf_vt.p2) +assert('b' == ch_Rvf_vt.p2) -val ch_Rtnfvt = new Rtnfvt('a', 'b') -val i_Rtnfvt = new Rtnfvt(1, 2) -assert(2 == i_Rtnfvt.a) -assert('b' == ch_Rtnfvt.a) -assert(2 == i_Rtnfvt.p2) -assert('b' == ch_Rtnfvt.p2) +val ch_Rvf_vf = new Rvf_vf('a', 'b') +val i_Rvf_vf = new Rvf_vf(1, 2) +assert(1 == i_Rvf_vf.`a b`) +assert(2 == i_Rvf_vf.a) +assert('a' == ch_Rvf_vf.`a b`) +assert('b' == ch_Rvf_vf.a) -val ch_Rtnfnt = new Rtnfnt('a', 'b') -val i_Rtnfnt = new Rtnfnt(1, 2) -assert(2 == i_Rtnfnt.p2) -assert('b' == ch_Rtnfnt.p2) +val ch_Rvf_nt = new Rvf_nt('a', 'b') +val i_Rvf_nt = new Rvf_nt(1, 2) +assert(1 == i_Rvf_nt.`a b`) +assert('a' == ch_Rvf_nt.`a b`) +assert(2 == i_Rvf_nt.p2) +assert('b' == ch_Rvf_nt.p2) -val ch_Rfpvtpvt = new Rfpvtpvt('a', 'b') -val i_Rfpvtpvt = new Rfpvtpvt(1, 2) -assert(1 == i_Rfpvtpvt.p1) -assert(2 == i_Rfpvtpvt.p2) -assert('a' == ch_Rfpvtpvt.p1) -assert('b' == ch_Rfpvtpvt.p2) +val ch_Rvf_nf = new Rvf_nf('a', 'b') +val i_Rvf_nf = new Rvf_nf(1, 2) +assert(1 == i_Rvf_nf.`a b`) +assert('a' == ch_Rvf_nf.`a b`) -val ch_Rfpvtpvf = new Rfpvtpvf('a', 'b') -val i_Rfpvtpvf = new Rfpvtpvf(1, 2) -assert(1 == i_Rfpvtpvf.p1) -assert('a' == ch_Rfpvtpvf.p1) +val ch_Rnt_pvt = new Rnt_pvt('a', 'b') +val i_Rnt_pvt = new Rnt_pvt(1, 2) +assert(1 == i_Rnt_pvt.p1) +assert(2 == i_Rnt_pvt.p2) +assert('a' == ch_Rnt_pvt.p1) +assert('b' == ch_Rnt_pvt.p2) -val ch_Rfpvtvt = new Rfpvtvt('a', 'b') -val i_Rfpvtvt = new Rfpvtvt(1, 2) -assert(2 == i_Rfpvtvt.a) -assert('b' == ch_Rfpvtvt.a) -assert(1 == i_Rfpvtvt.p1) -assert(2 == i_Rfpvtvt.p2) -assert('a' == ch_Rfpvtvt.p1) -assert('b' == ch_Rfpvtvt.p2) +val ch_Rnt_pvf = new Rnt_pvf('a', 'b') +val i_Rnt_pvf = new Rnt_pvf(1, 2) +assert(1 == i_Rnt_pvf.p1) +assert('a' == ch_Rnt_pvf.p1) -val ch_Rfpvtvf = new Rfpvtvf('a', 'b') -val i_Rfpvtvf = new Rfpvtvf(1, 2) -assert(2 == i_Rfpvtvf.a) -assert('b' == ch_Rfpvtvf.a) -assert(1 == i_Rfpvtvf.p1) -assert('a' == ch_Rfpvtvf.p1) +val ch_Rnt_vt = new Rnt_vt('a', 'b') +val i_Rnt_vt = new Rnt_vt(1, 2) +assert(2 == i_Rnt_vt.a) +assert('b' == ch_Rnt_vt.a) +assert(1 == i_Rnt_vt.p1) +assert(2 == i_Rnt_vt.p2) +assert('a' == ch_Rnt_vt.p1) +assert('b' == ch_Rnt_vt.p2) -val ch_Rfpvtnt = new Rfpvtnt('a', 'b') -val i_Rfpvtnt = new Rfpvtnt(1, 2) -assert(1 == i_Rfpvtnt.p1) -assert(2 == i_Rfpvtnt.p2) -assert('a' == ch_Rfpvtnt.p1) -assert('b' == ch_Rfpvtnt.p2) +val ch_Rnt_vf = new Rnt_vf('a', 'b') +val i_Rnt_vf = new Rnt_vf(1, 2) +assert(2 == i_Rnt_vf.a) +assert('b' == ch_Rnt_vf.a) +assert(1 == i_Rnt_vf.p1) +assert('a' == ch_Rnt_vf.p1) -val ch_Rfpvtnf = new Rfpvtnf('a', 'b') -val i_Rfpvtnf = new Rfpvtnf(1, 2) -assert(1 == i_Rfpvtnf.p1) -assert('a' == ch_Rfpvtnf.p1) +val ch_Rnt_nt = new Rnt_nt('a', 'b') +val i_Rnt_nt = new Rnt_nt(1, 2) +assert(1 == i_Rnt_nt.p1) +assert(2 == i_Rnt_nt.p2) +assert('a' == ch_Rnt_nt.p1) +assert('b' == ch_Rnt_nt.p2) -val ch_Rfpvfpvt = new Rfpvfpvt('a', 'b') -val i_Rfpvfpvt = new Rfpvfpvt(1, 2) -assert(2 == i_Rfpvfpvt.p2) -assert('b' == ch_Rfpvfpvt.p2) +val ch_Rnt_nf = new Rnt_nf('a', 'b') +val i_Rnt_nf = new Rnt_nf(1, 2) +assert(1 == i_Rnt_nf.p1) +assert('a' == ch_Rnt_nf.p1) -val ch_Rfpvfpvf = new Rfpvfpvf('a', 'b') -val i_Rfpvfpvf = new Rfpvfpvf(1, 2) +val ch_Rnf_pvt = new Rnf_pvt('a', 'b') +val i_Rnf_pvt = new Rnf_pvt(1, 2) +assert(2 == i_Rnf_pvt.p2) +assert('b' == ch_Rnf_pvt.p2) -val ch_Rfpvfvt = new Rfpvfvt('a', 'b') -val i_Rfpvfvt = new Rfpvfvt(1, 2) -assert(2 == i_Rfpvfvt.a) -assert('b' == ch_Rfpvfvt.a) -assert(2 == i_Rfpvfvt.p2) -assert('b' == ch_Rfpvfvt.p2) +val ch_Rnf_pvf = new Rnf_pvf('a', 'b') +val i_Rnf_pvf = new Rnf_pvf(1, 2) -val ch_Rfpvfvf = new Rfpvfvf('a', 'b') -val i_Rfpvfvf = new Rfpvfvf(1, 2) -assert(2 == i_Rfpvfvf.a) -assert('b' == ch_Rfpvfvf.a) +val ch_Rnf_vt = new Rnf_vt('a', 'b') +val i_Rnf_vt = new Rnf_vt(1, 2) +assert(2 == i_Rnf_vt.a) +assert('b' == ch_Rnf_vt.a) +assert(2 == i_Rnf_vt.p2) +assert('b' == ch_Rnf_vt.p2) -val ch_Rfpvfnt = new Rfpvfnt('a', 'b') -val i_Rfpvfnt = new Rfpvfnt(1, 2) -assert(2 == i_Rfpvfnt.p2) -assert('b' == ch_Rfpvfnt.p2) +val ch_Rnf_vf = new Rnf_vf('a', 'b') +val i_Rnf_vf = new Rnf_vf(1, 2) +assert(2 == i_Rnf_vf.a) +assert('b' == ch_Rnf_vf.a) -val ch_Rfpvfnf = new Rfpvfnf('a', 'b') -val i_Rfpvfnf = new Rfpvfnf(1, 2) +val ch_Rnf_nt = new Rnf_nt('a', 'b') +val i_Rnf_nt = new Rnf_nt(1, 2) +assert(2 == i_Rnf_nt.p2) +assert('b' == ch_Rnf_nt.p2) -val ch_Rfvtpvt = new Rfvtpvt('a', 'b') -val i_Rfvtpvt = new Rfvtpvt(1, 2) -assert(1 == i_Rfvtpvt.`a b`) -assert('a' == ch_Rfvtpvt.`a b`) -assert(1 == i_Rfvtpvt.p1) -assert(2 == i_Rfvtpvt.p2) -assert('a' == ch_Rfvtpvt.p1) -assert('b' == ch_Rfvtpvt.p2) - -val ch_Rfvtpvf = new Rfvtpvf('a', 'b') -val i_Rfvtpvf = new Rfvtpvf(1, 2) -assert(1 == i_Rfvtpvf.`a b`) -assert('a' == ch_Rfvtpvf.`a b`) -assert(1 == i_Rfvtpvf.p1) -assert('a' == ch_Rfvtpvf.p1) - - -val ch_Rfvtvt = new Rfvtvt('a', 'b') -val i_Rfvtvt = new Rfvtvt(1, 2) -assert(1 == i_Rfvtvt.`a b`) -assert(2 == i_Rfvtvt.a) -assert('a' == ch_Rfvtvt.`a b`) -assert('b' == ch_Rfvtvt.a) -assert(1 == i_Rfvtvt.p1) -assert(2 == i_Rfvtvt.p2) -assert('a' == ch_Rfvtvt.p1) -assert('b' == ch_Rfvtvt.p2) - - -val ch_Rfvtvf = new Rfvtvf('a', 'b') -val i_Rfvtvf = new Rfvtvf(1, 2) -assert(1 == i_Rfvtvf.`a b`) -assert(2 == i_Rfvtvf.a) -assert('a' == ch_Rfvtvf.`a b`) -assert('b' == ch_Rfvtvf.a) -assert(1 == i_Rfvtvf.p1) -assert('a' == ch_Rfvtvf.p1) - - -val ch_Rfvtnt = new Rfvtnt('a', 'b') -val i_Rfvtnt = new Rfvtnt(1, 2) -assert(1 == i_Rfvtnt.`a b`) -assert('a' == ch_Rfvtnt.`a b`) -assert(1 == i_Rfvtnt.p1) -assert(2 == i_Rfvtnt.p2) -assert('a' == ch_Rfvtnt.p1) -assert('b' == ch_Rfvtnt.p2) - - -val ch_Rfvtnf = new Rfvtnf('a', 'b') -val i_Rfvtnf = new Rfvtnf(1, 2) -assert(1 == i_Rfvtnf.`a b`) -assert('a' == ch_Rfvtnf.`a b`) -assert(1 == i_Rfvtnf.p1) -assert('a' == ch_Rfvtnf.p1) - - -val ch_Rfvfpvt = new Rfvfpvt('a', 'b') -val i_Rfvfpvt = new Rfvfpvt(1, 2) -assert(1 == i_Rfvfpvt.`a b`) -assert('a' == ch_Rfvfpvt.`a b`) -assert(2 == i_Rfvfpvt.p2) -assert('b' == ch_Rfvfpvt.p2) - - -val ch_Rfvfpvf = new Rfvfpvf('a', 'b') -val i_Rfvfpvf = new Rfvfpvf(1, 2) -assert(1 == i_Rfvfpvf.`a b`) -assert('a' == ch_Rfvfpvf.`a b`) - - -val ch_Rfvfvt = new Rfvfvt('a', 'b') -val i_Rfvfvt = new Rfvfvt(1, 2) -assert(1 == i_Rfvfvt.`a b`) -assert(2 == i_Rfvfvt.a) -assert('a' == ch_Rfvfvt.`a b`) -assert('b' == ch_Rfvfvt.a) -assert(2 == i_Rfvfvt.p2) -assert('b' == ch_Rfvfvt.p2) - - -val ch_Rfvfvf = new Rfvfvf('a', 'b') -val i_Rfvfvf = new Rfvfvf(1, 2) -assert(1 == i_Rfvfvf.`a b`) -assert(2 == i_Rfvfvf.a) -assert('a' == ch_Rfvfvf.`a b`) -assert('b' == ch_Rfvfvf.a) - - -val ch_Rfvfnt = new Rfvfnt('a', 'b') -val i_Rfvfnt = new Rfvfnt(1, 2) -assert(1 == i_Rfvfnt.`a b`) -assert('a' == ch_Rfvfnt.`a b`) -assert(2 == i_Rfvfnt.p2) -assert('b' == ch_Rfvfnt.p2) - - -val ch_Rfvfnf = new Rfvfnf('a', 'b') -val i_Rfvfnf = new Rfvfnf(1, 2) -assert(1 == i_Rfvfnf.`a b`) -assert('a' == ch_Rfvfnf.`a b`) - - -val ch_Rfntpvt = new Rfntpvt('a', 'b') -val i_Rfntpvt = new Rfntpvt(1, 2) -assert(1 == i_Rfntpvt.p1) -assert(2 == i_Rfntpvt.p2) -assert('a' == ch_Rfntpvt.p1) -assert('b' == ch_Rfntpvt.p2) - - -val ch_Rfntpvf = new Rfntpvf('a', 'b') -val i_Rfntpvf = new Rfntpvf(1, 2) -assert(1 == i_Rfntpvf.p1) -assert('a' == ch_Rfntpvf.p1) - - -val ch_Rfntvt = new Rfntvt('a', 'b') -val i_Rfntvt = new Rfntvt(1, 2) -assert(2 == i_Rfntvt.a) -assert('b' == ch_Rfntvt.a) -assert(1 == i_Rfntvt.p1) -assert(2 == i_Rfntvt.p2) -assert('a' == ch_Rfntvt.p1) -assert('b' == ch_Rfntvt.p2) - - -val ch_Rfntvf = new Rfntvf('a', 'b') -val i_Rfntvf = new Rfntvf(1, 2) -assert(2 == i_Rfntvf.a) -assert('b' == ch_Rfntvf.a) -assert(1 == i_Rfntvf.p1) -assert('a' == ch_Rfntvf.p1) - - -val ch_Rfntnt = new Rfntnt('a', 'b') -val i_Rfntnt = new Rfntnt(1, 2) -assert(1 == i_Rfntnt.p1) -assert(2 == i_Rfntnt.p2) -assert('a' == ch_Rfntnt.p1) -assert('b' == ch_Rfntnt.p2) - - -val ch_Rfntnf = new Rfntnf('a', 'b') -val i_Rfntnf = new Rfntnf(1, 2) -assert(1 == i_Rfntnf.p1) -assert('a' == ch_Rfntnf.p1) - - -val ch_Rfnfpvt = new Rfnfpvt('a', 'b') -val i_Rfnfpvt = new Rfnfpvt(1, 2) -assert(2 == i_Rfnfpvt.p2) -assert('b' == ch_Rfnfpvt.p2) - - -val ch_Rfnfpvf = new Rfnfpvf('a', 'b') -val i_Rfnfpvf = new Rfnfpvf(1, 2) - - -val ch_Rfnfvt = new Rfnfvt('a', 'b') -val i_Rfnfvt = new Rfnfvt(1, 2) -assert(2 == i_Rfnfvt.a) -assert('b' == ch_Rfnfvt.a) -assert(2 == i_Rfnfvt.p2) -assert('b' == ch_Rfnfvt.p2) - - -val ch_Rfnfvf = new Rfnfvf('a', 'b') -val i_Rfnfvf = new Rfnfvf(1, 2) -assert(2 == i_Rfnfvf.a) -assert('b' == ch_Rfnfvf.a) - - -val ch_Rfnfnt = new Rfnfnt('a', 'b') -val i_Rfnfnt = new Rfnfnt(1, 2) -assert(2 == i_Rfnfnt.p2) -assert('b' == ch_Rfnfnt.p2) - - -val ch_Rfnfnf = new Rfnfnf('a', 'b') -val i_Rfnfnf = new Rfnfnf(1, 2) +val ch_Rnf_nf = new Rnf_nf('a', 'b') +val i_Rnf_nf = new Rnf_nf(1, 2) TestJoint.joint() } diff --git a/test/files/run/t8831_many/generator.scala b/test/files/run/t8831_many/generator.scala index 28defb5620d1..287dcde8f24c 100644 --- a/test/files/run/t8831_many/generator.scala +++ b/test/files/run/t8831_many/generator.scala @@ -1,11 +1,11 @@ //Generate the classes and assertions under test. -case class TestCase(classType: String, specialized: Boolean, p1: ParamConfig, p2: ParamConfig) { - val className = s"${classType.headOption.getOrElse('r')}${specialized.toString().head}${abbr(p1)}${abbr(p2)}".capitalize - val tparams = if (specialized) "[@specialized(Int) A, @specialized(Int) B]" else "[A, B]" +case class TestCase(classType: String, p1: ParamConfig, p2: ParamConfig) { + val className = s"${classType.headOption.getOrElse('r')}${abbr(p1)}_${abbr(p2)}".capitalize + val tParams = "[@specialized(Int) A, @specialized(Int) B]" def abbr(p: ParamConfig): String = p.modifier.split(' ').toSeq.map(_.headOption.getOrElse('n')).mkString + p.accessed.toString().head //def access(param: ParamConfig, name: String) = if(param.accessed) def decl(param: ParamConfig): String = param.aliasName.map(n => s"val $n = ${param.constructorName}\n").getOrElse("") - def renderClass: String = s"""$classType class $className$tparams(${p1.modifier} ${p1.constructorName}: A, ${p2.modifier} a: B){ + def renderClass: String = s"""$classType class $className$tParams(${p1.modifier} ${p1.constructorName}: A, ${p2.modifier} a: B){ ${decl(p1)}${decl(p2)} }""" @@ -52,11 +52,9 @@ object Generator { val configurations = for { classConfig <- List("case", "") - specialized <- List(true, false) p1config <- paramConfigurations("`a b`", "p1") p2config <- paramConfigurations("a", "p2") - if (!(specialized && !(p1config.accessed || p2config.accessed))) - } yield TestCase(classConfig, specialized, p1config, p2config) + } yield TestCase(classConfig, p1config, p2config) def main(args: Array[String]): Unit = { import java.io.File