garray: add unit tests

Only append_ga_line() was not tested because it relies on global vim state.

test/unit/garray.moon

@@ -0,0 +1,262 @@
+{:cimport, :internalize, :eq, :neq, :ffi, :lib, :cstr, :to_cstr} = require 'test.unit.helpers'
+
+garray = cimport './src/garray.h'
+
+-- handy constants
+NULL = ffi.cast 'void*', 0
+
+-- define a basic interface to garray. We could make it a lot nicer by
+-- constructing a moonscript class wrapper around garray. It could for
+-- example associate ga_clear_strings to the underlying garray cdata if the
+-- garray is a string array. But for now I estimate that that kind of magic
+-- might make testing less "transparant" (i.e.: the interface would become
+-- quite different as to how one would use it from C.
+
+-- accessors
+ga_len = (garr) ->
+  garr[0].ga_len
+ga_maxlen = (garr) ->
+  garr[0].ga_maxlen
+ga_itemsize = (garr) ->
+  garr[0].ga_itemsize
+ga_growsize = (garr) ->
+  garr[0].ga_growsize
+ga_data = (garr) ->
+  garr[0].ga_data
+
+-- derived accessors
+ga_size = (garr) ->
+  ga_len(garr) * ga_itemsize(garr)
+ga_maxsize = (garr) ->
+  ga_maxlen(garr) * ga_itemsize(garr)
+ga_data_as_bytes = (garr) ->
+  ffi.cast('uint8_t *', ga_data(garr))
+ga_data_as_strings = (garr) ->
+  ffi.cast('char **', ga_data(garr))
+ga_data_as_ints = (garr) ->
+  ffi.cast('int *', ga_data(garr))
+
+-- garray manipulation
+ga_init = (garr, itemsize, growsize) ->
+  garray.ga_init(garr, itemsize, growsize)
+ga_clear = (garr) ->
+  garray.ga_clear(garr)
+ga_clear_strings = (garr) ->
+  assert.is_true(ga_itemsize(garr) == ffi.sizeof('char *'))
+  garray.ga_clear_strings(garr)
+ga_grow = (garr, n) ->
+  garray.ga_grow(garr, n)
+ga_concat = (garr, str) ->
+  garray.ga_concat(garr, to_cstr(str))
+ga_append = (garr, b) ->
+  if type(b) == 'string'
+    garray.ga_append(garr, string.byte(b))
+  else
+    garray.ga_append(garr, b)
+ga_concat_strings = (garr) ->
+  internalize(garray.ga_concat_strings(garr))
+ga_remove_duplicate_strings = (garr) ->
+  garray.ga_remove_duplicate_strings(garr)
+
+-- derived manipulators
+ga_set_len = (garr, len) ->
+  assert.is_true(len <= ga_maxlen(garr))
+  garr[0].ga_len = len
+ga_inc_len = (garr, by) ->
+  ga_set_len(garr, ga_len(garr) + 1)
+
+-- custom append functions
+-- not the C ga_append, which only works for bytes
+ga_append_int = (garr, it) ->
+  assert.is_true(ga_itemsize(garr) == ffi.sizeof('int'))
+
+  ga_grow(garr, 1)
+  data = ga_data_as_ints(garr)
+  data[ga_len(garr)] = it
+  ga_inc_len(garr, 1)
+ga_append_string = (garr, it) ->
+  assert.is_true(ga_itemsize(garr) == ffi.sizeof('char *'))
+
+  -- make a non-garbage collected string and copy the lua string into it,
+  -- TODO(aktau): we should probably call xmalloc here, though as long as
+  -- xmalloc is based on malloc it should work.
+  mem = ffi.C.malloc(string.len(it) + 1)
+  ffi.copy(mem, it)
+
+  ga_grow(garr, 1)
+  data = ga_data_as_strings(garr)
+  data[ga_len(garr)] = mem
+  ga_inc_len(garr, 1)
+ga_append_strings = (garr, ...) ->
+  prevlen = ga_len(garr)
+  len = select('#', ...)
+  for i = 1, len
+    ga_append_string(garr, select(i, ...))
+  eq prevlen + len, ga_len(garr)
+ga_append_ints = (garr, ...) ->
+  prevlen = ga_len(garr)
+  len = select('#', ...)
+  for i = 1, len
+    ga_append_int(garr, select(i, ...))
+  eq prevlen + len, ga_len(garr)
+
+-- enhanced constructors
+garray_ctype = ffi.typeof('garray_T[1]')
+new_garray = ->
+  garr = garray_ctype()
+  ffi.gc(garr, ga_clear)
+new_string_garray = ->
+  garr = garray_ctype()
+  ga_init(garr, ffi.sizeof("char_u *"), 1)
+  ffi.gc(garr, ga_clear_strings)
+
+randomByte = ->
+  ffi.cast('uint8_t', math.random(0, 255))
+
+-- scramble the data in a garray
+ga_scramble = (garr) ->
+  size, bytes = ga_size(garr), ga_data_as_bytes(garr)
+
+  for i = 0, size - 1
+    bytes[i] = randomByte()
+
+describe 'garray', ->
+  itemsize = 14
+  growsize = 95
+
+  describe 'ga_init', ->
+    it 'initializes the values of the garray', ->
+      garr = new_garray()
+      ga_init(garr, itemsize, growsize)
+      eq 0, ga_len(garr)
+      eq 0, ga_maxlen(garr)
+      eq growsize, ga_growsize(garr)
+      eq itemsize, ga_itemsize(garr)
+      eq NULL, ga_data(garr)
+
+  describe 'ga_grow', ->
+    new_and_grow = (itemsize, growsize, req) ->
+      garr = new_garray()
+      ga_init(garr, itemsize, growsize)
+
+      eq 0, ga_size(garr)       -- should be 0 at first
+      eq NULL, ga_data(garr)    -- should be NULL
+      ga_grow(garr, req)        -- add space for `req` items
+
+      garr
+
+    it 'grows by growsize items if num < growsize', ->
+      itemsize = 16
+      growsize = 4
+      grow_by = growsize - 1
+      garr = new_and_grow(itemsize, growsize, grow_by)
+      neq NULL, ga_data(garr)      -- data should be a ptr to memory
+      eq growsize, ga_maxlen(garr) -- we requested LESS than growsize, so...
+
+    it 'grows by num items if num > growsize', ->
+      itemsize = 16
+      growsize = 4
+      grow_by = growsize + 1
+      garr = new_and_grow(itemsize, growsize, grow_by)
+      neq NULL, ga_data(garr)      -- data should be a ptr to memory
+      eq grow_by, ga_maxlen(garr)  -- we requested MORE than growsize, so...
+
+    it 'does not grow when nothing is requested', ->
+      garr = new_and_grow(16, 4, 0)
+      eq NULL, ga_data(garr)
+      eq 0, ga_maxlen(garr)
+
+  describe 'ga_clear', ->
+    it 'clears an already allocated array', ->
+      -- allocate and scramble an array
+      garr = garray_ctype()
+      ga_init(garr, itemsize, growsize)
+      ga_grow(garr, 4)
+      ga_set_len(garr, 4)
+      ga_scramble(garr)
+
+      -- clear it and check
+      ga_clear(garr)
+      eq NULL, ga_data(garr)
+      eq 0, ga_maxlen(garr)
+      eq 0, ga_len(garr)
+
+  describe 'ga_append', ->
+    it 'can append bytes', ->
+      -- this is the actual ga_append, the others are just emulated lua
+      -- versions
+      garr = new_garray()
+      ga_init(garr, ffi.sizeof("uint8_t"), 1)
+      ga_append(garr, 'h')
+      ga_append(garr, 'e')
+      ga_append(garr, 'l')
+      ga_append(garr, 'l')
+      ga_append(garr, 'o')
+      ga_append(garr, 0)
+      bytes = ga_data_as_bytes(garr)
+      eq 'hello', ffi.string(bytes)
+
+    it 'can append integers', ->
+      garr = new_garray()
+      ga_init(garr, ffi.sizeof("int"), 1)
+      input = {-20, 94, 867615, 90927, 86}
+      ga_append_ints(garr, unpack(input))
+
+      ints = ga_data_as_ints(garr)
+      for i = 0, #input - 1
+        eq input[i+1], ints[i]
+
+    it 'can append strings to a growing array of strings', ->
+      garr = new_string_garray()
+      input = {"some", "str", "\r\n\r●●●●●●,,,", "hmm", "got it"}
+      ga_append_strings(garr, unpack(input))
+
+      -- check that we can get the same strings out of the array
+      strings = ga_data_as_strings(garr)
+      for i = 0, #input - 1
+        eq input[i+1], ffi.string(strings[i])
+
+  describe 'ga_concat', ->
+    it 'concatenates the parameter to the growing byte array', ->
+      garr = new_garray()
+      ga_init(garr, ffi.sizeof("char"), 1)
+
+      str = "ohwell●●"
+      loop = 5
+      for i = 1, loop
+        ga_concat(garr, str)
+
+      -- ga_concat does NOT append the NUL in the src string to the
+      -- destination, you have to do that manually by calling something like
+      -- ga_append(gar, '\0'). I'ts always used like that in the vim
+      -- codebase. I feel that this is a bit of an unnecesesary
+      -- micro-optimization.
+      ga_append(garr, 0)
+
+      result = ffi.string(ga_data_as_bytes(garr))
+      eq string.rep(str, loop), result
+
+  describe 'ga_concat_strings', ->
+    it 'returns an empty string when concatenating an empty array', ->
+      garr = new_string_garray()
+      eq '', ga_concat_strings(garr)
+
+    it 'can concatenate a non-empty array', ->
+      garr = new_string_garray()
+      input = {'oh', 'my', 'neovim'}
+      ga_append_strings(garr, unpack(input))
+      eq table.concat(input, ','), ga_concat_strings(garr)
+
+  describe 'ga_remove_duplicate_strings', ->
+    it 'sorts and removes duplicate strings', ->
+      garr = new_string_garray()
+      input = {'ccc', 'aaa', 'bbb', 'ddd●●', 'aaa', 'bbb', 'ccc', 'ccc', 'ddd●●'}
+      sorted_dedup_input = {'aaa', 'bbb', 'ccc', 'ddd●●'}
+
+      ga_append_strings(garr, unpack(input))
+      ga_remove_duplicate_strings(garr)
+      eq #sorted_dedup_input, ga_len(garr)
+
+      strings = ga_data_as_strings(garr)
+      for i = 0, #sorted_dedup_input - 1
+        eq sorted_dedup_input[i+1], ffi.string(strings[i])