Logical operator treating fractions as FALSE

Bitwise operators don't do floating-point math, so there's an implicit conversion going on before the operands are given for the And operator to do its bitwise thing.

"Logical" operators are a scam. There's no such thing, we've been lied to all this time - it's another Santa / Tooth Fairy / Easter Bunny (never mind, I'm being told the Easter Bunny is real): they're bitwise operators, always, regardless of what you give them.

And since the bitwise math yields 0, then it can only mean that the implicit conversion is simply slicing off the decimal portion.

Bottom line, ...don't do bitwise stuff with non-integers, and avoid implicit type conversions in general. The standard library has a bunch of explicit conversion functions for that:

Debug.Print VBA.Conversion.CLng(0.5) And True '<~ explicit conversion

CLng is documented to round 0.5 down to 0, If you need to determine whether to round down to 0 or up to 1, then be explicit about it:

Debug.Print CInt(0.5 + 0.01) And True '<~ explicit "round 0.5 up to 1"

In any case, working with non-integer operands to a bitwise operator makes no sense.

When the fractional part is exactly 0.5, CInt and CLng always round it to the nearest even number. For example, 0.5 rounds to 0, and 1.5 rounds to 2.

Javascript has worse quirks than that around those parts, not sure how fair calling implicit type conversions "strange" is.

I thought VBA would treat any number other than zero as TRUE

That depends on the context. -1 is True, but True is Not False. That makes True -1 internally, probably as a 32-bit integer, so in binary it might look like this:

11111111 11111111 11111111 11111111

Bit-wise, the Boolean value True must have this representation, because this needs to be the representation for False:

00000000 00000000 00000000 00000000

Bitwise logic needs the two operands to be the same type, so that the bits mean the same thing on both sides, otherwise the bitwise operation - which is supposed to be simple and fast - needs to start doing complicated analysis to work out what it's looking at, when it simply doesn't need to.. if we accept that bitwise logic works with integer types, period.

You can do MsgBox 42 And 12, you'll get the bitwise result 8:

00000000 00000000 00000000 00101010 ' 42
00000000 00000000 00000000 00001100 ' 12
00000000 00000000 00000000 00001000 '  8 (AND)

The result of the And operator is always going to be a bitwise-and result - what we call "logical operators" is just bitwise operators working with Boolean operands:

00000000 00000000 00000000 00000000 ' False
11111111 11111111 11111111 11111111 ' True
00000000 00000000 00000000 00000000 ' False (AND)

But if the operand themselves aren't of an integer type, then they get converted to one before the operator gets to look at them. That's when True becomes -1, and that's when 0.5 becomes 0.