#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

require "spec_helper"

module Qpid

  module Proton

    describe "A data object" do

      before :each do
        @data = Qpid::Proton::Codec::Data.new
      end

      it "can be initialized" do
        expect(@data).not_to be_nil
      end

      it "can hold a null" do
        @data.null
        expect(@data.null?).to eq(true)
      end

      it "can hold a true boolean" do
        @data.bool = true
        expect(@data.bool).to eq(true)
      end

      it "can hold a false boolean" do
        @data.bool = false
        expect(@data.bool).to eq(false)
      end

      it "raises an error on a negative ubyte" do
        expect {
          @data.ubyte = (0 - (rand(127) + 1))
        }.to raise_error(RangeError)
      end

      it "raises an error on a null ubyte" do
        expect {
          @data.ubyte = nil
        }.to raise_error(TypeError)
      end

      it "can hold an unsigned byte" do
        value = rand(255)
        @data.ubyte = value
        expect(@data.ubyte).to eq(value)
      end

      it "can hold a byte" do
        value = rand(128)
        @data.byte = value
        expect(@data.byte).to eq(value)
      end

      it "can hold a negative byte" do
        value = 0 - (rand(126) + 1)
        @data.byte = value
        expect(@data.byte).to eq(value)
      end

      it "raises an error on a negative ushort" do
        expect {
          @data.ushort = (0 - (rand(65535) + 1))
        }.to raise_error(RangeError)
      end

      it "raises an error on a nil ushort" do
        expect {
          @data.ushort = nil
        }.to raise_error(TypeError)
      end

      it "can hold a zero unsigned short" do
        @data.ushort = 0
        expect(@data.ushort).to eq(0)
      end

      it "can hold an unsigned short" do
        value = rand(2**15) + 1
        @data.ushort = value
        expect(@data.ushort).to eq(value)
      end

      it "raises an error on a nil short" do
        expect {
          @data.short = nil
        }.to raise_error(TypeError)
      end

      it "can hold a short" do
        value = rand(2**15) + 1
        @data.short = value
        expect(@data.short).to eq(value)
      end

      it "can hold a zero short" do
        @data.short = 0
        expect(@data.short).to eq(0)
      end

      it "can hold a negative short" do
        value = (0 - (rand(2**15) + 1))
        @data.short = value
        expect(@data.short).to eq(value)
      end

      it "raises an error on a nil uint" do
        expect {
          @data.uint = nil
        }.to raise_error(TypeError)
      end

      it "raises an error on a negative uint" do
        expect {
          @data.uint = (0 - (rand(2**32) + 1))
        }.to raise_error(RangeError)
      end

      it "can hold an unsigned integer" do
        value = rand(2**32) + 1
        @data.uint = value
        expect(@data.uint).to eq(value)
      end

      it "can hold a zero unsigned integer" do
        @data.uint = 0
        expect(@data.uint).to eq(0)
      end

      it "raise an error on a null integer" do
        expect {
          @data.int = nil
        }.to raise_error(TypeError)
      end

      it "can hold an integer" do
        value = rand(2**31) + 1
        @data.int = value
        expect(@data.int).to eq(value)
      end

      it "can hold zero as an integer" do
        @data.int = 0
        expect(@data.int).to eq(0)
      end

      it "raises an error on a null character" do
        expect {
          @data.char = nil
        }.to raise_error(TypeError)
      end

      it "can hold a character" do
        source = random_string(256)
        index = rand(source.length)
        value = source[index,1].bytes.to_a[0]
        @data.char = value
        expect(@data.char).to eq(value)
      end

      it "raises an error on a null ulong" do
        expect {
          @data.ulong = nil
        }.to raise_error(TypeError)
      end

      it "raises an error on a negative ulong" do
        expect {
          @data.ulong = (0 - (rand(2**63) + 1))
        }.to raise_error(RangeError)
      end

      it "can have a zero unsigned long" do
        @data.ulong = 0
        expect(@data.ulong).to eq(0)
      end

      it "can hold an unsigned long" do
        value = rand(2**63) + 1
        @data.ulong = value
        expect(@data.ulong).to eq(value)
      end

      it "raises an error on a null long" do
        expect {
          @data.long = nil
        }.to raise_error(TypeError)
      end

      it "can have a zero long" do
        @data.long = 0
        expect(@data.long).to eq(0)
      end

      it "can hold a long" do
        value = rand(2**63) + 1
        @data.long = value
        expect(@data.long).to eq(value)
      end

      it "raise an error on a null timestamp" do
        expect {
          @data.timestamp = nil
        }.to raise_error(TypeError)
      end

      it "can handle a negative timestamp" do
        last_year = Time.now - (60*60*24*365)
        @data.timestamp = last_year
        expect(@data.timestamp).to eq(last_year.to_i)
      end

      it "can handle a zero timestamp" do
        @data.timestamp = 0
        expect(@data.timestamp).to eq(0)
      end

      it "can hold a timestamp" do
        next_year = Time.now + (60*60*24*365)
        @data.timestamp = next_year
        expect(@data.timestamp).to eq(next_year.to_i)
      end

      it "raises an error on a null float" do
        expect {
          @data.float = nil
        }.to raise_error(TypeError)
      end

      it "can hold a negative float" do
        value = 0.0 - (1.0 + rand(2.0**15)).to_f
        @data.float = value
        expect(@data.float).to eq(value)
      end

      it "can hold a zero float" do
        @data.float = 0.0
        expect(@data.float).to eq(0.0)
      end

      it "can hold a float" do
        value = (1.0 + rand(2.0**15)).to_f
        @data.float = value
        expect(@data.float).to eq(value)
      end

      it "raise an error on a null double" do
        expect {
          @data.double = nil
        }.to raise_error(TypeError)
      end

      it "can hold a negative double" do
        value = 0.0 - (1.0 + rand(2.0**31)).to_f
        @data.double = value
        expect(@data.double).to eq(value)
      end

      it "can hold a zero double" do
        @data.double = 0.0
        expect(@data.double).to eq(0.0)
      end

      it "can hold a double" do
        value = (1.0 + rand(2.0**31)).to_f
        @data.double = value
        expect(@data.double).to eq(value)
      end

      it "raises an error on a null decimal32" do
        expect {
          @data.decimal32 = nil
        }.to raise_error(TypeError)
      end

      it "can hold a zero decimal32" do
        @data.decimal32 = 0
        expect(@data.decimal32).to eq(0)
      end

      it "can hold a decimal32" do
        value = 1 + rand(2**31)
        @data.decimal32 = value
        expect(@data.decimal32).to eq(value)
      end

      it "raises an error on a null decimal64" do
        expect {
          @data.decimal64 = nil
        }.to raise_error(TypeError)
      end

      it "can hold a zero decimal64" do
        @data.decimal64 = 0
        expect(@data.decimal64).to eq(0)
      end

      it "can hold a decimal64" do
        value = 1 + rand(2**63)
        @data.decimal64 = value
        expect(@data.decimal64).to eq(value)
      end

      it "raises an error on a null decimal128" do
        expect {
          @data.decimal128 = nil
        }.to raise_error(TypeError)
      end

      it "can hold a zero decimal128" do
        @data.decimal128 = 0
        expect(@data.decimal128).to eq(0)
      end

      it "can hold a decimal128" do
        value = rand(2**127)
        @data.decimal128 = value
        expect(@data.decimal128).to eq(value)
      end

      it "raises an error on a null UUID" do
        expect {
          @data.uuid = nil
        }.to raise_error(::ArgumentError)
      end

      it "raises an error on a malformed UUID" do
        expect {
          @data.uuid = random_string(36)
        }.to raise_error(::ArgumentError)
      end

      it "can set a UUID from an integer value" do
        @data.uuid = 336307859334295828133695192821923655679
        expect(@data.uuid).to eq("fd0289a5-8eec-4a08-9283-81d02c9d2fff")
      end

      it "can hold a UUID" do
        value = "fd0289a5-8eec-4a08-9283-81d02c9d2fff"
        @data.uuid = value
        expect(@data.uuid).to eq(value)
      end

      it "can hold a null binary" do
        @data.binary = nil
        expect(@data.binary).to eq("")
      end

      it "can hold a binary" do
        value = random_string(128)
        @data.binary = value
        expect(@data.binary).to eq(value)
      end

      it "can hold a null string" do
        @data.string = nil
        expect(@data.string).to eq("")
      end

      it "can hold a string" do
        value = random_string(128)
        @data.string = value
        expect(@data.string).to eq(value)
      end

      it "can hold a null symbol" do
        @data.symbol = nil
        expect(@data.symbol).to eq("")
      end

      it "can hold a symbol" do
        value = random_string(128)
        @data.symbol = value
        expect(@data.symbol).to eq(value)
      end

      it "can hold a described value" do
        name = random_string(16)
        value = random_string(16)
        @data.put_described
        @data.enter
        @data.symbol = name
        @data.string = value
        @data.exit

        expect(@data.described?).to eq(true)
        @data.enter
        @data.next
        expect(@data.symbol).to eq(name)
        @data.next
        expect(@data.string).to eq(value)
      end

      it "raises an error when setting the wrong type in an array"

      it "can hold an array" do
        values = []
        (1..(rand(100) + 5)).each { values << rand(2**16) }
        @data.put_array false, Qpid::Proton::Codec::INT
        @data.enter
        values.each { |value| @data.int = value }
        @data.exit

        @data.enter
        values.each do |value|
          @data.next
          expect(@data.int).to eq(value)
        end
      end

      it "can hold a described array" do
        values = []
        (1..(rand(100) + 5)).each { values << random_string(64) }
        descriptor = random_string(32)
        @data.put_array true, Qpid::Proton::Codec::STRING
        @data.enter
        @data.symbol = descriptor
        values.each { |value| @data.string = value }
        @data.exit

        expect(@data.array).to match_array([values.size, true, Qpid::Proton::Codec::STRING])
        @data.enter
        @data.next
        expect(@data.symbol).to eq(descriptor)
        values.each do |value|
          @data.next
          expect(@data.string).to eq(value)
        end
      end

      it "can hold a list" do
        values = []
        (1..(rand(100) + 5)).each { values << random_string(128) }
        @data.put_list
        @data.enter
        values.each {|value| @data.string = value}
        @data.exit

        @data.enter
        values.each do |value|
          @data.next
          expect(@data.string).to eq(value)
        end
      end

      it "can hold a map" do
        keys = []
        (1..(rand(100) + 5)).each {keys << random_string(128)}
        values = {}
        keys.each {|key| values[key] = random_string(128)}

        @data.put_map
        @data.enter
        keys.each do |key|
          @data.string = key
          @data.string = values[key]
        end
        @data.exit

        @data.enter
        keys.each do |key|
          @data.next
          expect(@data.string).to eq(key)
          @data.next
          expect(@data.string).to eq(values[key])
        end
      end

    end

  end

end