From b28e1f1613bff97d3ced3478d464c13462953641 Mon Sep 17 00:00:00 2001 From: Martijn Hoekstra Date: Sun, 31 May 2020 16:39:39 +0200 Subject: [PATCH] generate test cases --- test/files/run/t8831_many/Classes_1.scala | 2011 +++++++++++++++++++++ test/files/run/t8831_many/Tests_2.scala | 1488 +++++++++++++++ test/files/run/t8831_many/generator.scala | 93 + 3 files changed, 3592 insertions(+) create mode 100644 test/files/run/t8831_many/Classes_1.scala create mode 100644 test/files/run/t8831_many/Tests_2.scala create mode 100644 test/files/run/t8831_many/generator.scala diff --git a/test/files/run/t8831_many/Classes_1.scala b/test/files/run/t8831_many/Classes_1.scala new file mode 100644 index 000000000000..1f10723e8898 --- /dev/null +++ b/test/files/run/t8831_many/Classes_1.scala @@ -0,0 +1,2011 @@ +case class Ctpvtpvt[@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){ + val p1 = `a b` + + } +case class Ctpvtvt[@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){ + val p1 = `a b` + + } +case class Ctpvtnt[@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){ + val p1 = `a b` + + } +case class Ctpvfpvt[@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 Cfpvfvt[A, 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 Cfpvfnt[A, 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 Cfvtpvt[A, 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){ + val p1 = `a b` + + } +case class Cfvtvt[A, 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){ + val p1 = `a b` + + } +case class Cfvtnt[A, 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){ + val p1 = `a b` + + } +case class Cfvfpvt[A, 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 Cfvfvt[A, 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 Cfvfnt[A, B](val `a b`: A, a: B){ + val p2 = a + + } +case class Cfvfnf[A, B](val `a b`: A, a: B){ + + } +case class Cfntpvt[A, 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){ + val p1 = `a b` + + } +case class Cfntvt[A, 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){ + val p1 = `a b` + + } +case class Cfntnt[A, B]( `a b`: A, a: B){ + val p1 = `a b` +val p2 = a + + } +case class Cfntnf[A, B]( `a b`: A, a: B){ + val p1 = `a b` + + } +case class Cfnfpvt[A, 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 Cfnfvt[A, B]( `a b`: A, val a: B){ + val p2 = a + + } +case class Cfnfvf[A, B]( `a b`: A, val a: B){ + + } +case class Cfnfnt[A, B]( `a b`: A, a: B){ + val p2 = a + + } +case class Cfnfnf[A, B]( `a b`: A, a: B){ + + } + class Rtpvtpvt[@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){ + val p1 = `a b` + + } + class Rtpvtvt[@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){ + val p1 = `a b` + + } + class Rtpvtnt[@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){ + 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){ + 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 Rfpvfvt[A, 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 Rfpvfnt[A, B](private val `a b`: A, a: B){ + val p2 = a + + } + class Rfpvfnf[A, B](private val `a b`: A, a: B){ + + } + class Rfvtpvt[A, 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){ + val p1 = `a b` + + } + class Rfvtvt[A, 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){ + val p1 = `a b` + + } + class Rfvtnt[A, B](val `a b`: A, a: B){ + val p1 = `a b` +val p2 = a + + } + class Rfvtnf[A, B](val `a b`: A, a: B){ + val p1 = `a b` + + } + class Rfvfpvt[A, 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 Rfvfvt[A, B](val `a b`: A, val a: B){ + val p2 = a + + } + class Rfvfvf[A, B](val `a b`: A, val a: B){ + + } + class Rfvfnt[A, B](val `a b`: A, a: B){ + val p2 = a + + } + class Rfvfnf[A, B](val `a b`: A, a: B){ + + } + class Rfntpvt[A, 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){ + val p1 = `a b` + + } + class Rfntvt[A, B]( `a b`: A, val a: B){ + val p1 = `a b` +val p2 = a + + } + class Rfntvf[A, B]( `a b`: A, val a: B){ + val p1 = `a b` + + } + class Rfntnt[A, B]( `a b`: A, a: B){ + val p1 = `a b` +val p2 = a + + } + class Rfntnf[A, B]( `a b`: A, a: B){ + val p1 = `a b` + + } + class Rfnfpvt[A, B]( `a b`: A, private val a: B){ + val p2 = a + + } + class Rfnfpvf[A, B]( `a b`: A, private val a: B){ + + } + class Rfnfvt[A, B]( `a b`: A, val a: B){ + val p2 = a + + } + class Rfnfvf[A, B]( `a b`: A, val a: B){ + + } + class Rfnfnt[A, B]( `a b`: A, a: B){ + val p2 = a + + } + class Rfnfnf[A, 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_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_Rfpvfvf = new Rfpvfvf('a', 'b') +val i_Rfpvfvf = new Rfpvfvf(1, 2) +assert(2 == i_Rfpvfvf.a) +assert('b' == ch_Rfpvfvf.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_Rfpvfnf = new Rfpvfnf('a', 'b') +val i_Rfpvfnf = new Rfpvfnf(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_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) + + +}} diff --git a/test/files/run/t8831_many/Tests_2.scala b/test/files/run/t8831_many/Tests_2.scala new file mode 100644 index 000000000000..fba69ecabe56 --- /dev/null +++ b/test/files/run/t8831_many/Tests_2.scala @@ -0,0 +1,1488 @@ +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_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_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_Rfpvfvf = new Rfpvfvf('a', 'b') +val i_Rfpvfvf = new Rfpvfvf(1, 2) +assert(2 == i_Rfpvfvf.a) +assert('b' == ch_Rfpvfvf.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_Rfpvfnf = new Rfpvfnf('a', 'b') +val i_Rfpvfnf = new Rfpvfnf(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_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) + +TestJoint.joint() +} diff --git a/test/files/run/t8831_many/generator.scala b/test/files/run/t8831_many/generator.scala new file mode 100644 index 000000000000..28defb5620d1 --- /dev/null +++ b/test/files/run/t8831_many/generator.scala @@ -0,0 +1,93 @@ +//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]" + 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){ + ${decl(p1)}${decl(p2)} + }""" + + def accessConstr(p: ParamConfig) = Option(p).filterNot(p => p.modifier == "private val").filterNot(p => p.modifier == "" && classType == "").map(_.constructorName) + def testConstrCh(p: ParamConfig, expected: String) = accessConstr(p).map(name => s"assert($expected == ch_$className.$name)") + def testConstrI(p: ParamConfig, expected: String) = accessConstr(p).map(name => s"assert($expected == i_$className.$name)") + def testAliasCh(p: ParamConfig, expected: String) = p.aliasName.map(name => s"assert($expected == ch_$className.$name)") + def testAliasI(p: ParamConfig, expected: String) = p.aliasName.map(name => s"assert($expected == i_$className.$name)") + def testExtractors = Some(s"""val $className(extracted1i_$className, extracted2i_$className) = i_$className + |val $className(extracted1ch_$className, extracted2ch_$className) = ch_$className + |assert(1 == extracted1i_$className) + |assert(2 == extracted2i_$className) + |assert('a' == extracted1ch_$className) + |assert('b' == extracted2ch_$className) + |""".stripMargin).filter(_ => classType == "case") + val assertions = List( + testExtractors, + testConstrI(p1, "1"), + testConstrI(p2, "2"), + testConstrCh(p1, "'a'"), + testConstrCh(p2, "'b'"), + testAliasI(p1, "1"), + testAliasI(p2, "2"), + testAliasCh(p1, "'a'"), + testAliasCh(p2, "'b'"), + ).collect{ case Some(t) => t } + def renderTests: String = (instantiateChar :: instantiateInt :: assertions).mkString("\n", "\n", "\n") + def instantiateChar = s"val ch_$className = new $className('a', 'b')" + def instantiateInt = s"val i_$className = new $className(1, 2)" + +} + +case class ParamConfig(modifier: String, constructorName: String, aliasName: Option[String]) { + def accessed = aliasName.isDefined +} + +object Generator { + def paramConfigurations(constructorName: String, aliasName: String) = for { + modifier <- List("private val", "val", "") + accessed <- List(true, false) + } yield ParamConfig(modifier, constructorName, Option(aliasName).filter(_ => accessed)) + + def hasVal(p1: ParamConfig, p2: ParamConfig) = p1.modifier.contains("val") || p2.modifier.contains("val") + + 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) + + def main(args: Array[String]): Unit = { + import java.io.File + import java.io.PrintWriter + + val classes = new File("Classes_1.scala") + val tests = new File("Tests_2.scala") + val classWriter = new PrintWriter(classes) + val testWriter = new PrintWriter(tests) + + for(testClass <- configurations) { + classWriter.write(testClass.renderClass) + classWriter.write("\n") + } + + //test both separate and joint compilation. + + testWriter.write("object Test extends App {\n") + classWriter.write("object TestJoint {\n def joint(): Unit = {\n") + for(testClass <- configurations){ + classWriter.write(testClass.renderTests) + classWriter.write("\n") + testWriter.write(testClass.renderTests) + testWriter.write("\n") + } + classWriter.write("\n}}\n") + testWriter.write("TestJoint.joint()") + + testWriter.write("\n}\n") + classWriter.close() + testWriter.close() + + } +} \ No newline at end of file