btcruby 0.0.0 → 1.0.0

data/spec/address_spec.rb

@@ -0,0 +1,206 @@
+require_relative 'spec_helper'
+describe BTC::Address do
+
+  it "should decode/encode mainnet pay-to-pubkey-hash address" do
+    address = BTC::Address.parse("19FGfswVqxNubJbh1NW8A4t51T9x9RDVWQ")
+    address.is_a?(BTC::PublicKeyAddress).must_equal(true)
+
+    address.mainnet?.must_equal true
+    address.testnet?.must_equal false
+    address.p2sh?.must_equal    false
+    address.p2pkh?.must_equal   true
+
+    address.data.must_equal "5a73e920b7836c74f9e740a5bb885e8580557038".from_hex
+
+    address = BTC::PublicKeyAddress.new(hash: "5a73e920b7836c74f9e740a5bb885e8580557038".from_hex)
+
+    address.script.to_s.must_equal "OP_DUP OP_HASH160 5a73e920b7836c74f9e740a5bb885e8580557038 OP_EQUALVERIFY OP_CHECKSIG"
+
+    address.to_s.must_equal("19FGfswVqxNubJbh1NW8A4t51T9x9RDVWQ")
+    address.data.must_equal(BTC::Data.data_from_hex("5a73e920b7836c74f9e740a5bb885e8580557038"))
+  end
+
+  it "should decode/encode testnet pay-to-pubkey-hash address" do
+
+    address = BTC::Address.parse("mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn")
+    address.is_a?(BTC::PublicKeyAddress).must_equal true
+
+    address.mainnet?.must_equal false
+    address.testnet?.must_equal true
+    address.p2sh?.must_equal    false
+    address.p2pkh?.must_equal   true
+
+    address.data.must_equal "243f1394f44554f4ce3fd68649c19adc483ce924".from_hex
+
+    address2 = BTC::PublicKeyAddress.new(hash: "243f1394f44554f4ce3fd68649c19adc483ce924".from_hex, network: Network.testnet)
+
+    address2.to_s.must_equal("mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRfn")
+    address2.data.must_equal("243f1394f44554f4ce3fd68649c19adc483ce924".from_hex)
+  end
+
+  it "should detect invalid pay-to-pubkey-hash address" do
+    lambda { BTC::Address.parse(nil) }.must_raise ArgumentError
+    lambda { BTC::Address.parse("") }.must_raise FormatError
+    lambda { BTC::Address.parse("18FGfswVqxNubJbh1NW8A4t51T9x9RDVWQ") }.must_raise FormatError
+    lambda { BTC::Address.parse("19FGfswVqxNubJbh1NW8A4t51T9x9RDvwq") }.must_raise FormatError
+    lambda { BTC::Address.parse("19FGfswVqxNubJbh1NW8A4t51T9x9RD") }.must_raise FormatError
+    lambda { BTC::Address.parse("mipcBbFg9gMiCh81Kj8tqqdgoZub1ZJRf") }.must_raise FormatError
+    lambda { BTC::Address.parse("m") }.must_raise FormatError
+    lambda { BTC::Address.parse("mipc") }.must_raise FormatError
+  end
+
+  it "should decode/encode mainnet pay-to-script-hash address" do
+
+    address = BTC::Address.parse("3EktnHQD7RiAE6uzMj2ZifT9YgRrkSgzQX")
+    address.is_a?(BTC::ScriptHashAddress).must_equal(true)
+
+    address.mainnet?.must_equal true
+    address.testnet?.must_equal false
+    address.p2sh?.must_equal    true
+    address.p2pkh?.must_equal   false
+
+    address.data.must_equal "8f55563b9a19f321c211e9b9f38cdf686ea07845".from_hex
+    address.hash.must_equal "8f55563b9a19f321c211e9b9f38cdf686ea07845".from_hex
+
+    address = BTC::ScriptHashAddress.new(hash: "8f55563b9a19f321c211e9b9f38cdf686ea07845".from_hex)
+
+    address.script.to_s.must_equal "OP_HASH160 8f55563b9a19f321c211e9b9f38cdf686ea07845 OP_EQUAL"
+
+    address.to_s.must_equal("3EktnHQD7RiAE6uzMj2ZifT9YgRrkSgzQX")
+    address.data.must_equal("8f55563b9a19f321c211e9b9f38cdf686ea07845".from_hex)
+  end
+
+  it "should decode/encode testnet pay-to-script-hash address" do
+
+    address = BTC::Address.parse("3EktnHQD7RiAE6uzMj2ZifT9YgRrkSgzQX")
+    address.is_a?(BTC::ScriptHashAddress).must_equal(true)
+
+    address.mainnet?.must_equal true
+    address.testnet?.must_equal false
+    address.p2sh?.must_equal    true
+    address.p2pkh?.must_equal   false
+
+    address.data.must_equal "8f55563b9a19f321c211e9b9f38cdf686ea07845".from_hex
+
+    address = BTC::ScriptHashAddress.new(hash: "8f55563b9a19f321c211e9b9f38cdf686ea07845".from_hex)
+
+    address.to_s.must_equal("3EktnHQD7RiAE6uzMj2ZifT9YgRrkSgzQX")
+    address.data.must_equal("8f55563b9a19f321c211e9b9f38cdf686ea07845".from_hex)
+  end
+
+  it "should detect invalid pay-to-script-hash address" do
+    lambda { BTC::Address.parse("3ektnHQD7RiAE6uzMj2ZifT9YgRrkSgzQX") }.must_raise FormatError
+    lambda { BTC::Address.parse("3EktnHQD7RiAE6uzMj2ZifT9YgRrkSgzqX") }.must_raise FormatError
+    lambda { BTC::Address.parse("3EktnHQD7RiAE6uzMj2ZifT9YgRrkSg") }.must_raise FormatError
+    lambda { BTC::Address.parse("2mzQwSSnBHWHqSAqtTVQ6v47XtaisrJa1Vc") }.must_raise FormatError
+    lambda { BTC::Address.parse("2MzQwSSnBHWHqSAqtTVQ6v47XtaisrJa1vc") }.must_raise FormatError
+    lambda { BTC::Address.parse("2MzQwSSnBHWHqSAqtTVQ6v47XtaisrJ") }.must_raise FormatError
+  end
+
+
+  it "should decode/encode private key string with uncompressed pubkey" do
+
+    address = BTC::Address.parse("5KJvsngHeMpm884wtkJNzQGaCErckhHJBGFsvd3VyK5qMZXj3hS")
+    address.is_a?(BTC::WIF).must_equal(true)
+
+    address.public_key_compressed?.must_equal false
+    address.mainnet?.must_equal true
+    address.testnet?.must_equal false
+    address.p2sh?.must_equal    false
+    address.p2pkh?.must_equal   false
+
+    address.data.must_equal "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex
+
+    address = BTC::WIF.new(private_key: "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex)
+
+    address.to_s.must_equal("5KJvsngHeMpm884wtkJNzQGaCErckhHJBGFsvd3VyK5qMZXj3hS")
+    address.data.must_equal("c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex)
+
+  end
+
+  it "should decode/encode private key string with compressed pubkey" do
+
+    address = BTC::Address.parse("L3p8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJF9woSu")
+    address.is_a?(BTC::WIF).must_equal(true)
+
+    address.public_key_compressed?.must_equal true
+    address.mainnet?.must_equal true
+    address.testnet?.must_equal false
+    address.p2sh?.must_equal    false
+    address.p2pkh?.must_equal   false
+
+    address.data.must_equal "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex
+
+    address = BTC::WIF.new(private_key: "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex, public_key_compressed: true)
+
+    address.to_s.must_equal("L3p8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJF9woSu")
+    address.data.must_equal("c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex)
+
+  end
+
+  it "should detect invalid private key address" do
+    lambda { BTC::Address.parse("5kJvsngHeMpm884wtkJNzQGaCErckhHJBGFsvd3VyK5qMZXj3hS") }.must_raise FormatError
+    lambda { BTC::Address.parse("5KJvsngHeMpm884wtkJNzQGaCErckhHJBGFsvd3VyK5qMZXj3hs") }.must_raise FormatError
+    lambda { BTC::Address.parse("5KJvsngHeMpm884wtkJNzQGaCErckhHJBGFsvd3VyK5qMZ") }.must_raise FormatError
+    lambda { BTC::Address.parse("L3P8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJF9woSu") }.must_raise FormatError
+    lambda { BTC::Address.parse("L3p8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJF9woSU") }.must_raise FormatError
+    lambda { BTC::Address.parse("L3p8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJ") }.must_raise FormatError
+  end
+
+  it "should convert strings and addresses into normalized address" do
+    BTC::Address.parse(BTC::Address.parse("19FGfswVqxNubJbh1NW8A4t51T9x9RDVWQ")).class.must_equal BTC::PublicKeyAddress
+    BTC::Address.parse("19FGfswVqxNubJbh1NW8A4t51T9x9RDVWQ").class.must_equal BTC::PublicKeyAddress
+    ->{ BTC::Address.parse(nil) }.must_raise ArgumentError
+  end
+
+  it "should convert any address to a public_address" do
+    a1 = BTC::Address.parse("1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8")
+    a1.public_address.must_equal a1
+
+    a2 = BTC::Address.parse("L3p8oAcQTtuokSCRHQ7i4MhjWc9zornvpJLfmg62sYpLRJF9woSu")
+    a2.public_address.must_equal a1
+
+    a3 = BTC::Address.parse("3EktnHQD7RiAE6uzMj2ZifT9YgRrkSgzQX")
+    a3.public_address.must_equal a3
+  end
+
+  it "should support equality" do
+    address1  = BTC::Address.parse("19FGfswVqxNubJbh1NW8A4t51T9x9RDVWQ")
+    address2  = BTC::PublicKeyAddress.new(hash: "5a73e920b7836c74f9e740a5bb885e8580557038".from_hex)
+    address3  = BTC::PublicKeyAddress.new(hash: "5a73e920b7836c74f9e740a5bb885e8580557038".from_hex, network: BTC::Network.testnet)
+    address4  = BTC::WIF.new(private_key: "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex, public_key_compressed: true)
+    address41 = BTC::WIF.new(private_key: "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex, public_key_compressed: true)
+    address5  = BTC::WIF.new(private_key: "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex, public_key_compressed: false)
+    address51 = BTC::WIF.new(private_key: "c4bbcb1fbec99d65bf59d85c8cb62ee2db963f0fe106f483d9afa73bd4e39a8a".from_hex, public_key_compressed: false)
+
+    (address1 == address2).must_equal true
+    (address2 == address1).must_equal true
+    (address1 == address3).must_equal false
+    (address2 == address3).must_equal false
+
+    (address1 == address4).must_equal false
+    (address2 == address4).must_equal false
+    (address3 == address4).must_equal false
+    (address5 == address4).must_equal false
+    (address4 == address5).must_equal false
+
+    (address4 == address41).must_equal true
+    (address5 == address51).must_equal true
+  end
+
+  it "should detect if wrong subclass is used when parsing an address" do
+    btc_addr_string = "19FGfswVqxNubJbh1NW8A4t51T9x9RDVWQ"
+    asset_addr_string = "akB4NBW9UuCmHuepksob6yfZs6naHtRCPNy"
+    btc_addr = Address.parse(btc_addr_string)
+    asset_addr = Address.parse(asset_addr_string)
+    
+    ->{ BTC::AssetAddress.parse(btc_addr_string) }.must_raise ArgumentError
+    ->{ BTC::AssetAddress.parse(btc_addr) }.must_raise ArgumentError
+    
+    ->{ BTC::BitcoinPaymentAddress.parse(asset_addr_string) }.must_raise ArgumentError
+    ->{ BTC::BitcoinPaymentAddress.parse(asset_addr) }.must_raise ArgumentError
+  end
+
+end
+
+

data/spec/all.rb

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+test_folder = File.expand_path(File.dirname(__FILE__))
+(Dir["#{test_folder}/**/*_test.rb"].to_a + Dir["#{test_folder}/**/*_spec.rb"].to_a).sort.each do |spec|
+  require spec
+end

data/spec/base58_spec.rb

@@ -0,0 +1,83 @@
+require_relative 'spec_helper'
+describe BTC::Base58 do
+
+  def check_invalid_base58(base58_string, expected_class = BTC::FormatError)
+    lambda { Base58.data_from_base58(base58_string) }.must_raise expected_class
+  end
+
+  def check_invalid_base58check(base58check_string, expected_class = BTC::FormatError)
+    lambda { Base58.data_from_base58check(base58check_string) }.must_raise expected_class
+  end
+
+  def check_valid_base58(hex_string, base58_string)
+    # Convert to Base58
+    Base58.base58_from_data(BTC::Data.data_from_hex(hex_string)).must_equal(base58_string)
+
+    # Convert from Base58
+    BTC::Data.hex_from_data(Base58.data_from_base58(base58_string)).must_equal(hex_string)
+  end
+
+  def check_valid_base58check(hex, string)
+    # Convert to Base58Check
+    Base58.base58check_from_data(BTC::Data.data_from_hex(hex)).must_equal(string)
+
+    # Convert from Base58Check
+    BTC::Data.hex_from_data(Base58.data_from_base58check(string)).must_equal(hex)
+  end
+
+  describe "Base58" do
+    it "should handle valid input" do
+
+      lambda { Base58.data_from_base58(nil) }.must_raise ArgumentError
+      lambda { Base58.base58_from_data(nil) }.must_raise ArgumentError
+      check_valid_base58("", "")
+      check_valid_base58("13", "L")
+      check_valid_base58("2e", "o")
+      check_valid_base58("61", "2g")
+      check_valid_base58("626262", "a3gV")
+      check_valid_base58("636363", "aPEr")
+      check_valid_base58("73696d706c792061206c6f6e6720737472696e67", "2cFupjhnEsSn59qHXstmK2ffpLv2")
+      check_valid_base58("00eb15231dfceb60925886b67d065299925915aeb172c06647", "1NS17iag9jJgTHD1VXjvLCEnZuQ3rJDE9L")
+      check_valid_base58("516b6fcd0f", "ABnLTmg")
+      check_valid_base58("bf4f89001e670274dd", "3SEo3LWLoPntC")
+      check_valid_base58("572e4794", "3EFU7m")
+      check_valid_base58("ecac89cad93923c02321", "EJDM8drfXA6uyA")
+      check_valid_base58("10c8511e", "Rt5zm")
+      check_valid_base58("00000000000000000000", "1111111111")
+    end
+
+    it "should handle invalid input" do
+      check_invalid_base58(nil, ArgumentError);
+      check_invalid_base58(" ");
+      check_invalid_base58("lLoO");
+      check_invalid_base58("l");
+      check_invalid_base58("O");
+      check_invalid_base58("öまи");
+    end
+  end
+
+  describe "Base58Check" do
+
+    it "should handle valid input" do
+      check_valid_base58check("", "3QJmnh")
+      check_valid_base58check("007ab89f9fae3f8043dcee5f7b5467a0f0a6e2f7e1", "1CBtcGivXmHQ8ZqdPgeMfcpQNJrqTrSAcG")
+    end
+
+    it "should handle invalid input" do
+      check_invalid_base58check(nil, ArgumentError);
+      check_invalid_base58check(" ");
+      check_invalid_base58check("lLoO");
+      check_invalid_base58check("l");
+      check_invalid_base58check("O");
+      check_invalid_base58check("öまи");
+    end
+    it "should detect incorrect checksum" do
+      check_invalid_base58check("L");
+      check_invalid_base58check("o");
+      check_invalid_base58check("0CBtcGivXmHQ8ZqdPgeMfcpQNJrqTrSAcG");
+      check_invalid_base58check("2CBtcGivXmHQ8ZqdPgeMfcpQNJrqTrSAcG");
+      check_invalid_base58check("11BtcGivXmHQ8ZqdPgeMfcpQNJrqTrSAcG");
+      check_invalid_base58check("1CBtcGivXmHQ8ZqdPgeMfcpQNJrqTrSAbG");
+    end
+  end
+end

data/spec/block_header_spec.rb

@@ -0,0 +1,18 @@
+require_relative 'spec_helper'
+describe BTC::BlockHeader do
+
+  describe "Genesis Mainnet" do
+    it "should have a correct hash" do
+      BlockHeader.genesis_mainnet.block_id.must_equal "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
+      BlockHeader.genesis_mainnet.height.must_equal 0
+    end
+  end
+
+  describe "Genesis Testnet" do
+    it "should have a correct hash" do
+      BlockHeader.genesis_testnet.block_id.must_equal "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"
+      BlockHeader.genesis_testnet.height.must_equal 0
+    end
+  end
+  
+end

data/spec/block_spec.rb

@@ -0,0 +1,18 @@
+require_relative 'spec_helper'
+describe BTC::Block do
+
+  describe "Genesis Mainnet" do
+    it "should have a correct hash" do
+      Block.genesis_mainnet.block_id.must_equal "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
+      Block.genesis_mainnet.height.must_equal 0
+    end
+  end
+
+  describe "Genesis Testnet" do
+    it "should have a correct hash" do
+      Block.genesis_testnet.block_id.must_equal "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"
+      Block.genesis_testnet.height.must_equal 0
+    end
+  end
+  
+end

data/spec/currency_formatter_spec.rb

@@ -0,0 +1,46 @@
+require_relative 'spec_helper'
+
+describe BTC::CurrencyFormatter do
+
+  it "should support normal bitcoin formatting" do
+    fm = BTC::CurrencyFormatter.btc_formatter
+
+    fm.string_from_number(1*COIN).must_equal("1.0")
+    fm.string_from_number(42*COIN).must_equal("42.0")
+    fm.string_from_number(42000*COIN).must_equal("42000.0")
+    fm.string_from_number(42000*COIN + 123).must_equal("42000.00000123")
+    fm.string_from_number(42000*COIN + 123000).must_equal("42000.00123")
+    fm.string_from_number(42000*COIN + 123456).must_equal("42000.00123456")
+    fm.string_from_number(42000*COIN + COIN/2).must_equal("42000.5")
+
+    fm.number_from_string("1").must_equal 1*COIN
+    fm.number_from_string("1.").must_equal 1*COIN
+    fm.number_from_string("1.0").must_equal 1*COIN
+    fm.number_from_string("42").must_equal 42*COIN
+    fm.number_from_string("42.123").must_equal 42*COIN + 12300000
+    fm.number_from_string("42.12345678").must_equal 42*COIN + 12345678
+    fm.number_from_string("42.10000000").must_equal 42*COIN + 10000000
+    fm.number_from_string("42.10000").must_equal    42*COIN + 10000000
+  end
+
+  it "should support long bitcoin formatting" do
+    fm = BTC::CurrencyFormatter.btc_long_formatter
+
+    fm.string_from_number(1*COIN).must_equal("1.00000000")
+    fm.string_from_number(42*COIN).must_equal("42.00000000")
+    fm.string_from_number(42000*COIN).must_equal("42000.00000000")
+    fm.string_from_number(42000*COIN + 123).must_equal("42000.00000123")
+    fm.string_from_number(42000*COIN + 123000).must_equal("42000.00123000")
+    fm.string_from_number(42000*COIN + 123456).must_equal("42000.00123456")
+    fm.string_from_number(42000*COIN + COIN/2).must_equal("42000.50000000")
+
+    fm.number_from_string("1").must_equal 1*COIN
+    fm.number_from_string("1.").must_equal 1*COIN
+    fm.number_from_string("1.0").must_equal 1*COIN
+    fm.number_from_string("42").must_equal 42*COIN
+    fm.number_from_string("42.123").must_equal 42*COIN + 12300000
+    fm.number_from_string("42.12345678").must_equal 42*COIN + 12345678
+    fm.number_from_string("42.10000000").must_equal 42*COIN + 10000000
+    fm.number_from_string("42.10000").must_equal    42*COIN + 10000000
+  end
+end

data/spec/data_spec.rb

@@ -0,0 +1,50 @@
+require_relative 'spec_helper'
+
+describe BTC::Data do
+
+  it "should decode valid hex" do
+    lambda { BTC::Data.data_from_hex(nil) }.must_raise ArgumentError
+    BTC::Data.data_from_hex("fe").bytes.must_equal "\xfe".bytes
+    BTC::Data.data_from_hex("deadBEEF").bytes.must_equal "\xde\xad\xbe\xef".bytes
+    BTC::Data.data_from_hex("   \r\n\tdeadBEEF  \t \r \n").bytes.must_equal "\xde\xad\xbe\xef".bytes
+    BTC::Data.data_from_hex("").bytes.must_equal "".bytes
+    BTC::Data.data_from_hex("  \t  ").bytes.must_equal "".bytes
+  end
+
+  it "should not decode invalid hex" do
+    lambda { BTC::Data.data_from_hex("f") }.must_raise FormatError
+    lambda { BTC::Data.data_from_hex("dxadBEEF") }.must_raise FormatError
+    lambda { BTC::Data.data_from_hex("-") }.must_raise FormatError
+  end
+
+  it "should encode valid hex" do
+    lambda { BTC::Data.hex_from_data(nil) }.must_raise ArgumentError
+    BTC::Data.hex_from_data("\xfe").bytes.must_equal "fe".bytes
+    BTC::Data.hex_from_data("\xde\xad\xbe\xef").bytes.must_equal "deadbeef".bytes
+    BTC::Data.hex_from_data("").bytes.must_equal "".bytes
+  end
+
+  it "should encode bytes" do
+    BTC::Data.bytes_from_data("Hello, world").must_equal "Hello, world".bytes
+    BTC::Data.bytes_from_data("Hello, world").must_equal [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100]
+    BTC::Data.data_from_bytes([72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100]).must_equal "Hello, world"
+  end
+
+  it "should access ranges of bytes" do
+    BTC::Data.bytes_from_data("Hello, world", offset: 1).must_equal "ello, world".bytes
+    BTC::Data.bytes_from_data("Hello, world", offset: 0, limit: 3).must_equal "Hel".bytes
+
+    # Range takes precedence over offset/limit.
+    BTC::Data.bytes_from_data("Hello, world", offset: 0, limit: 3, range: 1..2).must_equal "el".bytes
+
+    BTC::Data.bytes_from_data("Hello, world", range: 1..3).must_equal "ell".bytes
+    BTC::Data.bytes_from_data("Hello, world", range: 1...3).must_equal "el".bytes
+
+    # Outside bounds
+    BTC::Data.bytes_from_data("Hello, world", offset: 110, limit: 3).must_equal []
+    BTC::Data.bytes_from_data("Hello, world", offset: 0, limit: 0).must_equal   []
+    BTC::Data.bytes_from_data("Hello, world", range: 100..101).must_equal       []
+    BTC::Data.bytes_from_data("Hello, world", range: 0...0).must_equal          []
+  end
+
+end

data/spec/diagnostics_spec.rb

@@ -0,0 +1,41 @@
+require_relative 'spec_helper'
+
+describe BTC::Diagnostics do
+
+  it "should record messages" do
+
+    BTC::Diagnostics.current.wont_be_nil
+
+    # Due to other tests this may not be nil, so we should not check for it.
+    # We also should not clear the state in order to test our recording code against whatever state was there before.
+    # BTC::Diagnostics.current.last_message.must_equal nil
+
+    BTC::Diagnostics.current.add_message("msg1")
+    BTC::Diagnostics.current.last_message.must_equal "msg1"
+    BTC::Diagnostics.current.add_message("msg2")
+    BTC::Diagnostics.current.last_message.must_equal "msg2"
+
+    BTC::Diagnostics.current.record do
+
+      BTC::Diagnostics.current.record do
+        BTC::Diagnostics.current.add_message("a")
+        BTC::Diagnostics.current.add_message("b")
+        BTC::Diagnostics.current.last_message.must_equal "b"
+      end.map(&:to_s).must_equal ["a", "b"]
+
+      BTC::Diagnostics.current.last_message.must_equal "b"
+
+      BTC::Diagnostics.current.add_message("c")
+
+      BTC::Diagnostics.current.record do
+        BTC::Diagnostics.current.add_message("d")
+        BTC::Diagnostics.current.add_message("e")
+      end.map(&:to_s).must_equal ["d", "e"]
+
+    end.map(&:to_s).must_equal ["a", "b", "c", "d", "e"]
+
+    BTC::Diagnostics.current.last_message.must_equal "e"
+
+  end
+
+end