wehub-resource-sync
e7738de6d2
CI / Deep Native Runtime Cases (1/6) (push) Has been skipped
CI / Native Preflight (push) Failing after 1s
CI / Native Runtime Cases (1/2) (push) Failing after 0s
CI / Native Runtime Cases (2/2) (push) Failing after 1s
CI / Native Metadata Reports (push) Failing after 0s
CI / Native Direct Backend Artifacts (push) Failing after 0s
CI / Native Sanitizer Smoke (push) Failing after 1s
CI / Command Contract Snapshots (push) Failing after 1s
CI / Deep Conformance Suite (push) Has been skipped
CI / Graph Build Perf (push) Failing after 1s
CI / Deep Native Preflight (push) Has been skipped
CI / Deep Native Runtime Cases (2/6) (push) Has been skipped
CI / Deep Native Runtime Cases (3/6) (push) Has been skipped
CI / Conformance Suite (push) Failing after 1s
CI / Workspace Checks (push) Failing after 0s
CI / Deep Native Runtime Cases (5/6) (push) Has been skipped
CI / Deep Native Runtime Cases (6/6) (push) Has been skipped
CI / Deep Native Runtime Cases (4/6) (push) Has been skipped
CI / Deep Graph Build Perf (push) Has been skipped
197 lines
20 KiB
Plaintext
197 lines
20 KiB
Plaintext
alias CollectionByte = u8
|
|
alias CollectionScore = u16
|
|
alias CollectionSet = FixedSet<CollectionByte>
|
|
alias CollectionDeque = FixedDeque<CollectionByte>
|
|
alias CollectionRing = FixedRingBuffer<CollectionByte>
|
|
alias CollectionMap = FixedMap<CollectionByte, CollectionScore>
|
|
|
|
pub fn main(world: World) -> Void raises {
|
|
var values: [4]u8 = [1, 2, 3, 4]
|
|
var len: usize = 4
|
|
let duplicate: usize = std.collections.setInsert(values, len, 3_u8)
|
|
len = std.collections.setRemove(values, len, 2_u8)
|
|
let inserted_len: usize = std.collections.insertAt(values, len, 1_usize, 8_u8)
|
|
let removed_len: usize = std.collections.removeAt(values, inserted_len, 1_usize)
|
|
len = removed_len
|
|
len = std.collections.setInsert(values, len, 5_u8)
|
|
let has_five: Bool = std.collections.setContains(values, len, 5_u8)
|
|
let first_value: Maybe<u8> = std.collections.first(values, len)
|
|
let last_value: Maybe<u8> = std.collections.last(values, len)
|
|
let popped_len: usize = std.collections.pop(values, len)
|
|
let cleared: usize = std.collections.clear(values, len)
|
|
let truncate_same: usize = std.collections.truncate(values, len, 4_usize)
|
|
let truncate_smaller: usize = std.collections.truncate(values, len, 3_usize)
|
|
len = std.collections.moveToFront(values, len, 2)
|
|
len = std.collections.removeSwap(values, len, 1)
|
|
let set_live: Span<u8> = std.collections.setView(values, len)
|
|
let set_remaining: usize = std.collections.setRemaining(values, len)
|
|
let set_full: Bool = std.collections.setIsFull(values, len)
|
|
let set_truncated: usize = std.collections.setTruncate(values, len, 2_usize)
|
|
let set_cleared: usize = std.collections.setClear(values, len)
|
|
var fixed_set_storage: [4]u8 = [1_u8, 2_u8, 0_u8, 0_u8]
|
|
var fixed_set: FixedSet<u8> = std.collections.fixedSet(fixed_set_storage, 2_usize)
|
|
let fixed_set_inserted: Bool = std.collections.fixedSetInsert(&mut fixed_set, 3_u8)
|
|
let fixed_set_duplicate: Bool = std.collections.fixedSetInsert(&mut fixed_set, 3_u8)
|
|
let fixed_set_removed: Bool = std.collections.fixedSetRemove(&mut fixed_set, 1_u8)
|
|
let fixed_set_missing_remove: Bool = std.collections.fixedSetRemove(&mut fixed_set, 9_u8)
|
|
let fixed_set_has_two: Bool = std.collections.fixedSetContains(&fixed_set, 2_u8)
|
|
let fixed_set_live: Span<u8> = std.collections.fixedSetView(&fixed_set)
|
|
let fixed_set_remaining: usize = std.collections.fixedSetRemaining(&fixed_set)
|
|
let fixed_set_full: Bool = std.collections.fixedSetIsFull(&fixed_set)
|
|
let fixed_set_len: usize = std.collections.fixedSetLen(&fixed_set)
|
|
let fixed_set_truncated: usize = std.collections.fixedSetTruncate(&mut fixed_set, 1_usize)
|
|
let fixed_set_cleared: usize = std.collections.fixedSetClear(&mut fixed_set)
|
|
var fixed_set_clamp_storage: [4]u8 = [1_u8, 2_u8, 3_u8, 4_u8]
|
|
var fixed_set_clamped: FixedSet<u8> = std.collections.fixedSet(fixed_set_clamp_storage, 9_usize)
|
|
let fixed_set_clamped_len: usize = std.collections.fixedSetLen(&fixed_set_clamped)
|
|
var fixed_map_keys: [3]u8 = [1_u8, 2_u8, 0_u8]
|
|
var fixed_map_scores: [3]u16 = [10_u16, 20_u16, 0_u16]
|
|
var fixed_map: FixedMap<u8, u16> = std.collections.fixedMap(fixed_map_keys, fixed_map_scores, 2_usize)
|
|
let fixed_map_start_len: usize = std.collections.fixedMapLen(&fixed_map)
|
|
let fixed_map_start_remaining: usize = std.collections.fixedMapRemaining(&fixed_map)
|
|
let fixed_map_added: Bool = std.collections.fixedMapPut(&mut fixed_map, 3_u8, 30_u16)
|
|
let fixed_map_updated: Bool = std.collections.fixedMapPut(&mut fixed_map, 2_u8, 25_u16)
|
|
let fixed_map_overflow: Bool = std.collections.fixedMapPut(&mut fixed_map, 4_u8, 40_u16)
|
|
let fixed_map_has_two: Bool = std.collections.fixedMapContains(&fixed_map, 2_u8)
|
|
let fixed_map_has_nine: Bool = std.collections.fixedMapContains(&fixed_map, 9_u8)
|
|
let fixed_map_found: Maybe<u16> = std.collections.fixedMapGet(&fixed_map, 2_u8)
|
|
let fixed_map_missing: Maybe<u16> = std.collections.fixedMapGet(&fixed_map, 9_u8)
|
|
let fixed_map_two_index: usize = std.collections.fixedMapIndex(&fixed_map, 2_u8)
|
|
let fixed_map_missing_index: usize = std.collections.fixedMapIndex(&fixed_map, 9_u8)
|
|
let fixed_map_live_keys: Span<u8> = std.collections.fixedMapKeys(&fixed_map)
|
|
let fixed_map_live_scores: Span<u16> = std.collections.fixedMapValues(&fixed_map)
|
|
let fixed_map_full: Bool = std.collections.fixedMapIsFull(&fixed_map)
|
|
let fixed_map_removed: Bool = std.collections.fixedMapRemove(&mut fixed_map, 1_u8)
|
|
let fixed_map_missing_remove: Bool = std.collections.fixedMapRemove(&mut fixed_map, 9_u8)
|
|
let fixed_map_after_remove_len: usize = std.collections.fixedMapLen(&fixed_map)
|
|
let fixed_map_truncated: usize = std.collections.fixedMapTruncate(&mut fixed_map, 1_usize)
|
|
let fixed_map_cleared: usize = std.collections.fixedMapClear(&mut fixed_map)
|
|
var fixed_map_clamp_keys: [2]u8 = [1_u8, 2_u8]
|
|
var fixed_map_clamp_scores: [1]u16 = [10_u16]
|
|
var fixed_map_clamped: FixedMap<u8, u16> = std.collections.fixedMap(fixed_map_clamp_keys, fixed_map_clamp_scores, 9_usize)
|
|
let fixed_map_clamped_len: usize = std.collections.fixedMapLen(&fixed_map_clamped)
|
|
var fixed_alias_set_storage: [2]CollectionByte = [1_u8, 0_u8]
|
|
var fixed_alias_set: CollectionSet = std.collections.fixedSet(fixed_alias_set_storage, 1_usize)
|
|
let fixed_alias_set_live: Span<CollectionByte> = std.collections.fixedSetView(&fixed_alias_set)
|
|
let fixed_alias_set_inserted: Bool = std.collections.fixedSetInsert(&mut fixed_alias_set, 2_u8)
|
|
var fixed_alias_deque_storage: [2]CollectionByte = [0_u8, 0_u8]
|
|
var fixed_alias_deque: CollectionDeque = std.collections.fixedDeque(fixed_alias_deque_storage, 0_usize)
|
|
let fixed_alias_deque_pushed: Bool = std.collections.fixedDequePushBack(&mut fixed_alias_deque, 7_u8)
|
|
let fixed_alias_deque_back: Maybe<CollectionByte> = std.collections.fixedDequeBack(&fixed_alias_deque)
|
|
var fixed_alias_ring_storage: [2]CollectionByte = [0_u8, 0_u8]
|
|
var fixed_alias_ring: CollectionRing = std.collections.fixedRingBuffer(fixed_alias_ring_storage, 0_usize, 0_usize)
|
|
let fixed_alias_ring_pushed: Bool = std.collections.fixedRingBufferPushBack(&mut fixed_alias_ring, 8_u8)
|
|
let fixed_alias_ring_front: Maybe<CollectionByte> = std.collections.fixedRingBufferFront(&fixed_alias_ring)
|
|
var fixed_alias_map_keys: [2]CollectionByte = [1_u8, 0_u8]
|
|
var fixed_alias_map_scores: [2]CollectionScore = [10_u16, 0_u16]
|
|
var fixed_alias_map: CollectionMap = std.collections.fixedMap(fixed_alias_map_keys, fixed_alias_map_scores, 1_usize)
|
|
let fixed_alias_map_put: Bool = std.collections.fixedMapPut(&mut fixed_alias_map, 2_u8, 20_u16)
|
|
let fixed_alias_map_found: Maybe<CollectionScore> = std.collections.fixedMapGet(&fixed_alias_map, 2_u8)
|
|
let fixed_alias_ok: Bool = std.mem.len(fixed_alias_set_live) == 1 && fixed_alias_set_live[0] == 1_u8 && fixed_alias_set_inserted && fixed_alias_deque_pushed && fixed_alias_deque_back.has && fixed_alias_deque_back.value == 7_u8 && fixed_alias_ring_pushed && fixed_alias_ring_front.has && fixed_alias_ring_front.value == 8_u8 && fixed_alias_map_put && fixed_alias_map_found.has && fixed_alias_map_found.value == 20_u16
|
|
let absent_remove: usize = std.collections.setRemove(values, len, 9_u8)
|
|
let invalid_remove: usize = std.collections.removeSwap(values, 9_usize, 0_usize)
|
|
let invalid_move: usize = std.collections.moveToFront(values, 9_usize, 1_usize)
|
|
let replaced_item: Bool = std.collections.replaceAt(values, len, 1_usize, 6_u8)
|
|
let swapped_items: Bool = std.collections.swapAt(values, len, 1_usize, 2_usize)
|
|
let invalid_replace: Bool = std.collections.replaceAt(values, len, 9_usize, 1_u8)
|
|
let invalid_swap: Bool = std.collections.swapAt(values, 9_usize, 0_usize, 1_usize)
|
|
var transform: [4]u8 = [1_u8, 2_u8, 3_u8, 4_u8]
|
|
let reversed_items: Bool = std.collections.reverse(transform, 4_usize)
|
|
let filled_items: Bool = std.collections.fill(transform, 2_usize, 9_u8)
|
|
let invalid_reverse: Bool = std.collections.reverse(transform, 9_usize)
|
|
let invalid_fill: Bool = std.collections.fill(transform, 9_usize, 1_u8)
|
|
let rotated_left: Bool = std.collections.rotateLeft(transform, 4_usize, 1_usize)
|
|
let rotated_right: Bool = std.collections.rotateRight(transform, 4_usize, 2_usize)
|
|
let invalid_rotate_left: Bool = std.collections.rotateLeft(transform, 9_usize, 1_usize)
|
|
let invalid_rotate_right: Bool = std.collections.rotateRight(transform, 9_usize, 1_usize)
|
|
let live: Span<u8> = std.collections.view(values, len)
|
|
let first: usize = std.search.indexOf(live, 3_u8)
|
|
let last: usize = std.search.lastIndexOf(live, 4_u8)
|
|
var deque_items: [4]u8 = [0_u8, 0_u8, 0_u8, 0_u8]
|
|
var deque_len: usize = 0
|
|
deque_len = std.collections.dequePushBack(deque_items, deque_len, 2_u8)
|
|
deque_len = std.collections.dequePushFront(deque_items, deque_len, 1_u8)
|
|
deque_len = std.collections.dequePushBack(deque_items, deque_len, 3_u8)
|
|
let deque_front: Maybe<u8> = std.collections.dequeFront(deque_items, deque_len)
|
|
let deque_back: Maybe<u8> = std.collections.dequeBack(deque_items, deque_len)
|
|
let deque_after_pop_back: usize = std.collections.dequePopBack(deque_items, deque_len)
|
|
deque_len = std.collections.dequePopFront(deque_items, deque_after_pop_back)
|
|
var fixed_deque_storage: [4]u8 = [0_u8, 0_u8, 0_u8, 0_u8]
|
|
var fixed_deque: FixedDeque<u8> = std.collections.fixedDeque(fixed_deque_storage, 0_usize)
|
|
let fixed_deque_push_back: Bool = std.collections.fixedDequePushBack(&mut fixed_deque, 2_u8)
|
|
let fixed_deque_push_front: Bool = std.collections.fixedDequePushFront(&mut fixed_deque, 1_u8)
|
|
let fixed_deque_push_back_again: Bool = std.collections.fixedDequePushBack(&mut fixed_deque, 3_u8)
|
|
let fixed_deque_len: usize = std.collections.fixedDequeLen(&fixed_deque)
|
|
let fixed_deque_remaining: usize = std.collections.fixedDequeRemaining(&fixed_deque)
|
|
let fixed_deque_front: Maybe<u8> = std.collections.fixedDequeFront(&fixed_deque)
|
|
let fixed_deque_back: Maybe<u8> = std.collections.fixedDequeBack(&fixed_deque)
|
|
let fixed_deque_live: Span<u8> = std.collections.fixedDequeView(&fixed_deque)
|
|
let fixed_deque_live_len: usize = std.mem.len(fixed_deque_live)
|
|
let fixed_deque_live_middle: u8 = fixed_deque_live[1]
|
|
let fixed_deque_push_to_full: Bool = std.collections.fixedDequePushBack(&mut fixed_deque, 4_u8)
|
|
let fixed_deque_full: Bool = std.collections.fixedDequeIsFull(&fixed_deque)
|
|
let fixed_deque_overflow: Bool = std.collections.fixedDequePushBack(&mut fixed_deque, 5_u8)
|
|
let fixed_deque_pop_back: Maybe<u8> = std.collections.fixedDequePopBack(&mut fixed_deque)
|
|
let fixed_deque_pop_front: Maybe<u8> = std.collections.fixedDequePopFront(&mut fixed_deque)
|
|
let fixed_deque_after_pop_len: usize = std.collections.fixedDequeLen(&fixed_deque)
|
|
let fixed_deque_truncated: usize = std.collections.fixedDequeTruncate(&mut fixed_deque, 1_usize)
|
|
let fixed_deque_cleared: usize = std.collections.fixedDequeClear(&mut fixed_deque)
|
|
var fixed_deque_clamp_storage: [4]u8 = [1_u8, 2_u8, 3_u8, 4_u8]
|
|
var fixed_deque_clamped: FixedDeque<u8> = std.collections.fixedDeque(fixed_deque_clamp_storage, 9_usize)
|
|
let fixed_deque_clamped_len: usize = std.collections.fixedDequeLen(&fixed_deque_clamped)
|
|
var fixed_ring_storage: [4]u8 = [0_u8, 0_u8, 0_u8, 0_u8]
|
|
var fixed_ring: FixedRingBuffer<u8> = std.collections.fixedRingBuffer(fixed_ring_storage, 0_usize, 0_usize)
|
|
let fixed_ring_push_back: Bool = std.collections.fixedRingBufferPushBack(&mut fixed_ring, 2_u8)
|
|
let fixed_ring_push_back_again: Bool = std.collections.fixedRingBufferPushBack(&mut fixed_ring, 3_u8)
|
|
let fixed_ring_push_front: Bool = std.collections.fixedRingBufferPushFront(&mut fixed_ring, 1_u8)
|
|
let fixed_ring_len: usize = std.collections.fixedRingBufferLen(&fixed_ring)
|
|
let fixed_ring_capacity: usize = std.collections.fixedRingBufferCapacity(&fixed_ring)
|
|
let fixed_ring_remaining: usize = std.collections.fixedRingBufferRemaining(&fixed_ring)
|
|
let fixed_ring_front: Maybe<u8> = std.collections.fixedRingBufferFront(&fixed_ring)
|
|
let fixed_ring_back: Maybe<u8> = std.collections.fixedRingBufferBack(&fixed_ring)
|
|
let fixed_ring_middle: Maybe<u8> = std.collections.fixedRingBufferGet(&fixed_ring, 1_usize)
|
|
let fixed_ring_pop_front: Maybe<u8> = std.collections.fixedRingBufferPopFront(&mut fixed_ring)
|
|
let fixed_ring_push_back_wrap: Bool = std.collections.fixedRingBufferPushBack(&mut fixed_ring, 4_u8)
|
|
let fixed_ring_push_back_to_full: Bool = std.collections.fixedRingBufferPushBack(&mut fixed_ring, 5_u8)
|
|
let fixed_ring_full: Bool = std.collections.fixedRingBufferIsFull(&fixed_ring)
|
|
let fixed_ring_overflow: Bool = std.collections.fixedRingBufferPushBack(&mut fixed_ring, 6_u8)
|
|
let fixed_ring_pop_back: Maybe<u8> = std.collections.fixedRingBufferPopBack(&mut fixed_ring)
|
|
let fixed_ring_after_wrap: Maybe<u8> = std.collections.fixedRingBufferGet(&fixed_ring, 2_usize)
|
|
let fixed_ring_truncated: usize = std.collections.fixedRingBufferTruncate(&mut fixed_ring, 2_usize)
|
|
let fixed_ring_cleared: usize = std.collections.fixedRingBufferClear(&mut fixed_ring)
|
|
var fixed_ring_clamp_storage: [4]u8 = [1_u8, 2_u8, 3_u8, 4_u8]
|
|
var fixed_ring_clamped: FixedRingBuffer<u8> = std.collections.fixedRingBuffer(fixed_ring_clamp_storage, 9_usize, 9_usize)
|
|
let fixed_ring_clamped_len: usize = std.collections.fixedRingBufferLen(&fixed_ring_clamped)
|
|
var fixed_ring_empty_storage: [4]u8 = [0_u8, 0_u8, 0_u8, 0_u8]
|
|
var fixed_ring_empty: FixedRingBuffer<u8> = std.collections.fixedRingBuffer(fixed_ring_empty_storage, 9_usize, 0_usize)
|
|
let fixed_ring_empty_pushed: Bool = std.collections.fixedRingBufferPushBack(&mut fixed_ring_empty, 7_u8)
|
|
var keys: [4]u8 = [1_u8, 2_u8, 3_u8, 0_u8]
|
|
var scores: [4]u16 = [10_u16, 20_u16, 30_u16, 0_u16]
|
|
var map_len: usize = 3
|
|
let map_start_remaining: usize = std.collections.mapRemaining(keys, scores, map_len)
|
|
let map_start_full: Bool = std.collections.mapIsFull(keys, scores, map_len)
|
|
let map_truncated: usize = std.collections.mapTruncate(keys, scores, map_len, 2_usize)
|
|
let map_cleared: usize = std.collections.mapClear(keys, scores, map_len)
|
|
let two_index: usize = std.collections.mapIndex(keys, map_len, 2_u8)
|
|
let found: Maybe<u16> = std.collections.mapGet(keys, scores, map_len, 2_u8)
|
|
let missing: Maybe<u16> = std.collections.mapGet(keys, scores, map_len, 9_u8)
|
|
let has_two: Bool = std.collections.mapContains(keys, map_len, 2_u8)
|
|
let has_nine: Bool = std.collections.mapContains(keys, map_len, 9_u8)
|
|
map_len = std.collections.mapPut(keys, scores, map_len, 4_u8, 40_u16)
|
|
let map_remaining_after_put: usize = std.collections.mapRemaining(keys, scores, map_len)
|
|
let map_full_after_put: Bool = std.collections.mapIsFull(keys, scores, map_len)
|
|
let added: Maybe<u16> = std.collections.mapGet(keys, scores, map_len, 4_u8)
|
|
let full_put: usize = std.collections.mapPut(keys, scores, map_len, 5_u8, 50_u16)
|
|
map_len = std.collections.mapPut(keys, scores, map_len, 2_u8, 25_u16)
|
|
let updated: Maybe<u16> = std.collections.mapGet(keys, scores, map_len, 2_u8)
|
|
let live_keys: Span<u8> = std.collections.mapKeys(keys, map_len)
|
|
let live_scores: Span<u16> = std.collections.mapValues(keys, scores, map_len)
|
|
let live_key_added: u8 = live_keys[3]
|
|
let live_score_updated: u16 = live_scores[1]
|
|
map_len = std.collections.mapRemove(keys, scores, map_len, 2_u8)
|
|
let removed_index: usize = std.collections.mapIndex(keys, map_len, 2_u8)
|
|
if len == 3 && duplicate == 4 && inserted_len == 4 && removed_len == 3 && has_five && first_value.has && first_value.value == 1_u8 && last_value.has && last_value.value == 5_u8 && popped_len == 3 && cleared == 0 && truncate_same == 4 && truncate_smaller == 3 && std.mem.len(set_live) == 3 && set_live[0] == 3_u8 && set_live[1] == 4_u8 && set_remaining == 1 && !set_full && set_truncated == 2 && set_cleared == 0 && fixed_set_inserted && !fixed_set_duplicate && fixed_set_removed && !fixed_set_missing_remove && fixed_set_has_two && std.mem.len(fixed_set_live) == 2 && fixed_set_live[0] == 3_u8 && fixed_set_live[1] == 2_u8 && fixed_set_remaining == 2 && !fixed_set_full && fixed_set_len == 2 && fixed_set_truncated == 1 && fixed_set_cleared == 0 && fixed_set_clamped_len == 4 && fixed_map_start_len == 2 && fixed_map_start_remaining == 1 && fixed_map_added && fixed_map_updated && !fixed_map_overflow && fixed_map_has_two && !fixed_map_has_nine && fixed_map_found.has && fixed_map_found.value == 25_u16 && !fixed_map_missing.has && fixed_map_two_index == 1 && fixed_map_missing_index == 3 && std.mem.len(fixed_map_live_keys) == 3 && fixed_map_live_keys[2] == 3_u8 && std.mem.len(fixed_map_live_scores) == 3 && fixed_map_live_scores[1] == 25_u16 && fixed_map_full && fixed_map_removed && !fixed_map_missing_remove && fixed_map_after_remove_len == 2 && fixed_map_truncated == 1 && fixed_map_cleared == 0 && fixed_map_clamped_len == 1 && fixed_alias_ok && absent_remove == 3 && invalid_remove == 9 && invalid_move == 9 && replaced_item && swapped_items && !invalid_replace && !invalid_swap && reversed_items && filled_items && rotated_left && rotated_right && !invalid_reverse && !invalid_fill && !invalid_rotate_left && !invalid_rotate_right && transform[0] == 1_u8 && transform[1] == 9_u8 && transform[2] == 9_u8 && transform[3] == 2_u8 && values[0] == 3_u8 && values[1] == 4_u8 && values[2] == 6_u8 && first == 0 && last == 1 && deque_front.has && deque_front.value == 1_u8 && deque_back.has && deque_back.value == 3_u8 && deque_after_pop_back == 2 && deque_len == 1 && deque_items[0] == 2_u8 && fixed_deque_push_back && fixed_deque_push_front && fixed_deque_push_back_again && fixed_deque_len == 3 && fixed_deque_remaining == 1 && fixed_deque_front.has && fixed_deque_front.value == 1_u8 && fixed_deque_back.has && fixed_deque_back.value == 3_u8 && fixed_deque_live_len == 3 && fixed_deque_live_middle == 2_u8 && fixed_deque_push_to_full && fixed_deque_full && !fixed_deque_overflow && fixed_deque_pop_back.has && fixed_deque_pop_back.value == 4_u8 && fixed_deque_pop_front.has && fixed_deque_pop_front.value == 1_u8 && fixed_deque_after_pop_len == 2 && fixed_deque_storage[0] == 2_u8 && fixed_deque_truncated == 1 && fixed_deque_cleared == 0 && fixed_deque_clamped_len == 4 && fixed_ring_push_back && fixed_ring_push_back_again && fixed_ring_push_front && fixed_ring_len == 3 && fixed_ring_capacity == 4 && fixed_ring_remaining == 1 && fixed_ring_front.has && fixed_ring_front.value == 1_u8 && fixed_ring_back.has && fixed_ring_back.value == 3_u8 && fixed_ring_middle.has && fixed_ring_middle.value == 2_u8 && fixed_ring_pop_front.has && fixed_ring_pop_front.value == 1_u8 && fixed_ring_push_back_wrap && fixed_ring_push_back_to_full && fixed_ring_full && !fixed_ring_overflow && fixed_ring_pop_back.has && fixed_ring_pop_back.value == 5_u8 && fixed_ring_after_wrap.has && fixed_ring_after_wrap.value == 4_u8 && fixed_ring_truncated == 2 && fixed_ring_cleared == 0 && fixed_ring_storage[0] == 2_u8 && fixed_ring_storage[2] == 4_u8 && fixed_ring_clamped_len == 4 && fixed_ring_empty_pushed && fixed_ring_empty_storage[0] == 7_u8 && fixed_ring_empty_storage[1] == 0_u8 && map_start_remaining == 1 && !map_start_full && map_truncated == 2 && map_cleared == 0 && two_index == 1 && found.has && found.value == 20_u16 && !missing.has && has_two && !has_nine && map_remaining_after_put == 0 && map_full_after_put && added.has && added.value == 40_u16 && full_put == 4 && updated.has && updated.value == 25_u16 && std.mem.len(live_keys) == 4 && live_key_added == 4_u8 && std.mem.len(live_scores) == 4 && live_score_updated == 25_u16 && map_len == 3 && removed_index == 3 && keys[1] == 4_u8 && scores[1] == 40_u16 {
|
|
check world.out.write("std collections u8 ok\n")
|
|
}
|
|
}
|