Очередная отличная идея от Google

Идея заключается в частичном отказе от "continious integration" и в том, что бы запускать тесты немедленно после изменения модуля. Но запускать не все тесты, а только те, которые к этому модулю относятся.
На схеме приведен пример, демонстрирующий процесс (кликабельно):

Более подробно в оригинальной статье (англ.) в блоге Google Testing.

Data structures: Queue

Простая очередь - структура данных имеющая набор элементов и поддерживающая методы Поставить в очередь и Удалить из очереди. Название структуры говорит само за себя: элементы вносятся в набор и удаляются из него в порядке очереди (т.е. FIFO). Данный код демонстрирует две реализации очереди: на базе массива и на базе связного списка.

Data structures: Linked list

Совсем краткое описание. 

Связный список - структура данных, имеющая набор своих данных и содержащая ссылку на следующий элемент  (или две ссылки: одна на следующий, одна на предыдущие). В случае, если  

в списке ссылка только на следующий элемент, то список называется однонаправленным. Если на следующий и предыдущий, то двунаправленным.   

Data structures: Stack

Стек - структура данных имеющая набор элементов и поддерживающая методы Затолкнуть и Извлечь. Элементы вносятся в набор и удаляются из него в следующие порядке: в первую очередь обрабатывается элемент поступивший последним  (т.е. LIFO).

Серия статей "How Google Tests Software" (продолжение)

Часть 6:
http://googletesting.blogspot.com/2011/05/how-google-tests-software-break-for-q.html

Часть 7:
http://googletesting.blogspot.com/2011/05/how-google-tests-software-part-seven.html

Data structures: Hash Table

Хэш-таблица - один из вариантов ассоциативного массива.

Работает достаточно просто: по значению ключа рассчитывается хэш-код. Хэш-код в данном случае является индексом массива. Таким образом в идеале доступ к значению занимает время, равное O(1). В идеале, потому что редко бывает так, чтобы одному хэш-коду соответствовал один ключ. И в "реальной жизни" доступ занимает время равное O(k), где k - количество ключей соответствующих одному хэш-коду.

Data structures: Priority Queue (based on Binary Heap)

#ifndef PRIORITY_QUEUE 
#define PRIORITY_QUEUE 

template<typename ItemType>

struct binary_heap
{
    public: 

        ItemType *heap; 
        int index; 
    
        binary_heap(int heap_size)
        {
            index=0;
            heap=new ItemType[heap_size];         
        };

        void add_item(ItemType new_item)
        {
            index++;

            heap[index]=new_item; 
            bubble_up(index);
        }; 

        ItemType get_min()
        {
            ItemType min=heap[1];
            heap[1]=heap[index];
            
            index=index-1; 
            
            bubble_down(1);
            
            return min; 
        };

    private: 
    
        void bubble_up(int n)
        {
            if (get_parent(n)!=-1)
            {
                if (heap[n]<heap[get_parent(n)]) 
                {
                    ItemType tmp=heap[n]; 
                    heap[n]=heap[get_parent(n)];
                    heap[get_parent(n)]=tmp; 
                
                    bubble_up(get_parent(n));
                }; 
            };
        }; 

        void bubble_down(int n)
        {
                int first_child=get_first_child(n); 
                
                int min_child_index=n; 

                for (int i=0; i<=1; i++)
                {
                    if ((first_child+i)<=index) 
                    {
                        if (heap[min_child_index]>heap[first_child+i]) min_child_index=first_child+i; 
                    }; 
                };

                if (min_child_index!=n)
                {
                    ItemType tmp=heap[min_child_index]; 
                    heap[min_child_index]=heap[n];
                    heap[n]=tmp; 

                    bubble_down(min_child_index);
                };
        };

        int get_parent(int n)
        {
            if (n==1) return -1; 

            return (int)(n/2); 
        }; 

        int get_first_child(int n)
        {
                return (n*2); 
        }; 
};

template <typename ItemType> 

struct priority_queue
{
    public:
        
        binary_heap<ItemType> *pq; 
        int ITEMS_COUNT; 
     
        priority_queue(int items_num)
        {
            pq=new binary_heap<ItemType>(items_num);         
            ITEMS_COUNT=pq->index;
        };

        void push(ItemType new_item)
        {
            pq->add_item(new_item); 
        };

        ItemType pop()
        {
            return pq->get_min();
        };
};