test: Cover coerced binding storage layouts

b4d4c376122f0d2667418777cd0959a54bcff658a64b28375a9fcb7fa24e43e3
Alexis Sellier committed ago 1 parent f7523bce
test/tests/binding.storage.rad added +35 -0
1 + 
//! returns: 0
2 + 

    

  
    

      
      3
      +
      
/// Aggregate whose fields need initialized storage.

    

  
    

      
      4
      +
      
record Pair: Copy {

    

  
    

      
      5
      +
      
    /// First summand.

    

  
    

      
      6
      +
      
    first: u32,

    

  
    

      
      7
      +
      
    /// Second summand.

    

  
    

      
      8
      +
      
    second: u64,

    

  
    

      
      9
      +
      
}

    

  
    

      
      10
      +
      

    

  
    

      
      11
      +
      
/// Check initialized values and storage layouts.

    

  
    

      
      12
      +
      
@default unsafe fn main() -> u32 {

    

  
    

      
      13
      +
      
    let mut pair: Pair = undefined;

    

  
    

      
      14
      +
      
    set pair.first = 40;

    

  
    

      
      15
      +
      
    set pair.second = 0x1122334455667788;

    

  
    

      
      16
      +
      
    let numbers: [u32; 2] = [40, 2];

    

  
    

      
      17
      +
      
    assert pair.first == numbers[0];

    

  
    

      
      18
      +
      
    assert pair.second == 0x1122334455667788;

    

  
    

      
      19
      +
      
    let wrapped: ?Pair = pair;

    

  
    

      
      20
      +
      
    let value = wrapped else panic;

    

  
    

      
      21
      +
      
    assert value.first == 40;

    

  
    

      
      22
      +
      
    assert value.second == 0x1122334455667788;

    

  
    

      
      23
      +
      
    let scalar: u32 = 42;

    

  
    

      
      24
      +
      
    let mut optional: ?u32 = scalar;

    

  
    

      
      25
      +
      
    assert readOptional(&optional) == 42;

    

  
    

      
      26
      +
      
    set optional = nil;

    

  
    

      
      27
      +
      
    assert optional == nil;

    

  
    

      
      28
      +
      
    return 0;

    

  
    

      
      29
      +
      
}

    

  
    

      
      30
      +
      

    

  
    

      
      31
      +
      
/// Read a coerced optional through its stored representation.

    

  
    

      
      32
      +
      
fn readOptional(value: &?u32) -> u32 {

    

  
    

      
      33
      +
      
    let present = *value else return 0;

    

  
    

      
      34
      +
      
    return present;

    

  
    

      
      35
      +
      
}