test_serialize.c

/*
Author: Maximilian Huber
Copyright (C) 2018, TNG Technology Consulting GmbH

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
version 2 as published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*/
#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <libfocunit.h>

#include "serialize.h"
#include "monk.h"
#include "match.h"
#include "license.h"
#include "libfocunit.h"

Licenses* getNLicensesWithText2(int count, ...) {
  GArray* licenseArray = g_array_new(TRUE, FALSE, sizeof(License));
  va_list texts;
  va_start(texts, count);
  for (int i = 0; i < count; i++) {
    char* text = g_strdup(va_arg(texts, char*));
    License license;
    license.refId = i;
    license.shortname = g_strdup_printf("%d-testLic", i);
    license.tokens = tokenize(text, "^" );

    g_array_append_val(licenseArray, license);
    g_free(text);
  }
  va_end(texts);

  return buildLicenseIndexes(licenseArray, 1, 0);
}

Licenses* roundtrip(Licenses* licenses) {
  FILE *out, *in;
  size_t size;
  char *ptr;
  out = open_memstream(&ptr, &size);
  if (out == NULL){
    return NULL;
  }

  serialize(licenses, out);
  fclose(out);

  in = fmemopen(ptr, size, "r");
  Licenses* lics = deserialize(in, MIN_ADJACENT_MATCHES, MAX_LEADING_DIFF);

  free(ptr);

  return lics;
}

void assert_Token(Token* token1, Token* token2) {
  CU_ASSERT_EQUAL(token1->length, token2->length);
  CU_ASSERT_EQUAL(token1->removedBefore, token2->removedBefore);
  CU_ASSERT_EQUAL(token1->hashedContent, token2->hashedContent);
}

void assert_License(License* lic1, License* lic2) {
  CU_ASSERT_EQUAL(lic1->refId, lic2->refId);
  CU_ASSERT_STRING_EQUAL(lic1->shortname, lic2->shortname);
  CU_ASSERT_EQUAL(lic1->tokens->len, lic2->tokens->len);

  for (guint i = 0; i < lic1->tokens->len; i++) {
    Token* tokenFrom1 = tokens_index(lic1->tokens, i);
    Token* tokenFrom2 = tokens_index(lic2->tokens, i);

    assert_Token(tokenFrom1, tokenFrom2);
  }
}

void assert_Licenses(Licenses* lics1, Licenses* lics2) {
  CU_ASSERT_EQUAL(lics1->licenses->len, lics2->licenses->len);

  for (guint i = 0; i < lics1->licenses->len; i++) {
    License* licFrom1 = license_index(lics1->licenses, i);
    License* licFrom2 = license_index(lics2->licenses, i);

    assert_License(licFrom1, licFrom2);
  }
}

void test_roundtrip_one() {
  Licenses* licenses = getNLicensesWithText2(1,"a b cde f");
  Licenses* returnedLicenses = roundtrip(licenses);

  assert_Licenses(licenses, returnedLicenses);
}

void test_roundtrip() {
  Licenses* licenses = getNLicensesWithText2(6, "a^b", "a^b^c^d", "d", "e", "f", "e^f^g");
  Licenses* returnedLicenses = roundtrip(licenses);

  assert_Licenses(licenses, returnedLicenses);
}

CU_TestInfo serialize_testcases[] = {
  {"Test roundtrip with empty:", test_roundtrip_one},
  {"Test roundtrip with some licenses with tokens:", test_roundtrip},
  CU_TEST_INFO_NULL
};