CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-scala-js--scalajs-junit-test-runtime

JUnit test runtime for Scala.js - provides the runtime infrastructure for running JUnit tests compiled with Scala.js

—

Pending
Overview
Eval results
Files

array-assertions.mddocs/

Array Assertions

JUnit provides specialized assertion methods for comparing arrays element-by-element. These methods offer detailed failure messages showing exactly which elements differ and support different array types including primitive arrays and object arrays.

Object Array Assertions

def assertArrayEquals(expecteds: Array[AnyRef], actuals: Array[AnyRef]): Unit
def assertArrayEquals(message: String, expecteds: Array[AnyRef], actuals: Array[AnyRef]): Unit

Usage:

val expected = Array("apple", "banana", "cherry")
val actual = fruitProcessor.getSortedFruits()

assertArrayEquals(expected, actual)
assertArrayEquals("Fruit sorting failed", expected, actual)

Primitive Array Assertions

Boolean Arrays

def assertArrayEquals(expecteds: Array[Boolean], actuals: Array[Boolean]): Unit
def assertArrayEquals(message: String, expecteds: Array[Boolean], actuals: Array[Boolean]): Unit

Usage:

val expected = Array(true, false, true, false)
val actual = validator.validateInputs(Array("valid", "invalid", "valid", "invalid"))

assertArrayEquals("Validation results mismatch", expected, actual)

Numeric Arrays

// Byte arrays
def assertArrayEquals(expecteds: Array[Byte], actuals: Array[Byte]): Unit
def assertArrayEquals(message: String, expecteds: Array[Byte], actuals: Array[Byte]): Unit

// Character arrays  
def assertArrayEquals(expecteds: Array[Char], actuals: Array[Char]): Unit
def assertArrayEquals(message: String, expecteds: Array[Char], actuals: Array[Char]): Unit

// Short arrays
def assertArrayEquals(expecteds: Array[Short], actuals: Array[Short]): Unit
def assertArrayEquals(message: String, expecteds: Array[Short], actuals: Array[Short]): Unit

// Integer arrays
def assertArrayEquals(expecteds: Array[Int], actuals: Array[Int]): Unit
def assertArrayEquals(message: String, expecteds: Array[Int], actuals: Array[Int]): Unit

// Long arrays
def assertArrayEquals(expecteds: Array[Long], actuals: Array[Long]): Unit
def assertArrayEquals(message: String, expecteds: Array[Long], actuals: Array[Long]): Unit

Usage Examples:

// Integer array comparison
val expectedScores = Array(95, 87, 92, 78)
val actualScores = grader.calculateScores(submissions)
assertArrayEquals("Score calculation failed", expectedScores, actualScores)

// Byte array comparison (useful for binary data)
val expectedBytes = Array[Byte](0x48, 0x65, 0x6C, 0x6C, 0x6F) // "Hello" in ASCII
val actualBytes = encoder.encode("Hello")
assertArrayEquals(expectedBytes, actualBytes)

// Character array comparison
val expectedChars = Array('H', 'e', 'l', 'l', 'o')
val actualChars = stringProcessor.toCharArray("Hello")
assertArrayEquals(expectedChars, actualChars)

Floating-Point Array Assertions

Double Arrays with Delta

def assertArrayEquals(expecteds: Array[Double], actuals: Array[Double], delta: Double): Unit
def assertArrayEquals(message: String, expecteds: Array[Double], actuals: Array[Double], delta: Double): Unit

Usage:

val expectedValues = Array(3.14159, 2.71828, 1.41421)
val actualValues = calculator.computeMathConstants()

assertArrayEquals("Math constants calculation", expectedValues, actualValues, 0.001)

Float Arrays with Delta

def assertArrayEquals(expecteds: Array[Float], actuals: Array[Float], delta: Float): Unit
def assertArrayEquals(message: String, expecteds: Array[Float], actuals: Array[Float], delta: Float): Unit

Usage:

val expectedCoordinates = Array(1.5f, 2.3f, 4.7f)
val actualCoordinates = geometryEngine.calculateCoordinates(shape)

assertArrayEquals("Coordinate calculation failed", expectedCoordinates, actualCoordinates, 0.01f)

Error Reporting

Array assertions provide detailed error messages showing:

  1. Array length differences:
val expected = Array(1, 2, 3)
val actual = Array(1, 2)
assertArrayEquals(expected, actual)
// Error: arrays length differ expected:<3> but was:<2>
  1. Element-specific differences:
val expected = Array("a", "b", "c")
val actual = Array("a", "x", "c")
assertArrayEquals(expected, actual)
// Error: arrays first differed at element [1]; expected:<b> but was:<x>
  1. Multi-dimensional array support:
val expected = Array(Array(1, 2), Array(3, 4))
val actual = Array(Array(1, 2), Array(3, 5))
assertArrayEquals(expected, actual)
// Error: arrays first differed at element [1][1]; expected:<4> but was:<5>

Complex Array Testing Examples

Testing Array Transformations

class ArrayProcessorTest {
  @Test
  def shouldSortIntegerArray(): Unit = {
    val input = Array(3, 1, 4, 1, 5, 9, 2, 6)
    val expected = Array(1, 1, 2, 3, 4, 5, 6, 9)
    val actual = ArrayProcessor.sort(input)
    
    assertArrayEquals("Array should be sorted in ascending order", expected, actual)
  }
  
  @Test
  def shouldFilterEvenNumbers(): Unit = {
    val input = Array(1, 2, 3, 4, 5, 6, 7, 8)
    val expected = Array(2, 4, 6, 8)
    val actual = ArrayProcessor.filterEven(input)
    
    assertArrayEquals(expected, actual)
  }
  
  @Test
  def shouldComputeMovingAverage(): Unit = {
    val input = Array(1.0, 2.0, 3.0, 4.0, 5.0)
    val expected = Array(1.5, 2.5, 3.5, 4.5) // Window size 2
    val actual = StatisticsEngine.movingAverage(input, windowSize = 2)
    
    assertArrayEquals("Moving average calculation", expected, actual, 0.001)
  }
}

Testing Binary Data

class BinaryDataTest {
  @Test
  def shouldEncodeStringToBytes(): Unit = {
    val input = "Hello, 世界"
    val expected = Array[Byte](-2, -1, 0, 72, 0, 101, 0, 108, 0, 108, 0, 111, 0, 44, 0, 32, 78, 22, 117, -26)
    val actual = BinaryEncoder.encodeUTF16(input)
    
    assertArrayEquals("UTF-16 encoding failed", expected, actual)
  }
  
  @Test
  def shouldCompressData(): Unit = {
    val originalData = "Hello World! ".repeat(100).getBytes("UTF-8")
    val compressed = CompressionEngine.compress(originalData)
    val decompressed = CompressionEngine.decompress(compressed)
    
    assertArrayEquals("Compression round-trip failed", originalData, decompressed)
  }
}

Testing Matrix Operations

class MatrixTest {
  @Test
  def shouldMultiplyMatrices(): Unit = {
    val matrixA = Array(
      Array(1, 2),
      Array(3, 4)
    )
    val matrixB = Array(
      Array(5, 6),
      Array(7, 8)
    )
    val expected = Array(
      Array(19, 22),
      Array(43, 50)
    )
    
    val actual = MatrixOperations.multiply(matrixA, matrixB)
    
    // Compare each row
    for (i <- expected.indices) {
      assertArrayEquals(s"Row $i multiplication failed", expected(i), actual(i))
    }
  }
}

Internal Implementation Details

Array assertions use specialized comparison criteria:

// Internal comparison classes
abstract class ComparisonCriteria {
  def arrayEquals(message: String, expecteds: AnyRef, actuals: AnyRef): Unit
  protected def assertElementsEqual(expected: AnyRef, actual: AnyRef): Unit
}

class ExactComparisonCriteria extends ComparisonCriteria {
  // Uses Objects.equals for exact comparison
}

class InexactComparisonCriteria(delta: Double) extends ComparisonCriteria {
  // Uses delta tolerance for floating-point comparison
}

Best Practices

  1. Use Appropriate Delta: For floating-point arrays, choose delta values that account for precision limits:
// Too strict - may fail due to precision
assertArrayEquals(expected, actual, 0.0)

// Appropriate for most calculations  
assertArrayEquals(expected, actual, 1e-10)

// Too loose - may miss real errors
assertArrayEquals(expected, actual, 1.0)
  1. Test Array Properties: Consider testing length, ordering, and content separately:
// Test length first
assertEquals("Array length mismatch", expected.length, actual.length)

// Then test contents
assertArrayEquals("Array contents differ", expected, actual)
  1. Handle Null Arrays: Be explicit about null array handling:
// Both null - passes
assertArrayEquals(null, null)

// One null - fails with clear message
assertArrayEquals("Expected array", expectedArray, null)
  1. Use Descriptive Messages: Include context about what the array represents:
assertArrayEquals("User permission flags", expectedPermissions, actualPermissions)
assertArrayEquals("Pixel RGB values", expectedPixels, actualPixels)
  1. Consider Collection Assertions: For more complex array testing, consider converting to collections:
import scala.collection.JavaConverters._

// More flexible collection assertions
assertEquals(expectedArray.toList, actualArray.toList)
assertThat(actualArray.toList, hasItems(expectedElements: _*))

Install with Tessl CLI

npx tessl i tessl/maven-org-scala-js--scalajs-junit-test-runtime

docs

array-assertions.md

core-assertions.md

exception-handling.md

hamcrest-matchers.md

index.md

test-assumptions.md

test-lifecycle.md

test-runners.md

tile.json