Apply agreed naming conventions

Parse strings to integer (binary, octal, decimal, or hexadecimal)

isa/README.md

@@ -16,7 +16,7 @@ Performs a jump-and-link function call, with label size up to 32 bits.
 
 _HARDWARE:_ Store PC+4 in the result register when in jump mode.
 
-## `li %a(register) %b:U32(immediate | label)
+## `li %a(register) %b:U32(immediate | label)`
 Loads an immediate up to 32 bits long
 
 _HARDWARE:_ No requirements

isa/test.isa

@@ -332,12 +332,13 @@ ret
 li %r(register), %a:S33(immediate | label)
 ; assert(0 - 0x80000000 <= %a, "%a is too low")
 ; assert(%a <= 0xffffffff, "%a is too high")
-%nota = ~%a
+%s = trailing_zeros(%a)
-when 0x0000 <= %a && %a <= 0xffff: 00110001 rrrr0000 %a[15:0]                                           ; First 64k
+%sa = %a >> %s
-when %nota <= 0xffff             : 00110001 rrrr0000 %nota[15:0]    00100011 rrrr0000 0000rrrr 00000000 ; Last 64k
+%nota = %a ^ 0xffffffff
-when !(%a & 0x0f) && %a < 0xffff0: 00110001 rrrr0000 %a[19:4]       00100111 rrrrrrrr 00000000 00000100 ; 16-byte aligned
+when %a <=u 0xffff   : 00110001 %r[3:0]0000 %a[15:0]                                                 ; First 64k
-when !(%a & 0x03) && %a < 0x3fffc: 00110001 rrrr0000 %a[17:2]       00100111 rrrrrrrr 00000000 00000010 ; 4-byte aligned
+when %nota <=u 0xffff: 00110001 %r[3:0]0000 %nota[15:0]    00100011 %r[3:0]0000 0000%r[3:0] 00000000 ; Last 64k
-00110001 rrrr0000 %a[31:16]   00100111 rrrrrrrr 00000000 00010000   00110001 rrrrrrrr %a[15:0]          ; Any 32-bit
+when %sa <=u 0xffff  : 00110001 %r[3:0]0000 %sa[15:0]      00110111 %r[3:0]%r[3:0] 00000000 %s[7:0]  ; Aligned
+00110001 %r[3:0]0000 %a[31:16]   00110111 %r[3:0]%r[3:0] 00000000 00010000   00110001 %r[3:0]%r[3:0] %a[15:0]          ; Any 32-bit
 # Load 32-bit immediate %a into %r
 
 qcall %a:U32(label)
@@ -345,14 +346,16 @@ qcall %a:U32(label)
 ; assert(%a <= 0xffffffff, "%a is too high")
 %r = 13
 %f = 15
-%nota = ~%a
+%s = trailing_zeros(%a)
-when 0x0000 <= %a && %a <= 0xffff: 01011000 rrrrffff %a[15:0]                                                                                  ; First 64k
+%sa = %a >> %s
-when %nota <= 0xffff             : 00110001 rrrr0000 %nota[15:0]    00100011 rrrr0000 0000rrrr 00000000    01001000 rrrrffff 0000rrrr 00000000 ; Last 64k
+%nota = %a ^ 0xffffffff
-when !(%a & 0x0f) && %a < 0xffff0: 00110001 rrrr0000 %a[19:4]       00100111 rrrrrrrr 00000000 00000100    01001000 rrrrffff 0000rrrr 00000000 ; 16-byte aligned
+when %a <=u 0xffff   : 01011000 %r[3:0]ffff %a[15:0]                                                                                              ; First 64k
-when !(%a & 0x03) && %a < 0x3fffc: 00110001 rrrr0000 %a[17:2]       00100111 rrrrrrrr 00000000 00000010    01001000 rrrrffff 0000rrrr 00000000 ; 4-byte aligned
+when %nota <=u 0xffff: 00110001 %r[3:0]0000 %nota[15:0]    00100011 %r[3:0]0000 0000%r[3:0] 00000000    01001000 %r[3:0]ffff 0000%r[3:0] 00000000 ; Last 64k
-00110001 rrrr0000 %a[31:16]   00100111 rrrrrrrr 00000000 00010000   00110001 rrrrrrrr %a[15:0]             01001000 rrrrffff 0000rrrr 00000000 ; Any 32-bit
+when %sa <=u 0xffff  : 00110001 %r[3:0]0000 %sa[15:0]      00110111 %r[3:0]%r[3:0] 00000000 %s[7:0]     01001000 %r[3:0]ffff 0000%r[3:0] 00000000 ; Aligned
+00110001 %r[3:0]0000 %a[31:16]   00110111 %r[3:0]%r[3:0] 00000000 00010000   00110001 %r[3:0]%r[3:0] %a[15:0]    01001000 %r[3:0]ffff 0000%r[3:0] 00000000 ; Any 32-bit
 # Jump and link to 32-bit label
 
 halt%c(condition)
 1000cccc 00001111 00000000 00000000
 # Halt on condition %c
+

src/imath.asm

@@ -4,22 +4,53 @@
 ; r2 - The second value
 ; Result:
 ; r1 - The lower 32 bits of the result
-; Clobbers: r2, r3, r4, r5
+; Clobbers: r2, r3, r4, r5, r6
 pub mul_low:
-	mov r3, 0 ; result
+	cmp r1, r2
-	mov r4, 31 ; loop counter
+	jbe mul_low_noswap
-	
+	xor r1, r2, r1
-	mul_low_loop:
+	xor r2, r1, r2
-		asr r5, r2, 31
+	xor r1, r2, r1
-		and r5, r5, r1
+	; Passthrough
-		lsl r5, r5, r4
+
-		add r3, r3, r5
+; Multiplies r1 and r2, returning the lower part of the result
-		lsl r2, r2, 1
+; This method assumes r1 is smaller than r2, which results in faster execution
-		sub r4, r4, 1
+; Arguments:
-		cmp r4, 0
+; r1 - The first value
-		jge mul_low_loop
+; r2 - The second value
-	mov r1, r3
+; Result:
+; r1 - The lower 32 bits of the result
+; Clobbers: r2, r3, r4, r5, r6
+pub mul_low_noswap:
+	mov r4, 0 ; r4 has the result
+	mov r6, mul_loop_end
+	add r3, r2, r2
 	
+	mul_loop:
+		and r5, r1, 14 ; Taking the first four bits, discarding the odd
+		lsl r5, r5, 1 ; 0000 - 0, 0001 - 2, 0010 - 4, 0011 - 8, etc.
+		sub r5, r6, r5
+		jmp r5
+		
+		add r4, r4, r3
+		add r4, r4, r3
+		add r4, r4, r3
+		add r4, r4, r3
+		add r4, r4, r3
+		add r4, r4, r3
+		add r4, r4, r3
+		mul_loop_end:
+			mov flags, r1
+			jne mul_skip_one
+			add r4, r4, r2
+			mul_skip_one:
+			lsl r2, r2, 4
+			lsl r3, r3, 4
+			lsr r1, r1, 4
+			cmp r1, zr
+			jne mul_loop
+
+	mov r1, r4
 	jmp r13
 
 ; Calculates the absolute value of the value provided in the r1 register

src/mem.asm

@@ -0,0 +1,174 @@
+; int compare(uint8_t* a, uint8_t* b, size_t count);
+;   Compares two memory segment of equal length lexicographically.
+;
+; Arguments:
+; - `r1`: A pointer to the first memory segment.
+; - `r2`: A pointer to the second memory segment.
+; - `r3`: The size of both memory segments.
+; Results:
+; - `r1`:
+;   -  `0` if both segments are equal.
+;   - `<0` if the first segment is less than the second segment.
+;   - `>0` if the first segment is greater than the second segment.
+;
+pub compare:
+    ; Exclusive end point of the first segment.
+    add r3, r3, r1
+    sub r3, r3, 4
+_compare__loop:
+    load_32 r4, [r1]
+    add r1, r1, 4
+    load_32 r5, [r2]
+    add r2, r2, 4
+    ; Comparing two sequences of 4 bytes lexicographically is equivalent to
+    ; comparing the corresponding big endian 32 bit words.
+    cmp r4, r5
+    jne _compare__break
+    ; Check if there are enough bytes left to continue with the vectorized loop.
+    cmp r1, r3
+    jbe _compare__loop
+    ; `r3 + 4 - r1 = <remaining byte count> = r3 - r1 mod 4`
+    sub flags, r3, r1
+    ; Check if one of the lowest 2 bits is non-zero
+    jbe _compare__rem
+    ; If not, we are done. Both segments are equal.
+    mov r1, 0
+    jmp r13
+_compare__break:
+    ; `flags` is the comparison result in the format of `cmp`. Convert it to the desired format.
+    ; 00 => 0x40000000 > 0
+    ; 01 => 0x00000000 = 0
+    ; 10 => 0xC0000000 < 0
+    xor r1, flags, 1
+    lsl r1, r1, 30
+    jmp r13
+_compare__rem:
+    ; Compute `S = 8*(4 - <remaining byte count>)` and
+    ; [r1] >> S, [r2] >> S
+    mov r3, 8
+    load_32 r4, [r1]
+    sub r3, r3, flags
+    load_32 r5, [r2]
+    lsl r3, r3, 3
+    lsr r4, r4, r3
+    lsr r5, r5, r3
+    ; Compare both values, now with garbage bytes removed.
+    cmp r4, r5
+    jmp _compare__break
+
+
+; void copy(void* src, void* dest, size_t count);
+;   Copies `count` bytes from `src` to `dest`. The two memory segments must not overlap.
+;
+; Arguments:
+; - `r1`: Pointer to the memory segment to be copied.
+; - `r2`: Pointer to the memory segment to be copied into.
+; - `r3`: Byte size of both the `src` and `dest` segments.
+;
+pub copy:
+    ; Exclusive end point of the source segment.
+    add r3, r1, r3
+    ; Last index from where we can safely copy 8 bytes per loop iteration.
+    sub r3, r3, 8
+    jmp _copy__loop_entry
+_copy__loop:
+    ; Copy 8 bytes from `src` to `dest`.
+    load_32 flags, [r1]
+    add r1, r1, 4
+    store_32 [r2], flags
+    add r2, r2, 4
+    load_32 flags, [r1]
+    add r1, r1, 4
+    store_32 [r2], flags
+    add r2, r2, 4
+_copy__loop_entry:
+    ; Check if we can process more data in the vectorized loop.
+    cmp r1, r3
+    jbe _copy__loop
+    ; The remaining amount of bytes `R` is `R = r3 + 8 - r1 = r3 - r1 mod 8`.
+    sub flags, r3, r1
+    ; Test if `R` is not a multiple of `4`, i.e. the lowest 2 bits are non-zero.
+    jbe _copy__rem
+    ; `R` is a multiple of `4`. Special case this.
+    ; Check if `R` is `0`, i.e. the third bit is also 0. In that case, we are already done.
+    ; There are no conditional indirect jumps, so we can't return immediately.
+    jge _copy__ret
+    ; `R = 4`. No need to update `r1` or `r2`, we don't need them anymore.
+    load_32 flags, [r1]
+    store_32 [r2], flags
+_copy__ret:
+    ; Return
+    jmp r13
+_copy__rem:
+    ; Optimize the remaining cases for code size.
+    ; End point of the source segment.
+    add r3, r3, 8
+    ; We already handled the case `R = 0` earlier,
+    ; so no bounds check needed for the first iteration.
+_copy__rem_loop:
+    ; Copy 1 byte.
+    load_8 flags, [r1]
+    add r1, r1, 1
+    store_8 [r2], flags
+    add r2, r2, 1
+    ; Check if we are still within the bounds.
+    cmp r1, r3
+    jb _copy__rem_loop
+    jmp r13
+    
+; void fill32(uint8_t* dest, size_t count, uint32_t value);
+;   Fills `count` bytes in `dest` with `value`. If `count` is not a multiple of 4, 
+;   the least significant bytes of `value` are cut off for the last entry.
+;
+; Arguments:
+; - `r1`: A pointer to the destination segment.
+; - `r2`: The size of the destination segment.
+; - `r3`: The 32 bit value that the segment is filled with.
+;
+pub fill32:
+    ; Exclusive end point of the destination segment.
+    add r2, r1, r2
+    ; Last index from where we can safely write 8 bytes per loop iteration.
+    sub r2, r2, 8
+    jmp _fill32__entry
+_fill32__loop:
+	; Set 8 bytes per loop iteraion.
+    store_32 [r1], r3
+    add r1, r1, 4
+    store_32 [r1], r3
+    add r1, r1, 4
+_fill32__entry:
+    ; Check if we can process more data in the vectorized loop.
+    cmp r1, r2
+    jbe _fill32__loop
+    ; The remaining amount of bytes `R` is `R = r2 + 8 - r1 = r2 - r1 mod 8`.
+    sub flags, r2, r1
+    ; Check if the third bit of the remainder is cleared.
+    jge _fill32__r4
+    ; Otherwise set 4 bytes.
+    store_32 [r1], r3
+    add r1, r1, 4
+_fill32__r4:
+    ; Check if the two least significant bits of the remainder are zero.
+    ja _fill32__ret
+    ; Handle the remaining bytes `R` individually, in reverse order.
+    add r2, r2, 4
+    ; `r1 + 4 - r2 = 4 - R`.
+    sub flags, r1, r2
+    ; Exclusive end point of the destination segment.
+    add r2, r2, 4
+    ; Shift out the least significant `8*(4 - R)` bits of the value.
+    lsl flags, flags, 3
+    lsr r3, r3, flags
+    jmp _fill32__loop2_entry
+_fill32__loop2:
+    sub r2, r2, 1
+    ; Write the least significant byte of the value...
+    store_8 [r2], r3
+    ; and then shift it out.
+    lsr r3, r3, 8
+_fill32__loop2_entry:
+    cmp r1, r2
+    jb _fill32__loop2
+_fill32__ret:
+    jmp r13

src/stdlib.asm

@@ -2,6 +2,8 @@ pub include bit
 pub include imath
 pub include array
 pub include console
+pub include mem
+pub include string_to_int
 
 ; Needs to be last!
 pub include LUTs

src/string_to_int.asm

@@ -0,0 +1,188 @@
+; Internal register assignments:
+; r1 - Partially parsed output integer
+; r2 - Parsing position
+; r3 - Character being parsed
+; r4 - Set to -1 if the input is negative
+
+; Convert string to integer (akin to libc atoi(), strotoi())
+; Arguments:
+; r1 - Pointer to string
+; Result:
+; r1 - Parsed integer
+; r2 - Pointer to first rejected input byte
+; Clobbers:
+; flags
+; r3 - last character read
+; r4 - Negative marker
+; Note: Unless the input is "0", tail-calls into a base-specific specialization.
+pub auto:
+mov r2, r1
+mov r1, 0
+mov r4, 0
+load_8 r3, [r2]
+cmp r3, 0x2D ; '-'
+jne auto_positive
+sub r4, zr, 1           ; Set r4 to -1
+add r2, r2, 1
+auto_positive:
+load_16 r3, [r2]        ; 2-byte prefix "0b", "0o", "0x", etc.
+or r3, r3, 0x20         ; 2nd char to lower case
+add r2, r2, 2
+cmp r3, 0x3062 ; "0b"
+je bin_loop
+cmp r3, 0x306F ; "0o"
+je oct_loop
+cmp r3, 0x3078 ; "0x"
+je hex_loop
+sub r2, r2, 2           ; no matching prefix, move pointer back
+jmp dec_loop
+
+; Epilogue
+done:
+add r1, r1, r4          ; If r4 is -1, negate r1. Else it's 0 and no effect.
+xor r1, r1, r4
+mov flags, 0            ; No error
+jmp r13
+
+; Convert decimal string to integer
+; Arguments:
+; r1 - Pointer to string
+; Result:
+; r1 - Parsed integer
+; r2 - Pointer to first rejected input byte
+; Clobbers:
+; flags
+; r3 - last character read
+; r4 - Negative marker
+pub dec:
+mov r2, r1
+mov r1, 0
+mov r4, 0
+load_8 r3, [r2]
+cmp r3, 0x2D ; '-'
+jne dec_positive
+sub r4, zr, 1           ; Set r4 to -1
+add r2, r2, 1
+dec_loop:
+load_8 r3, [r2]
+dec_positive:
+sub r3, r3, 0x30 ; '0'
+cmp r3, 9
+ja done
+add r2, r2, 1
+lsl flags, r1, 2        ; Use flags to help multiply by 10
+add r1, r1, flags
+lsl r1, r1, 1
+add r1, r1, r3
+jmp dec_loop
+
+; Convert binary string to integer
+; Arguments:
+; r1 - Pointer to string
+; Result:
+; r1 - Parsed integer
+; r2 - Pointer to first rejected input byte
+; Clobbers:
+; flags
+; r3 - last character read
+; r4 - Negative marker
+pub bin:
+mov r2, r1
+mov r1, 0
+mov r4, 0
+load_8 r3, [r2]
+cmp r3, 0x2D ; '-'
+jne bin_positive
+sub r4, zr, 1           ; Set r4 to -1
+add r2, r2, 1
+bin_positive:
+load_16 r3, [r2]        ; check for prefix
+or r3, r3, 0x20         ; 2nd char to lower case
+cmp r3, 0x3062 ; "0b"
+jne bin_loop
+add r2, r2, 2
+bin_loop:
+load_8 r3, [r2]
+sub r3, r3, 0x30 ; '0'
+cmp r3, 1
+ja done
+add r2, r2, 1
+lsl r1, r1, 1
+add r1, r1, r3
+jmp bin_loop
+
+; Convert octal string to integer
+; Arguments:
+; r1 - Pointer to string
+; Result:
+; r1 - Parsed integer
+; r2 - Pointer to first rejected input byte
+; Clobbers:
+; flags
+; r3 - last character read
+; r4 - Negative marker
+pub oct:
+mov r2, r1
+mov r1, 0
+mov r4, 0
+load_8 r3, [r2]
+cmp r3, 0x2D ; '-'
+jne oct_positive
+sub r4, zr, 1           ; Set r4 to -1
+add r2, r2, 1
+oct_positive:
+load_16 r3, [r2]        ; check for prefix
+or r3, r3, 0x20         ; 2nd char to lower case
+cmp r3, 0x306F ; "0o"
+jne oct_loop
+add r2, r2, 2
+oct_loop:
+load_8 r3, [r2]
+sub r3, r3, 0x30 ; '0'
+cmp r3, 7
+ja done
+add r2, r2, 1
+lsl r1, r1, 3
+add r1, r1, r3
+jmp oct_loop
+
+; Convert hexadecimal string to integer
+; Arguments:
+; r1 - Pointer to string
+; Result:
+; r1 - Parsed integer
+; r2 - Pointer to first rejected input byte
+; Clobbers:
+; flags
+; r3 - last character read
+; r4 - Negative marker
+pub hex:
+mov r2, r1
+mov r1, 0
+mov r4, 0
+load_8 r3, [r2]
+cmp r3, 0x2D ; '-'
+jne hex_positive
+sub r4, zr, 1           ; Set r4 to -1
+add r2, r2, 1
+hex_positive:
+load_16 r3, [r2]        ; check for prefix
+or r3, r3, 0x20         ; 2nd char to lower case
+cmp r3, 0x3078 ; "0x"
+jne hex_loop
+add r2, r2, 2
+hex_loop:
+load_8 r3, [r2]
+sub r3, r3, 0x30 ; '0'
+cmp r3, 10
+jb hex_add
+sub r3, r3, 0x11 ; 'A' - '0'
+and r3, r3, 0xdf        ; to lower case
+cmp r3, 5               ; 0-5: 6 letters
+ja done
+add r3, r3, 10          ; Adjust for digits below
+hex_add:
+add r2, r2, 1
+lsl r1, r1, 4
+add r1, r1, r3
+jmp hex_loop

src/unsafe_mem.asm

@@ -0,0 +1,77 @@
+; int compare(uint8_t* a, uint8_t* b, size_t count);
+;   Compares two memory segment of equal length lexicographically.
+;   Temporarily modifies the byte at address `a + count`.
+;
+; Arguments:
+; - `r1`: A pointer to the first memory segment.
+; - `r2`: A pointer to the second memory segment.
+; - `r3`: The size of both memory segments.
+; Results:
+; - `r1`:
+;   -  `0` if both segments are equal.
+;   - `<0` if the first segment is less than the second segment.
+;   - `>0` if the first segment is greater than the second segment.
+pub compare:
+    cmp r1, r2
+    je _compare__is_eq
+    ; Exclusive end point of the second segment.
+    add r4, r3, r2
+    ; Exclusive end point of the first segment.
+    add r3, r3, r1
+    load_8 r6, [r3]
+    load_8 flags, [r4]
+    ; Check if the first bytes behind the sequences are equal.
+    cmp flags, r6
+    jne _compare__loop
+    ; Change the byte directly behind the first segment.
+    xor r4, r6, 1
+    ; This would be problematic if someone calls compare with a first segment
+    ; whose end point overlaps the program memory of this function.
+    store_8 [r3], r4
+_compare__loop:
+    load_32 r4, [r1]
+    add r1, r1, 4
+    load_32 r5, [r2]
+    add r2, r2, 4
+    ; Comparing two sequences of 4 bytes lexicographically is equivalent to
+    ; comparing the corresponding big endian 32 bit words.
+    cmp r4, r5
+    je _compare__loop
+    ; We overshot in the loop; decrement r1 again. (Only by 2, we backtrack the rest if necessary later)
+    sub r1, r1, 2
+    ; Restore the byte we changed.
+    store_8 [r3], r6
+    ; We encountered two different words. Figure out what byte they differ on.
+    xor r4, r4, r5
+    ; Store the flags for later, to figure out the return value.
+    mov r5, flags
+    ; Check if at least one of the two most significant bytes is not 0.
+    cmp r4, 0xffff
+    jbe _compare__low2
+    ; If it is, backtrack the remaining 2 indices.
+    ; Shift the most significant bytes to the least significant ones.
+    sub r1, r1, 2
+    lsr r4, r4, 16
+_compare__low2:
+    ; r1 now points to a non-zero 16 bit value.
+    ; If the 16 bit value at r1-2 is in-bounds, then it is 0.
+    ; Check if the most significant byte of the 16 bit value is 0.
+    cmp r4, 0xff
+    ja _compare__low1
+    ; If it is, our target is the least significant byte.
+    add r1, r1, 1
+_compare__low1:
+    ; Otherwise, the target is that non-zero byte.
+    ; Check if the target is out of bounds, i.e. the loop terminated through the "bounds check".
+    cmp r1, r3
+    jae _compare__is_eq
+    ; r5 is the comparison result in the format of `cmp`. Convert it to the desired format.
+    ; 00 => 0x40000000 > 0
+    ; 01 => 0x00000000 = 0
+    ; 10 => 0xC0000000 < 0
+    xor r1, r5, 1
+    lsl r1, r1, 30
+    jmp r13
+_compare__is_eq:
+    mov r1, 0
+    jmp r13

tests/string_to_int_test.asm

@@ -0,0 +1,57 @@
+; test harness for string_to_int
+; Registers:
+; r8 - test address
+; r9 - expected result
+; r10 - actual length
+; r11 - expected length
+li r8, tests
+li r12, end_of_tests
+next_test:
+; Set up arguments and run test
+add r1, r8, 5          ; Start of test string
+mov r13, atoi_test_ret
+jmp stdlib.string_to_int.auto
+atoi_test_ret:
+
+; Load reference data
+load_32 r9, [r8]       ; Expected result
+sub r10, r2, r8
+sub r10, r10, 5        ; Actual string length
+add r11, r8, 4         ; Address of expected length
+load_8 r11, [r11]      ; Expected length
+
+; Verify results
+cmp r1, r9
+incorrect_result: jne incorrect_result
+cmp r10, r11
+incorrect_length: jne incorrect_length
+
+; Next test
+add r8, r8, 0x10
+cmp r8, r12
+jl next_test
+
+; Done
+success: jmp success
+
+include ../src/stdlib
+
+@0x20000
+tests:
+; inlen is the number of input bytes the function is expected to consume
+; addr  result          inlen  instr
+@0x20000 U32 0           U8 0   "\0"
+@0x20010 U32 0           U8 1   "0\0"
+@0x20020 U32 1           U8 1   "1\0"
+@0x20030 U32 2           U8 1   "2:\0"
+@0x20040 U32 42          U8 2   "42\0"
+@0x20050 U32 67          U8 2   "67lol\0"
+@0x20060 U32 0x69a       U8 5   "0x69a@\0"
+@0x20070 U32 0x4B4       U8 5   "0x4B4g\0"
+@0x20080 U32 0o23        U8 4   "0o239\0"
+@0x20090 U32 0b1011      U8 6   "0b1011\0"
+@0x200a0 U32 0b10001     U8 7   "0b100012\0"
+@0x200b0 U32 0xFFFFFFEB  U8 3   "-21\0"       ; Yuk
+@0x200c0
+end_of_tests:
+