linked_list.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2014 Pavel Kirienko <pavel.kirienko@gmail.com>
 */
 
#include <gtest/gtest.h>
#include <uavcan/util/linked_list.hpp>
 
struct ListItem : uavcan::LinkedListNode<ListItem>
{
    int value;
 
    ListItem(int value = 0)
        : value(value)
    { }
 
    struct GreaterThanComparator
    {
        const int compare_with;
 
        GreaterThanComparator(int compare_with)
            : compare_with(compare_with)
        { }
 
        bool operator()(const ListItem* item) const
        {
            return item->value > compare_with;
        }
    };
 
    void insort(uavcan::LinkedListRoot<ListItem>& root)
    {
        root.insertBefore(this, GreaterThanComparator(value));
    }
};
 
TEST(LinkedList, Basic)
{
    uavcan::LinkedListRoot<ListItem> root;
 
    /*
     * Insert/remove
     */
    EXPECT_EQ(0, root.getLength());
 
    ListItem item1;
    root.insert(&item1);
    root.insert(&item1);         // Insert twice - second will be ignored
    EXPECT_EQ(1, root.getLength());
 
    root.remove(&item1);
    root.remove(&item1);
    EXPECT_EQ(0, root.getLength());
 
    ListItem items[3];
    root.insert(&item1);
    root.insert(items + 0);
    root.insert(items + 1);
    root.insert(items + 2);
    EXPECT_EQ(4, root.getLength());
 
    /*
     * Order persistence
     */
    items[0].value = 10;
    items[1].value = 11;
    items[2].value = 12;
    const int expected_values[] = {12, 11, 10, 0};
    ListItem* node = root.get();
    for (int i = 0; i < 4; i++)
    {
        EXPECT_EQ(expected_values[i], node->value);
        node = node->getNextListNode();
    }
 
    root.remove(items + 0);
    root.remove(items + 2);
    root.remove(items + 2);
    EXPECT_EQ(2, root.getLength());
 
    const int expected_values2[] = {11, 0};
    node = root.get();
    for (int i = 0; i < 2; i++)
    {
        EXPECT_EQ(expected_values2[i], node->value);
        node = node->getNextListNode();
    }
 
    root.insert(items + 2);
    EXPECT_EQ(3, root.getLength());
    EXPECT_EQ(12, root.get()->value);
 
    /*
     * Emptying
     */
    root.remove(&item1);
    root.remove(items + 0);
    root.remove(items + 1);
    root.remove(items + 2);
    EXPECT_EQ(0, root.getLength());
}
 
TEST(LinkedList, Sorting)
{
    uavcan::LinkedListRoot<ListItem> root;
    ListItem items[6];
    for (int i = 0; i < 6; i++)
    {
        items[i].value = i;
    }
 
    EXPECT_EQ(0, root.getLength());
 
    items[2].insort(root);
    EXPECT_EQ(1, root.getLength());
 
    items[2].insort(root);              // Making sure the duplicate will be removed
    EXPECT_EQ(1, root.getLength());
 
    items[3].insort(root);
 
    items[0].insort(root);
 
    items[4].insort(root);
    EXPECT_EQ(4, root.getLength());
 
    items[1].insort(root);
    EXPECT_EQ(5, root.getLength());
 
    items[1].insort(root);              // Another duplicate
    EXPECT_EQ(5, root.getLength());
 
    items[5].insort(root);
 
    EXPECT_EQ(6, root.getLength());
 
    int prev_val = -100500;
    const ListItem* item = root.get();
    while (item)
    {
        //std::cout << item->value << std::endl;
        EXPECT_LT(prev_val, item->value);
        prev_val = item->value;
        item = item->getNextListNode();
    }
}