pax_global_header 0000666 0000000 0000000 00000000064 14522360300 0014505 g ustar 00root root 0000000 0000000 52 comment=09e839e5ad7642276fb27aa1a159f9c78690ea4e
base64-0.2.0/ 0000775 0000000 0000000 00000000000 14522360300 0012570 5 ustar 00root root 0000000 0000000 base64-0.2.0/.github/ 0000775 0000000 0000000 00000000000 14522360300 0014130 5 ustar 00root root 0000000 0000000 base64-0.2.0/.github/dependabot.yml 0000664 0000000 0000000 00000000166 14522360300 0016763 0 ustar 00root root 0000000 0000000 version: 2
updates:
- package-ecosystem: 'github-actions'
directory: '/'
schedule:
interval: 'weekly'
base64-0.2.0/.github/workflows/ 0000775 0000000 0000000 00000000000 14522360300 0016165 5 ustar 00root root 0000000 0000000 base64-0.2.0/.github/workflows/test.yml 0000664 0000000 0000000 00000001461 14522360300 0017671 0 ustar 00root root 0000000 0000000 name: test
on: [push, pull_request]
jobs:
ruby-versions:
uses: ruby/actions/.github/workflows/ruby_versions.yml@master
with:
min_version: 2.4
test:
needs: ruby-versions
name: build (${{ matrix.ruby }} / ${{ matrix.os }})
strategy:
matrix:
ruby: ${{ fromJson(needs.ruby-versions.outputs.versions) }}
os: [ ubuntu-latest, macos-latest, windows-latest ]
exclude:
- { os: windows-latest, ruby: truffleruby-head }
- { os: windows-latest, ruby: truffleruby }
runs-on: ${{ matrix.os }}
steps:
- uses: actions/checkout@v4
- name: Set up Ruby
uses: ruby/setup-ruby@v1
with:
ruby-version: ${{ matrix.ruby }}
- name: Install dependencies
run: bundle install
- name: Run test
run: rake test
base64-0.2.0/.gitignore 0000664 0000000 0000000 00000000126 14522360300 0014557 0 ustar 00root root 0000000 0000000 /.bundle/
/.yardoc
/_yardoc/
/coverage/
/doc/
/pkg/
/spec/reports/
/tmp/
Gemfile.lock
base64-0.2.0/Gemfile 0000664 0000000 0000000 00000000072 14522360300 0014062 0 ustar 00root root 0000000 0000000 source "https://rubygems.org"
gem "rake"
gem "test-unit"
base64-0.2.0/LICENSE.txt 0000664 0000000 0000000 00000002402 14522360300 0014411 0 ustar 00root root 0000000 0000000 Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
base64-0.2.0/README.md 0000664 0000000 0000000 00000002625 14522360300 0014054 0 ustar 00root root 0000000 0000000 # Base64
The Base64 module provides for the encoding (`#encode64`, `#strict_encode64`,
`#urlsafe_encode64`) and decoding (`#decode64`, `#strict_decode64`,
`#urlsafe_decode64`) of binary data using a Base64 representation.
## Installation
Add this line to your application's Gemfile:
```ruby
gem 'base64'
```
And then execute:
$ bundle install
Or install it yourself as:
$ gem install base64
## Usage
A simple encoding and decoding.
```ruby
require "base64"
enc = Base64.encode64('Send reinforcements')
# -> "U2VuZCByZWluZm9yY2VtZW50cw==\n"
plain = Base64.decode64(enc)
# -> "Send reinforcements"
```
The purpose of using base64 to encode data is that it translates any
binary data into purely printable characters.
## Development
After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
## Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/base64.
base64-0.2.0/Rakefile 0000664 0000000 0000000 00000000306 14522360300 0014234 0 ustar 00root root 0000000 0000000 require "bundler/gem_tasks"
require "rake/testtask"
Rake::TestTask.new(:test) do |t|
t.libs << "test"
t.libs << "lib"
t.test_files = FileList["test/**/test_*.rb"]
end
task :default => :test
base64-0.2.0/base64.gemspec 0000664 0000000 0000000 00000002075 14522360300 0015225 0 ustar 00root root 0000000 0000000 name = File.basename(__FILE__, ".gemspec")
version = ["lib", Array.new(name.count("-")+1).join("/")].find do |dir|
break File.foreach(File.join(__dir__, dir, "#{name.tr('-', '/')}.rb")) do |line|
/^\s*VERSION\s*=\s*"(.*)"/ =~ line and break $1
end rescue nil
end
Gem::Specification.new do |spec|
spec.name = name
spec.version = version
spec.authors = ["Yusuke Endoh"]
spec.email = ["mame@ruby-lang.org"]
spec.summary = %q{Support for encoding and decoding binary data using a Base64 representation.}
spec.description = %q{Support for encoding and decoding binary data using a Base64 representation.}
spec.homepage = "https://github.com/ruby/base64"
spec.required_ruby_version = Gem::Requirement.new(">= 2.4")
spec.licenses = ["Ruby", "BSD-2-Clause"]
spec.metadata["homepage_uri"] = spec.homepage
spec.metadata["source_code_uri"] = spec.homepage
spec.files = ["README.md", "LICENSE.txt", "lib/base64.rb"]
spec.bindir = "exe"
spec.executables = []
spec.require_paths = ["lib"]
end
base64-0.2.0/bin/ 0000775 0000000 0000000 00000000000 14522360300 0013340 5 ustar 00root root 0000000 0000000 base64-0.2.0/bin/console 0000775 0000000 0000000 00000000525 14522360300 0014732 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
require "bundler/setup"
require "base64"
# You can add fixtures and/or initialization code here to make experimenting
# with your gem easier. You can also use a different console, if you like.
# (If you use this, don't forget to add pry to your Gemfile!)
# require "pry"
# Pry.start
require "irb"
IRB.start(__FILE__)
base64-0.2.0/bin/setup 0000775 0000000 0000000 00000000203 14522360300 0014421 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'
set -vx
bundle install
# Do any other automated setup that you need to do here
base64-0.2.0/lib/ 0000775 0000000 0000000 00000000000 14522360300 0013336 5 ustar 00root root 0000000 0000000 base64-0.2.0/lib/base64.rb 0000664 0000000 0000000 00000032341 14522360300 0014752 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# \Module \Base64 provides methods for:
#
# - Encoding a binary string (containing non-ASCII characters)
# as a string of printable ASCII characters.
# - Decoding such an encoded string.
#
# \Base64 is commonly used in contexts where binary data
# is not allowed or supported:
#
# - Images in HTML or CSS files, or in URLs.
# - Email attachments.
#
# A \Base64-encoded string is about one-third larger that its source.
# See the {Wikipedia article}[https://en.wikipedia.org/wiki/Base64]
# for more information.
#
# This module provides three pairs of encode/decode methods.
# Your choices among these methods should depend on:
#
# - Which character set is to be used for encoding and decoding.
# - Whether "padding" is to be used.
# - Whether encoded strings are to contain newlines.
#
# Note: Examples on this page assume that the including program has executed:
#
# require 'base64'
#
# == Encoding Character Sets
#
# A \Base64-encoded string consists only of characters from a 64-character set:
#
# - ('A'..'Z').
# - ('a'..'z').
# - ('0'..'9').
# - =, the 'padding' character.
# - Either:
# - %w[+ /]:
# {RFC-2045-compliant}[https://datatracker.ietf.org/doc/html/rfc2045];
# _not_ safe for URLs.
# - %w[- _]:
# {RFC-4648-compliant}[https://datatracker.ietf.org/doc/html/rfc4648];
# safe for URLs.
#
# If you are working with \Base64-encoded strings that will come from
# or be put into URLs, you should choose this encoder-decoder pair
# of RFC-4648-compliant methods:
#
# - Base64.urlsafe_encode64 and Base64.urlsafe_decode64.
#
# Otherwise, you may choose any of the pairs in this module,
# including the pair above, or the RFC-2045-compliant pairs:
#
# - Base64.encode64 and Base64.decode64.
# - Base64.strict_encode64 and Base64.strict_decode64.
#
# == Padding
#
# \Base64-encoding changes a triplet of input bytes
# into a quartet of output characters.
#
# Padding in Encode Methods
#
# Padding -- extending an encoded string with zero, one, or two trailing
# = characters -- is performed by methods Base64.encode64,
# Base64.strict_encode64, and, by default, Base64.urlsafe_encode64:
#
# Base64.encode64('s') # => "cw==\n"
# Base64.strict_encode64('s') # => "cw=="
# Base64.urlsafe_encode64('s') # => "cw=="
# Base64.urlsafe_encode64('s', padding: false) # => "cw"
#
# When padding is performed, the encoded string is always of length 4n,
# where +n+ is a non-negative integer:
#
# - Input bytes of length 3n generate unpadded output characters
# of length 4n:
#
# # n = 1: 3 bytes => 4 characters.
# Base64.strict_encode64('123') # => "MDEy"
# # n = 2: 6 bytes => 8 characters.
# Base64.strict_encode64('123456') # => "MDEyMzQ1"
#
# - Input bytes of length 3n+1 generate padded output characters
# of length 4(n+1), with two padding characters at the end:
#
# # n = 1: 4 bytes => 8 characters.
# Base64.strict_encode64('1234') # => "MDEyMw=="
# # n = 2: 7 bytes => 12 characters.
# Base64.strict_encode64('1234567') # => "MDEyMzQ1Ng=="
#
# - Input bytes of length 3n+2 generate padded output characters
# of length 4(n+1), with one padding character at the end:
#
# # n = 1: 5 bytes => 8 characters.
# Base64.strict_encode64('12345') # => "MDEyMzQ="
# # n = 2: 8 bytes => 12 characters.
# Base64.strict_encode64('12345678') # => "MDEyMzQ1Njc="
#
# When padding is suppressed, for a positive integer n:
#
# - Input bytes of length 3n generate unpadded output characters
# of length 4n:
#
# # n = 1: 3 bytes => 4 characters.
# Base64.urlsafe_encode64('123', padding: false) # => "MDEy"
# # n = 2: 6 bytes => 8 characters.
# Base64.urlsafe_encode64('123456', padding: false) # => "MDEyMzQ1"
#
# - Input bytes of length 3n+1 generate unpadded output characters
# of length 4n+2, with two padding characters at the end:
#
# # n = 1: 4 bytes => 6 characters.
# Base64.urlsafe_encode64('1234', padding: false) # => "MDEyMw"
# # n = 2: 7 bytes => 10 characters.
# Base64.urlsafe_encode64('1234567', padding: false) # => "MDEyMzQ1Ng"
#
# - Input bytes of length 3n+2 generate unpadded output characters
# of length 4n+3, with one padding character at the end:
#
# # n = 1: 5 bytes => 7 characters.
# Base64.urlsafe_encode64('12345', padding: false) # => "MDEyMzQ"
# # m = 2: 8 bytes => 11 characters.
# Base64.urlsafe_encode64('12345678', padding: false) # => "MDEyMzQ1Njc"
#
# Padding in Decode Methods
#
# All of the \Base64 decode methods support (but do not require) padding.
#
# \Method Base64.decode64 does not check the size of the padding:
#
# Base64.decode64("MDEyMzQ1Njc") # => "01234567"
# Base64.decode64("MDEyMzQ1Njc=") # => "01234567"
# Base64.decode64("MDEyMzQ1Njc==") # => "01234567"
#
# \Method Base64.strict_decode64 strictly enforces padding size:
#
# Base64.strict_decode64("MDEyMzQ1Njc") # Raises ArgumentError
# Base64.strict_decode64("MDEyMzQ1Njc=") # => "01234567"
# Base64.strict_decode64("MDEyMzQ1Njc==") # Raises ArgumentError
#
# \Method Base64.urlsafe_decode64 allows padding in +str+,
# which if present, must be correct:
# see {Padding}[Base64.html#module-Base64-label-Padding], above:
#
# Base64.urlsafe_decode64("MDEyMzQ1Njc") # => "01234567"
# Base64.urlsafe_decode64("MDEyMzQ1Njc=") # => "01234567"
# Base64.urlsafe_decode64("MDEyMzQ1Njc==") # Raises ArgumentError.
#
# == Newlines
#
# An encoded string returned by Base64.encode64 or Base64.urlsafe_encode64
# has an embedded newline character
# after each 60-character sequence, and, if non-empty, at the end:
#
# # No newline if empty.
# encoded = Base64.encode64("\x00" * 0)
# encoded.index("\n") # => nil
#
# # Newline at end of short output.
# encoded = Base64.encode64("\x00" * 1)
# encoded.size # => 4
# encoded.index("\n") # => 4
#
# # Newline at end of longer output.
# encoded = Base64.encode64("\x00" * 45)
# encoded.size # => 60
# encoded.index("\n") # => 60
#
# # Newlines embedded and at end of still longer output.
# encoded = Base64.encode64("\x00" * 46)
# encoded.size # => 65
# encoded.rindex("\n") # => 65
# encoded.split("\n").map {|s| s.size } # => [60, 4]
#
# The string to be encoded may itself contain newlines,
# which are encoded as \Base64:
#
# # Base64.encode64("\n\n\n") # => "CgoK\n"
# s = "This is line 1\nThis is line 2\n"
# Base64.encode64(s) # => "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK\n"
#
module Base64
VERSION = "0.2.0"
module_function
# Returns a string containing the RFC-2045-compliant \Base64-encoding of +bin+.
#
# Per RFC 2045, the returned string may contain the URL-unsafe characters
# + or /;
# see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
#
# Base64.encode64("\xFB\xEF\xBE") # => "++++\n"
# Base64.encode64("\xFF\xFF\xFF") # => "////\n"
#
# The returned string may include padding;
# see {Padding}[Base64.html#module-Base64-label-Padding] above.
#
# Base64.encode64('*') # => "Kg==\n"
#
# The returned string ends with a newline character, and if sufficiently long
# will have one or more embedded newline characters;
# see {Newlines}[Base64.html#module-Base64-label-Newlines] above:
#
# Base64.encode64('*') # => "Kg==\n"
# Base64.encode64('*' * 46)
# # => "KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq\nKg==\n"
#
# The string to be encoded may itself contain newlines,
# which will be encoded as ordinary \Base64:
#
# Base64.encode64("\n\n\n") # => "CgoK\n"
# s = "This is line 1\nThis is line 2\n"
# Base64.encode64(s) # => "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK\n"
#
def encode64(bin)
[bin].pack("m")
end
# Returns a string containing the decoding of an RFC-2045-compliant
# \Base64-encoded string +str+:
#
# s = "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK\n"
# Base64.decode64(s) # => "This is line 1\nThis is line 2\n"
#
# Non-\Base64 characters in +str+ are ignored;
# see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
# these include newline characters and characters - and /:
#
# Base64.decode64("\x00\n-_") # => ""
#
# Padding in +str+ (even if incorrect) is ignored:
#
# Base64.decode64("MDEyMzQ1Njc") # => "01234567"
# Base64.decode64("MDEyMzQ1Njc=") # => "01234567"
# Base64.decode64("MDEyMzQ1Njc==") # => "01234567"
#
def decode64(str)
str.unpack1("m")
end
# Returns a string containing the RFC-2045-compliant \Base64-encoding of +bin+.
#
# Per RFC 2045, the returned string may contain the URL-unsafe characters
# + or /;
# see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
#
# Base64.strict_encode64("\xFB\xEF\xBE") # => "++++\n"
# Base64.strict_encode64("\xFF\xFF\xFF") # => "////\n"
#
# The returned string may include padding;
# see {Padding}[Base64.html#module-Base64-label-Padding] above.
#
# Base64.strict_encode64('*') # => "Kg==\n"
#
# The returned string will have no newline characters, regardless of its length;
# see {Newlines}[Base64.html#module-Base64-label-Newlines] above:
#
# Base64.strict_encode64('*') # => "Kg=="
# Base64.strict_encode64('*' * 46)
# # => "KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg=="
#
# The string to be encoded may itself contain newlines,
# which will be encoded as ordinary \Base64:
#
# Base64.strict_encode64("\n\n\n") # => "CgoK"
# s = "This is line 1\nThis is line 2\n"
# Base64.strict_encode64(s) # => "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK"
#
def strict_encode64(bin)
[bin].pack("m0")
end
# Returns a string containing the decoding of an RFC-2045-compliant
# \Base64-encoded string +str+:
#
# s = "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK"
# Base64.strict_decode64(s) # => "This is line 1\nThis is line 2\n"
#
# Non-\Base64 characters in +str+ not allowed;
# see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
# these include newline characters and characters - and /:
#
# Base64.strict_decode64("\n") # Raises ArgumentError
# Base64.strict_decode64('-') # Raises ArgumentError
# Base64.strict_decode64('_') # Raises ArgumentError
#
# Padding in +str+, if present, must be correct:
#
# Base64.strict_decode64("MDEyMzQ1Njc") # Raises ArgumentError
# Base64.strict_decode64("MDEyMzQ1Njc=") # => "01234567"
# Base64.strict_decode64("MDEyMzQ1Njc==") # Raises ArgumentError
#
def strict_decode64(str)
str.unpack1("m0")
end
# Returns the RFC-4648-compliant \Base64-encoding of +bin+.
#
# Per RFC 4648, the returned string will not contain the URL-unsafe characters
# + or /,
# but instead may contain the URL-safe characters
# - and _;
# see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
#
# Base64.urlsafe_encode64("\xFB\xEF\xBE") # => "----"
# Base64.urlsafe_encode64("\xFF\xFF\xFF") # => "____"
#
# By default, the returned string may have padding;
# see {Padding}[Base64.html#module-Base64-label-Padding], above:
#
# Base64.urlsafe_encode64('*') # => "Kg=="
#
# Optionally, you can suppress padding:
#
# Base64.urlsafe_encode64('*', padding: false) # => "Kg"
#
# The returned string will have no newline characters, regardless of its length;
# see {Newlines}[Base64.html#module-Base64-label-Newlines] above:
#
# Base64.urlsafe_encode64('*') # => "Kg=="
# Base64.urlsafe_encode64('*' * 46)
# # => "KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg=="
#
def urlsafe_encode64(bin, padding: true)
str = strict_encode64(bin)
str.chomp!("==") or str.chomp!("=") unless padding
str.tr!("+/", "-_")
str
end
# Returns the decoding of an RFC-4648-compliant \Base64-encoded string +str+:
#
# +str+ may not contain non-Base64 characters;
# see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
#
# Base64.urlsafe_decode64('+') # Raises ArgumentError.
# Base64.urlsafe_decode64('/') # Raises ArgumentError.
# Base64.urlsafe_decode64("\n") # Raises ArgumentError.
#
# Padding in +str+, if present, must be correct:
# see {Padding}[Base64.html#module-Base64-label-Padding], above:
#
# Base64.urlsafe_decode64("MDEyMzQ1Njc") # => "01234567"
# Base64.urlsafe_decode64("MDEyMzQ1Njc=") # => "01234567"
# Base64.urlsafe_decode64("MDEyMzQ1Njc==") # Raises ArgumentError.
#
def urlsafe_decode64(str)
# NOTE: RFC 4648 does say nothing about unpadded input, but says that
# "the excess pad characters MAY also be ignored", so it is inferred that
# unpadded input is also acceptable.
if !str.end_with?("=") && str.length % 4 != 0
str = str.ljust((str.length + 3) & ~3, "=")
str.tr!("-_", "+/")
else
str = str.tr("-_", "+/")
end
strict_decode64(str)
end
end
base64-0.2.0/test/ 0000775 0000000 0000000 00000000000 14522360300 0013547 5 ustar 00root root 0000000 0000000 base64-0.2.0/test/base64/ 0000775 0000000 0000000 00000000000 14522360300 0014633 5 ustar 00root root 0000000 0000000 base64-0.2.0/test/base64/test_base64.rb 0000664 0000000 0000000 00000012367 14522360300 0017314 0 ustar 00root root 0000000 0000000 # coding: US-ASCII
# frozen_string_literal: true
require "test/unit"
require "base64"
class TestBase64 < Test::Unit::TestCase
def test_sample
assert_equal("U2VuZCByZWluZm9yY2VtZW50cw==\n", Base64.encode64('Send reinforcements'))
assert_equal('Send reinforcements', Base64.decode64("U2VuZCByZWluZm9yY2VtZW50cw==\n"))
assert_equal(
"Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBjb2RlcnMKdG8gbGVhcm4g\nUnVieQ==\n",
Base64.encode64("Now is the time for all good coders\nto learn Ruby"))
assert_equal(
"Now is the time for all good coders\nto learn Ruby",
Base64.decode64("Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBjb2RlcnMKdG8gbGVhcm4g\nUnVieQ==\n"))
assert_equal(
"VGhpcyBpcyBsaW5lIG9uZQpUaGlzIGlzIGxpbmUgdHdvClRoaXMgaXMgbGlu\nZSB0aHJlZQpBbmQgc28gb24uLi4K\n",
Base64.encode64("This is line one\nThis is line two\nThis is line three\nAnd so on...\n"))
assert_equal(
"This is line one\nThis is line two\nThis is line three\nAnd so on...\n",
Base64.decode64("VGhpcyBpcyBsaW5lIG9uZQpUaGlzIGlzIGxpbmUgdHdvClRoaXMgaXMgbGluZSB0aHJlZQpBbmQgc28gb24uLi4K"))
end
def test_encode64
assert_equal("", Base64.encode64(""))
assert_equal("AA==\n", Base64.encode64("\0"))
assert_equal("AAA=\n", Base64.encode64("\0\0"))
assert_equal("AAAA\n", Base64.encode64("\0\0\0"))
assert_equal("/w==\n", Base64.encode64("\377"))
assert_equal("//8=\n", Base64.encode64("\377\377"))
assert_equal("////\n", Base64.encode64("\377\377\377"))
assert_equal("/+8=\n", Base64.encode64("\xff\xef"))
end
def test_decode64
assert_equal("", Base64.decode64(""))
assert_equal("\0", Base64.decode64("AA==\n"))
assert_equal("\0\0", Base64.decode64("AAA=\n"))
assert_equal("\0\0\0", Base64.decode64("AAAA\n"))
assert_equal("\377", Base64.decode64("/w==\n"))
assert_equal("\377\377", Base64.decode64("//8=\n"))
assert_equal("\377\377\377", Base64.decode64("////\n"))
assert_equal("\xff\xef", Base64.decode64("/+8=\n"))
end
def test_strict_encode64
assert_equal("", Base64.strict_encode64(""))
assert_equal("AA==", Base64.strict_encode64("\0"))
assert_equal("AAA=", Base64.strict_encode64("\0\0"))
assert_equal("AAAA", Base64.strict_encode64("\0\0\0"))
assert_equal("/w==", Base64.strict_encode64("\377"))
assert_equal("//8=", Base64.strict_encode64("\377\377"))
assert_equal("////", Base64.strict_encode64("\377\377\377"))
assert_equal("/+8=", Base64.strict_encode64("\xff\xef"))
end
def test_strict_decode64
assert_equal("", Base64.strict_decode64(""))
assert_equal("\0", Base64.strict_decode64("AA=="))
assert_equal("\0\0", Base64.strict_decode64("AAA="))
assert_equal("\0\0\0", Base64.strict_decode64("AAAA"))
assert_equal("\377", Base64.strict_decode64("/w=="))
assert_equal("\377\377", Base64.strict_decode64("//8="))
assert_equal("\377\377\377", Base64.strict_decode64("////"))
assert_equal("\xff\xef", Base64.strict_decode64("/+8="))
assert_raise(ArgumentError) { Base64.strict_decode64("^") }
assert_raise(ArgumentError) { Base64.strict_decode64("A") }
assert_raise(ArgumentError) { Base64.strict_decode64("A^") }
assert_raise(ArgumentError) { Base64.strict_decode64("AA") }
assert_raise(ArgumentError) { Base64.strict_decode64("AA=") }
assert_raise(ArgumentError) { Base64.strict_decode64("AA===") }
assert_raise(ArgumentError) { Base64.strict_decode64("AA=x") }
assert_raise(ArgumentError) { Base64.strict_decode64("AAA") }
assert_raise(ArgumentError) { Base64.strict_decode64("AAA^") }
assert_raise(ArgumentError) { Base64.strict_decode64("AB==") }
assert_raise(ArgumentError) { Base64.strict_decode64("AAB=") }
end
def test_urlsafe_encode64
assert_equal("", Base64.urlsafe_encode64(""))
assert_equal("AA==", Base64.urlsafe_encode64("\0"))
assert_equal("AAA=", Base64.urlsafe_encode64("\0\0"))
assert_equal("AAAA", Base64.urlsafe_encode64("\0\0\0"))
assert_equal("_w==", Base64.urlsafe_encode64("\377"))
assert_equal("__8=", Base64.urlsafe_encode64("\377\377"))
assert_equal("____", Base64.urlsafe_encode64("\377\377\377"))
assert_equal("_-8=", Base64.urlsafe_encode64("\xff\xef"))
end
def test_urlsafe_encode64_unpadded
assert_equal("", Base64.urlsafe_encode64("", padding: false))
assert_equal("AA", Base64.urlsafe_encode64("\0", padding: false))
assert_equal("AAA", Base64.urlsafe_encode64("\0\0", padding: false))
assert_equal("AAAA", Base64.urlsafe_encode64("\0\0\0", padding: false))
end
def test_urlsafe_decode64
assert_equal("", Base64.urlsafe_decode64(""))
assert_equal("\0", Base64.urlsafe_decode64("AA=="))
assert_equal("\0\0", Base64.urlsafe_decode64("AAA="))
assert_equal("\0\0\0", Base64.urlsafe_decode64("AAAA"))
assert_equal("\377", Base64.urlsafe_decode64("_w=="))
assert_equal("\377\377", Base64.urlsafe_decode64("__8="))
assert_equal("\377\377\377", Base64.urlsafe_decode64("____"))
assert_equal("\xff\xef", Base64.urlsafe_decode64("_+8="))
end
def test_urlsafe_decode64_unpadded
assert_equal("\0", Base64.urlsafe_decode64("AA"))
assert_equal("\0\0", Base64.urlsafe_decode64("AAA"))
assert_equal("\0\0\0", Base64.urlsafe_decode64("AAAA"))
assert_raise(ArgumentError) { Base64.urlsafe_decode64("AA=") }
end
end