# runtime_extract_value_literal

As a developer
I want to extract a $TYPE value
In order get the result I calculated with my phasm code

```py
@exported
def testEntry() -> $TYPE:
    return $VAL0
```

```py
expect(VAL0)
```

# runtime_extract_value_round_trip

As a developer
I want to extract a $TYPE value that I've input
In order let the code select a value that I've predefined

```py
@exported
def testEntry(x: $TYPE) -> $TYPE:
    return x
```

```py
expect(VAL0, given=[VAL0])
```

# module_constant_def_ok

As a developer
I want to define $TYPE module constants
In order to make hardcoded values more visible
and to make it easier to change hardcoded values

```py
CONSTANT: $TYPE = $VAL0

@exported
def testEntry() -> i32:
    return 9
```

```py
expect(9)
```

# module_constant_def_bad

As a developer
I want to receive a type error on an invalid assignment on a $TYPE module constant
In order to make debugging easier

```py
CONSTANT: (u32, ) = $VAL0
```

```py
if TYPE_NAME.startswith('tuple_') or TYPE_NAME.startswith('static_array_') or TYPE_NAME.startswith('dynamic_array_'):
    expect_type_error('Tuple element count mismatch')
else:
    expect_type_error('Must be tuple')
```

# function_result_is_literal_ok

As a developer
I want to use return a literal from a function
In order to define constants in a more dynamic way

```py
def drop_arg_return_9(x: $TYPE) -> i32:
    return 9

def constant() -> $TYPE:
    return $VAL0

@exported
def testEntry() -> i32:
    return drop_arg_return_9(constant())
```

```py
expect(9)
```

# function_result_is_literal_bad

As a developer
I want to receive a type error when returning a $TYPE literal for a function that doesn't return that type
In order to make debugging easier

```py
def drop_arg_return_9(x: (u32, )) -> i32:
    return 9

def constant() -> (u32, ):
    return $VAL0

@exported
def testEntry() -> i32:
    return drop_arg_return_9(constant())
```

```py
if TYPE_NAME.startswith('tuple_') or TYPE_NAME.startswith('static_array_') or TYPE_NAME.startswith('dynamic_array_'):
    expect_type_error('Tuple element count mismatch')
elif TYPE_NAME.startswith('struct_'):
    expect_type_error('Not the same type')
else:
    expect_type_error('Must be tuple')
```

# function_result_is_module_constant_ok

As a developer
I want to use return a $TYPE module constant from a function
In order to use my module constants in return statements

```py
CONSTANT: $TYPE = $VAL0

def helper(x: $TYPE) -> i32:
    return 9

def constant() -> $TYPE:
    return CONSTANT

@exported
def testEntry() -> i32:
    return helper(constant())
```

```py
expect(9)
```

# function_result_is_module_constant_bad

As a developer
I want to receive a type error when returning a $TYPE module constant for a function that doesn't return that type
In order to make debugging easier

```py
CONSTANT: $TYPE = $VAL0

def drop_arg_return_9(x: (u32, )) -> i32:
    return 9

def constant() -> (u32, ):
    return CONSTANT

@exported
def testEntry() -> i32:
    return drop_arg_return_9(constant())
```

```py
expect_type_error('Not the same type')
```

# function_result_is_arg_ok

As a developer
I want to use return a $TYPE function argument
In order to make it possible to select a value using a function

```py
CONSTANT: $TYPE = $VAL0

def drop_arg_return_9(x: $TYPE) -> i32:
    return 9

def select(x: $TYPE) -> $TYPE:
    return x

@exported
def testEntry() -> i32:
    return drop_arg_return_9(select(CONSTANT))
```

```py
expect(9)
```

# function_result_is_arg_bad

As a developer
I want to receive a type error when returning a $TYPE argument for a function that doesn't return that type
In order to make debugging easier

```py
def drop_arg_return_9(x: (u32, )) -> i32:
    return 9

def select(x: $TYPE) -> (u32, ):
    return x
```

```py
expect_type_error('Not the same type')
```

# function_arg_literal_ok

As a developer
I want to use a $TYPE literal by passing it to a function
In order to use a pre-existing function with the values I specify

```py
def helper(x: $TYPE) -> i32:
    return 9

@exported
def testEntry() -> i32:
    return helper($VAL0)
```

```py
expect(9)
```

# function_arg_literal_bad

As a developer
I want to receive a type error when passing a $TYPE literal to a function that does not accept it
In order to make debugging easier

```py
def helper(x: (u32, )) -> i32:
    return 9

@exported
def testEntry() -> i32:
    return helper($VAL0)
```

```py
if TYPE_NAME.startswith('tuple_') or TYPE_NAME.startswith('static_array_') or TYPE_NAME.startswith('dynamic_array_'):
    expect_type_error('Tuple element count mismatch')
elif TYPE_NAME.startswith('struct_'):
    expect_type_error('Not the same type')
else:
    expect_type_error('Must be tuple')
```

# function_arg_module_constant_def_ok

As a developer
I want to use a $TYPE module constant by passing it to a function
In order to use my defined value with a pre-existing function

```py
CONSTANT: $TYPE = $VAL0

def helper(x: $TYPE) -> i32:
    return 9

@exported
def testEntry() -> i32:
    return helper(CONSTANT)
```

```py
expect(9)
```

# function_arg_module_constant_def_bad

As a developer
I want to receive a type error when passing a $TYPE module constant to a function that does not accept it
In order to make debugging easier

```py
CONSTANT: $TYPE = $VAL0

def helper(x: (u32, )) -> i32:
    return 9

@exported
def testEntry() -> i32:
    return helper(CONSTANT)
```

```py
if TYPE_NAME.startswith('tuple_') or TYPE_NAME.startswith('static_array_') or TYPE_NAME.startswith('dynamic_array_'):
    expect_type_error('Not the same type constructor')
else:
    expect_type_error('Not the same type')
```