diff --git a/include/dice/cbor_writer.h b/include/dice/cbor_writer.h
index 9835c6e..700d57f 100644
--- a/include/dice/cbor_writer.h
+++ b/include/dice/cbor_writer.h
@@ -15,6 +15,7 @@
 #ifndef DICE_CBOR_WRITER_H_
 #define DICE_CBOR_WRITER_H_
 
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ -24,32 +25,49 @@
 
 struct CborOut {
   uint8_t* buffer;
-  size_t size;
-  size_t offset;
+  size_t buffer_size;
+  size_t cursor;
 };
 
+// Initializes an output stream for writing CBOR tokens.
+static inline void CborOutInit(uint8_t* buffer, size_t buffer_size,
+                               struct CborOut* out) {
+  out->buffer = buffer;
+  out->buffer_size = buffer_size;
+  out->cursor = 0;
+}
+
+// Returns the number of bytes of encoded data. If |CborOutOverflowed()|
+// returns false, this number of bytes have been written, otherwise, this is the
+// number of bytes that that would have been written had there been space.
+static inline size_t CborOutSize(const struct CborOut* out) {
+  return out->cursor;
+}
+
+// Returns whether the |out| buffer contains the encoded tokens written to it or
+// whether the encoded tokens did not fit and the contents of the buffer should
+// be considered invalid.
+static inline bool CborOutOverflowed(const struct CborOut* out) {
+  return out->cursor == SIZE_MAX || out->cursor > out->buffer_size;
+}
+
 // These functions write simple deterministically encoded CBOR tokens to an
-// output buffer. If a NULL buffer is provided, nothing is written but the
-// offset is still increased and the size returned to allow for measurement of
-// the encoded data.
+// output buffer. The offset is always increased, even if there is not enough
+// space in the output buffer to allow for measurement of the encoded data.
+// Use |CborOutOverflowed()| to check whether or not the buffer successfully
+// contains all of the of the encoded data.
 //
 // Complex types are constructed from these simple types, see RFC 8949. The
 // caller is responsible for correct and deterministic encoding of complex
 // types.
-//
-// If the encoding would overflow the offset or cannot be written to the
-// remaining space in non-null buffer, 0 is returned and the output stream must
-// be considered corrupted as there may have been a partial update to the
-// output.
-size_t CborWriteInt(int64_t val, struct CborOut* out);
-size_t CborWriteBstr(size_t data_size, const uint8_t* data,
-                     struct CborOut* out);
-size_t CborWriteTstr(const char* str, struct CborOut* out);
-size_t CborWriteArray(size_t num_elements, struct CborOut* out);
-size_t CborWriteMap(size_t num_pairs, struct CborOut* out);
-size_t CborWriteFalse(struct CborOut* out);
-size_t CborWriteTrue(struct CborOut* out);
-size_t CborWriteNull(struct CborOut* out);
+void CborWriteInt(int64_t val, struct CborOut* out);
+void CborWriteBstr(size_t data_size, const uint8_t* data, struct CborOut* out);
+void CborWriteTstr(const char* str, struct CborOut* out);
+void CborWriteArray(size_t num_elements, struct CborOut* out);
+void CborWriteMap(size_t num_pairs, struct CborOut* out);
+void CborWriteFalse(struct CborOut* out);
+void CborWriteTrue(struct CborOut* out);
+void CborWriteNull(struct CborOut* out);
 
 #ifdef __cplusplus
 }  // extern "C"
diff --git a/src/cbor_cert_op.c b/src/cbor_cert_op.c
index b8ed738..c3e6c91 100644
--- a/src/cbor_cert_op.c
+++ b/src/cbor_cert_op.c
@@ -35,17 +35,16 @@
   const int64_t kCoseHeaderAlgLabel = 1;
   const int64_t kCoseAlgEdDSA = -8;
 
-  struct CborOut out = {
-      .buffer = buffer,
-      .size = buffer_size,
-  };
-  if (!CborWriteMap(/*num_elements=*/1, &out) ||
-      // Add the algorithm.
-      !CborWriteInt(kCoseHeaderAlgLabel, &out) ||
-      !CborWriteInt(kCoseAlgEdDSA, &out)) {
+  struct CborOut out;
+  CborOutInit(buffer, buffer_size, &out);
+  CborWriteMap(/*num_elements=*/1, &out);
+  // Add the algorithm.
+  CborWriteInt(kCoseHeaderAlgLabel, &out);
+  CborWriteInt(kCoseAlgEdDSA, &out);
+  if (CborOutOverflowed(&out)) {
     return kDiceResultBufferTooSmall;
   }
-  *encoded_size = out.offset;
+  *encoded_size = CborOutSize(&out);
   return kDiceResultOk;
 }
 
@@ -63,30 +62,29 @@
   const int64_t kCoseKeyOpsVerify = 2;
   const int64_t kCoseCrvEd25519 = 6;
 
-  struct CborOut out = {
-      .buffer = buffer,
-      .size = buffer_size,
-  };
-  if (!CborWriteMap(/*num_pairs=*/5, &out) ||
-      // Add the key type.
-      !CborWriteInt(kCoseKeyKtyLabel, &out) ||
-      !CborWriteInt(kCoseKeyTypeOkp, &out) ||
-      // Add the algorithm.
-      !CborWriteInt(kCoseKeyAlgLabel, &out) ||
-      !CborWriteInt(kCoseAlgEdDSA, &out) ||
-      // Add the KeyOps.
-      !CborWriteInt(kCoseKeyOpsLabel, &out) ||
-      !CborWriteArray(/*num_elements=*/1, &out) ||
-      !CborWriteInt(kCoseKeyOpsVerify, &out) ||
-      // Add the curve.
-      !CborWriteInt(kCoseOkpCrvLabel, &out) ||
-      !CborWriteInt(kCoseCrvEd25519, &out) ||
-      // Add the subject public key.
-      !CborWriteInt(kCoseOkpXLabel, &out) ||
-      !CborWriteBstr(/*data_size=*/32, subject_public_key, &out)) {
+  struct CborOut out;
+  CborOutInit(buffer, buffer_size, &out);
+  CborWriteMap(/*num_pairs=*/5, &out);
+  // Add the key type.
+  CborWriteInt(kCoseKeyKtyLabel, &out);
+  CborWriteInt(kCoseKeyTypeOkp, &out);
+  // Add the algorithm.
+  CborWriteInt(kCoseKeyAlgLabel, &out);
+  CborWriteInt(kCoseAlgEdDSA, &out);
+  // Add the KeyOps.
+  CborWriteInt(kCoseKeyOpsLabel, &out);
+  CborWriteArray(/*num_elements=*/1, &out);
+  CborWriteInt(kCoseKeyOpsVerify, &out);
+  // Add the curve.
+  CborWriteInt(kCoseOkpCrvLabel, &out);
+  CborWriteInt(kCoseCrvEd25519, &out);
+  // Add the subject public key.
+  CborWriteInt(kCoseOkpXLabel, &out);
+  CborWriteBstr(/*data_size=*/32, subject_public_key, &out);
+  if (CborOutOverflowed(&out)) {
     return kDiceResultBufferTooSmall;
   }
-  *encoded_size = out.offset;
+  *encoded_size = CborOutSize(&out);
   return kDiceResultOk;
 }
 
@@ -129,29 +127,23 @@
     map_pairs += 1;
   }
 
-  struct CborOut out = {
-      .buffer = buffer,
-      .size = buffer_size,
-  };
-  if (!CborWriteMap(map_pairs, &out) ||
-      // Add the issuer.
-      !CborWriteInt(kCwtIssuerLabel, &out) ||
-      !CborWriteTstr(authority_id_hex, &out) ||
-      // Add the subject.
-      !CborWriteInt(kCwtSubjectLabel, &out) ||
-      !CborWriteTstr(subject_id_hex, &out) ||
-      // Add the code hash.
-      !CborWriteInt(kCodeHashLabel, &out) ||
-      !CborWriteBstr(DICE_HASH_SIZE, input_values->code_hash, &out)) {
-    return kDiceResultBufferTooSmall;
-  }
+  struct CborOut out;
+  CborOutInit(buffer, buffer_size, &out);
+  CborWriteMap(map_pairs, &out);
+  // Add the issuer.
+  CborWriteInt(kCwtIssuerLabel, &out);
+  CborWriteTstr(authority_id_hex, &out);
+  // Add the subject.
+  CborWriteInt(kCwtSubjectLabel, &out);
+  CborWriteTstr(subject_id_hex, &out);
+  // Add the code hash.
+  CborWriteInt(kCodeHashLabel, &out);
+  CborWriteBstr(DICE_HASH_SIZE, input_values->code_hash, &out);
   // Add the code descriptor, if provided.
   if (input_values->code_descriptor_size > 0) {
-    if (!CborWriteInt(kCodeDescriptorLabel, &out) ||
-        !CborWriteBstr(input_values->code_descriptor_size,
-                       input_values->code_descriptor, &out)) {
-      return kDiceResultBufferTooSmall;
-    }
+    CborWriteInt(kCodeDescriptorLabel, &out);
+    CborWriteBstr(input_values->code_descriptor_size,
+                  input_values->code_descriptor, &out);
   }
   // Add the config inputs.
   if (input_values->config_type == kDiceConfigTypeDescriptor) {
@@ -162,52 +154,41 @@
     if (result != kDiceResultOk) {
       return result;
     }
-    if (
-        // Add the config descriptor.
-        !CborWriteInt(kConfigDescriptorLabel, &out) ||
-        !CborWriteBstr(input_values->config_descriptor_size,
-                       input_values->config_descriptor, &out) ||
-        // Add the Config hash.
-        !CborWriteInt(kConfigHashLabel, &out) ||
-        !CborWriteBstr(DICE_HASH_SIZE, config_descriptor_hash, &out)) {
-      return kDiceResultBufferTooSmall;
-    }
+    // Add the config descriptor.
+    CborWriteInt(kConfigDescriptorLabel, &out);
+    CborWriteBstr(input_values->config_descriptor_size,
+                  input_values->config_descriptor, &out);
+    // Add the Config hash.
+    CborWriteInt(kConfigHashLabel, &out);
+    CborWriteBstr(DICE_HASH_SIZE, config_descriptor_hash, &out);
   } else if (input_values->config_type == kDiceConfigTypeInline) {
     // Add the inline config.
-    if (!CborWriteInt(kConfigDescriptorLabel, &out) ||
-        !CborWriteBstr(DICE_INLINE_CONFIG_SIZE, input_values->config_value,
-                       &out)) {
-      return kDiceResultBufferTooSmall;
-    }
+    CborWriteInt(kConfigDescriptorLabel, &out);
+    CborWriteBstr(DICE_INLINE_CONFIG_SIZE, input_values->config_value, &out);
   }
   // Add the authority inputs.
-  if (!CborWriteInt(kAuthorityHashLabel, &out) ||
-      !CborWriteBstr(DICE_HASH_SIZE, input_values->authority_hash, &out)) {
-    return kDiceResultBufferTooSmall;
-  }
+  CborWriteInt(kAuthorityHashLabel, &out);
+  CborWriteBstr(DICE_HASH_SIZE, input_values->authority_hash, &out);
   if (input_values->authority_descriptor_size > 0) {
-    if (!CborWriteInt(kAuthorityDescriptorLabel, &out) ||
-        !CborWriteBstr(input_values->authority_descriptor_size,
-                       input_values->authority_descriptor, &out)) {
-      return kDiceResultBufferTooSmall;
-    }
+    CborWriteInt(kAuthorityDescriptorLabel, &out);
+    CborWriteBstr(input_values->authority_descriptor_size,
+                  input_values->authority_descriptor, &out);
   }
   uint8_t mode_byte = input_values->mode;
   uint8_t key_usage = kKeyUsageCertSign;
-  if (
-      // Add the mode input.
-      !CborWriteInt(kModeLabel, &out) ||
-      !CborWriteBstr(/*data_sisze=*/1, &mode_byte, &out) ||
-      // Add the subject public key.
-      !CborWriteInt(kSubjectPublicKeyLabel, &out) ||
-      !CborWriteBstr(encoded_public_key_size, encoded_public_key, &out) ||
-      // Add the key usage.
-      !CborWriteInt(kKeyUsageLabel, &out) ||
-      !CborWriteBstr(/*data_size=*/1, &key_usage, &out)) {
+  // Add the mode input.
+  CborWriteInt(kModeLabel, &out);
+  CborWriteBstr(/*data_sisze=*/1, &mode_byte, &out);
+  // Add the subject public key.
+  CborWriteInt(kSubjectPublicKeyLabel, &out);
+  CborWriteBstr(encoded_public_key_size, encoded_public_key, &out);
+  // Add the key usage.
+  CborWriteInt(kKeyUsageLabel, &out);
+  CborWriteBstr(/*data_size=*/1, &key_usage, &out);
+  if (CborOutOverflowed(&out)) {
     return kDiceResultBufferTooSmall;
   }
-
-  *encoded_size = out.offset;
+  *encoded_size = CborOutSize(&out);
   return kDiceResultOk;
 }
 
@@ -216,24 +197,22 @@
                                 const uint8_t* payload, size_t payload_size,
                                 size_t buffer_size, uint8_t* buffer,
                                 size_t* encoded_size) {
-  struct CborOut out = {
-      .buffer = buffer,
-      .size = buffer_size,
-  };
-  if (
-      // TBS is an array of four elements.
-      !CborWriteArray(/*num_elements=*/4, &out) ||
-      // Context string field.
-      !CborWriteTstr("Signature1", &out) ||
-      // Protected attributes from COSE_Sign1.
-      !CborWriteBstr(protected_attributes_size, protected_attributes, &out) ||
-      // Empty application data.
-      !CborWriteBstr(/*data_size=*/0, /*data=*/NULL, &out) ||
-      // Payload from COSE_Sign1.
-      !CborWriteBstr(payload_size, payload, &out)) {
+  struct CborOut out;
+  CborOutInit(buffer, buffer_size, &out);
+  // TBS is an array of four elements.
+  CborWriteArray(/*num_elements=*/4, &out);
+  // Context string field.
+  CborWriteTstr("Signature1", &out);
+  // Protected attributes from COSE_Sign1.
+  CborWriteBstr(protected_attributes_size, protected_attributes, &out);
+  // Empty application data.
+  CborWriteBstr(/*data_size=*/0, /*data=*/NULL, &out);
+  // Payload from COSE_Sign1.
+  CborWriteBstr(payload_size, payload, &out);
+  if (CborOutOverflowed(&out)) {
     return kDiceResultBufferTooSmall;
   }
-  *encoded_size = out.offset;
+  *encoded_size = CborOutSize(&out);
   return kDiceResultOk;
 }
 
@@ -243,24 +222,22 @@
                                   const uint8_t signature[64],
                                   size_t buffer_size, uint8_t* buffer,
                                   size_t* encoded_size) {
-  struct CborOut out = {
-      .buffer = buffer,
-      .size = buffer_size,
-  };
-  if (
-      // COSE_Sign1 is an array of four elements.
-      !CborWriteArray(/*num_elements=*/4, &out) ||
-      // Protected attributes.
-      !CborWriteBstr(protected_attributes_size, protected_attributes, &out) ||
-      // Empty map for unprotected attributes.
-      !CborWriteMap(/*num_pairs=*/0, &out) ||
-      // Payload.
-      !CborWriteBstr(payload_size, payload, &out) ||
-      // Signature.
-      !CborWriteBstr(/*num_elements=*/64, signature, &out)) {
+  struct CborOut out;
+  CborOutInit(buffer, buffer_size, &out);
+  // COSE_Sign1 is an array of four elements.
+  CborWriteArray(/*num_elements=*/4, &out);
+  // Protected attributes.
+  CborWriteBstr(protected_attributes_size, protected_attributes, &out);
+  // Empty map for unprotected attributes.
+  CborWriteMap(/*num_pairs=*/0, &out);
+  // Payload.
+  CborWriteBstr(payload_size, payload, &out);
+  // Signature.
+  CborWriteBstr(/*num_elements=*/64, signature, &out);
+  if (CborOutOverflowed(&out)) {
     return kDiceResultBufferTooSmall;
   }
-  *encoded_size = out.offset;
+  *encoded_size = CborOutSize(&out);
   return kDiceResultOk;
 }
 
diff --git a/src/cbor_writer.c b/src/cbor_writer.c
index b5517d9..9b29f76 100644
--- a/src/cbor_writer.c
+++ b/src/cbor_writer.c
@@ -30,9 +30,17 @@
   CBOR_TYPE_SIMPLE = 7,
 };
 
-static size_t CborWriteType(enum CborType type, uint64_t val,
-                            struct CborOut* out) {
-  // Check how much space is needed.
+static bool CborWriteWouldOverflowCursor(size_t size, struct CborOut* out) {
+  return size > SIZE_MAX - out->cursor;
+}
+
+static bool CborWriteFitsInBuffer(size_t size, struct CborOut* out) {
+  return out->cursor <= out->buffer_size &&
+         size <= out->buffer_size - out->cursor;
+}
+
+static void CborWriteType(enum CborType type, uint64_t val,
+                          struct CborOut* out) {
   size_t size;
   if (val <= 23) {
     size = 1;
@@ -45,104 +53,86 @@
   } else {
     size = 9;
   }
-  // Don't allow offset to overflow.
-  if (size > SIZE_MAX - out->offset) {
-    return 0;
+  if (CborWriteWouldOverflowCursor(size, out)) {
+    out->cursor = SIZE_MAX;
+    return;
   }
-  // Only write if a buffer is provided.
-  if (out->buffer) {
-    if (out->size < out->offset + size) {
-      return 0;
-    }
+  if (CborWriteFitsInBuffer(size, out)) {
     if (size == 1) {
-      out->buffer[out->offset] = (type << 5) | val;
+      out->buffer[out->cursor] = (type << 5) | val;
     } else if (size == 2) {
-      out->buffer[out->offset] = (type << 5) | 24;
-      out->buffer[out->offset + 1] = val & 0xff;
+      out->buffer[out->cursor] = (type << 5) | 24;
+      out->buffer[out->cursor + 1] = val & 0xff;
     } else if (size == 3) {
-      out->buffer[out->offset] = (type << 5) | 25;
-      out->buffer[out->offset + 1] = (val >> 8) & 0xff;
-      out->buffer[out->offset + 2] = val & 0xff;
+      out->buffer[out->cursor] = (type << 5) | 25;
+      out->buffer[out->cursor + 1] = (val >> 8) & 0xff;
+      out->buffer[out->cursor + 2] = val & 0xff;
     } else if (size == 5) {
-      out->buffer[out->offset] = (type << 5) | 26;
-      out->buffer[out->offset + 1] = (val >> 24) & 0xff;
-      out->buffer[out->offset + 2] = (val >> 16) & 0xff;
-      out->buffer[out->offset + 3] = (val >> 8) & 0xff;
-      out->buffer[out->offset + 4] = val & 0xff;
+      out->buffer[out->cursor] = (type << 5) | 26;
+      out->buffer[out->cursor + 1] = (val >> 24) & 0xff;
+      out->buffer[out->cursor + 2] = (val >> 16) & 0xff;
+      out->buffer[out->cursor + 3] = (val >> 8) & 0xff;
+      out->buffer[out->cursor + 4] = val & 0xff;
     } else if (size == 9) {
-      out->buffer[out->offset] = (type << 5) | 27;
-      out->buffer[out->offset + 1] = (val >> 56) & 0xff;
-      out->buffer[out->offset + 2] = (val >> 48) & 0xff;
-      out->buffer[out->offset + 3] = (val >> 40) & 0xff;
-      out->buffer[out->offset + 4] = (val >> 32) & 0xff;
-      out->buffer[out->offset + 5] = (val >> 24) & 0xff;
-      out->buffer[out->offset + 6] = (val >> 16) & 0xff;
-      out->buffer[out->offset + 7] = (val >> 8) & 0xff;
-      out->buffer[out->offset + 8] = val & 0xff;
-    } else {
-      return 0;
+      out->buffer[out->cursor] = (type << 5) | 27;
+      out->buffer[out->cursor + 1] = (val >> 56) & 0xff;
+      out->buffer[out->cursor + 2] = (val >> 48) & 0xff;
+      out->buffer[out->cursor + 3] = (val >> 40) & 0xff;
+      out->buffer[out->cursor + 4] = (val >> 32) & 0xff;
+      out->buffer[out->cursor + 5] = (val >> 24) & 0xff;
+      out->buffer[out->cursor + 6] = (val >> 16) & 0xff;
+      out->buffer[out->cursor + 7] = (val >> 8) & 0xff;
+      out->buffer[out->cursor + 8] = val & 0xff;
     }
   }
-  // Update the offset with the size it needs.
-  out->offset += size;
-  return size;
+  out->cursor += size;
 }
 
-static size_t CborWriteStr(enum CborType type, size_t data_size,
-                           const uint8_t* data, struct CborOut* out) {
-  // Write the type.
-  size_t type_size = CborWriteType(type, data_size, out);
-  if (type_size == 0) {
-    return 0;
+static void CborWriteStr(enum CborType type, size_t data_size,
+                         const uint8_t* data, struct CborOut* out) {
+  CborWriteType(type, data_size, out);
+  if (CborWriteWouldOverflowCursor(data_size, out)) {
+    out->cursor = SIZE_MAX;
+    return;
   }
-  // Don't allow offset to overflow.
-  if (data_size > SIZE_MAX - out->offset) {
-    return 0;
+  if (CborWriteFitsInBuffer(data_size, out) && data_size) {
+    memcpy(&out->buffer[out->cursor], data, data_size);
   }
-  // Write the data if a buffer is provided.
-  if (data_size > 0 && out->buffer) {
-    if (out->size < out->offset + data_size) {
-      return 0;
-    }
-    memcpy(&out->buffer[out->offset], data, data_size);
-  }
-  // Update the offset with the size it needs.
-  out->offset += data_size;
-  return type_size + data_size;
+  out->cursor += data_size;
 }
 
-size_t CborWriteInt(int64_t val, struct CborOut* out) {
+void CborWriteInt(int64_t val, struct CborOut* out) {
   if (val < 0) {
-    return CborWriteType(CBOR_TYPE_NINT, (-1 - val), out);
+    CborWriteType(CBOR_TYPE_NINT, (-1 - val), out);
+  } else {
+    CborWriteType(CBOR_TYPE_UINT, val, out);
   }
-  return CborWriteType(CBOR_TYPE_UINT, val, out);
 }
 
-size_t CborWriteBstr(size_t data_size, const uint8_t* data,
-                     struct CborOut* out) {
-  return CborWriteStr(CBOR_TYPE_BSTR, data_size, data, out);
+void CborWriteBstr(size_t data_size, const uint8_t* data, struct CborOut* out) {
+  CborWriteStr(CBOR_TYPE_BSTR, data_size, data, out);
 }
 
-size_t CborWriteTstr(const char* str, struct CborOut* out) {
-  return CborWriteStr(CBOR_TYPE_TSTR, strlen(str), (const uint8_t*)str, out);
+void CborWriteTstr(const char* str, struct CborOut* out) {
+  CborWriteStr(CBOR_TYPE_TSTR, strlen(str), (const uint8_t*)str, out);
 }
 
-size_t CborWriteArray(size_t num_elements, struct CborOut* out) {
-  return CborWriteType(CBOR_TYPE_ARRAY, num_elements, out);
+void CborWriteArray(size_t num_elements, struct CborOut* out) {
+  CborWriteType(CBOR_TYPE_ARRAY, num_elements, out);
 }
 
-size_t CborWriteMap(size_t num_pairs, struct CborOut* out) {
-  return CborWriteType(CBOR_TYPE_MAP, num_pairs, out);
+void CborWriteMap(size_t num_pairs, struct CborOut* out) {
+  CborWriteType(CBOR_TYPE_MAP, num_pairs, out);
 }
 
-size_t CborWriteFalse(struct CborOut* out) {
-  return CborWriteType(CBOR_TYPE_SIMPLE, /*val=*/20, out);
+void CborWriteFalse(struct CborOut* out) {
+  CborWriteType(CBOR_TYPE_SIMPLE, /*val=*/20, out);
 }
 
-size_t CborWriteTrue(struct CborOut* out) {
-  return CborWriteType(CBOR_TYPE_SIMPLE, /*val=*/21, out);
+void CborWriteTrue(struct CborOut* out) {
+  CborWriteType(CBOR_TYPE_SIMPLE, /*val=*/21, out);
 }
 
-size_t CborWriteNull(struct CborOut* out) {
-  return CborWriteType(CBOR_TYPE_SIMPLE, /*val=*/22, out);
+void CborWriteNull(struct CborOut* out) {
+  CborWriteType(CBOR_TYPE_SIMPLE, /*val=*/22, out);
 }
diff --git a/src/cbor_writer_fuzzer.cc b/src/cbor_writer_fuzzer.cc
index fc1b739..bb4b3bd 100644
--- a/src/cbor_writer_fuzzer.cc
+++ b/src/cbor_writer_fuzzer.cc
@@ -41,11 +41,8 @@
 
   auto buffer_size = fdp.ConsumeIntegralInRange<size_t>(0, kMaxBufferSize);
   std::vector<uint8_t> buffer(buffer_size);
-  CborOut out = {
-      .buffer = buffer_size == 0 ? nullptr : buffer.data(),
-      .size = buffer_size,
-      .offset = fdp.ConsumeIntegral<size_t>(),
-  };
+  CborOut out;
+  CborOutInit(buffer.data(), buffer.size(), &out);
 
   for (size_t i = 0; i < kIterations; i++) {
     switch (fdp.ConsumeEnum<CborWriterFunction>()) {
diff --git a/src/cbor_writer_test.cc b/src/cbor_writer_test.cc
index ed0cdc8..1bcfd59 100644
--- a/src/cbor_writer_test.cc
+++ b/src/cbor_writer_test.cc
@@ -23,28 +23,26 @@
 TEST(CborWriterTest, Int1ByteEncoding) {
   const uint8_t kExpectedEncoding[] = {0, 23, 0x20, 0x37};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(1u, CborWriteInt(0, &out));
-  EXPECT_EQ(1u, CborWriteInt(23, &out));
-  EXPECT_EQ(1u, CborWriteInt(-1, &out));
-  EXPECT_EQ(1u, CborWriteInt(-24, &out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteInt(0, &out);
+  CborWriteInt(23, &out);
+  CborWriteInt(-1, &out);
+  CborWriteInt(-24, &out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
 TEST(CborWriterTest, Int2Bytes) {
   const uint8_t kExpectedEncoding[] = {24, 24, 24, 0xff, 0x38, 24, 0x38, 0xff};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(2u, CborWriteInt(24, &out));
-  EXPECT_EQ(2u, CborWriteInt(0xff, &out));
-  EXPECT_EQ(2u, CborWriteInt(-25, &out));
-  EXPECT_EQ(2u, CborWriteInt(-0x100, &out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteInt(24, &out);
+  CborWriteInt(0xff, &out);
+  CborWriteInt(-25, &out);
+  CborWriteInt(-0x100, &out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
@@ -52,14 +50,13 @@
   const uint8_t kExpectedEncoding[] = {25,   0x01, 0x00, 25,   0xff, 0xff,
                                        0x39, 0x01, 0x00, 0x39, 0xff, 0xff};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(3u, CborWriteInt(0x100, &out));
-  EXPECT_EQ(3u, CborWriteInt(0xffff, &out));
-  EXPECT_EQ(3u, CborWriteInt(-0x101, &out));
-  EXPECT_EQ(3u, CborWriteInt(-0x10000, &out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteInt(0x100, &out);
+  CborWriteInt(0xffff, &out);
+  CborWriteInt(-0x101, &out);
+  CborWriteInt(-0x10000, &out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
@@ -68,14 +65,13 @@
                                        0xff, 0xff, 0xff, 0x3a, 0x00, 0x01, 0x00,
                                        0x00, 0x3a, 0xff, 0xff, 0xff, 0xff};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(5u, CborWriteInt(0x10000, &out));
-  EXPECT_EQ(5u, CborWriteInt(0xffffffff, &out));
-  EXPECT_EQ(5u, CborWriteInt(-0x10001, &out));
-  EXPECT_EQ(5u, CborWriteInt(-0x100000000, &out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteInt(0x10000, &out);
+  CborWriteInt(0xffffffff, &out);
+  CborWriteInt(-0x10001, &out);
+  CborWriteInt(-0x100000000, &out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
@@ -85,14 +81,13 @@
       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3b, 0x00, 0x00, 0x00, 0x01, 0x00,
       0x00, 0x00, 0x00, 0x3b, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(9u, CborWriteInt(0x100000000, &out));
-  EXPECT_EQ(9u, CborWriteInt(INT64_MAX, &out));
-  EXPECT_EQ(9u, CborWriteInt(-0x100000001, &out));
-  EXPECT_EQ(9u, CborWriteInt(INT64_MIN, &out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteInt(0x100000000, &out);
+  CborWriteInt(INT64_MAX, &out);
+  CborWriteInt(-0x100000001, &out);
+  CborWriteInt(INT64_MIN, &out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
@@ -102,13 +97,12 @@
       0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
   };
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(3u, CborWriteInt(0x1234, &out));
-  EXPECT_EQ(5u, CborWriteInt(0x12345678, &out));
-  EXPECT_EQ(9u, CborWriteInt(0x123456789abcdef0, &out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteInt(0x1234, &out);
+  CborWriteInt(0x12345678, &out);
+  CborWriteInt(0x123456789abcdef0, &out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
@@ -116,226 +110,253 @@
   const uint8_t kExpectedEncoding[] = {0x45, 'h', 'e', 'l', 'l', 'o'};
   const uint8_t kData[] = {'h', 'e', 'l', 'l', 'o'};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(sizeof(kExpectedEncoding),
-            CborWriteBstr(sizeof(kData), kData, &out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(sizeof(kData), kData, &out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
 TEST(CborWriterTest, TstrEncoding) {
   const uint8_t kExpectedEncoding[] = {0x65, 'w', 'o', 'r', 'l', 'd'};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(sizeof(kExpectedEncoding), CborWriteTstr("world", &out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteTstr("world", &out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
 TEST(CborWriterTest, ArrayEncoding) {
   const uint8_t kExpectedEncoding[] = {0x98, 29};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(sizeof(kExpectedEncoding),
-            CborWriteArray(/*num_elements=*/29, &out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteArray(/*num_elements=*/29, &out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
 TEST(CborWriterTest, MapEncoding) {
   const uint8_t kExpectedEncoding[] = {0xb9, 0x02, 0x50};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(sizeof(kExpectedEncoding), CborWriteMap(/*num_pairs=*/592, &out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteMap(/*num_pairs=*/592, &out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
 TEST(CborWriterTest, FalseEncoding) {
   const uint8_t kExpectedEncoding[] = {0xf4};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(sizeof(kExpectedEncoding), CborWriteFalse(&out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteFalse(&out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
 TEST(CborWriterTest, TrueEncoding) {
   const uint8_t kExpectedEncoding[] = {0xf5};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(sizeof(kExpectedEncoding), CborWriteTrue(&out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteTrue(&out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
 TEST(CborWriterTest, NullEncoding) {
   const uint8_t kExpectedEncoding[] = {0xf6};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(sizeof(kExpectedEncoding), CborWriteNull(&out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteNull(&out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   EXPECT_EQ(0, memcmp(buffer, kExpectedEncoding, sizeof(kExpectedEncoding)));
 }
 
 TEST(CborWriterTest, CborOutInvariants) {
   const uint8_t kData[] = {0xb2, 0x34, 0x75, 0x92, 0x52};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  EXPECT_EQ(3u, CborWriteInt(0xab34, &out));
-  EXPECT_EQ(6u, CborWriteBstr(sizeof(kData), kData, &out));
-  EXPECT_EQ(9u, CborWriteTstr("A string", &out));
-  EXPECT_EQ(1u, CborWriteArray(/*num_elements=*/16, &out));
-  EXPECT_EQ(2u, CborWriteMap(/*num_pairs=*/35, &out));
-  EXPECT_EQ(1u, CborWriteFalse(&out));
-  EXPECT_EQ(1u, CborWriteTrue(&out));
-  EXPECT_EQ(1u, CborWriteNull(&out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteInt(0xab34, &out);
+  CborWriteBstr(sizeof(kData), kData, &out);
+  CborWriteTstr("A string", &out);
+  CborWriteArray(/*num_elements=*/16, &out);
+  CborWriteMap(/*num_pairs=*/35, &out);
+  CborWriteFalse(&out);
+  CborWriteTrue(&out);
+  CborWriteNull(&out);
+  EXPECT_FALSE(CborOutOverflowed(&out));
   // Offset is the cumulative size.
-  EXPECT_EQ(3 + 6 + 9 + 1 + 2 + 1 + 1 + 1u, out.offset);
-  // Buffer and size are unchanged.
-  EXPECT_EQ(buffer, out.buffer);
-  EXPECT_EQ(sizeof(buffer), out.size);
+  EXPECT_EQ(3 + 6 + 9 + 1 + 2 + 1 + 1 + 1u, CborOutSize(&out));
 }
 
 TEST(CborWriterTest, NullBufferForMeasurement) {
   const uint8_t kData[] = {16, 102, 246, 12, 156, 35, 84};
-  CborOut out = {
-      .buffer = nullptr,
-      .size = 2,  // Ignored.
-  };
-  EXPECT_EQ(1u, CborWriteNull(&out));
-  EXPECT_EQ(1u, CborWriteTrue(&out));
-  EXPECT_EQ(1u, CborWriteFalse(&out));
-  EXPECT_EQ(3u, CborWriteMap(/*num_pairs=*/623, &out));
-  EXPECT_EQ(5u, CborWriteArray(/*num_elements=*/70000, &out));
-  EXPECT_EQ(7u, CborWriteTstr("length", &out));
-  EXPECT_EQ(8u, CborWriteBstr(sizeof(kData), kData, &out));
-  EXPECT_EQ(5u, CborWriteInt(-10002000, &out));
+  CborOut out;
+  CborOutInit(nullptr, 0, &out);
+  CborWriteNull(&out);
+  CborWriteTrue(&out);
+  CborWriteFalse(&out);
+  CborWriteMap(/*num_pairs=*/623, &out);
+  CborWriteArray(/*num_elements=*/70000, &out);
+  CborWriteTstr("length", &out);
+  CborWriteBstr(sizeof(kData), kData, &out);
+  CborWriteInt(-10002000, &out);
+  // Measurement has occurred, but output did not.
+  EXPECT_TRUE(CborOutOverflowed(&out));
   // Offset is the cumulative size.
-  EXPECT_EQ(1 + 1 + 1 + 3 + 5 + 7 + 8 + 5u, out.offset);
-  // Buffer and size are unchanged.
-  EXPECT_EQ(nullptr, out.buffer);
-  EXPECT_EQ(2u, out.size);
+  EXPECT_EQ(1 + 1 + 1 + 3 + 5 + 7 + 8 + 5u, CborOutSize(&out));
 }
 
 TEST(CborWriterTest, BufferTooSmall) {
   const uint8_t kData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
   uint8_t buffer[1];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
   // Reset offset each time as it may be corrupted on failures.
-  out.offset = 0;
-  EXPECT_EQ(0u, CborWriteInt(-55667788, &out));
-  out.offset = 0;
-  EXPECT_EQ(0u, CborWriteBstr(sizeof(kData), kData, &out));
-  out.offset = 0;
-  EXPECT_EQ(0u, CborWriteTstr("Buffer too small", &out));
-  out.offset = 0;
-  EXPECT_EQ(0u, CborWriteArray(/*num_elements=*/563, &out));
-  out.offset = 0;
-  EXPECT_EQ(0u, CborWriteMap(/*num_pairs=*/29, &out));
-  out.size = 0;
-  out.offset = 0;
-  EXPECT_EQ(0u, CborWriteFalse(&out));
-  out.offset = 0;
-  EXPECT_EQ(0u, CborWriteTrue(&out));
-  out.offset = 0;
-  EXPECT_EQ(0u, CborWriteNull(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteInt(-55667788, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(sizeof(kData), kData, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteTstr("Buffer too small", &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteArray(/*num_elements=*/563, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteMap(/*num_pairs=*/29, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, 0, &out);
+  CborWriteFalse(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, 0, &out);
+  CborWriteTrue(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, 0, &out);
+  CborWriteNull(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
 }
 
 TEST(CborWriterTest, NotEnoughRemainingSpace) {
   const uint8_t kData[] = {0xff, 0xee, 0xdd, 0xcc};
+  uint8_t zeros[64] = {0};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  // Reset offset each time as it may be corrupted on failures.
-  out.offset = sizeof(buffer) - 1;
-  EXPECT_EQ(0u, CborWriteInt(-36, &out));
-  out.offset = sizeof(buffer) - 1;
-  EXPECT_EQ(0u, CborWriteBstr(sizeof(kData), kData, &out));
-  out.offset = sizeof(buffer) - 1;
-  EXPECT_EQ(0u, CborWriteTstr("Won't fit", &out));
-  out.offset = sizeof(buffer) - 1;
-  EXPECT_EQ(0u, CborWriteArray(/*num_elements=*/352, &out));
-  out.offset = sizeof(buffer) - 1;
-  EXPECT_EQ(0u, CborWriteMap(/*num_pairs=*/73, &out));
-  out.offset = sizeof(buffer);
-  EXPECT_EQ(0u, CborWriteFalse(&out));
-  out.offset = sizeof(buffer);
-  EXPECT_EQ(0u, CborWriteTrue(&out));
-  out.offset = sizeof(buffer);
-  EXPECT_EQ(0u, CborWriteNull(&out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
+  CborWriteInt(-36, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
+  CborWriteBstr(sizeof(kData), kData, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
+  CborWriteTstr("Won't fit", &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
+  CborWriteArray(/*num_elements=*/352, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(sizeof(buffer) - 3, zeros, &out);
+  CborWriteMap(/*num_pairs=*/73, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(sizeof(buffer) - 2, zeros, &out);
+  CborWriteFalse(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(sizeof(buffer) - 2, zeros, &out);
+  CborWriteTrue(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(sizeof(buffer) - 2, zeros, &out);
+  CborWriteNull(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
 }
 
 TEST(CborWriterTest, OffsetOverflow) {
   const uint8_t kData[] = {0xff, 0xee, 0xdd, 0xcc};
   uint8_t buffer[64];
-  CborOut out = {
-      .buffer = buffer,
-      .size = sizeof(buffer),
-  };
-  // Reset offset each time as it may be corrupted on failures.
-  out.offset = SIZE_MAX - 1;
-  EXPECT_EQ(0u, CborWriteInt(0x234198adb, &out));
-  out.offset = SIZE_MAX - 1;
-  EXPECT_EQ(0u, CborWriteBstr(sizeof(kData), kData, &out));
-  out.offset = SIZE_MAX - 1;
-  EXPECT_EQ(0u, CborWriteTstr("Overflow", &out));
-  out.offset = SIZE_MAX - 1;
-  EXPECT_EQ(0u, CborWriteArray(/*num_elements=*/41, &out));
-  out.offset = SIZE_MAX - 1;
-  EXPECT_EQ(0u, CborWriteMap(/*num_pairs=*/998844, &out));
-  out.offset = SIZE_MAX;
-  EXPECT_EQ(0u, CborWriteFalse(&out));
-  out.offset = SIZE_MAX;
-  EXPECT_EQ(0u, CborWriteTrue(&out));
-  out.offset = SIZE_MAX;
-  EXPECT_EQ(0u, CborWriteNull(&out));
+  CborOut out;
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
+  CborWriteInt(0x234198adb, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
+  CborWriteBstr(sizeof(kData), kData, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
+  CborWriteTstr("Overflow", &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
+  CborWriteArray(/*num_elements=*/41, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
+  CborWriteMap(/*num_pairs=*/998844, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
+  CborWriteFalse(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
+  CborWriteTrue(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(buffer, sizeof(buffer), &out);
+  CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
+  CborWriteNull(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
 }
 
 TEST(CborWriterTest, MeasurementOffsetOverflow) {
   const uint8_t kData[] = {0xf0, 0x0f, 0xca, 0xfe, 0xfe, 0xed};
-  CborOut out = {
-      .buffer = nullptr,
-  };
-  // Reset offset each time as it may be corrupted on failures.
-  out.offset = SIZE_MAX - 1;
-  EXPECT_EQ(0u, CborWriteInt(0x1419823646241245, &out));
-  out.offset = SIZE_MAX - 1;
-  EXPECT_EQ(0u, CborWriteBstr(sizeof(kData), kData, &out));
-  out.offset = SIZE_MAX - 1;
-  EXPECT_EQ(0u, CborWriteTstr("Measured overflow", &out));
-  out.offset = SIZE_MAX - 1;
-  EXPECT_EQ(0u, CborWriteArray(/*num_elements=*/8368257314, &out));
-  out.offset = SIZE_MAX - 1;
-  EXPECT_EQ(0u, CborWriteMap(/*num_pairs=*/92, &out));
-  out.offset = SIZE_MAX;
-  EXPECT_EQ(0u, CborWriteFalse(&out));
-  out.offset = SIZE_MAX;
-  EXPECT_EQ(0u, CborWriteTrue(&out));
-  out.offset = SIZE_MAX;
-  EXPECT_EQ(0u, CborWriteNull(&out));
+  CborOut out;
+  CborOutInit(nullptr, 0, &out);
+  CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
+  CborWriteInt(0x1419823646241245, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(nullptr, 0, &out);
+  CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
+  CborWriteBstr(sizeof(kData), kData, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(nullptr, 0, &out);
+  CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
+  CborWriteTstr("Measured overflow", &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(nullptr, 0, &out);
+  CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
+  CborWriteArray(/*num_elements=*/8368257314, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(nullptr, 0, &out);
+  CborWriteBstr(SIZE_MAX - 10, nullptr, &out);
+  CborWriteMap(/*num_pairs=*/92, &out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(nullptr, 0, &out);
+  CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
+  CborWriteFalse(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(nullptr, 0, &out);
+  CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
+  CborWriteTrue(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
+  CborOutInit(nullptr, 0, &out);
+  CborWriteBstr(SIZE_MAX - 9, nullptr, &out);
+  CborWriteNull(&out);
+  EXPECT_TRUE(CborOutOverflowed(&out));
 }
 }