notzmv has quit [Remote host closed the connection]
v0idify has quit [Remote host closed the connection]
zags has quit [Ping timeout: 256 seconds]
v0idify has joined #zig
nycex- has quit [Remote host closed the connection]
nycex has joined #zig
brzg has joined #zig
midgard has quit [Ping timeout: 246 seconds]
Kiori_ has joined #zig
Kiori has quit [Ping timeout: 272 seconds]
midgard has joined #zig
a_chou has joined #zig
xackus_ has quit [Ping timeout: 264 seconds]
<v0idify>
I just properly understood how async works in zig and... it's so simple yet powerful! :)
gazler__ has quit [Remote host closed the connection]
gazler__ has joined #zig
midgard_ has joined #zig
midgard has quit [Ping timeout: 240 seconds]
dongcarl8 has joined #zig
dongcarl has quit [Ping timeout: 265 seconds]
dongcarl8 is now known as dongcarl
dyeplexer has joined #zig
brzg has quit [Quit: leaving]
a_chou has quit [Quit: a_chou]
earnestly has quit [Ping timeout: 240 seconds]
<andrewrk>
:)
<andrewrk>
evented I/O mode is still experimental, but I think the core design is solid
geemili has quit [Ping timeout: 258 seconds]
reductum has quit [Quit: WeeChat 3.0]
cole-h has quit [Quit: Goodbye]
cole-h has joined #zig
cole-h has quit [Client Quit]
cole-h has joined #zig
cole-h has quit [Client Quit]
leon-p has quit [Quit: leaving]
<daurnimator>
andrewrk: I'm not sure about that
<daurnimator>
I'd like to have about the discussion of it in a library context
<daurnimator>
god my language parser is broken
<daurnimator>
I'd like to have a discussion about it in a library context
<motiejus>
andrewrk: I see you solved the compilation problem by ignoring the `-c` flag, and now output is incompatible if I use plain clang vs `zig cc` (zig cc produces non-stripped binary, even though if `-c` is requested). It's OK for me, but something to keep in mind for `zig cc` users
<andrewrk>
motiejus, this is a missing feature of zig's linking abilities, to honor the request to strip
<andrewrk>
it will come in time
notzmv has joined #zig
<motiejus>
understood. so `zig build-obj` cannot build stripped libraries too? I am trying to find a workaround (compile object file and then link it as a separate step)
<andrewrk>
you can't build a stripped object; that is a contradictory request
<motiejus>
I mean, link it
<motiejus>
i.e. during the linking step
<motiejus>
unless `build-obj` is not a linker? (sorry I am new to this)
_whitelogger has joined #zig
<andrewrk>
daurnimator, I'm available for that
<andrewrk>
motiejus, generally one compiles into objects, and links into executables
<andrewrk>
build-obj is more of an advanced use case
<andrewrk>
stripping is something one does after linking (or during linking) removing some redundant information from the final binary
<andrewrk>
it's an optional step
<motiejus>
Yeah, that's what I tried - create an object file (`zig cc -o`) and then link+strip with ld equivalent (I assumed build-obj). Nevermind, the non-stripped binary is already smaller to the official stripped one, so I'm good with this
<motiejus>
Thanks for quick turnaround
cole-h has joined #zig
cole-h has quit [Client Quit]
squeek502 has quit [Remote host closed the connection]
squeek502 has joined #zig
jukan has quit [Read error: Connection reset by peer]
jukan has joined #zig
cole-h has joined #zig
waleee-cl has quit [Quit: Connection closed for inactivity]
cole-h has quit [Client Quit]
sord937 has joined #zig
cole-h has joined #zig
GreaseMonkey has quit [Remote host closed the connection]
decentpenguin has quit [Read error: Connection reset by peer]
decentpenguin has joined #zig
cole-h has quit [Quit: Goodbye]
cole-h has joined #zig
tnorth has joined #zig
<marler8997>
the first PR to win32metadata from the Zig community: https://github.com/microsoft/win32metadata/pull/212 I feel proud to be apart of this community that fixes other people's upstream projects
<daurnimator>
andrewrk: I'm around now if you still are.
zags has joined #zig
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
earnestly has joined #zig
gazler__ has quit [Ping timeout: 272 seconds]
gazler has joined #zig
cole-h has quit [Ping timeout: 256 seconds]
Snetry has quit [Ping timeout: 264 seconds]
<ifreund>
andrewrk: working on switches now :)
<zags>
ifreund: damn, what kind of espresso are you on? :D
<ifreund>
I find poking at the ast kind fun, and I'm very motivated to get andrew unblocked on this so stage2 can move forward and I can someday never have to use stage1 again :D
<ifreund>
plus, this is my way of procrastinating other things
<zags>
haha :D
<Piraty>
marler8997: if i'd be that upstream, i'd require you to give that commit a descriptive text
<Piraty>
mainly so people can read on the intention / change context without opening a browser to read #211 (and who knows if that issue will be online in N years)
<ifreund>
tbh a microsoft repo is not the place I'd worry about that
<ifreund>
I do very consciously avoid depending on github issues/PR descriptions for my own stuff and projects like zig thoughu
<Piraty>
that is wise to do
<Piraty>
and why not teach M$ how to properly git
<daurnimator>
I use `git-bug` to get a local copy of issues/pullrequests
<ifreund>
from their readme: "doesn't pollute your project: no files are added in your project"
<ifreund>
how does it work then?
<earnestly>
It pollutes^Wembeds in your .git directory
<zags>
maybe Fossil was right all along, every repo is also an issues tracker/wiki :)
<earnestly>
I appreciate though that the architecture for git allows for this sort of experimentation
<earnestly>
for/of
<ifreund>
indeed, I also take advantage of it with random .git/todo files
<daurnimator>
ifreund: yeah it essentially makes a heap of git objects with the bugs
layneson has joined #zig
layneson has quit [Client Quit]
betawaffle has quit [Ping timeout: 240 seconds]
gonz_ has quit [Read error: Connection reset by peer]
yrashk has quit [Ping timeout: 246 seconds]
shurane has quit [Ping timeout: 264 seconds]
dch has quit [Read error: Connection reset by peer]
euantorano has quit [Read error: Connection reset by peer]
rtpg has quit [Ping timeout: 272 seconds]
jzelinskie has quit [Write error: Connection reset by peer]
ovf has quit [Ping timeout: 260 seconds]
lukego has quit [Read error: Connection reset by peer]
bitmapper has quit [Read error: Connection reset by peer]
eddyb[legacy] has quit [Read error: Connection reset by peer]
r0bby has quit [Read error: Connection reset by peer]
kwilczynski has quit [Read error: Connection reset by peer]
dch has joined #zig
betawaffle has joined #zig
gonz_ has joined #zig
euantorano has joined #zig
eddyb[legacy] has joined #zig
lukego has joined #zig
yrashk has joined #zig
kwilczynski has joined #zig
midgard_ has quit [Ping timeout: 264 seconds]
ovf has joined #zig
jzelinskie has joined #zig
r0bby has joined #zig
rtpg has joined #zig
midgard has joined #zig
bitmapper has joined #zig
bsrd has quit [Quit: WeeChat 3.0]
bsrd has joined #zig
xackus_ has joined #zig
shurane has joined #zig
Snetry has joined #zig
<zags>
is there a syntax to get an instance of the default value of a given type? Useful in generic code. In C++ you'd do T{} or T()
<g-w1>
const s: S = .{};
<zags>
zero-initialization basically
<ifreund>
T{} works if you define default values for your type's fields
<g-w1>
there is only that if you specify default
<zags>
type 'u64' does not support array initialization
<zags>
need to support primitives
<g-w1>
why not just 0?
<ifreund>
yeah, .{} only works for structs that have a default value for every field
<zags>
g-w1: because it's a generic function
<zags>
type can be struct or primitive
<ifreund>
there's std.mem.zeros if you really want to init everything to zero
<ifreund>
this is considered an antipattern in zig though
<zags>
ifreund: but how do I declare the variable?
<zags>
it needs to be initialized
<zags>
or zig says no
<ifreund>
std.mem.zeros returns a value
<g-w1>
var m: T = std.mem.zeroes(T);
<zags>
oh I see
<zags>
that's exactly what I need, thanks guys
kchambers has joined #zig
<zags>
ifreund: I don't see why zero-init would be an anti-pattern, quite common in C++ tempalte code at least
<zags>
template*
<ifreund>
being similar to C++ template code is not a goal
<zags>
but being able to do the same things is
<ifreund>
in idiomatic zig you either use undefined or a value that actually has meaning
<zags>
it's well-defined what var x: T = .{} means if would also zero-init primitives
<zags>
or some other general syntax
<ifreund>
but is zero a meaningful default value in all case? I think not
<zags>
in many cases it is
<zags>
and you'd explicitely ask for it
<zags>
now i have to resort to mem.zeroes
<ifreund>
mem.zeroes exists so there's no need for new language syntax/semantics
<zags>
always good to have an anti-pattern in the tool belt
<ifreund>
it's in the std primarily for use when interfacing with C code that expects zero init
<ifreund>
note the doc comment
<zags>
this is so I can spring a variable in a generic into existence
<ifreund>
you can also do var m: T = undefined
<zags>
yeah, true
donniewest1 has joined #zig
leon-p has joined #zig
<ifreund>
andrewrk: switches done, I'm going to take a break working on zig fmt and go back to river for a bit now :)
<fengb>
Handmade Seattle has a podcast where Andrew explains why not zero init
<ifreund>
TLDR you already can but the ergonomics suck
<ifreund>
and using an anon function isn't a great solution as you'd have to pass everything in as arguments
hnOsmium0001 has joined #zig
<v0idify>
how do I see if a frame is done?
<v0idify>
ex. it has returned, without blocking
xackus_ has quit [Read error: Connection reset by peer]
xackus__ has joined #zig
<zags>
fengb: yeah it does, but error propagation is already a sort of exceptions :) I would use the block/catch rarely, but sometimes it makes a lot of sense
<zags>
ifreund: thanks, good issue
<zags>
having switch |err| as sugar for catch |err| switch (err) would also be helpful to me, but that's already been rejected iirc
<zags>
which is strange given that the language tries to optimize for making error handling smooth
tnorth has quit [Ping timeout: 258 seconds]
<v0idify>
are string literals null terminated by default?
<mikdusan>
yes
<fengb>
Yes, only literals though
<ifreund>
string literals are pointers to null-terminated arrayrs
<mikdusan>
wait wait I can do better. string literals are const pointers to null-terminated arrays
<dutchie>
on the other hand, a "string" is normally a slice of u8 (i.e. a fat pointer with a length field)
<DarkUranium>
mikdusan, string literals in C are non-const pointers to const null-terminated arrays.
<dutchie>
(and not in general null-terminated)
<DarkUranium>
(type of a string literal in C is `char[n]`, not `const char[n]`)
<fengb>
We're not talking about C
amk has quit [Remote host closed the connection]
amk has joined #zig
<zags>
#1717 expression can be immediately evaluates right? as in fn() bool {...}()
<zags>
evaluated*
<Snektron>
probably but you can always just use `blk: { ... break :blk value; }`
Kiori_ has quit [Ping timeout: 240 seconds]
<ifreund>
zags: your code in the comment you posted should work with the current proposal, but without the try keyword
<zags>
your original comment has multiple try's inside
<ifreund>
though you probably want try on your explode(), sleep(), and run() calls
<zags>
that's what my comment changes :)
<ifreund>
ew now please lets not do that
<zags>
why not
<ifreund>
that's implicit control flow
<zags>
try is that already
<zags>
it returns
<ifreund>
the keyword makes it explict
<ifreund>
implict would be the possiblity for a function call to cause a return *without* a keyword prefixing it
<ifreund>
which is what your suggestion does
<zags>
the try in front of fn makes it clear what will happen
<ifreund>
imagine the case in which the anon function is much longer and has non-trivial control flow
<ifreund>
and some functions called from within it return errors and some don
<ifreund>
t
<zags>
comment gone, I need to think it through haha
<ifreund>
heh, it would be completely contradictory to the core principles of zig IMO :P
<companion_cube>
zags: `fn() {…}()` is an abomination that only exists in languages that don't have blocks-returning-values
<companion_cube>
(namely, js and go)
<ifreund>
zags: really, I think #5610 is what you want
<zags>
well, I'm making a stream-like interface and Zig makes it real hard to make it fluent, so just trying out various ideas
<companion_cube>
stream, like map/filter stuff
<companion_cube>
?
<zags>
yeah, the {}catch thing is what I came up with independently
<zags>
companion_cube: yeah
<ifreund>
I seem to recall that andrew isn't really a fan of such APIs specifically because they conflict with robust and explict error handling
<companion_cube>
without closures that' ll be hard
<zags>
ifreund: i'll make it anyway because I'm a huge fan of it
<ifreund>
I for one am very curious to see where your library ends up :)
<zags>
companion_cube: yeah it sucks, but a large number of common freestanding functions you can plug in (lt,gt,mul,div, etc) will help
<companion_cube>
oh, like as function pointers?
<zags>
ifreund: raw loops suck too, i tend to use <algorithms> and Stream type apis where available. Very readable and easy to refactor.
<zags>
companion_cube: yeah, wrapped in applicatives
<zags>
var result = try intStream.from(&ages).filter(lessThan(min)).map(u64, asFloat64).reduce(1, mul);
<zags>
this works in the prototype
<zags>
nice thing is you can lazily build a type safe pipelines of operations, and it doesn't do anything until you want to do the terminating operation
<zags>
should be possible to make parallell streams as well
<zags>
and stuff like zipping, skipping, limiting, flat-mapping, sorting, averaging and other tasty things
<companion_cube>
the language will fight you
<zags>
sure, it already does - anyway, good way to learn zig even if nobody will ever use it :)
<zags>
but so far it looks better than I expected actually
<zags>
like the zip (non-streamy so far) was actually quite nice thanks to comptime
<fengb>
It's all fun and games until you realize the secret memory usage
<zags>
what do you mean?
<zags>
streams are very good at not using memory
<fengb>
Oh I see
<companion_cube>
seems to work ok in rust, I'd say
notzmv has quit [Read error: Connection reset by peer]
cole-h has joined #zig
<justin_smith>
my experience is that the common programming error with streams is that they can make resource lifetimes and reliance of external state break
<zags>
in what language? never had the issue
<justin_smith>
the "secret memory usage" that comes up in haskell (which effectively streams implicitly) is because of all the resources a stream might keep alive
<justin_smith>
zags: in clojure where more ~half of stdlib is lazy
<zags>
yikes, yeah
<companion_cube>
it's only in haskell
<companion_cube>
otherwise streams are consumed on demand
<justin_smith>
for example, someone creates a code block that consumes a FD - two mistakes are possible here - returning the streaming op while closing the fd (using an expired fd) or leaving an fd open (didn't finalize the stream)
<zags>
yup
<zags>
i've never done anything remotely like that, and i use streams like 10 times per day lol
<justin_smith>
companion_cube: as a real world example: I used a clojure lib that provided a lazy API over a tagsoup style xml api
<justin_smith>
companion_cube: I had a huge memory leak as it "helpfully" held off closing the input stream until end of stream is reached
<companion_cube>
the bugs caused by evaluating lazy stuff too late is real
<companion_cube>
are real*
<companion_cube>
ahaha damn
<justin_smith>
(while one point of a tag soup is you can just stop consuming...)
<companion_cube>
I'd expect it to not leak, but fail if you consume stuff too late as the underlying source is not present anymore
<companion_cube>
it's a tradeoff
<justin_smith>
companion_cube: right - but it's an intrinsic one with the streaming model
<zags>
i love lisp and hated clojure despite its neat persistent data structures
<zags>
the jvm marriage is disgusting
<zags>
convenient of course
<justin_smith>
zags: haha, it's the kind of disgusting that ensures I can use a lispy language at an "enterprise" type company
<zags>
lol right :D
<justin_smith>
zags: in fact, I think what it shares with zig is providing uncomplicated access to the substrate
<justin_smith>
in clj that's the vm, in zig that's the hardware
<zags>
give me a scheme with a good stdlib and good C interop instead
<justin_smith>
for values of "uncomplicated" approximating "only the complexity of the thing offered"
<justin_smith>
zags: good luck pitching that to a startup :D
<zags>
yeah I get the problem :)
<zags>
fortunately I'm the one deciding in my comp :D
<zags>
which means Zig will get used way before it should hehe
dyeplexer has quit [Remote host closed the connection]
notzmv has joined #zig
ifreund has quit [Read error: Connection reset by peer]
ifreund1 has joined #zig
ifreund1 is now known as ifreund
Akuli has joined #zig
<v0idify>
*y = slot.advance.y >> 6; // why is this wrong? "invalid left-hand side to assignment"
<waleee-cl>
there's also carp, but lisp + borrow-checker seems like a potential match mad -in hell
<ifreund>
janet is sweet :)
<waleee-cl>
ifreund: yeah, that recommendation should have had an attribution (saw you mention it there)
<ifreund>
there == #river?
<waleee-cl>
ah. yeah :)
<ifreund>
:)
craigo has joined #zig
craigo has quit [Remote host closed the connection]
<v0idify>
how do I check for an overflow without actually saving the result
<v0idify>
like if overflow { this value } else { just use the result }
<g-w1>
if i +% 1 = 0 ?
<g-w1>
*==
<v0idify>
well yeah but i'm not just using 1
<ikskuh>
v0idify: @addWithOverflow
Akuli has quit [Quit: Leaving]
<v0idify>
i already looked into that but for some reason it was no good. i'll check again
<ikskuh>
you have to have a result location for it
<ikskuh>
but you can just use a temporary
<zags>
waleee-cl: not yet! Swift, Rust, Julia, Nim and now Zig has already been enough for my "try new languages" list the past couple of months
<v0idify>
i33 to fit a u32 feels very wrong
<ikskuh>
v0idify, can you post the code snippet in question?
<ikskuh>
maybe there's an easy solution
<ifreund>
zags: which one of those did you like the most? (and why is it zig? :P)
<v0idify>
ikskuh, dw i'm just having serious issues with middle school math
<ikskuh>
hm?
<v0idify>
addition and substraction lol
<zags>
ifreund: It is Zig :) I liked Nim a great deal, but the low quality of the 3rd party modules I had to rely on was a show stopper.
<zags>
That's why I was bitching about a peer-reviewed, community driven boost-like initiative for Zig, and boy did I get crushed :D
<companion_cube>
boost doesn't cover that much, does it?
<companion_cube>
compared to the stdlib of non C++ languages
<zags>
i does, it's a life saver
<zags>
starting with ASIO
<companion_cube>
what kind of things do you use it for?
<zags>
boost?
<ikskuh>
companion_cube: c++11 adopted a lot of boost into c++ s td
<zags>
yep
<zags>
i would like a similar initiative for Zig, but not the monolithic style. Small-language communities always get low quality, unmaintained libraries. Nim is great proof too.
<v0idify>
essentially the problem i'm having is i want to (u32 - c_int) and if that would result in < 0 (underflow) just set to 0
<v0idify>
but it seems i need to convert to i33 to do the math
<zags>
waleee-cl: thanks for that link, it looks like a great lisp dialect
<v0idify>
zags, you're forgetting that zig is aiming for total world domination :P
<companion_cube>
ikskuh: but that's my point
<v0idify>
i like the idea
<companion_cube>
there still isn't that much in C++'s stdlib
ur5us_ has joined #zig
<companion_cube>
in a modern language most of that should already be in the stdlib, not in 3rd party libs
<v0idify>
that doesn't solve my "problem", t needs to be i33
<ikskuh>
ah
<v0idify>
although it it useful, i'm doing what that function does manually :)
<ikskuh>
what guarantees do you have?
remby has joined #zig
<v0idify>
well, c_int comes from freetype
<v0idify>
it's the offset of a character
<ikskuh>
and you add that to?
<ikskuh>
a pixel coordinate?
<v0idify>
yes
<ikskuh>
you can also cast both to i32
<ikskuh>
because your result might be negative
<v0idify>
u32 can't be casted into i32
<v0idify>
it needs to be i33
<v0idify>
but also i don't care about the negative result (if i get that, i set to 0)
<v0idify>
so i need to go from u32 and i32 to i33 and i33 to u32 again
<ikskuh>
@intCast exists ;)
<ikskuh>
it cannot be coerced into i32, but it can be casted
<v0idify>
fair enough, i doubt the coordinate will be the limit of u32 ^^
<ifreund>
I don't follow, what are the two endpoints you are trying to convert between?
<ikskuh>
u32-c_int
<ifreund>
you could just use u31
<v0idify>
well i would have to set everything to use u32 coordinates
<v0idify>
31*
<v0idify>
(y: u32) - (bitmap_top: c_int). i care if bitmap_top is negative but not if the result is negative (if it is, i set to 0)
<v0idify>
i guess i will intCast the y to i32
<ifreund>
hrm can I use @fieldParentPtr() a pointer to the payload of an optional field?
<ifreund>
that would certainly be convienent right now
<ifreund>
also, can I set an optional field to undefined but non-null?
<ikskuh>
ifreund:
<ikskuh>
var x: ?u32 = @as(u32, undefined);
<ifreund>
that makes sense
<ikskuh>
yes, you can optional-pointer fieldParentPtr afaik
<ifreund>
I have a pointer to the payload not the struct field though
<ifreund>
it feels like it's probably UB but it could theoretically be allowed
<ifreund>
maybe spexguy can help me
<v0idify>
expected type '[*c]const u8', found '[]const u8' what am I supposed to do?
<ifreund>
ikskuh: it doesn't compile :(
<ikskuh>
sad :(
<ifreund>
/tmp/foo.zig:11:50: error: expected type '*const ?u32', found '*const u32'
<ifreund>
yeah...
<zags>
Zig says no
<ifreund>
a @optionalParent() builtin would be possible to implement
<ikskuh>
ifreund: you can probably just ptrcast?
<ifreund>
that's gotta be UB right?
<ikskuh>
nah, the address isn't changing
<ifreund>
you sure? I thought optionals don't have a well defined memory layout
<ikskuh>
optionals for non-allowzero pointers have the same memory layout as a pointer
<ifreund>
the payload isn't a pointer though, it's a struct
<ikskuh>
v0idify: []const u8 is a slice (so ptr+len), but [*c]const u8 is a C pointer
<ikskuh>
ifreund: ah dang
<v0idify>
ikskuh, but can't it downgrade to a pointer?
<ikskuh>
v0idify: so solution would be: find out what pointer C expects there
<v0idify>
i ptrCast'd
<ikskuh>
you can probably just use slice.ptr
<ikskuh>
instead of slice
Kiori has quit [Read error: Connection reset by peer]
<v0idify>
oh! i didn't know that
<ifreund>
unless C wants a null terminated pointer...
xackus__ has quit [Ping timeout: 256 seconds]
<ikskuh>
note that if it's a C string, you might want to use [:0]const u8 (zero-terminated slice with runtime check for terminator)
<v0idify>
oh that's cool
<v0idify>
thanks
jukan_ has joined #zig
<v0idify>
time to add harfbuzz into the mix
jukan has quit [Ping timeout: 256 seconds]
<ikskuh>
time to go to bed! o/
<v0idify>
o/
euantorano has quit [Read error: Connection reset by peer]
shurane has quit [Read error: Connection reset by peer]
euantorano has joined #zig
shurane has joined #zig
<ifreund>
ah, found a way to work around my problems by refactoring :)
<ifreund>
still some inefficiency due to lack of @optonalParentPtr() though
riba has quit [Ping timeout: 265 seconds]
donniewest1 has quit [Quit: WeeChat 3.0.1]
nvmd has quit [Quit: Later nerds.]
<andrewrk>
ifreund, really appreciate your help! I took a break this weekend so as to not burn out but now I'm back at it :)
ky0ko has quit [Remote host closed the connection]
ur5us_ has quit [Ping timeout: 264 seconds]
<ifreund>
no problem! not burning out is very important :)
<ifreund>
I'm taking a break right now too to work on river, though I've got a PR up for switches and stuff
<ifreund>
andrewrk: I actually did try the @as(*[1]Node.Index, foo) but it didn't compile for whatever reason
<andrewrk>
ah
<andrewrk>
probably not enough magic smoke in your computer
<ifreund>
:D
<ifreund>
I've noticed that coercion between the branches of if statements is funky before
midgard has quit [Read error: Connection reset by peer]
<andrewrk>
oh yeah. good news is that I solved it really cleanly in self-hosted
nycex has quit [Remote host closed the connection]
nycex has joined #zig
midgard has joined #zig
<ifreund>
I can't wait :)
remby has quit [Quit: Connection closed]
<ifreund>
hence my motivation to get the zig fmt refactor done so you can get back to the rest of stage2
<ifreund>
plus futzing around with the ast is kind fun
<andrewrk>
:)
<andrewrk>
btw you know how people always say it's too hard to do cleanup right because it's a rarely tested codepath?
<andrewrk>
each of those parser_test.zig cases get run with every possible allocation failing and makes sure the returned error is OutOfMemory with no leaks