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
82 lines
7.4 KiB
Plaintext
82 lines
7.4 KiB
Plaintext
pub fn main(world: World) -> Void raises {
|
|
var storage: [4]u8 = [0, 0, 0, 0]
|
|
var vec: Vec = std.mem.vec(storage)
|
|
let emptyBeforePush: Bool = std.mem.vecIsEmpty(&vec)
|
|
let pushedA: Bool = std.mem.vecPush(&mut vec, 65_u8)
|
|
let pushedB: Bool = std.mem.vecPush(&mut vec, 66_u8)
|
|
let setSecond: Bool = std.mem.vecSet(&mut vec, 1_usize, 67_u8)
|
|
let setMissing: Bool = std.mem.vecSet(&mut vec, 9_usize, 68_u8)
|
|
let remaining: usize = std.mem.vecRemaining(&vec)
|
|
let fullAfterTwo: Bool = std.mem.vecIsFull(&vec)
|
|
let firstRead: Maybe<u8> = std.mem.vecGet(&vec, 0_usize)
|
|
let secondRead: Maybe<u8> = std.mem.vecGet(&vec, 1_usize)
|
|
let missingRead: Maybe<u8> = std.mem.vecGet(&vec, 9_usize)
|
|
let containsSecond: Bool = std.mem.vecContains(&vec, 67_u8)
|
|
let missingValue: Bool = std.mem.vecContains(&vec, 68_u8)
|
|
let secondIndex: usize = std.mem.vecIndex(&vec, 67_u8)
|
|
let missingIndex: usize = std.mem.vecIndex(&vec, 68_u8)
|
|
let uniqueDuplicate: Bool = std.mem.vecInsertUnique(&mut vec, 67_u8)
|
|
let uniqueInsert: Bool = std.mem.vecInsertUnique(&mut vec, 68_u8)
|
|
let valueRemoved: Bool = std.mem.vecRemoveValue(&mut vec, 65_u8)
|
|
let valueRemoveMissing: Bool = std.mem.vecRemoveValue(&mut vec, 65_u8)
|
|
let removedFirst: Bool = std.mem.vecRemoveSwap(&mut vec, 0_usize)
|
|
let removeMissing: Bool = std.mem.vecRemoveSwap(&mut vec, 9_usize)
|
|
let firstAfterRemove: Maybe<u8> = std.mem.vecGet(&vec, 0_usize)
|
|
let pushedC: Bool = std.mem.vecPush(&mut vec, 69_u8)
|
|
let bytesBeforeTruncate: Span<u8> = std.mem.vecBytes(&vec)
|
|
let truncatedHigh: usize = std.mem.vecTruncate(&mut vec, 4_usize)
|
|
let truncated: usize = std.mem.vecTruncate(&mut vec, 1_usize)
|
|
let secondAfterTruncate: Maybe<u8> = std.mem.vecGet(&vec, 1_usize)
|
|
let bytesBeforePop: Span<u8> = std.mem.vecBytes(&vec)
|
|
let popped: Bool = std.mem.vecPop(&mut vec)
|
|
let bytesAfterPop: Span<u8> = std.mem.vecBytes(&vec)
|
|
let cleared: usize = std.mem.vecClear(&mut vec)
|
|
let emptyAfterClear: Bool = std.mem.vecIsEmpty(&vec)
|
|
var values: [4]u8 = [0, 0, 0, 0]
|
|
var len: usize = 0
|
|
len = std.collections.push(values, len, 65_u8)
|
|
len = std.collections.push(values, len, 66_u8)
|
|
let live: Span<u8> = std.collections.view(values, len)
|
|
var setBacking: [4]u8 = [0_u8; 4]
|
|
var dequeBacking: [4]u8 = [0_u8; 4]
|
|
var mapKeyBacking: [3]u8 = [0_u8; 3]
|
|
var mapValueBacking: [3]u8 = [0_u8; 3]
|
|
var setAlloc: FixedBufAlloc = std.mem.fixedBufAlloc(setBacking)
|
|
var dequeAlloc: FixedBufAlloc = std.mem.fixedBufAlloc(dequeBacking)
|
|
var mapKeyAlloc: FixedBufAlloc = std.mem.fixedBufAlloc(mapKeyBacking)
|
|
var mapValueAlloc: FixedBufAlloc = std.mem.fixedBufAlloc(mapValueBacking)
|
|
let setStorageMaybe: Maybe<MutSpan<u8>> = std.mem.allocBytes(setAlloc, 4_usize)
|
|
let dequeStorageMaybe: Maybe<MutSpan<u8>> = std.mem.allocBytes(dequeAlloc, 4_usize)
|
|
let mapKeysMaybe: Maybe<MutSpan<u8>> = std.mem.allocBytes(mapKeyAlloc, 3_usize)
|
|
let mapValuesMaybe: Maybe<MutSpan<u8>> = std.mem.allocBytes(mapValueAlloc, 3_usize)
|
|
var allocatorContainersOk: Bool = false
|
|
if setStorageMaybe.has && dequeStorageMaybe.has && mapKeysMaybe.has && mapValuesMaybe.has {
|
|
var allocatorSet: FixedSet<u8> = std.collections.fixedSet(setStorageMaybe.value, 0_usize)
|
|
let allocatorSetInsertedA: Bool = std.collections.fixedSetInsert(&mut allocatorSet, 70_u8)
|
|
let allocatorSetInsertedB: Bool = std.collections.fixedSetInsert(&mut allocatorSet, 71_u8)
|
|
let allocatorSetDuplicate: Bool = std.collections.fixedSetInsert(&mut allocatorSet, 71_u8)
|
|
let allocatorSetRemoved: Bool = std.collections.fixedSetRemove(&mut allocatorSet, 70_u8)
|
|
let allocatorSetLive: Span<u8> = std.collections.fixedSetView(&allocatorSet)
|
|
var allocatorDeque: FixedDeque<u8> = std.collections.fixedDeque(dequeStorageMaybe.value, 0_usize)
|
|
let allocatorDequePushBack: Bool = std.collections.fixedDequePushBack(&mut allocatorDeque, 80_u8)
|
|
let allocatorDequePushFront: Bool = std.collections.fixedDequePushFront(&mut allocatorDeque, 79_u8)
|
|
let allocatorDequeFront: Maybe<u8> = std.collections.fixedDequeFront(&allocatorDeque)
|
|
let allocatorDequeBack: Maybe<u8> = std.collections.fixedDequeBack(&allocatorDeque)
|
|
let allocatorDequePopFront: Maybe<u8> = std.collections.fixedDequePopFront(&mut allocatorDeque)
|
|
let allocatorDequeLive: Span<u8> = std.collections.fixedDequeView(&allocatorDeque)
|
|
var allocatorMap: FixedMap<u8, u8> = std.collections.fixedMap(mapKeysMaybe.value, mapValuesMaybe.value, 0_usize)
|
|
let allocatorMapPutA: Bool = std.collections.fixedMapPut(&mut allocatorMap, 1_u8, 90_u8)
|
|
let allocatorMapPutB: Bool = std.collections.fixedMapPut(&mut allocatorMap, 2_u8, 91_u8)
|
|
let allocatorMapUpdated: Bool = std.collections.fixedMapPut(&mut allocatorMap, 2_u8, 92_u8)
|
|
let allocatorMapValue: Maybe<u8> = std.collections.fixedMapGet(&allocatorMap, 2_u8)
|
|
let allocatorMapKeys: Span<u8> = std.collections.fixedMapKeys(&allocatorMap)
|
|
let allocatorMapValues: Span<u8> = std.collections.fixedMapValues(&allocatorMap)
|
|
let allocatorMapBeforeRemoveOk: Bool = allocatorMapValue.has && allocatorMapValue.value == 92_u8 && std.mem.len(allocatorMapKeys) == 2 && std.mem.len(allocatorMapValues) == 2 && allocatorMapKeys[0] == 1_u8 && allocatorMapKeys[1] == 2_u8 && allocatorMapValues[0] == 90_u8 && allocatorMapValues[1] == 92_u8
|
|
let allocatorMapRemoved: Bool = std.collections.fixedMapRemove(&mut allocatorMap, 1_u8)
|
|
allocatorContainersOk = allocatorSetInsertedA && allocatorSetInsertedB && !allocatorSetDuplicate && allocatorSetRemoved && std.mem.len(allocatorSetLive) == 1 && allocatorSetLive[0] == 71_u8 && std.collections.fixedSetContains(&allocatorSet, 71_u8) && allocatorDequePushBack && allocatorDequePushFront && allocatorDequeFront.has && allocatorDequeFront.value == 79_u8 && allocatorDequeBack.has && allocatorDequeBack.value == 80_u8 && allocatorDequePopFront.has && allocatorDequePopFront.value == 79_u8 && std.mem.len(allocatorDequeLive) == 1 && allocatorDequeLive[0] == 80_u8 && allocatorMapPutA && allocatorMapPutB && allocatorMapUpdated && allocatorMapBeforeRemoveOk && allocatorMapRemoved && std.collections.fixedMapLen(&allocatorMap) == 1 && std.collections.fixedMapContains(&allocatorMap, 2_u8)
|
|
}
|
|
if emptyBeforePush && pushedA && pushedB && setSecond && !setMissing && std.mem.vecLen(&vec) == 0 && std.mem.vecCapacity(&vec) == 4 && remaining == 2 && !fullAfterTwo && firstRead.has && firstRead.value == 65_u8 && secondRead.has && secondRead.value == 67_u8 && !missingRead.has && containsSecond && !missingValue && secondIndex == 1_usize && missingIndex == 2_usize && !uniqueDuplicate && uniqueInsert && valueRemoved && !valueRemoveMissing && removedFirst && !removeMissing && firstAfterRemove.has && firstAfterRemove.value == 67_u8 && pushedC && truncatedHigh == 2 && truncated == 1 && !secondAfterTruncate.has && popped && cleared == 0 && emptyAfterClear && std.mem.len(bytesBeforeTruncate) == 2 && std.mem.len(bytesBeforePop) == 1 && std.mem.len(bytesAfterPop) == 0 && bytesBeforeTruncate[0] == 67_u8 && bytesBeforeTruncate[1] == 69_u8 && bytesBeforePop[0] == 67_u8 && storage[0] == 67_u8 && storage[1] == 69_u8 && std.mem.len(live) == 2 && std.collections.remaining(values, len) == 2 && !std.collections.isFull(values, len) && std.collections.contains(values, len, 66_u8) && allocatorContainersOk {
|
|
check world.out.write("std mem collections ok\n")
|
|
}
|
|
}
|