/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            test_framelist.cc
 *
 *  Fri Jan  3 08:45:14 CET 2014
 *  Copyright 2014 Bent Bisballe Nyeng
 *  deva@aasimon.org
 ****************************************************************************/

/*
 *  This file is part of lrtp.
 *
 * lrtp is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * lrtp 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with lrtp; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <cppunit/extensions/HelperMacros.h>

#include <lrtp.h>
#include "../src/rtp.h"

#include <stdio.h>

#include <string>
#include <vector>

#define KEY "123456789012345678901234567890123456789012345678901234567890"
#define SSRC 1234567890

typedef union {
  int n;
  char c[sizeof(int)];
} num_t;

class test_conn_class : public CppUnit::TestFixture
{
  CPPUNIT_TEST_SUITE(test_conn_class);
	CPPUNIT_TEST(test_framelist_single);
	CPPUNIT_TEST(test_framelist);
	CPPUNIT_TEST_SUITE_END();

public:
	void setUp() {}
	void tearDown() {}

	void test_framelist_single() {
    int ret;

    std::vector<std::string> packets;
    unsigned int csrc = 42;

    num_t num[3];

    lrtp_status_t status;
    struct lrtp_t *lrtp = lrtp_init(&status, KEY, SSRC);
    CPPUNIT_ASSERT_EQUAL(LRTP_OK, status);

    struct lrtp_t *lrtp2 = lrtp_init(&status, KEY, SSRC);
    CPPUNIT_ASSERT_EQUAL(LRTP_OK, status);
    
    ret = lrtp_create_profile(lrtp, PROFILE_RAW, csrc,
                              OPTION_RAW_PKG_SIZE, sizeof(num_t),
                              OPTION_END);
    CPPUNIT_ASSERT_EQUAL(0, ret);

    ret = lrtp_create_profile(lrtp2, PROFILE_RAW, csrc,
                              OPTION_RAW_PKG_SIZE, sizeof(num_t),
                              OPTION_END);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    num[0].n = 0;
    ret = lrtp_enqueue_frame(lrtp, csrc, num[0].c, sizeof(num_t), 0, LRTP_COPY);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    num[1].n = 1;
    ret = lrtp_enqueue_frame(lrtp, csrc, num[1].c, sizeof(num_t), 1, LRTP_COPY);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    num[2].n = 2;
    ret = lrtp_enqueue_frame(lrtp, csrc, num[2].c, sizeof(num_t), 2, LRTP_COPY);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    for(int i = 0; i < 3; i++) {
      char packet[16*1024];
      
      ret = lrtp_pack(lrtp, packet, sizeof(packet));
      CPPUNIT_ASSERT_EQUAL((int)(26 + sizeof(num_t)), ret);
      
      ret = lrtp_unpack(lrtp2, packet, ret);
      CPPUNIT_ASSERT_EQUAL(0, ret);

      char frame[16*1024];
      ret = lrtp_dequeue_frame(lrtp2, frame, sizeof(frame), NULL, NULL);
      CPPUNIT_ASSERT_EQUAL((int)sizeof(num_t), ret);
      int n = *((int*)frame);

      CPPUNIT_ASSERT_EQUAL(i, n);
    }
    
    lrtp_destroy_profile(lrtp, csrc);
    lrtp_destroy_profile(lrtp2, csrc);
    
    lrtp_close(lrtp);
    lrtp_close(lrtp2);
  }

	void test_framelist() {
    int ret;

    std::vector<std::string> packets;
    unsigned int csrc = 42;

    num_t num[4];

    lrtp_status_t status;
    struct lrtp_t *lrtp = lrtp_init(&status, KEY, SSRC);
    CPPUNIT_ASSERT_EQUAL(LRTP_OK, status);
    
    struct lrtp_t *lrtp2 = lrtp_init(&status, KEY, SSRC);
    CPPUNIT_ASSERT_EQUAL(LRTP_OK, status);

    ret = lrtp_create_profile(lrtp, PROFILE_RAW, csrc + 2,
                              OPTION_RAW_PKG_SIZE, sizeof(num_t),
                              OPTION_END);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    ret = lrtp_create_profile(lrtp, PROFILE_RAW, csrc,
                              OPTION_RAW_PKG_SIZE, sizeof(num_t),
                              OPTION_END);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    ret = lrtp_create_profile(lrtp, PROFILE_RAW, csrc + 1,
                              OPTION_RAW_PKG_SIZE, sizeof(num_t),
                              OPTION_END);
    CPPUNIT_ASSERT_EQUAL(0, ret);

    ret = lrtp_create_profile(lrtp2, PROFILE_RAW, csrc + 2,
                              OPTION_RAW_PKG_SIZE, sizeof(num_t),
                              OPTION_END);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    ret = lrtp_create_profile(lrtp2, PROFILE_RAW, csrc,
                              OPTION_RAW_PKG_SIZE, sizeof(num_t),
                              OPTION_END);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    ret = lrtp_create_profile(lrtp2, PROFILE_RAW, csrc + 1,
                              OPTION_RAW_PKG_SIZE, sizeof(num_t),
                              OPTION_END);
    CPPUNIT_ASSERT_EQUAL(0, ret);

    
    num[0].n = 0;
    ret = lrtp_enqueue_frame(lrtp, csrc, num[0].c, sizeof(num_t), 0, LRTP_COPY);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    num[1].n = 2;
    ret = lrtp_enqueue_frame(lrtp, csrc + 2, num[1].c, sizeof(num_t), 1, LRTP_COPY);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    num[2].n = 1;
    ret = lrtp_enqueue_frame(lrtp, csrc + 1, num[2].c, sizeof(num_t), 2, LRTP_COPY);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    num[3].n = 3;
    ret = lrtp_enqueue_frame(lrtp, csrc + 1, num[3].c, sizeof(num_t), 3, LRTP_COPY);
    CPPUNIT_ASSERT_EQUAL(0, ret);
    
    for(int i = 0; i < 4; i++) {
      char packet[16*1024];
      
      ret = lrtp_pack(lrtp, packet, sizeof(packet));
      CPPUNIT_ASSERT_EQUAL((int)(26 + sizeof(num_t)), ret);
      
      ret = lrtp_unpack(lrtp2, packet, ret);
      CPPUNIT_ASSERT_EQUAL(0, ret);

      char frame[16*1024];
      ret = lrtp_dequeue_frame(lrtp2, frame, sizeof(frame), NULL, NULL);
      CPPUNIT_ASSERT_EQUAL((int)sizeof(num_t), ret);
      int n = *((int*)frame);

      CPPUNIT_ASSERT_EQUAL(i, n);
    }
    
    lrtp_destroy_profile(lrtp, csrc);
    lrtp_destroy_profile(lrtp, csrc + 1);
    lrtp_destroy_profile(lrtp, csrc + 2);
    
    lrtp_destroy_profile(lrtp2, csrc);
    lrtp_destroy_profile(lrtp2, csrc + 1);
    lrtp_destroy_profile(lrtp2, csrc + 2);
    
    lrtp_close(lrtp);
    lrtp_close(lrtp2);
  }
};

// Registers the fixture into the 'registry'
CPPUNIT_TEST_SUITE_REGISTRATION(test_conn_class);