Move tests with fixed ci

.scalafmt.conf

@@ -1,5 +1,40 @@
 version = 3.6.0
 runner.dialect = scala212
 align.preset = some
-maxColumn = 120
+align.tokens."+" = [
+    {
+        code = "="
+        owners = [{
+            regex = "Defn\\.Val"
+        }]
+    }
+    {
+        code = ":="
+        owners = [{
+            regex = "Term\\.ApplyInfix"
+            parents = ["Term\\.Block|Template"]
+        }]
+    }
+    {
+        code = "#="
+        owners = [{
+            regex = "Term\\.ApplyInfix"
+            parents = ["Term\\.Block|Template"]
+        }]
+    }
+    {
+        code = "port"
+        owners = [{
+            regex = "Term\\.ApplyInfix"
+            parents = ["Defn\\.Val"]
+        }]
+    }
+    {
+        code = "->"
+        owners = [{
+            regex = "Term\\.ApplyInfix"
+        }]
+    }
+]
 docstrings.wrap = no
+docstrings.oneline = fold

build.sbt

@@ -126,14 +126,16 @@ val defaultSettingsWithPlugin = defaultSettings ++ Seq(
   }.value
 )
 
-lazy val core = (project in file("core"))
+lazy val core: Project = (project in file("core"))
   .dependsOn(idslplugin)
   .settings(
     defaultSettingsWithPlugin,
     name := "SpinalHDL-core",
     libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value,
     libraryDependencies += "com.github.scopt" %% "scopt" % "3.7.1",
     libraryDependencies += "com.lihaoyi" %% "sourcecode" % "0.2.7",
+    Test / unmanagedClasspath ++= (LocalProject("tester") / Compile / fullClasspath).value,
+    Test / unmanagedClasspath ++= (LocalProject("lib") / Compile / fullClasspath).value,
 
     resolvers += Resolver.sonatypeRepo("public"),
     version := SpinalVersion.core,
@@ -153,18 +155,17 @@ lazy val core = (project in file("core"))
   )
   .dependsOn(sim)
 
-lazy val lib = (project in file("lib"))
+lazy val lib: Project = (project in file("lib"))
   .settings(
     defaultSettingsWithPlugin,
     name := "SpinalHDL-lib",
     libraryDependencies += "commons-io" % "commons-io" % "2.4",
-    version := SpinalVersion.lib
+    version := SpinalVersion.lib,
+    Test / unmanagedClasspath ++= (LocalProject("tester") / Compile / fullClasspath).value
   )
-  .dependsOn (sim, core)
+  .dependsOn(sim, core)
 
-
-
-lazy val tester = (project in file("tester"))
+lazy val tester: Project = (project in file("tester"))
   .settings(
     defaultSettingsWithPlugin,
     name := "SpinalHDL-tester",

core/src/main/scala/spinal/core/Vec.scala

@@ -311,7 +311,7 @@ class VecBitwisePimper[T <: Data with BitwiseOp[T]](pimped : Vec[T]) extends Bit
 
   private def map2with(f: (T, T) => T)(other: Vec[T]): Vec[T] = {
     if (pimped.length != other.length)
-      SpinalError(s"Cannot apply a bitwize opration on vectors with different size (${pimped.length} vs ${other.length})")
+      SpinalError(s"Cannot apply a bitwize operation on vectors with different sizes (${pimped.length} vs ${other.length})")
     Vec((pimped, other).zipped.map(f))
   }
 }

core/src/test/scala/integration/CommonTester.scala

@@ -0,0 +1,115 @@
+package integration
+
+import spinal.tester.SpinalTesterCocotbBase
+
+import spinal.core._
+
+object CommonTester {
+  class BundleA() extends Bundle {
+    val bod = new Bundle {
+      val gggg = Bool()
+      val aosi = UInt(3 bit)
+    }
+    val ahe = Bool()
+    val zwg = Bool()
+  }
+
+  case class BundleAA() extends BundleA {
+    val vsw  = Bool()
+    val lwee = UInt(5 bit)
+  }
+
+  case class CommonTester() extends Component {
+    val io = new Bundle {
+      val conds = in port Vec(Bool(), 8)
+
+      val inUIntA      = in  port UInt(8 bit)
+      val inUIntB      = in  port UInt(8 bit)
+      val outUIntAdder = out port UInt()
+
+      val inAA      = in  port BundleAA()
+      val inAABits  = in  port Bits(BundleAA().getBitsWidth bit)
+      val outAA     = out port BundleAA()
+      val outAABits = out port Bits(BundleAA().getBitsWidth bit)
+
+      val complexLiteral = out port UInt(16 bit)
+
+      val assign = new Bundle {
+        val sel      = in  port Vec(UInt(4 bit), 4)
+        val bitDemux = out port Bits(16 bit)
+
+        def doIt(): Unit = {
+          bitDemux         := B(0)
+          bitDemux(sel(0)) := conds(0)
+
+          when(conds(1)) {
+            bitDemux(sel(1)) := conds(2)
+          } elsewhen (conds(3)) {
+            bitDemux(sel(0)) := conds(4)
+          }
+
+          when(conds(5)) {
+            bitDemux(sel(1)) := conds(6)
+          }
+
+          bitDemux(5) := True
+        }
+      }
+
+      def doIt(): Unit = {
+        assign.doIt()
+      }
+    }
+
+    io.doIt()
+
+    io.outAA.assignFromBits(io.inAABits)
+    io.outAABits := io.inAA.asBits
+
+    io.complexLiteral(15 downto 4)  := 0x70
+    io.complexLiteral(15 downto 12) := (U(2) + U(1)).resized
+    io.complexLiteral(6)            := True
+    io.complexLiteral(3)            := True
+    io.complexLiteral(5)            := True
+    io.complexLiteral(3 downto 0)   := 2
+    io.complexLiteral(13)           := False
+
+    def combAdderFunc(x: UInt, y: UInt): UInt = {
+      val ret  = UInt(widthOf(x) max widthOf(y) bits)
+      val size = io.inUIntA.getWidth
+
+      var c = False
+      for (i <- 0 until size) {
+        val a = x(i)
+        val b = y(i)
+        ret(i) := a ^ b ^ c
+        c \= (a & b) | (a & c) | (b & c)
+      }
+
+      ret
+    }
+
+    io.outUIntAdder := combAdderFunc(io.inUIntA, io.inUIntB)
+
+    // Clone test
+    case class MyBundle(paramBool: Bool, asd: Int) extends Bundle {
+      val a = cloneOf(paramBool)
+    }
+
+    case class MyBundle2() extends Bundle {
+      val a = Bool()
+    }
+
+    cloneOf(MyBundle(True, 1))
+    cloneOf(MyBundle2())
+  }
+}
+
+class CommonTesterCocotbBoot extends SpinalTesterCocotbBase {
+  override def getName: String = "CommonTester"
+
+  override def createToplevel: Component = new CommonTester.CommonTester
+
+  override def pythonTestLocation: String =
+    "tester/src/test/python/spinal/CommonTester"
+}

tester/src/test/scala/spinal/tester/scalatest/OperatorTester.scala → core/src/test/scala/integration/OperatorTester.scala

@@ -1,26 +1,8 @@
-/*
- * SpinalHDL
- * Copyright (c) Dolu, All rights reserved.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3.0 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.
- */
-
-package spinal.tester.scalatest
+package integration
+
+import spinal.tester.SpinalTesterCocotbBase
 
 import spinal.core._
-import spinal.lib._
-import spinal.tester.scalatest.OperatorTester.OperatorTester
 
 object OperatorTester {
   object State extends SpinalEnum{
@@ -295,7 +277,7 @@ object OperatorTester {
 
 class OperatorTesterCocotbBoot extends SpinalTesterCocotbBase {
   override def getName: String = "OperatorTester"
-  override def createToplevel: Component =  new OperatorTester.OperatorTester
+  override def createToplevel: Component = new OperatorTester.OperatorTester
   override def pythonTestLocation: String = "tester/src/test/python/spinal/OperatorTester"
 }
 

tester/src/test/scala/spinal/tester/scalatest/ZeroWidthTester.scala → core/src/test/scala/integration/ZeroWidthTester.scala

@@ -16,16 +16,15 @@
  * License along with this library.
  */
 
-package spinal.tester.scalatest
+package integration
+
+import spinal.tester.SpinalTesterCocotbBase
 
 import spinal.core._
-import spinal.lib._
 
 import scala.io.Source
 
 object ZeroWidthTester {
-
-
   class ZeroWidthTester extends Component {
     val uint8 = in UInt(8 bits)
     val sint8 = in SInt(8 bits)
@@ -51,8 +50,6 @@ object ZeroWidthTester {
     val sint08ShiftLeftUint  = out(sint0 << uint8)
     val bits08ShiftLeftUint  = out(bits0 << uint8)
 
-
-
     val uint08Equals    = out(uint0 === uint8)
     val uint08NotEquals = out(uint0 =/= uint8)
 
@@ -69,7 +66,6 @@ object ZeroWidthTester {
     val uint08Bigger        = out(uint0 > uint8)
     val uint08BiggerEquals  = out(uint0 >= uint8)
 
-
     val sint08Equals= out(sint0 === sint8)
     val sint08NotEquals = out(sint0 =/= sint8)
 
@@ -86,16 +82,13 @@ object ZeroWidthTester {
     val sint08Bigger = out(sint0 > sint8)
     val sint08BiggerEquals = out(sint0 >= sint8)
 
-
-
     val bits08Equals= out(0 === bits8)
     val bits08NotEquals = out(0 =/= bits8)
 
     val bits08And = out(bits0.resized & bits8)
     val bits08Or = out(bits0.resized | bits8)
     val bits08Xor = out(bits0.resized ^ bits8)
 
-
     val uint80ShiftLeftUint  = out(uint8 >> uint0)
     val sint80ShiftLeftUint  = out(sint8 >> uint0)
     val bits80ShiftLeftUint  = out(bits8 >> uint0)
@@ -139,14 +132,12 @@ object ZeroWidthTester {
     val bits80Or = out(bits8 | bits0.resized)
     val bits80Xor = out(bits8 ^ bits0.resized)
 
-
     val bitsResizeBigger  = out(bits0.resize(16))
     val uintResizeBigger  = out(uint0.resize(16))
     val sintResizeBigger  = out(sint0.resize(16))
 
     val bits08Cat = out(bits0 ## bits8)
     val bits80Cat = out(bits8 ## bits0)
-
   }
 }
 
@@ -174,4 +165,4 @@ class ZeroWidthTesterCocotbBoot extends SpinalTesterCocotbBase {
       }
     }
   }
-}
+}

tester/src/test/scala/spinal/tester/scalatest/SpinalSimAFixTester.scala → core/src/test/scala/spinal/core/AFix.scala

@@ -1,9 +1,8 @@
-package spinal.tester.scalatest
+package spinal.core
 
-import spinal.core._
-import org.scalatest.funsuite.AnyFunSuite
 import spinal.core.sim._
 
+import org.scalatest.funsuite.AnyFunSuite
 import java.math.MathContext
 import scala.collection.mutable
 import scala.math.BigDecimal.RoundingMode

core/src/test/scala/spinal/core/Area.scala

@@ -0,0 +1,34 @@
+package spinal.core
+
+import org.scalatest.funsuite.AnyFunSuite
+
+import spinal.core.sim._
+
+class AreaTester extends AnyFunSuite {
+  test("SlowArea") {
+    SimConfig
+      .withConfig(
+        SpinalConfig(defaultClockDomainFrequency = FixedFrequency(4000 Hz))
+      )
+      .compile(new Component {
+        val counter = out(RegInit(U"0000"))
+        counter := counter + 1
+        assert(clockDomain.samplingRate.getValue.toInt == 4000)
+
+        val slowArea = new SlowArea(4) {
+          val counter = out(RegInit(U"0000"))
+          counter := counter + 1
+          assert(clockDomain.samplingRate.getValue.toInt == 1000)
+        }
+      })
+      .doSim { dut =>
+        dut.clockDomain.forkStimulus(10)
+
+        for (i <- 0 until 1000) {
+          dut.clockDomain.waitSampling()
+          assert(dut.counter.toInt == i % 16)
+          assert(dut.slowArea.counter.toInt == (i - 1) / 4 % 16)
+        }
+      }
+  }
+}