return err
	}
	if numDays <= 0 {
		return errLifecycleInvalidDays
	}
	*eDays = ExpirationDays(numDays)
	return nil
}

// MarshalXML encodes number of days to expire if it is non-zero and
// encodes empty string otherwise
func (eDays ExpirationDays) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
	if eDays == 0 {
		return nil
	}
	return e.EncodeElement(int(eDays), startElement)
}

  private const val INITIAL_BIAS = 72
  private const val INITIAL_N = 0x80

  /**
   * Returns null if any label is oversized so much that the encoder cannot encode it without
   * integer overflow. This will not return null for labels that fit within the DNS size
   * limits.
   */
  fun encode(string: String): String? {
    var pos = 0
    val limit = string.length
    val result = Buffer()

    while (pos < limit) {

## Base64 vs Files { #base64-vs-files }

Consider first if you can use [Request Files](../tutorial/request-files.md) for uploading binary data and [Custom Response - FileResponse](./custom-response.md#fileresponse--fileresponse-) for sending binary data, instead of encoding it in JSON.

JSON can only contain UTF-8 encoded strings, so it can't contain raw bytes.

    assertThat(encoding.encode(decoded.getBytes(UTF_8), offset, len)).isEqualTo(encoded);
  }

  private static void testDecodes(BaseEncoding encoding, String encoded, String decoded) {
    assertThat(encoding.canDecode(encoded)).isTrue();
    assertThat(encoding.decode(encoded)).isEqualTo(decoded.getBytes(UTF_8));
  }

  private static void testDecodesByBytes(BaseEncoding encoding, String encoded, byte[] decoded) {

		return errTransitionDateNotMidnight
	}

	*tDate = TransitionDate{trnDate}
	return nil
}

// MarshalXML encodes expiration date if it is non-zero and encodes
// empty string otherwise
func (tDate TransitionDate) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
	if tDate.IsZero() {
		return nil
	}
	return e.EncodeElement(tDate.Format(time.RFC3339), startElement)
}

        long decoded = Encdec.dec_uint64le(buffer, 0);

        // Then
        assertEquals(currentDate.getTime(), decoded, "Encoded and decoded time should match");
    }

    @Test
    @DisplayName("Should encode and decode UUIDs")
    void testUUIDOperations() {
        // Given

        final int i = index - start;
        final int n = (i + m & ~m) - i;
        advance(n);
        return n;
    }

    /**
     * Encodes a small integer (1 byte) in NDR format.
     *
     * @param s the small integer value to encode
     */
    public void enc_ndr_small(final int s) {
        buf[index] = (byte) (s & 0xFF);
        advance(1);
    }

    /**

    assertFailsWith<ProtocolException> {
      derReader.read("test") {}
    }.also { expected ->
      assertThat(expected.message)
        .isEqualTo("length encoded with more than 8 bytes is not supported")
    }
  }

  @Test fun `encode tag and length`() {
    val buffer = Buffer()
    val derWriter = DerWriter(buffer)

    derWriter.write("test", tagClass = DerHeader.TAG_CLASS_UNIVERSAL, tag = 30L) {

			t.Fatalf("Test %d: failed to create erasure: %v", i, err)
		}
		encoded, err := erasure.EncodeData(t.Context(), buffer)
		if err != nil {
			t.Fatalf("Test %d: failed to encode data: %v", i, err)
		}

		for j := range encoded[:test.missingData] {
			encoded[j] = nil
		}
		for j := test.dataBlocks; j < test.dataBlocks+test.missingParity; j++ {
			encoded[j] = nil
		}

		if test.reconstructParity {

        // When
        int encoded = messageBlock.encode(buffer, encodeIndex);
        int decoded = messageBlock.decode(buffer, decodeIndex);

        // Then
        assertEquals(encodeLength, encoded);
        assertEquals(decodeLength, decoded);
        verify(messageBlock).encode(buffer, encodeIndex);
        verify(messageBlock).decode(buffer, decodeIndex);
    }