unittests: Add tests for vim_to_object function

test/unit/api/helpers.lua

@@ -0,0 +1,150 @@
+local helpers = require('test.unit.helpers')
+local eval_helpers = require('test.unit.eval.helpers')
+
+local cimport = helpers.cimport
+local to_cstr = helpers.to_cstr
+local ffi = helpers.ffi
+
+local list_type = eval_helpers.list_type
+local dict_type = eval_helpers.dict_type
+local func_type = eval_helpers.func_type
+local int_type = eval_helpers.int_type
+local flt_type = eval_helpers.flt_type
+local type_key = eval_helpers.type_key
+
+local api = cimport('./src/nvim/api/private/defs.h',
+                    './src/nvim/api/private/helpers.h',
+                    './src/nvim/memory.h')
+
+local obj2lua
+
+local obj2lua_tab = {
+  [tonumber(api.kObjectTypeArray)] = function(obj)
+    local ret = {[type_key]=list_type}
+    for i = 1,tonumber(obj.data.array.size) do
+      ret[i] = obj2lua(obj.data.array.items[i - 1])
+    end
+    if ret[1] then
+      ret[type_key] = nil
+    end
+    return ret
+  end,
+  [tonumber(api.kObjectTypeDictionary)] = function(obj)
+    local ret = {}
+    for i = 1,tonumber(obj.data.dictionary.size) do
+      local kv_pair = obj.data.dictionary.items[i - 1]
+      ret[ffi.string(kv_pair.key.data, kv_pair.key.size)] = obj2lua(kv_pair.value)
+    end
+    return ret
+  end,
+  [tonumber(api.kObjectTypeBoolean)] = function(obj)
+    if obj.data.boolean == false then
+      return false
+    else
+      return true
+    end
+  end,
+  [tonumber(api.kObjectTypeNil)] = function(obj)
+    return NIL
+  end,
+  [tonumber(api.kObjectTypeFloat)] = function(obj)
+    return tonumber(obj.data.floating)
+  end,
+  [tonumber(api.kObjectTypeInteger)] = function(obj)
+    return {[type_key]=int_type, value=tonumber(obj.data.integer)}
+  end,
+  [tonumber(api.kObjectTypeString)] = function(obj)
+    return ffi.string(obj.data.string.data, obj.data.string.size)
+  end,
+}
+
+obj2lua = function(obj)
+  return ((obj2lua_tab[tonumber(obj['type'])] or function(obj)
+    assert(false, 'Converting ' .. tostring(tonumber(obj['type'])) .. ' is not implementing yet')
+  end)(obj))
+end
+
+local obj = function(typ, data)
+  return ffi.gc(ffi.new('Object', {['type']=typ, data=data}),
+                api.api_free_object)
+end
+
+local lua2obj_type_tab = {
+  [int_type] = function(l)
+    return obj(api.kObjectTypeInteger, {integer=l.value})
+  end,
+  [flt_type] = function(l)
+    return obj(api.kObjectTypeFloat, {floating=l})
+  end,
+  [list_type] = function(l)
+    local len = #l
+    local arr = obj(api.kObjectTypeArray, {array={
+      size=len,
+      capacity=len,
+      items=ffi.cast('Object *', api.xmalloc(len * ffi.sizeof('Object'))),
+    }})
+    for i = 1, len do
+      arr.data.array.items[i - 1] = ffi.gc(lua2obj(l[i]), nil)
+    end
+    return arr
+  end,
+  [dict_type] = function(l)
+    local kvs = {}
+    for k, v in pairs(l) do
+      if type(k) == 'string' then
+        kvs[#kvs + 1] = {k, v}
+      end
+    end
+    local len = #kvs
+    local dct = obj(api.kObjectTypeDictionary, {dictionary={
+      size=len,
+      capacity=len,
+      items=ffi.cast('KeyValuePair *',
+                     api.xmalloc(len * ffi.sizeof('KeyValuePair'))),
+    }})
+    for i = 1, len do
+      local key, value = table.unpack(kvs[i])
+      dct.data.dictionary.items[i - 1] = ffi.new(
+          'KeyValuePair', {key=ffi.gc(lua2obj(key), nil).data.string,
+                           value=ffi.gc(lua2obj(val), nil)})
+    end
+    return dct
+  end,
+}
+
+lua2obj = function(l)
+  if type(l) == 'table' then
+    if l[type_key] then
+      return lua2obj_type_tab[l[type_key]](l)
+    else
+      if l[1] then
+        return lua2obj_type_tab[list_type](l)
+      else
+        return lua2obj_type_tab[dict_type](l)
+      end
+    end
+  elseif type(l) == 'number' then
+    return lua2obj_type_tab[flt_type](l)
+  elseif type(l) == 'boolean' then
+    return obj(api.kObjectTypeBoolean, {boolean=l})
+  elseif type(l) == 'string' then
+    return obj(api.kObjectTypeString, {string={
+      size=#l,
+      data=eval.xmemdupz(to_cstr(l), #l),
+    }})
+  elseif l == nil or l == NIL then
+    return obj(api.kObjectTypeNil, {integer=0})
+  end
+end
+
+return {
+  list_type=list_type,
+  dict_type=dict_type,
+  func_type=func_type,
+  int_type=int_type,
+  flt_type=flt_type,
+  type_key=type_key,
+
+  obj2lua=obj2lua,
+  lua2obj=lua2obj,
+}

test/unit/api/private_helpers_spec.lua

@@ -0,0 +1,87 @@
+local helpers = require('test.unit.helpers')
+local eval_helpers = require('test.unit.eval.helpers')
+local api_helpers = require('test.unit.api.helpers')
+
+local cimport = helpers.cimport
+local NULL = helpers.NULL
+local eq = helpers.eq
+
+local lua2typvalt = eval_helpers.lua2typvalt
+local typvalt = eval_helpers.typvalt
+
+local list_type = api_helpers.list_type
+local int_type = api_helpers.int_type
+local type_key = api_helpers.type_key
+local obj2lua = api_helpers.obj2lua
+
+local api = cimport('./src/nvim/api/private/helpers.h')
+
+describe('vim_to_object', function()
+  local vim_to_object = function(l)
+    return obj2lua(api.vim_to_object(lua2typvalt(l)))
+  end
+
+  local different_output_test = function(name, input, output)
+    it(name, function()
+      eq(output, vim_to_object(input))
+    end)
+  end
+
+  local simple_test = function(name, l)
+    different_output_test(name, l, l)
+  end
+
+  simple_test('converts true', true)
+  simple_test('converts false', false)
+  simple_test('converts nil', NIL)
+  simple_test('converts 1', 1)
+  simple_test('converts -1.5', -1.5)
+  simple_test('converts empty string', '')
+  simple_test('converts non-empty string', 'foobar')
+  simple_test('converts integer 10', {[type_key]=int_type, value=10})
+  simple_test('converts empty dictionary', {})
+  simple_test('converts dictionary with scalar values', {test=10, test2=true, test3='test'})
+  simple_test('converts dictionary with containers inside', {test={}, test2={1, 2}})
+  simple_test('converts empty list', {[type_key]=list_type})
+  simple_test('converts list with scalar values', {1, 2, 'test', 'foo'})
+  simple_test('converts list with containers inside', {{}, {test={}, test3={test4=true}}})
+
+  local dct = {}
+  dct.dct = dct
+  different_output_test('outputs nil for nested dictionaries (1 level)', dct, {dct=NIL})
+
+  local lst = {}
+  lst[1] = lst
+  different_output_test('outputs nil for nested lists (1 level)', lst, {NIL})
+
+  local dct2 = {test=true, dict=NIL}
+  dct2.dct = {dct2}
+  different_output_test('outputs nil for nested dictionaries (2 level, in list)',
+                        dct2, {dct={NIL}, test=true, dict=NIL})
+
+  local dct3 = {test=true, dict=NIL}
+  dct3.dct = {dctin=dct3}
+  different_output_test('outputs nil for nested dictionaries (2 level, in dict)',
+                        dct3, {dct={dctin=NIL}, test=true, dict=NIL})
+
+  local lst2 = {}
+  lst2[1] = {lst2}
+  different_output_test('outputs nil for nested lists (2 level, in list)', lst2, {{NIL}})
+
+  local lst3 = {nil, true, false, 'ttest'}
+  lst3[1] = {lst=lst3}
+  different_output_test('outputs nil for nested lists (2 level, in dict)',
+                        lst3, {{lst=NIL}, true, false, 'ttest'})
+
+  it('outputs empty list for NULL list', function()
+    local tt = typvalt('VAR_LIST', {v_list=NULL})
+    eq(nil, tt.vval.v_list)
+    eq({[type_key]=list_type}, obj2lua(api.vim_to_object(tt)))
+  end)
+
+  it('outputs empty dict for NULL dict', function()
+    local tt = typvalt('VAR_DICT', {v_dict=NULL})
+    eq(nil, tt.vval.v_dict)
+    eq({}, obj2lua(api.vim_to_object(tt)))
+  end)
+end)