#include <cstdio>
#define NO_ACC 4000000
#define MAX_SIZE 200

class Edge
{
public:
    int end,weight;
    Edge* next;
    bool isHouse;
    bool wasChecked;
    Edge* other;

    Edge()
    {
        end=0;
        weight=1;
        isHouse=wasChecked=false;
        next=other=NULL;
    }
};

Edge edge_pool[3200000];
int pool_size=-1;

Edge* new_edge(int end)
{
    pool_size++;
    edge_pool[pool_size].end=end;
    return &edge_pool[pool_size];
}
void clear_pool()
{
    for(int i=0;i<=pool_size;i++)
    {
        edge_pool[i].end=0;
        edge_pool[i].isHouse=false;
        edge_pool[i].next=NULL;
    }
    pool_size=-1;
}
class entry{
public:
    int v;
    int a;
    entry* next;

    entry(int _v,int _a)
    {
        v=_v;
        a=_a;
        next=NULL;
    }
};

class Queue
{
public:
    entry* head;
    entry* tail;

    void push(int v, int w)
    {
        entry* temp=new entry(v,w);
        if(head==NULL)
        {
            head=temp;
            tail=temp;
        }
        else
        {
            tail->next=temp;
            tail=temp;
        }
    }

    entry* pop()
    {
        if(tail==NULL) return NULL;
        entry* temp=head;
        if(tail==head)
        {
            head=NULL;
            tail=NULL;
            return temp;
        }
        entry* ret=tail;
        while(temp->next!=tail)
            temp=temp->next;
        tail=temp;
        return ret;
    }

    bool is_empty()
    {
        return head==NULL;
    }
};

class City
{
private:
    Edge** Edges;
    Queue* queue;
    bool* checked;
public:
    int groups_count,size;
    City()
    {
        size=0;
        Edges=new Edge*[MAX_SIZE];
        for(int i=0;i<MAX_SIZE;i++)
            Edges[i]=NULL;
        queue=new Queue();
        checked=new bool[MAX_SIZE];
    }

    void set_size(int _size)
    {
        size=_size;
        groups_count=size;
    }

    Edge* get_edge(int e)
    {
        return Edges[e];
    }

    void unsafe_add(int start, int end)
    {
        Edge* estart=new_edge(end);;
        Edge* eend=new_edge(start);
        Edge* temp=Edges[start];
        Edges[start]=estart;
        Edges[start]->next=temp;

        temp=Edges[end];
        Edges[end]=eend;
        Edges[end]->next=temp;

        estart->other=eend;
        eend->other=estart;
    }

    void add_edge(int start, int end)
    {
        if(has_element(start,end)||start==end) return;
        unsafe_add(start,end);
    }

    bool has_element(int i, int e)
    {
        if(Edges[i]==NULL) return false;
        Edge* temp=Edges[i];
        while(temp!=NULL)
        {
            if(temp->end==e) return true;
            temp=temp->next;
        }
        return false;
    }

    void set_house(int point)
    {
        Edges[point]->isHouse=true;
    }

    void clear()
    {
        for(int i=0; i<size; i++)
            Edges[i]=NULL;
        size=0;
        clear_pool();
    }

    void print()
    {
        Edge* temp;
        printf("Digraph G{\n");
        for(int i=0;i<size;i++)
        {
            temp=Edges[i];
            while(temp!=NULL)
            {
                printf("\"%d\" -> \"%d\" ;\n",i,temp->end);
                temp=temp->next;
            }
        }
        printf("}\n");
    }

    void clear_checked()
    {
        for(int i=0;i<size;i++)
            checked[i]=false;
    }

    int find_it()
    {
        bool breakpoint=false;
        entry* queue_entry;
        Edge* edge;
        int so_far=1,smallest=33000000,current;

        for(int i=0;i<size; i++)
        {
            clear_checked();
            edge=Edges[i];
            if(edge!=NULL)
            {
                if(!edge->isHouse) continue;
                queue->push(i,so_far);
                checked[i]=true;
                while(!queue->is_empty())
                {
                    queue_entry=queue->pop();
                    current=queue_entry->v;
                    delete queue_entry;

                    edge=Edges[current];
                    while(edge!=NULL)
                    {
                        if (!checked[edge->end])
                        {
                            checked[edge->end]=true;
                            if(Edges[edge->end]->isHouse)
                            {
                                if(smallest>so_far) smallest=so_far;
                                breakpoint=true;
                                break;
                            }
                            else queue->push(edge->end,so_far);
                        }
                        edge=edge->next;
                    }
                    if(breakpoint){breakpoint=false;break;}
                    so_far++;
                }
            }
            so_far=1;
        }
        return smallest;
    }
};


int main()
{
    City* city=new City();
    int c,d,vn,en,u,v,vx;
    scanf("%d",&c);
    for(int i=0;i<c;i++)
    {
        scanf("%d %d",&vn,&en);
        city->set_size(vn);
        for(int a=0;a<en;a++)
        {
            scanf("%d %d",&u,&v);
            city->add_edge(u,v);

        }
        scanf("%d",&d);
        for(int b=0;b<d;b++)
        {
            scanf("%d",&vx);
            city->set_house(vx);
        }
        printf("%d\n",city->find_it());
        city->clear();
    }
    return 0;
}