/* * 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. */ /*! * \brief gotvm package * \file array_test.go */ package gotvm import ( "testing" "unsafe" "math/rand" ) // Create an array and check size. func TestArrayCreateSize(t *testing.T) { _, err := Empty([]int64{4}) if err != nil { t.Error(err.Error()) return } _, err = Empty([]int64{4, 5, 6}) if err != nil { t.Error(err.Error()) return } _, err = Empty([]int64{}) if err == nil { t.Error("Expected err for empty Array created, but didn't got !!") return } } // Check array creation via various different arguments. func TestArrayCreateArgs(t *testing.T) { _, err := Empty([]int64{4, 2}, "float32", CPU(0)) if err != nil { t.Error(err.Error()) return } _, err = Empty([]int64{4, 2}, "float32") if err != nil { t.Error(err.Error()) return } _, err = Empty([]int64{4, 2}, CPU(0)) if err != nil { t.Error(err.Error()) return } _, err = Empty([]int64{4, 2}, CPU(0), "float32") if err != nil { t.Error(err.Error()) return } } // Create an array and check the NDim. func TestArrayNDim(t *testing.T) { arr, err := Empty([]int64{4, 5, 6}) if err != nil { t.Error(err.Error()) return } if 3 != arr.GetNdim() { t.Errorf("GetNdim failed Expected: 3 Got :%v\n", arr.GetNdim()) return } } // Create an array and check Shape. func TestArrayShape(t *testing.T) { arr, err := Empty([]int64{4, 5, 6}) if err != nil { t.Error(err.Error()) return } shape := arr.GetShape() if len(shape) != 3 { t.Errorf("Shape slice expected: 3 Got :%v\n", len(shape)) return } if shape[0] != 4 || shape[1] != 5 || shape[2] != 6 { t.Errorf("Shape values expected {4, 5, 6} Got : %v\n", shape); return } } // Create an array and check created Context. func TestArrayCtx(t *testing.T) { // TODO: Could some test cases for other targets arr, err := Empty([]int64{4}, CPU(0)) if err != nil { t.Error(err.Error()) return } ctx := arr.GetCtx() if ctx.DeviceType != KDLCPU { t.Errorf("Ctx DeviceType expected: %v Got :%v\n", KDLCPU, ctx.DeviceType) return } if ctx.DeviceID != 0 { t.Errorf("Ctx DeviceID expected: %v Got :%v\n", KDLCPU, ctx.DeviceID) return } arr, err = Empty([]int64{4}, CPU(2)) if err != nil { t.Error(err.Error()) return } ctx = arr.GetCtx() if ctx.DeviceType != KDLCPU { t.Errorf("Ctx DeviceType expected: %v Got :%v\n", KDLCPU, ctx.DeviceType) return } if ctx.DeviceID != 2 { t.Errorf("Ctx DeviceID expected: %v Got :%v\n", KDLCPU, ctx.DeviceID) return } } // Create array of different dtypes and check dtypes. func TestArrayDType(t *testing.T) { for _, dtype := range []string{"int8", "int16", "int32", "int64", "uint8", "uint16", "uint32", "uint64", "float32", "float64"} { arr, err := Empty([]int64{4}, dtype) if err != nil { t.Error(err.Error()) return } if dtype != arr.GetDType() { t.Errorf("Dtype expected: %v Got :%v\n", dtype, arr.GetDType()) return } } } // Copy Int8 data to created Array and verify. func TestArrayCopySliceInt8(t *testing.T) { dlen := int64(32) arr, err := Empty([]int64{4, dlen/4}, "int8") if err != nil { t.Error(err.Error()) return } bdata := make([]byte, dlen) rand.Read(bdata) data := (*[1<<31]int8)(unsafe.Pointer(&bdata[0]))[:dlen:dlen] err = arr.CopyFrom(data) if err != nil { t.Error(err.Error()) return } ret, err := arr.AsSlice() if err != nil { t.Error(err.Error()) return } switch ret.(type) { case []int8: default: t.Errorf("Expected : %T but got :%T\n", data, ret) return } dataRet := ret.([]int8) if len(data) != len(dataRet) { t.Errorf("Data expected Len: %v Got :%v\n", len(data), len(dataRet)) return } for i := range data { if data[i] != dataRet[i] { t.Errorf("Data expected: %v Got :%v\n", data, dataRet) return } } } // Copy Int16 data to created Array and verify. func TestArrayCopySliceInt16(t *testing.T) { dlen := int64(32) arr, err := Empty([]int64{4, dlen/4}, "int16") if err != nil { t.Error(err.Error()) return } bdata := make([]byte, dlen*2) rand.Read(bdata) data := (*[1<<31]int16)(unsafe.Pointer(&bdata[0]))[:dlen:dlen] err = arr.CopyFrom(data) if err != nil { t.Error(err.Error()) return } ret, err := arr.AsSlice() if err != nil { t.Error(err.Error()) return } switch ret.(type) { case []int16: default: t.Errorf("Expected : %T but got :%T\n", data, ret) return } dataRet := ret.([]int16) if len(data) != len(dataRet) { t.Errorf("Data expected Len: %v Got :%v\n", len(data), len(dataRet)) return } for i := range data { if data[i] != dataRet[i] { t.Errorf("Data expected: %v Got :%v\n", data, dataRet) return } } } // Copy Int32 data to created Array and verify. func TestArrayCopySliceInt32(t *testing.T) { dlen := int64(32) arr, err := Empty([]int64{4, dlen/4}, "int32") if err != nil { t.Error(err.Error()) return } bdata := make([]byte, dlen*4) rand.Read(bdata) data := (*[1<<31]int32)(unsafe.Pointer(&bdata[0]))[:dlen:dlen] err = arr.CopyFrom(data) if err != nil { t.Error(err.Error()) return } ret, err := arr.AsSlice() if err != nil { t.Error(err.Error()) return } switch ret.(type) { case []int32: default: t.Errorf("Expected : %T but got :%T\n", data, ret) return } dataRet := ret.([]int32) if len(data) != len(dataRet) { t.Errorf("Data expected Len: %v Got :%v\n", len(data), len(dataRet)) return } for i := range data { if data[i] != dataRet[i] { t.Errorf("Data expected: %v Got :%v\n", data, dataRet) return } } } // Copy Int64 data to created Array and verify. func TestArrayCopySliceInt64(t *testing.T) { dlen := int64(32) arr, err := Empty([]int64{4, dlen/4}, "int64") if err != nil { t.Error(err.Error()) return } bdata := make([]byte, dlen*8) rand.Read(bdata) data := (*[1<<31]int64)(unsafe.Pointer(&bdata[0]))[:dlen:dlen] err = arr.CopyFrom(data) if err != nil { t.Error(err.Error()) return } ret, err := arr.AsSlice() if err != nil { t.Error(err.Error()) return } switch ret.(type) { case []int64: default: t.Errorf("Expected : %T but got :%T\n", data, ret) return } dataRet := ret.([]int64) if len(data) != len(dataRet) { t.Errorf("Data expected Len: %v Got :%v\n", len(data), len(dataRet)) return } for i := range data { if data[i] != dataRet[i] { t.Errorf("Data expected: %v Got :%v\n", data, dataRet) return } } } // Copy UInt8 data to created Array and verify. func TestArrayCopySliceUInt8(t *testing.T) { dlen := int64(32) arr, err := Empty([]int64{4, dlen/4}, "uint8") if err != nil { t.Error(err.Error()) return } bdata := make([]byte, dlen) rand.Read(bdata) data := (*[1<<31]uint8)(unsafe.Pointer(&bdata[0]))[:dlen:dlen] err = arr.CopyFrom(data) if err != nil { t.Error(err.Error()) return } ret, err := arr.AsSlice() if err != nil { t.Error(err.Error()) return } switch ret.(type) { case []uint8: default: t.Errorf("Expected : %T but got :%T\n", data, ret) return } dataRet := ret.([]uint8) if len(data) != len(dataRet) { t.Errorf("Data expected Len: %v Got :%v\n", len(data), len(dataRet)) return } for i := range data { if data[i] != dataRet[i] { t.Errorf("Data expected: %v Got :%v\n", data, dataRet) return } } } // Copy UInt16 data to created Array and verify. func TestArrayCopySliceUInt16(t *testing.T) { dlen := int64(32) arr, err := Empty([]int64{4, dlen/4}, "uint16") if err != nil { t.Error(err.Error()) return } bdata := make([]byte, dlen*2) rand.Read(bdata) data := (*[1<<31]uint16)(unsafe.Pointer(&bdata[0]))[:dlen:dlen] err = arr.CopyFrom(data) if err != nil { t.Error(err.Error()) return } ret, err := arr.AsSlice() if err != nil { t.Error(err.Error()) return } switch ret.(type) { case []uint16: default: t.Errorf("Expected : %T but got :%T\n", data, ret) return } dataRet := ret.([]uint16) if len(data) != len(dataRet) { t.Errorf("Data expected Len: %v Got :%v\n", len(data), len(dataRet)) return } for i := range data { if data[i] != dataRet[i] { t.Errorf("Data expected: %v Got :%v\n", data, dataRet) return } } } // Copy UInt32 data to created Array and verify. func TestArrayCopySliceUInt32(t *testing.T) { dlen := int64(32) arr, err := Empty([]int64{4, dlen/4}, "uint32") if err != nil { t.Error(err.Error()) return } bdata := make([]byte, dlen*4) rand.Read(bdata) data := (*[1<<31]uint32)(unsafe.Pointer(&bdata[0]))[:dlen:dlen] err = arr.CopyFrom(data) if err != nil { t.Error(err.Error()) return } ret, err := arr.AsSlice() if err != nil { t.Error(err.Error()) return } switch ret.(type) { case []uint32: default: t.Errorf("Expected : %T but got :%T\n", data, ret) return } dataRet := ret.([]uint32) if len(data) != len(dataRet) { t.Errorf("Data expected Len: %v Got :%v\n", len(data), len(dataRet)) return } for i := range data { if data[i] != dataRet[i] { t.Errorf("Data expected: %v Got :%v\n", data, dataRet) return } } } // Copy UInt64 data to created Array and verify. func TestArrayCopySliceUInt64(t *testing.T) { dlen := int64(32) arr, err := Empty([]int64{4, dlen/4}, "uint64") if err != nil { t.Error(err.Error()) return } bdata := make([]byte, dlen*8) rand.Read(bdata) data := (*[1<<31]uint64)(unsafe.Pointer(&bdata[0]))[:dlen:dlen] err = arr.CopyFrom(data) if err != nil { t.Error(err.Error()) return } ret, err := arr.AsSlice() if err != nil { t.Error(err.Error()) return } switch ret.(type) { case []uint64: default: t.Errorf("Expected : %T but got :%T\n", data, ret) return } dataRet := ret.([]uint64) if len(data) != len(dataRet) { t.Errorf("Data expected Len: %v Got :%v\n", len(data), len(dataRet)) return } for i := range data { if data[i] != dataRet[i] { t.Errorf("Data expected: %v Got :%v\n", data, dataRet) return } } } // Copy Float32 data to created Array and verify. func TestArrayCopySliceFloat32(t *testing.T) { dlen := int64(32) arr, err := Empty([]int64{4, dlen/4}, "float32") if err != nil { t.Error(err.Error()) return } data := make([]float32, dlen) for i := range data { data[i] = rand.Float32() } err = arr.CopyFrom(data) if err != nil { t.Error(err.Error()) return } ret, err := arr.AsSlice() if err != nil { t.Error(err.Error()) return } switch ret.(type) { case []float32: default: t.Errorf("Expected : %T but got :%T\n", data, ret) return } dataRet := ret.([]float32) if len(data) != len(dataRet) { t.Errorf("Data expected Len: %v Got :%v\n", len(data), len(dataRet)) return } for i := range data { if data[i] != dataRet[i] { t.Errorf("Data expected: %v \nGot :%v \n", data, dataRet) return } } } // Copy Float64 data to created Array and verify. func TestArrayCopySliceFloat64(t *testing.T) { dlen := int64(32) arr, err := Empty([]int64{4, dlen/4}, "float64") if err != nil { t.Error(err.Error()) return } data := make([]float64, dlen) for i := range data { data[i] = rand.Float64() } err = arr.CopyFrom(data) if err != nil { t.Error(err.Error()) return } ret, err := arr.AsSlice() if err != nil { t.Error(err.Error()) return } switch ret.(type) { case []float64: default: t.Errorf("Expected : %T but got :%T\n", data, ret) return } dataRet := ret.([]float64) if len(data) != len(dataRet) { t.Errorf("Data expected Len: %v Got :%v\n", len(data), len(dataRet)) return } for i := range data { if data[i] != dataRet[i] { t.Errorf("Data expected: %v Got :%v\n", data, dataRet) return } } }