| /* |
| * 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. |
| */ |
| |
| package hessian |
| |
| import ( |
| "github.com/stretchr/testify/assert" |
| "testing" |
| ) |
| |
| func TestBooleanArray(t *testing.T) { |
| booleanArray := &BooleanArray{[]bool{true, false}} |
| e := &Encoder{} |
| a := assert.New(t) |
| |
| err := e.Encode(booleanArray) |
| a.Nil(err) |
| |
| decoder := NewDecoder(e.buffer) |
| decodeValue, err := decoder.DecodeValue() |
| a.Nil(err) |
| a.Equal(booleanArray.Values, decodeValue.(*BooleanArray).Values) |
| } |
| |
| func TestIntegerArray(t *testing.T) { |
| ia := &IntegerArray{[]int32{1, 2, 3}} |
| a := assert.New(t) |
| |
| e := &Encoder{} |
| err := e.Encode(ia) |
| a.Nil(err) |
| |
| decoder := NewDecoder(e.buffer) |
| decodeValue, err := decoder.DecodeValue() |
| a.Nil(err) |
| a.Equal(ia.Values, decodeValue.(*IntegerArray).Values) |
| |
| // Integer[] that length > 7 |
| bigIa := &IntegerArray{[]int32{1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3}} |
| ne := &Encoder{} |
| err = ne.Encode(bigIa) |
| a.Nil(err) |
| |
| decoder = NewDecoder(e.buffer) |
| decodeValue, err = decoder.DecodeValue() |
| a.Nil(err) |
| a.Equal(ia.Values, decodeValue.(*IntegerArray).Values) |
| } |
| |
| func TestByteArray(t *testing.T) { |
| ba := &ByteArray{} |
| ba.Values = []uint8{1, 2, 3} |
| a := assert.New(t) |
| |
| e := &Encoder{} |
| err := e.Encode(ba) |
| a.Nil(err) |
| |
| decoder := NewDecoder(e.buffer) |
| decodeValue, err := decoder.DecodeValue() |
| a.Nil(err) |
| a.Equal(ba.Values, decodeValue.(*ByteArray).Values) |
| } |
| |
| func TestShortArray(t *testing.T) { |
| sa := &ShortArray{} |
| sa.Values = []int16{1, 2, 3} |
| a := assert.New(t) |
| |
| e := &Encoder{} |
| err := e.Encode(sa) |
| a.Nil(err) |
| |
| decoder := NewDecoder(e.buffer) |
| decodeValue, err := decoder.DecodeValue() |
| a.Nil(err) |
| a.Equal(sa.Values, decodeValue.(*ShortArray).Values) |
| } |
| |
| func TestLongArray(t *testing.T) { |
| la := &LongArray{[]int64{1, 2, 3, 4}} |
| a := assert.New(t) |
| |
| e := &Encoder{} |
| err := e.Encode(la) |
| a.Nil(err) |
| |
| decoder := NewDecoder(e.buffer) |
| decodeValue, err := decoder.DecodeValue() |
| a.Nil(err) |
| a.Equal(la.Values, decodeValue.(*LongArray).Values) |
| } |
| |
| func TestFloatArray(t *testing.T) { |
| fa := &FloatArray{[]float32{1, 2, 3, 4}} |
| a := assert.New(t) |
| |
| e := &Encoder{} |
| err := e.Encode(fa) |
| a.Nil(err) |
| |
| decoder := NewDecoder(e.buffer) |
| decodeValue, err := decoder.DecodeValue() |
| a.Nil(err) |
| a.Equal(fa.Values, decodeValue.(*FloatArray).Values) |
| } |
| |
| func TestDoubleArray(t *testing.T) { |
| da := &DoubleArray{[]float64{1, 2, 3, 4}} |
| a := assert.New(t) |
| |
| e := &Encoder{} |
| err := e.Encode(da) |
| a.Nil(err) |
| |
| decoder := NewDecoder(e.buffer) |
| decodeValue, err := decoder.DecodeValue() |
| a.Nil(err) |
| a.Equal(da.Values, decodeValue.(*DoubleArray).Values) |
| } |
| |
| func TestCharacterArray(t *testing.T) { |
| ca := &CharacterArray{"hello world"} |
| a := assert.New(t) |
| |
| e := &Encoder{} |
| err := e.Encode(ca) |
| a.Nil(err) |
| |
| decoder := NewDecoder(e.buffer) |
| decodeValue, err := decoder.DecodeValue() |
| a.Nil(err) |
| a.Equal(ca.Values, decodeValue.(*CharacterArray).Values) |
| } |