import encoding.base64 fn test_long_encoding() { repeats := 1000 input_size := 3000 s_original := []u8{len: input_size, init: `a`} s_encoded := base64.encode(s_original) s_encoded_bytes := s_encoded.bytes() s_decoded := base64.decode(s_encoded) assert s_encoded.len > s_original.len assert s_original == s_decoded ebuffer := unsafe { malloc(s_encoded.len) } dbuffer := unsafe { malloc(s_decoded.len) } defer { unsafe { free(ebuffer) } unsafe { free(dbuffer) } } // encoded_size := base64.encode_in_buffer(s_original, ebuffer) mut encoded_in_buf := []u8{len: encoded_size} unsafe { C.memcpy(encoded_in_buf.data, ebuffer, encoded_size) } assert input_size * 4 / 3 == encoded_size assert encoded_in_buf[0] == `Y` assert encoded_in_buf[1] == `W` assert encoded_in_buf[2] == `F` assert encoded_in_buf[3] == `h` assert encoded_in_buf[encoded_size - 4] == `Y` assert encoded_in_buf[encoded_size - 3] == `W` assert encoded_in_buf[encoded_size - 2] == `F` assert encoded_in_buf[encoded_size - 1] == `h` assert encoded_in_buf == s_encoded_bytes decoded_size := base64.decode_in_buffer(s_encoded, dbuffer) assert decoded_size == input_size mut decoded_in_buf := []u8{len: decoded_size} unsafe { C.memcpy(decoded_in_buf.data, dbuffer, decoded_size) } assert decoded_in_buf == s_original mut s := 0 for _ in 0 .. repeats { resultsize := base64.encode_in_buffer(s_original, ebuffer) s += resultsize assert resultsize == s_encoded.len } for _ in 0 .. repeats { resultsize := base64.decode_in_buffer(s_encoded, dbuffer) s += resultsize assert resultsize == s_decoded.len } println('Final s: $s') // assert s == 39147008 }