/* -*- mode: C; c-file-style: "gnu" -*- */

/* dbus-marshal-recursive-util.c  Would be in dbus-marshal-recursive.c, but only used in bus/tests

 *

 * Copyright (C) 2004, 2005 Red Hat, Inc.

 * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 * Licensed under the Academic Free License version 2.1

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#ifdef __SYMBIAN32__

#include "config.h"

#else

#include <config.h>

#endif

#ifdef DBUS_BUILD_TESTS

#include "dbus-marshal-recursive.h"

#include "dbus-marshal-basic.h"

#include "dbus-signature.h"

#include "dbus-internals.h"

#include <string.h>

static void

basic_value_zero (DBusBasicValue *value)

{

#ifdef DBUS_HAVE_INT64

  value->u64 = 0;

#else

  value->u64.first32 = 0;

  value->u64.second32 = 0;

#endif

}

static dbus_bool_t

basic_value_equal (int             type,

                   DBusBasicValue *lhs,

                   DBusBasicValue *rhs)

{

  if (type == DBUS_TYPE_STRING ||

      type == DBUS_TYPE_SIGNATURE ||

      type == DBUS_TYPE_OBJECT_PATH)

    {

      return strcmp (lhs->str, rhs->str) == 0;

    }

  else

    {

#ifdef DBUS_HAVE_INT64

      return lhs->u64 == rhs->u64;

#else

      return lhs->u64.first32 == rhs->u64.first32 &&

        lhs->u64.second32 == rhs->u64.second32;

#endif

    }

}

static dbus_bool_t

equal_values_helper (DBusTypeReader *lhs,

                     DBusTypeReader *rhs)

{

  int lhs_type;

  int rhs_type;

  lhs_type = _dbus_type_reader_get_current_type (lhs);

  rhs_type = _dbus_type_reader_get_current_type (rhs);

  if (lhs_type != rhs_type)

    return FALSE;

  if (lhs_type == DBUS_TYPE_INVALID)

    return TRUE;

  if (dbus_type_is_basic (lhs_type))

    {

      DBusBasicValue lhs_value;

      DBusBasicValue rhs_value;

      basic_value_zero (&lhs_value);

      basic_value_zero (&rhs_value);

      _dbus_type_reader_read_basic (lhs, &lhs_value);

      _dbus_type_reader_read_basic (rhs, &rhs_value);

      return basic_value_equal (lhs_type, &lhs_value, &rhs_value);

    }

  else

    {

      DBusTypeReader lhs_sub;

      DBusTypeReader rhs_sub;

      _dbus_type_reader_recurse (lhs, &lhs_sub);

      _dbus_type_reader_recurse (rhs, &rhs_sub);

      return equal_values_helper (&lhs_sub, &rhs_sub);

    }

}

/**

 * See whether the two readers point to identical data blocks.

 *

 * @param lhs reader 1

 * @param rhs reader 2

 * @returns #TRUE if the data blocks have the same values

 */

dbus_bool_t

_dbus_type_reader_equal_values (const DBusTypeReader *lhs,

                                const DBusTypeReader *rhs)

{

  DBusTypeReader copy_lhs = *lhs;

  DBusTypeReader copy_rhs = *rhs;

  return equal_values_helper (&copy_lhs, &copy_rhs);

}

/* TESTS */

#ifndef DOXYGEN_SHOULD_SKIP_THIS

#include "dbus-test.h"

#include "dbus-list.h"

#include <stdio.h>

#include <stdlib.h>

/* Whether to do the OOM stuff (only with other expensive tests) */

#define TEST_OOM_HANDLING 0

/* We do start offset 0 through 9, to get various alignment cases. Still this

 * obviously makes the test suite run 10x as slow.

 */

#define MAX_INITIAL_OFFSET 9

/* Largest iteration count to test copying, realignment,

 * etc. with. i.e. we only test this stuff with some of the smaller

 * data sets.

 */

#define MAX_ITERATIONS_FOR_EXPENSIVE_TESTS 1000

typedef struct

{

  int byte_order;

  int initial_offset;

  DBusString signature;

  DBusString body;

} DataBlock;

typedef struct

{

  int saved_sig_len;

  int saved_body_len;

} DataBlockState;

#define N_FENCE_BYTES 5

#define FENCE_BYTES_STR "abcde"

#define INITIAL_PADDING_BYTE '\0'

static dbus_bool_t

data_block_init (DataBlock *block,

                 int        byte_order,

                 int        initial_offset)

{

  if (!_dbus_string_init (&block->signature))

    return FALSE;

  if (!_dbus_string_init (&block->body))

    {

      _dbus_string_free (&block->signature);

      return FALSE;

    }

  if (!_dbus_string_insert_bytes (&block->signature, 0, initial_offset,

                                  INITIAL_PADDING_BYTE) ||

      !_dbus_string_insert_bytes (&block->body, 0, initial_offset,

                                  INITIAL_PADDING_BYTE) ||

      !_dbus_string_append (&block->signature, FENCE_BYTES_STR) ||

      !_dbus_string_append (&block->body, FENCE_BYTES_STR))

    {

      _dbus_string_free (&block->signature);

      _dbus_string_free (&block->body);

      return FALSE;

    }

  block->byte_order = byte_order;

  block->initial_offset = initial_offset;

  return TRUE;

}

static void

data_block_save (DataBlock      *block,

                 DataBlockState *state)

{

  state->saved_sig_len = _dbus_string_get_length (&block->signature) - N_FENCE_BYTES;

  state->saved_body_len = _dbus_string_get_length (&block->body) - N_FENCE_BYTES;

}

static void

data_block_restore (DataBlock      *block,

                    DataBlockState *state)

{

  _dbus_string_delete (&block->signature,

                       state->saved_sig_len,

                       _dbus_string_get_length (&block->signature) - state->saved_sig_len - N_FENCE_BYTES);

  _dbus_string_delete (&block->body,

                       state->saved_body_len,

                       _dbus_string_get_length (&block->body) - state->saved_body_len - N_FENCE_BYTES);

}

static void

data_block_verify (DataBlock *block)

{

  if (!_dbus_string_ends_with_c_str (&block->signature,

                                     FENCE_BYTES_STR))

    {

      int offset;

      offset = _dbus_string_get_length (&block->signature) - N_FENCE_BYTES - 8;

      if (offset < 0)

        offset = 0;

      _dbus_verbose_bytes_of_string (&block->signature,

                                     offset,

                                     _dbus_string_get_length (&block->signature) - offset);

      _dbus_assert_not_reached ("block did not verify: bad bytes at end of signature");

    }

  if (!_dbus_string_ends_with_c_str (&block->body,

                                     FENCE_BYTES_STR))

    {

      int offset;

      offset = _dbus_string_get_length (&block->body) - N_FENCE_BYTES - 8;

      if (offset < 0)

        offset = 0;

      _dbus_verbose_bytes_of_string (&block->body,

                                     offset,

                                     _dbus_string_get_length (&block->body) - offset);

      _dbus_assert_not_reached ("block did not verify: bad bytes at end of body");

    }

  _dbus_assert (_dbus_string_validate_nul (&block->signature,

                                           0, block->initial_offset));

  _dbus_assert (_dbus_string_validate_nul (&block->body,

                                           0, block->initial_offset));

}

static void

data_block_free (DataBlock *block)

{

  data_block_verify (block);

  _dbus_string_free (&block->signature);

  _dbus_string_free (&block->body);

}

static void

data_block_reset (DataBlock *block)

{

  data_block_verify (block);

  _dbus_string_delete (&block->signature,

                       block->initial_offset,

                       _dbus_string_get_length (&block->signature) - N_FENCE_BYTES - block->initial_offset);

  _dbus_string_delete (&block->body,

                       block->initial_offset,

                       _dbus_string_get_length (&block->body) - N_FENCE_BYTES - block->initial_offset);

  data_block_verify (block);

}

static void

data_block_init_reader_writer (DataBlock      *block,

                               DBusTypeReader *reader,

                               DBusTypeWriter *writer)

{

  if (reader)

    _dbus_type_reader_init (reader,

                            block->byte_order,

                            &block->signature,

                            block->initial_offset,

                            &block->body,

                            block->initial_offset);

  if (writer)

    _dbus_type_writer_init (writer,

                            block->byte_order,

                            &block->signature,

                            _dbus_string_get_length (&block->signature) - N_FENCE_BYTES,

                            &block->body,

                            _dbus_string_get_length (&block->body) - N_FENCE_BYTES);

}

static void

real_check_expected_type (DBusTypeReader *reader,

                          int             expected,

                          const char     *funcname,

                          int             line)

{

  int t;

  t = _dbus_type_reader_get_current_type (reader);

  if (t != expected)

    {

      _dbus_warn ("Read type %s while expecting %s at %s line %d\n",

                  _dbus_type_to_string (t),

                  _dbus_type_to_string (expected),

                  funcname, line);

      _dbus_assert_not_reached ("read wrong type");

    }

}

#define check_expected_type(reader, expected) real_check_expected_type (reader, expected, _DBUS_FUNCTION_NAME, __LINE__)

#define NEXT_EXPECTING_TRUE(reader)  do { if (!_dbus_type_reader_next (reader))         \

 {                                                                                      \

    _dbus_warn ("_dbus_type_reader_next() should have returned TRUE at %s %d\n",        \

                              _DBUS_FUNCTION_NAME, __LINE__);                           \

    _dbus_assert_not_reached ("test failed");                                           \

 }                                                                                      \

} while (0)

#define NEXT_EXPECTING_FALSE(reader) do { if (_dbus_type_reader_next (reader))          \

 {                                                                                      \

    _dbus_warn ("_dbus_type_reader_next() should have returned FALSE at %s %d\n",       \

                              _DBUS_FUNCTION_NAME, __LINE__);                           \

    _dbus_assert_not_reached ("test failed");                                           \

 }                                                                                      \

 check_expected_type (reader, DBUS_TYPE_INVALID);                                       \

} while (0)

typedef struct TestTypeNode               TestTypeNode;

typedef struct TestTypeNodeClass          TestTypeNodeClass;

typedef struct TestTypeNodeContainer      TestTypeNodeContainer;

typedef struct TestTypeNodeContainerClass TestTypeNodeContainerClass;

struct TestTypeNode

{

  const TestTypeNodeClass *klass;

};

struct TestTypeNodeContainer

{

  TestTypeNode base;

  DBusList    *children;

};

struct TestTypeNodeClass

{

  int typecode;

  int instance_size;

  int subclass_detail; /* a bad hack to avoid a bunch of subclass casting */

  dbus_bool_t   (* construct)     (TestTypeNode   *node);

  void          (* destroy)       (TestTypeNode   *node);

  dbus_bool_t (* write_value)     (TestTypeNode   *node,

                                   DataBlock      *block,

                                   DBusTypeWriter *writer,

                                   int             seed);

  dbus_bool_t (* read_value)      (TestTypeNode   *node,

                                   DBusTypeReader *reader,

                                   int             seed);

  dbus_bool_t (* set_value)       (TestTypeNode   *node,

                                   DBusTypeReader *reader,

                                   DBusTypeReader *realign_root,

                                   int             seed);

  dbus_bool_t (* build_signature) (TestTypeNode   *node,

                                   DBusString     *str);

  dbus_bool_t (* write_multi)     (TestTypeNode   *node,

                                   DataBlock      *block,

                                   DBusTypeWriter *writer,

                                   int             seed,

                                   int             count);

  dbus_bool_t (* read_multi)      (TestTypeNode   *node,

                                   DBusTypeReader *reader,

                                   int             seed,

                                   int             count);

};

struct TestTypeNodeContainerClass

{

  TestTypeNodeClass base;

};

/* FIXME this could be chilled out substantially by unifying

 * the basic types into basic_write_value/basic_read_value

 * and by merging read_value and set_value into one function

 * taking a flag argument.

 */

static dbus_bool_t int16_write_value       (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed);

static dbus_bool_t int16_read_value        (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            int             seed);

static dbus_bool_t int16_set_value         (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            DBusTypeReader *realign_root,

                                            int             seed);

static dbus_bool_t int16_write_multi       (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed,

                                            int             count);

static dbus_bool_t int16_read_multi        (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            int             seed,

                                            int             count);

static dbus_bool_t int32_write_value       (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed);

static dbus_bool_t int32_read_value        (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            int             seed);

static dbus_bool_t int32_set_value         (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            DBusTypeReader *realign_root,

                                            int             seed);

static dbus_bool_t int32_write_multi       (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed,

                                            int             count);

static dbus_bool_t int32_read_multi        (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            int             seed,

                                            int             count);

static dbus_bool_t int64_write_value       (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed);

static dbus_bool_t int64_read_value        (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            int             seed);

static dbus_bool_t int64_set_value         (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            DBusTypeReader *realign_root,

                                            int             seed);

static dbus_bool_t string_write_value      (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed);

static dbus_bool_t string_read_value       (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            int             seed);

static dbus_bool_t string_set_value        (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            DBusTypeReader *realign_root,

                                            int             seed);

static dbus_bool_t bool_write_value        (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed);

static dbus_bool_t bool_read_value         (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            int             seed);

static dbus_bool_t bool_set_value          (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            DBusTypeReader *realign_root,

                                            int             seed);

static dbus_bool_t byte_write_value        (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed);

static dbus_bool_t byte_read_value         (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            int             seed);

static dbus_bool_t byte_set_value          (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            DBusTypeReader *realign_root,

                                            int             seed);

static dbus_bool_t double_write_value      (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed);

static dbus_bool_t double_read_value       (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            int             seed);

static dbus_bool_t double_set_value        (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            DBusTypeReader *realign_root,

                                            int             seed);

static dbus_bool_t object_path_write_value (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed);

static dbus_bool_t object_path_read_value  (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            int             seed);

static dbus_bool_t object_path_set_value   (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            DBusTypeReader *realign_root,

                                            int             seed);

static dbus_bool_t signature_write_value   (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed);

static dbus_bool_t signature_read_value    (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            int             seed);

static dbus_bool_t signature_set_value     (TestTypeNode   *node,

                                            DBusTypeReader *reader,

                                            DBusTypeReader *realign_root,

                                            int             seed);

static dbus_bool_t struct_write_value      (TestTypeNode   *node,

                                            DataBlock      *block,

                                            DBusTypeWriter *writer,

                                            int             seed);