nvti_tests.c

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2009-2023 Greenbone AG
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#include "nvti.c"
 
#include <cgreen/cgreen.h>
#include <cgreen/mocks.h>
 
Describe (nvti);
BeforeEach (nvti)
{
}
AfterEach (nvti)
{
}
 
/* make_nvti */
 
Ensure (nvti, nvti_new_never_returns_null)
{
  nvti_t *nvti;
 
  nvti = nvti_new ();
  assert_that (nvti, is_not_null);
  nvti_free (nvti);
}
 
/* nvti solution_method */
 
Ensure (nvti, nvti_parse_timestamp)
{
  setenv ("TZ", "utc 0", 1);
  tzset ();
 
  assert_that (
    parse_nvt_timestamp ("2018-09-07 11:08:31 +0200 (Fri, 07 Sep 2018)"),
    is_equal_to (1536311311));
  assert_that_double (
    parse_nvt_timestamp ("2022-05-31 20:54:22 +0100 (Tue, 31 May 2022)"),
    is_equal_to_double (1654026862));
  assert_that_double (parse_nvt_timestamp ("2012-09-23 02:15:34 +0400"),
                      is_equal_to_double (1348352134));
  assert_that_double (parse_nvt_timestamp ("Fri Feb 10 16:09:30 2023 +0100"),
                      is_equal_to_double (1676041770));
}
 
/* nvti solution_method */
 
Ensure (nvti, nvti_set_solution_method_correct)
{
  nvti_t *nvti;
  gchar *solution_method;
 
  nvti = nvti_new ();
  nvti_set_solution_method (nvti, "DebianAPTUpgrade");
  solution_method = nvti_solution_method (nvti);
 
  assert_that (solution_method, is_equal_to_string ("DebianAPTUpgrade"));
 
  nvti_free (nvti);
}
 
/* nvti_get_tag */
 
Ensure (nvti, nvti_get_tag_gets_correct_value_one_tag)
{
  nvti_t *nvti;
  gchar *tag;
 
  nvti = nvti_new ();
  nvti_set_tag (nvti, "a=1");
  tag = nvti_get_tag (nvti, "a");
 
  assert_that (tag, is_equal_to_string ("1"));
 
  g_free (tag);
  nvti_free (nvti);
}
 
Ensure (nvti, nvti_get_tag_gets_correct_value_many_tags)
{
  nvti_t *nvti;
  gchar *tag;
 
  nvti = nvti_new ();
  nvti_set_tag (nvti, "a=1|b=2|c=3");
  tag = nvti_get_tag (nvti, "b");
 
  assert_that (tag, is_equal_to_string ("2"));
 
  g_free (tag);
  nvti_free (nvti);
}
 
Ensure (nvti, nvti_get_tag_handles_empty_tag)
{
  nvti_t *nvti;
 
  nvti = nvti_new ();
 
  assert_that (nvti_get_tag (nvti, "b"), is_null);
 
  nvti_free (nvti);
}
 
Ensure (nvti, nvti_get_tag_handles_null_nvti)
{
  assert_that (nvti_get_tag (NULL, "example"), is_null);
}
 
Ensure (nvti, nvti_get_tag_handles_null_name)
{
  nvti_t *nvti;
 
  nvti = nvti_new ();
  nvti_set_tag (nvti, "example=1");
 
  assert_that (nvti_get_tag (nvti, NULL), is_null);
 
  nvti_free (nvti);
}
 
/* nvtis_add */
 
Ensure (nvti, nvtis_add_does_not_use_oid_as_key)
{
  nvtis_t *nvtis;
  nvti_t *nvti;
  gchar *oid;
 
  nvtis = nvtis_new ();
 
  nvti = nvti_new ();
  nvti_set_oid (nvti, "1");
 
  oid = nvti_oid (nvti);
 
  /* This should not use the pointer nvti->oid as the key, because nvti_set_oid
   * could free nvti->oid. */
  nvtis_add (nvtis, nvti);
 
  /* Change the first character of the OID. */
  *oid = '2';
 
  /* To check that the key is not the same pointer as nvti->oid, check
   * that changing the first character of nvti->oid did not affect the key. */
  assert_that (nvtis_lookup (nvtis, "1"), is_not_null);
  assert_that (nvtis_lookup (nvtis, "2"), is_null);
 
  nvtis_free (nvtis);
}
 
/* nvti severity vector */
 
Ensure (nvti, nvti_get_severity_vector_both)
{
  nvti_t *nvti;
  gchar *vector;
 
  nvti = nvti_new ();
  nvti_set_tag (nvti, "cvss_base_vector=DEF");
  nvti_set_tag (nvti, "severity_vector=ABC");
 
  vector = nvti_severity_vector_from_tag (nvti);
 
  assert_that (vector, is_equal_to_string ("ABC"));
 
  g_free (vector);
  nvti_free (nvti);
}
 
Ensure (nvti, nvti_get_severity_vector_no_cvss_base)
{
  nvti_t *nvti;
  gchar *vector;
 
  nvti = nvti_new ();
  nvti_set_tag (nvti, "severity_vector=ABC");
 
  vector = nvti_severity_vector_from_tag (nvti);
 
  assert_that (vector, is_equal_to_string ("ABC"));
 
  g_free (vector);
  nvti_free (nvti);
}
 
Ensure (nvti, nvti_get_severity_vector_no_severity_vector)
{
  nvti_t *nvti;
  gchar *vector;
 
  nvti = nvti_new ();
  nvti_set_tag (nvti, "cvss_base_vector=DEF");
 
  vector = nvti_severity_vector_from_tag (nvti);
  assert_that (vector, is_equal_to_string ("DEF"));
 
  g_free (vector);
  nvti_free (nvti);
}
 
/* Test suite. */
 
int
main (int argc, char **argv)
{
  int ret;
  TestSuite *suite;
 
  suite = create_test_suite ();
 
  add_test_with_context (suite, nvti, nvti_new_never_returns_null);
 
  add_test_with_context (suite, nvti, nvti_get_tag_gets_correct_value_one_tag);
  add_test_with_context (suite, nvti,
                         nvti_get_tag_gets_correct_value_many_tags);
  add_test_with_context (suite, nvti, nvti_get_tag_handles_empty_tag);
  add_test_with_context (suite, nvti, nvti_get_tag_handles_null_nvti);
  add_test_with_context (suite, nvti, nvti_get_tag_handles_null_name);
 
  add_test_with_context (suite, nvti, nvti_set_solution_method_correct);
 
  add_test_with_context (suite, nvti, nvtis_add_does_not_use_oid_as_key);
 
  add_test_with_context (suite, nvti, nvti_get_severity_vector_both);
  add_test_with_context (suite, nvti,
                         nvti_get_severity_vector_no_severity_vector);
  add_test_with_context (suite, nvti, nvti_get_severity_vector_no_cvss_base);
  add_test_with_context (suite, nvti, nvti_parse_timestamp);
 
  if (argc > 1)
    ret = run_single_test (suite, argv[1], create_text_reporter ());
  else
    ret = run_test_suite (suite, create_text_reporter ());
 
  destroy_test_suite (suite);
 
  return ret;
}