[libftdi] / test / baudrate.cpp

/**@file
@brief Test baudrate calculator code

@author Thomas Jarosch
*/

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

#include <ftdi.h>

#define BOOST_TEST_DYN_LINK
#include <boost/test/unit_test.hpp>
#include <boost/foreach.hpp>
#include <map>

using namespace std;

extern "C" int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi,
                                 unsigned short *value, unsigned short *index);

/// Basic initialization of libftdi for every test
class BaseFTDIFixture
{
protected:
    ftdi_context *ftdi;

public:
    BaseFTDIFixture()
        : ftdi(NULL)
    {
        ftdi = ftdi_new();
    }

    ~BaseFTDIFixture()
    {
        delete ftdi;
        ftdi = NULL;
    }
};

BOOST_FIXTURE_TEST_SUITE(Baudrate, BaseFTDIFixture)

/// Helper class to store the convert_baudrate_UT_export result
struct calc_result
{
    int actual_baudrate;
    unsigned short expected_value;
    unsigned short expected_index;

    calc_result(int actual, int my_value, int my_index)
        : actual_baudrate(actual)
        , expected_value(my_value)
        , expected_index(my_index)
    {
    }

    calc_result()
        : actual_baudrate(0)
        , expected_value(0)
        , expected_index(0)
    {
    }
};

/**
 * @brief Test convert_baudrate code against a list of baud rates
 *
 * @param baudrates Baudrates to check
 **/
static void test_baudrates(ftdi_context *ftdi, const map<int, calc_result> &baudrates)
{
    typedef std::pair<int, calc_result> baudrate_type;
    BOOST_FOREACH(const baudrate_type &baudrate, baudrates)
    {
        unsigned short calc_value = 0, calc_index = 0;
        int calc_baudrate = convert_baudrate_UT_export(baudrate.first, ftdi, &calc_value, &calc_index);

        const calc_result *res = &baudrate.second;

        // Aid debugging since this test is a generic function
        BOOST_CHECK_MESSAGE(res->actual_baudrate == calc_baudrate && res->expected_value == calc_value && res->expected_index == calc_index,
                            "\n\nERROR: baudrate calculation failed for --" << baudrate.first << " baud--. Details below: ");

        BOOST_CHECK_EQUAL(res->actual_baudrate, calc_baudrate);
        BOOST_CHECK_EQUAL(res->expected_value, calc_value);
        BOOST_CHECK_EQUAL(res->expected_index, calc_index);
    }
}

BOOST_AUTO_TEST_CASE(TypeAMFixedBaudrates)
{
    ftdi->type = TYPE_AM;

    map<int, calc_result> baudrates;
    baudrates[300] = calc_result(300, 10000, 0);
    baudrates[600] = calc_result(600, 5000, 0);
    baudrates[600] = calc_result(600, 5000, 0);
    baudrates[1200] = calc_result(1200, 2500, 0);
    baudrates[2400] = calc_result(2400, 1250, 0);
    baudrates[4800] = calc_result(4800, 625, 0);
    baudrates[9600] = calc_result(9600, 16696, 0);
    baudrates[19200] = calc_result(19200, 32924, 0);
    baudrates[38400] = calc_result(38400, 49230, 0);
    baudrates[57600] = calc_result(57554, 49204, 0);
    baudrates[115200] = calc_result(115385, 26, 0);
    baudrates[230400] = calc_result(230769, 13, 0);
    baudrates[460800] = calc_result(461538, 16390, 0);
    baudrates[921600] = calc_result(923077, 32771, 0);

    test_baudrates(ftdi, baudrates);
}

BOOST_AUTO_TEST_CASE(TypeBMFixedBaudrates)
{
    ftdi->type = TYPE_BM;

    map<int, calc_result> baudrates;
    baudrates[300] = calc_result(300, 10000, 0);
    baudrates[600] = calc_result(600, 5000, 0);
    baudrates[600] = calc_result(600, 5000, 0);
    baudrates[1200] = calc_result(1200, 2500, 0);
    baudrates[2400] = calc_result(2400, 1250, 0);
    baudrates[4800] = calc_result(4800, 625, 0);
    baudrates[9600] = calc_result(9600, 16696, 0);
    baudrates[19200] = calc_result(19200, 32924, 0);
    baudrates[38400] = calc_result(38400, 49230, 0);
    baudrates[57600] = calc_result(57554, 49204, 0);
    baudrates[115200] = calc_result(115385, 26, 0);
    baudrates[230400] = calc_result(230769, 13, 0);
    baudrates[460800] = calc_result(461538, 16390, 0);
    baudrates[921600] = calc_result(923077, 32771, 0);

    test_baudrates(ftdi, baudrates);
}

BOOST_AUTO_TEST_CASE(Type2232CFixedBaudrates)
{
    ftdi->type = TYPE_2232C;

    map<int, calc_result> baudrates;
    baudrates[300] = calc_result(300, 10000, 1);
    baudrates[600] = calc_result(600, 5000, 1);
    baudrates[600] = calc_result(600, 5000, 1);
    baudrates[1200] = calc_result(1200, 2500, 1);
    baudrates[2400] = calc_result(2400, 1250, 1);
    baudrates[4800] = calc_result(4800, 625, 1);
    baudrates[9600] = calc_result(9600, 16696, 1);
    baudrates[19200] = calc_result(19200, 32924, 1);
    baudrates[38400] = calc_result(38400, 49230, 1);
    baudrates[57600] = calc_result(57554, 49204, 1);
    baudrates[115200] = calc_result(115385, 26, 1);
    baudrates[230400] = calc_result(230769, 13, 1);
    baudrates[460800] = calc_result(461538, 16390, 1);
    baudrates[921600] = calc_result(923077, 32771, 1);

    test_baudrates(ftdi, baudrates);
}

BOOST_AUTO_TEST_CASE(TypeRFixedBaudrates)
{
    ftdi->type = TYPE_R;

    map<int, calc_result> baudrates;
    baudrates[300] = calc_result(300, 10000, 0);
    baudrates[600] = calc_result(600, 5000, 0);
    baudrates[600] = calc_result(600, 5000, 0);
    baudrates[1200] = calc_result(1200, 2500, 0);
    baudrates[2400] = calc_result(2400, 1250, 0);
    baudrates[4800] = calc_result(4800, 625, 0);
    baudrates[9600] = calc_result(9600, 16696, 0);
    baudrates[19200] = calc_result(19200, 32924, 0);
    baudrates[38400] = calc_result(38400, 49230, 0);
    baudrates[57600] = calc_result(57554, 49204, 0);
    baudrates[115200] = calc_result(115385, 26, 0);
    baudrates[230400] = calc_result(230769, 13, 0);
    baudrates[460800] = calc_result(461538, 16390, 0);
    baudrates[921600] = calc_result(923077, 32771, 0);

    test_baudrates(ftdi, baudrates);
}

BOOST_AUTO_TEST_CASE(Type2232HFixedBaudrates)
{
    ftdi->type = TYPE_2232H;

    map<int, calc_result> baudrates;
    baudrates[300] = calc_result(300, 10000, 1);
    baudrates[600] = calc_result(600, 5000, 1);
    baudrates[600] = calc_result(600, 5000, 1);
    baudrates[1200] = calc_result(1200, 2500, 1);
    baudrates[2400] = calc_result(2400, 1250, 1);
    baudrates[4800] = calc_result(4800, 625, 1);
    baudrates[9600] = calc_result(9600, 16696, 1);
    baudrates[19200] = calc_result(19200, 32924, 1);
    baudrates[38400] = calc_result(38400, 49230, 1);
    baudrates[57600] = calc_result(57554, 49204, 1);
    baudrates[115200] = calc_result(115385, 26, 1);
    baudrates[230400] = calc_result(230769, 13, 1);
    baudrates[460800] = calc_result(461538, 16390, 1);
    baudrates[921600] = calc_result(923077, 32771, 1);

    test_baudrates(ftdi, baudrates);
}

BOOST_AUTO_TEST_CASE(Type4232HFixedBaudrates)
{
    ftdi->type = TYPE_4232H;

    map<int, calc_result> baudrates;
    baudrates[300] = calc_result(300, 10000, 1);
    baudrates[600] = calc_result(600, 5000, 1);
    baudrates[600] = calc_result(600, 5000, 1);
    baudrates[1200] = calc_result(1200, 2500, 1);
    baudrates[2400] = calc_result(2400, 1250, 1);
    baudrates[4800] = calc_result(4800, 625, 1);
    baudrates[9600] = calc_result(9600, 16696, 1);
    baudrates[19200] = calc_result(19200, 32924, 1);
    baudrates[38400] = calc_result(38400, 49230, 1);
    baudrates[57600] = calc_result(57554, 49204, 1);
    baudrates[115200] = calc_result(115385, 26, 1);
    baudrates[230400] = calc_result(230769, 13, 1);
    baudrates[460800] = calc_result(461538, 16390, 1);
    baudrates[921600] = calc_result(923077, 32771, 1);

    test_baudrates(ftdi, baudrates);
}

BOOST_AUTO_TEST_CASE(Type232HFixedBaudrates)
{
    ftdi->type = TYPE_232H;

    map<int, calc_result> baudrates;
    baudrates[300] = calc_result(300, 10000, 1);
    baudrates[600] = calc_result(600, 5000, 1);
    baudrates[600] = calc_result(600, 5000, 1);
    baudrates[1200] = calc_result(1200, 2500, 1);
    baudrates[2400] = calc_result(2400, 1250, 1);
    baudrates[4800] = calc_result(4800, 625, 1);
    baudrates[9600] = calc_result(9600, 16696, 1);
    baudrates[19200] = calc_result(19200, 32924, 1);
    baudrates[38400] = calc_result(38400, 49230, 1);
    baudrates[57600] = calc_result(57554, 49204, 1);
    baudrates[115200] = calc_result(115385, 26, 1);
    baudrates[230400] = calc_result(230769, 13, 1);
    baudrates[460800] = calc_result(461538, 16390, 1);
    baudrates[921600] = calc_result(923077, 32771, 1);

    test_baudrates(ftdi, baudrates);
}

BOOST_AUTO_TEST_SUITE_END()
Commit	Line	Data
a87a0712 TJ	1	/**@file
	2	@brief Test baudrate calculator code
	3
	4	@author Thomas Jarosch
	5	*/
	6
	7	/***************************************************************************
	8	* *
	9	* This program is free software; you can redistribute it and/or modify *
	10	* it under the terms of the GNU Lesser General Public License *
	11	* version 2.1 as published by the Free Software Foundation; *
	12	* *
	13	***************************************************************************/
	14
ac6944cc TJ	15	#include <ftdi.h>
ac6944cc TJ	16
a87a0712 TJ	17	#define BOOST_TEST_DYN_LINK
a87a0712 TJ	18	#include <boost/test/unit_test.hpp>
ac6944cc TJ	19	#include <boost/foreach.hpp>
	20	#include <map>
	21
	22	using namespace std;
	23
	24	extern "C" int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi,
	25	unsigned short value, unsigned short index);
	26
	27	/// Basic initialization of libftdi for every test
	28	class BaseFTDIFixture
	29	{
	30	protected:
	31	ftdi_context *ftdi;
	32
	33	public:
	34	BaseFTDIFixture()
	35	: ftdi(NULL)
	36	{
	37	ftdi = ftdi_new();
	38	}
	39
	40	~BaseFTDIFixture()
	41	{
	42	delete ftdi;
	43	ftdi = NULL;
	44	}
	45	};
a87a0712	46
c4517f98	47	BOOST_FIXTURE_TEST_SUITE(Baudrate, BaseFTDIFixture)
a87a0712	48
ac6944cc TJ	49	/// Helper class to store the convert_baudrate_UT_export result
ac6944cc TJ	50	struct calc_result
a87a0712	51	{
ac6944cc TJ	52	int actual_baudrate;
	53	unsigned short expected_value;
	54	unsigned short expected_index;
	55
	56	calc_result(int actual, int my_value, int my_index)
	57	: actual_baudrate(actual)
	58	, expected_value(my_value)
	59	, expected_index(my_index)
	60	{
	61	}
	62
	63	calc_result()
	64	: actual_baudrate(0)
	65	, expected_value(0)
	66	, expected_index(0)
	67	{
	68	}
	69	};
	70
	71	/**
	72	* @brief Test convert_baudrate code against a list of baud rates
	73	*
	74	* @param baudrates Baudrates to check
	75	**/
	76	static void test_baudrates(ftdi_context *ftdi, const map<int, calc_result> &baudrates)
	77	{
	78	typedef std::pair<int, calc_result> baudrate_type;
	79	BOOST_FOREACH(const baudrate_type &baudrate, baudrates)
	80	{
	81	unsigned short calc_value = 0, calc_index = 0;
	82	int calc_baudrate = convert_baudrate_UT_export(baudrate.first, ftdi, &calc_value, &calc_index);
	83
	84	const calc_result *res = &baudrate.second;
	85
	86	// Aid debugging since this test is a generic function
	87	BOOST_CHECK_MESSAGE(res->actual_baudrate == calc_baudrate && res->expected_value == calc_value && res->expected_index == calc_index,
c4517f98	88	"\n\nERROR: baudrate calculation failed for --" << baudrate.first << " baud--. Details below: ");
ac6944cc TJ	89
	90	BOOST_CHECK_EQUAL(res->actual_baudrate, calc_baudrate);
	91	BOOST_CHECK_EQUAL(res->expected_value, calc_value);
	92	BOOST_CHECK_EQUAL(res->expected_index, calc_index);
	93	}
	94	}
	95
	96	BOOST_AUTO_TEST_CASE(TypeAMFixedBaudrates)
	97	{
	98	ftdi->type = TYPE_AM;
	99
	100	map<int, calc_result> baudrates;
	101	baudrates[300] = calc_result(300, 10000, 0);
	102	baudrates[600] = calc_result(600, 5000, 0);
	103	baudrates[600] = calc_result(600, 5000, 0);
	104	baudrates[1200] = calc_result(1200, 2500, 0);
	105	baudrates[2400] = calc_result(2400, 1250, 0);
	106	baudrates[4800] = calc_result(4800, 625, 0);
	107	baudrates[9600] = calc_result(9600, 16696, 0);
	108	baudrates[19200] = calc_result(19200, 32924, 0);
	109	baudrates[38400] = calc_result(38400, 49230, 0);
	110	baudrates[57600] = calc_result(57554, 49204, 0);
	111	baudrates[115200] = calc_result(115385, 26, 0);
	112	baudrates[230400] = calc_result(230769, 13, 0);
	113	baudrates[460800] = calc_result(461538, 16390, 0);
	114	baudrates[921600] = calc_result(923077, 32771, 0);
	115
	116	test_baudrates(ftdi, baudrates);
	117	}
	118
	119	BOOST_AUTO_TEST_CASE(TypeBMFixedBaudrates)
	120	{
	121	ftdi->type = TYPE_BM;
	122
	123	map<int, calc_result> baudrates;
	124	baudrates[300] = calc_result(300, 10000, 0);
	125	baudrates[600] = calc_result(600, 5000, 0);
	126	baudrates[600] = calc_result(600, 5000, 0);
	127	baudrates[1200] = calc_result(1200, 2500, 0);
	128	baudrates[2400] = calc_result(2400, 1250, 0);
	129	baudrates[4800] = calc_result(4800, 625, 0);
	130	baudrates[9600] = calc_result(9600, 16696, 0);
	131	baudrates[19200] = calc_result(19200, 32924, 0);
	132	baudrates[38400] = calc_result(38400, 49230, 0);
	133	baudrates[57600] = calc_result(57554, 49204, 0);
	134	baudrates[115200] = calc_result(115385, 26, 0);
	135	baudrates[230400] = calc_result(230769, 13, 0);
	136	baudrates[460800] = calc_result(461538, 16390, 0);
	137	baudrates[921600] = calc_result(923077, 32771, 0);
	138
	139	test_baudrates(ftdi, baudrates);
	140	}
	141
	142	BOOST_AUTO_TEST_CASE(Type2232CFixedBaudrates)
	143	{
	144	ftdi->type = TYPE_2232C;
	145
	146	map<int, calc_result> baudrates;
	147	baudrates[300] = calc_result(300, 10000, 1);
	148	baudrates[600] = calc_result(600, 5000, 1);
	149	baudrates[600] = calc_result(600, 5000, 1);
	150	baudrates[1200] = calc_result(1200, 2500, 1);
	151	baudrates[2400] = calc_result(2400, 1250, 1);
	152	baudrates[4800] = calc_result(4800, 625, 1);
153	baudrates[9600] = calc_result(9600, 16696, 1);
154	baudrates[19200] = calc_result(19200, 32924, 1);
155	baudrates[38400] = calc_result(38400, 49230, 1);
156	baudrates[57600] = calc_result(57554, 49204, 1);
157	baudrates[115200] = calc_result(115385, 26, 1);
158	baudrates[230400] = calc_result(230769, 13, 1);
159	baudrates[460800] = calc_result(461538, 16390, 1);
160	baudrates[921600] = calc_result(923077, 32771, 1);
161
162	test_baudrates(ftdi, baudrates);
163	}
164
165	BOOST_AUTO_TEST_CASE(TypeRFixedBaudrates)
166	{
167	ftdi->type = TYPE_R;
168
169	map<int, calc_result> baudrates;
170	baudrates[300] = calc_result(300, 10000, 0);
171	baudrates[600] = calc_result(600, 5000, 0);
172	baudrates[600] = calc_result(600, 5000, 0);
173	baudrates[1200] = calc_result(1200, 2500, 0);
174	baudrates[2400] = calc_result(2400, 1250, 0);
175	baudrates[4800] = calc_result(4800, 625, 0);
176	baudrates[9600] = calc_result(9600, 16696, 0);
177	baudrates[19200] = calc_result(19200, 32924, 0);
178	baudrates[38400] = calc_result(38400, 49230, 0);
179	baudrates[57600] = calc_result(57554, 49204, 0);
180	baudrates[115200] = calc_result(115385, 26, 0);
181	baudrates[230400] = calc_result(230769, 13, 0);
182	baudrates[460800] = calc_result(461538, 16390, 0);
183	baudrates[921600] = calc_result(923077, 32771, 0);
184
185	test_baudrates(ftdi, baudrates);
186	}
187
188	BOOST_AUTO_TEST_CASE(Type2232HFixedBaudrates)
189	{
190	ftdi->type = TYPE_2232H;
191
192	map<int, calc_result> baudrates;
193	baudrates[300] = calc_result(300, 10000, 1);
194	baudrates[600] = calc_result(600, 5000, 1);
195	baudrates[600] = calc_result(600, 5000, 1);
196	baudrates[1200] = calc_result(1200, 2500, 1);
197	baudrates[2400] = calc_result(2400, 1250, 1);
198	baudrates[4800] = calc_result(4800, 625, 1);
199	baudrates[9600] = calc_result(9600, 16696, 1);
200	baudrates[19200] = calc_result(19200, 32924, 1);
201	baudrates[38400] = calc_result(38400, 49230, 1);
202	baudrates[57600] = calc_result(57554, 49204, 1);
203	baudrates[115200] = calc_result(115385, 26, 1);
204	baudrates[230400] = calc_result(230769, 13, 1);
205	baudrates[460800] = calc_result(461538, 16390, 1);
206	baudrates[921600] = calc_result(923077, 32771, 1);
207
208	test_baudrates(ftdi, baudrates);
209	}
210
211	BOOST_AUTO_TEST_CASE(Type4232HFixedBaudrates)
212	{
213	ftdi->type = TYPE_4232H;
214
215	map<int, calc_result> baudrates;
216	baudrates[300] = calc_result(300, 10000, 1);
217	baudrates[600] = calc_result(600, 5000, 1);
218	baudrates[600] = calc_result(600, 5000, 1);
219	baudrates[1200] = calc_result(1200, 2500, 1);
220	baudrates[2400] = calc_result(2400, 1250, 1);
221	baudrates[4800] = calc_result(4800, 625, 1);
222	baudrates[9600] = calc_result(9600, 16696, 1);
223	baudrates[19200] = calc_result(19200, 32924, 1);
224	baudrates[38400] = calc_result(38400, 49230, 1);
225	baudrates[57600] = calc_result(57554, 49204, 1);
226	baudrates[115200] = calc_result(115385, 26, 1);
227	baudrates[230400] = calc_result(230769, 13, 1);
228	baudrates[460800] = calc_result(461538, 16390, 1);
229	baudrates[921600] = calc_result(923077, 32771, 1);
230
231	test_baudrates(ftdi, baudrates);
232	}
233
234	BOOST_AUTO_TEST_CASE(Type232HFixedBaudrates)
235	{
236	ftdi->type = TYPE_232H;
237
238	map<int, calc_result> baudrates;
239	baudrates[300] = calc_result(300, 10000, 1);
240	baudrates[600] = calc_result(600, 5000, 1);
241	baudrates[600] = calc_result(600, 5000, 1);
242	baudrates[1200] = calc_result(1200, 2500, 1);
243	baudrates[2400] = calc_result(2400, 1250, 1);
244	baudrates[4800] = calc_result(4800, 625, 1);
245	baudrates[9600] = calc_result(9600, 16696, 1);
246	baudrates[19200] = calc_result(19200, 32924, 1);
247	baudrates[38400] = calc_result(38400, 49230, 1);
248	baudrates[57600] = calc_result(57554, 49204, 1);
249	baudrates[115200] = calc_result(115385, 26, 1);
250	baudrates[230400] = calc_result(230769, 13, 1);
251	baudrates[460800] = calc_result(461538, 16390, 1);
252	baudrates[921600] = calc_result(923077, 32771, 1);
253
254	test_baudrates(ftdi, baudrates);
a87a0712 TJ	255	}
	256
	257	BOOST_AUTO_TEST_SUITE_END()