/*
 * Copyright (c) 2013, NLNet Labs, Verisign, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * * Neither the names of the copyright holders nor the
 *   names of its contributors may be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL Verisign, Inc. BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef _check_getdns_context_set_upstream_recursive_servers_h_
#define _check_getdns_context_set_upstream_recursive_servers_h_

    /*
     ******************************************************************************************
     *                                                                                        *
     *  T E S T S  F O R  G E T D N S _ C O N T E X T _ S E T _ S T U B _ R E S O L U T I O N *
     *                                                                                        *
     ******************************************************************************************
    */

    START_TEST (getdns_context_set_upstream_recursive_servers_1)
    {
     /*
      *  context is NULL
      *  expect:  GETDNS_RETURN_INVALID_PARAMETER
      */

      struct getdns_context *context = NULL;
      struct getdns_list    *upstream_list = NULL;
     
      LIST_CREATE(upstream_list);
      
      ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
        GETDNS_RETURN_INVALID_PARAMETER, "Return code from getdns_context_set_upstream_recursive_servers()");

            LIST_DESTROY(upstream_list);
    }
    END_TEST

    START_TEST (getdns_context_set_upstream_recursive_servers_2)
    {
     /*
      *  upstream_list  is NULL
      *  expect: GETDNS_RETURN_INVALID_PARAMETER
      */

      struct getdns_context *context = NULL;
      CONTEXT_CREATE(TRUE);

      ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, NULL),
        GETDNS_RETURN_INVALID_PARAMETER, "Return code from getdns_context_set_upstream_recursive_servers()");


      CONTEXT_DESTROY;        
    }
    END_TEST

    START_TEST (getdns_context_set_upstream_recursive_servers_3)
    {
     /*
      *  create upstream_list 
      *  create context
      * a dict in upstream_list does not contain getdns_bindata
      */

      struct getdns_context *context = NULL;
      struct getdns_list    *upstream_list = NULL;
      struct getdns_dict *dict = NULL;
      size_t index = 0;

      CONTEXT_CREATE(TRUE);
      LIST_CREATE(upstream_list);
      DICT_CREATE(dict);

      ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
        "Return code from getdns_list_set_dict()");


      ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
        GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");

      CONTEXT_DESTROY;  
      LIST_DESTROY(upstream_list);
      DICT_DESTROY(dict);      
    }
    END_TEST

    START_TEST (getdns_context_set_upstream_recursive_servers_4)
    {
     /*
      *  create upstream_list 
      *  create context
      * a dict in upstream_list does not contain two names
      */

      struct getdns_context *context = NULL;
      struct getdns_list    *upstream_list = NULL;
      struct getdns_dict *dict = NULL;
      struct getdns_bindata address_type = { 5, (void *) "IPv4" };
      size_t index = 0;

      CONTEXT_CREATE(TRUE);
      LIST_CREATE(upstream_list);
      DICT_CREATE(dict);

      ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
        "Return code from getdns_list_set_dict()");

      ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");


      ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
        GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");

      CONTEXT_DESTROY;  
      LIST_DESTROY(upstream_list);
      DICT_DESTROY(dict);      
    }
    END_TEST

    START_TEST (getdns_context_set_upstream_recursive_servers_5)
    {
     /*
      *  create upstream_list 
      *  create context
      * a dict in upstream_list contains names other than address_type , 
         address_data, and port
      */

      struct getdns_context *context = NULL;
      struct getdns_list    *upstream_list = NULL;
      struct getdns_dict *dict = NULL;
      struct getdns_bindata address_data = { 4, (void *)"\x08\x08\x08\x08" };
      size_t index = 0;

      CONTEXT_CREATE(TRUE);
      LIST_CREATE(upstream_list);
      DICT_CREATE(dict);

      ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
        "Return code from getdns_list_set_dict()");

     ASSERT_RC(getdns_dict_set_int(dict, "not_address_type", 100),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_int()");

       ASSERT_RC(getdns_dict_set_bindata(dict, "not_address_data", &address_data),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");

      ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
        GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");

      CONTEXT_DESTROY;  
      LIST_DESTROY(upstream_list);
      DICT_DESTROY(dict);      
    }
    END_TEST

    START_TEST (getdns_context_set_upstream_recursive_servers_6)
    {
     /*
      *  create upstream_list 
      *  create context
      * a dict in upstream_list contains invalid address_ type (not “IPv4” or “IPv6”)
      */

      struct getdns_context *context = NULL;
      struct getdns_list    *upstream_list = NULL;
      struct getdns_dict *dict = NULL;
      struct getdns_bindata address_type = { 5, (void *)"IPv5" };
       struct getdns_bindata address_data = { 4, (void *)"\x08\x08\x08\x08" };
      size_t index = 0;

      CONTEXT_CREATE(TRUE);
      LIST_CREATE(upstream_list);
      DICT_CREATE(dict);

      ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
        "Return code from getdns_list_set_dict()");

     ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
       ASSERT_RC(getdns_dict_set_bindata(dict, "address_data", &address_data),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");

      ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
        GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");

      CONTEXT_DESTROY;  
      LIST_DESTROY(upstream_list);
      DICT_DESTROY(dict);      
    }
    END_TEST

    START_TEST (getdns_context_set_upstream_recursive_servers_7)
    {
     /*
      *  create upstream_list 
      *  create context
      * a dict in upstream_list contains named address_type and 
         address_data but the data type isn’t bindata
      */

      struct getdns_context *context = NULL;
      struct getdns_list    *upstream_list = NULL;
      struct getdns_dict *dict = NULL;
      size_t index = 0;

      CONTEXT_CREATE(TRUE);
      LIST_CREATE(upstream_list);
      DICT_CREATE(dict);

     ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
        "Return code from getdns_list_set_dict()"); 

     ASSERT_RC(getdns_dict_set_int(dict, "address_type", 100),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_int()");

       ASSERT_RC(getdns_dict_set_int(dict, "address_data", 200),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_int()");

      ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
        GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");

      CONTEXT_DESTROY;  
      LIST_DESTROY(upstream_list);
      DICT_DESTROY(dict);      
    }
    END_TEST

    START_TEST (getdns_context_set_upstream_recursive_servers_8)
    {
     /*
      *  create upstream_list 
      *  create context
      *  a dict in upstream_list contains invalid address_data
      */

      struct getdns_context *context = NULL;
      struct getdns_list    *upstream_list = NULL;
      struct getdns_dict *dict = NULL;
      struct getdns_bindata address_type = { 5, (void *)"IPv5" };
      struct getdns_bindata address_data = { 4, (void *)"\x08\x08\x08\x08" };
      size_t index = 0;

      CONTEXT_CREATE(TRUE);
      LIST_CREATE(upstream_list);
      DICT_CREATE(dict);

     ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
        "Return code from getdns_list_set_dict()"); 

     ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
       ASSERT_RC(getdns_dict_set_bindata(dict, "address_data", &address_data),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");

      ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
        GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");

      CONTEXT_DESTROY;  
      LIST_DESTROY(upstream_list);
      DICT_DESTROY(dict);      
    }
    END_TEST

    START_TEST (getdns_context_set_upstream_recursive_servers_9)
    {
     /*
      *  create context
      *  Call getdns_list_create() to create a list
      *  Call getdns_dict_create() to create a list
      *  Create bindata containing “IPv4” 
      */

      struct getdns_context *context = NULL;
      struct getdns_list    *upstream_list = NULL;
      struct getdns_dict *dict = NULL;
      struct getdns_dict *response = NULL;
      struct getdns_bindata address_type = { 5, (void *)"IPv4" };
      struct getdns_bindata address_data = { 4, (void *)"\x0A\xAA\x0C\x38" };
      size_t index = 0;

      CONTEXT_CREATE(TRUE);
      LIST_CREATE(upstream_list);
      DICT_CREATE(dict);

      ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");

      ASSERT_RC(getdns_dict_set_bindata(dict, "address_data", &address_data),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");

      ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
        "Return code from getdns_list_set_dict()"); 


      ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
        GETDNS_RETURN_GOOD, "Return code from getdns_context_set_upstream_recursive_servers()");

      ASSERT_RC(getdns_general_sync(context, "google.com", GETDNS_RRTYPE_A, NULL, &response), 
         GETDNS_RETURN_GOOD, "Return code from getdns_general_sync()");


      EXTRACT_RESPONSE;

       assert_noerror(&ex_response);
       assert_address_in_answer(&ex_response, TRUE, FALSE);

      CONTEXT_DESTROY;  
      LIST_DESTROY(upstream_list);
      DICT_DESTROY(dict);
      DICT_DESTROY(response);
    }
    END_TEST

    START_TEST (getdns_context_set_upstream_recursive_servers_10)
    {
     /*
      *  create context
      *  Call getdns_list_create() to create a list
      * Call getdns_dict_create() to create a list
      * Create bindata containing “IPv6” 
      */

      struct getdns_context *context = NULL;
      struct getdns_list    *upstream_list = NULL;
      struct getdns_dict *dict = NULL;
      struct getdns_dict *response = NULL;
      struct getdns_bindata address_type = { 5, (void *)"IPv6" };
      struct getdns_bindata address_data = { 16, (void *)"\x20\x01\x48\x60\x48\x60\x00\x00\x00\x00\x00\x00\x00\x00\x88\x44" };
      size_t index = 0;

      CONTEXT_CREATE(TRUE);
      LIST_CREATE(upstream_list);
      DICT_CREATE(dict);

      ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");

      ASSERT_RC(getdns_dict_set_bindata(dict, "address_data", &address_data),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");

      ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
        "Return code from getdns_list_set_dict()"); 


      ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
        GETDNS_RETURN_GOOD, "Return code from getdns_context_set_upstream_recursive_servers()");

      ASSERT_RC(getdns_general_sync(context, "google.com", GETDNS_RRTYPE_A, NULL, &response), 
         GETDNS_RETURN_GOOD, "Return code from getdns_general_sync()");

      EXTRACT_RESPONSE;

       assert_noerror(&ex_response);
       assert_address_in_answer(&ex_response, TRUE, FALSE);

      CONTEXT_DESTROY;  
      LIST_DESTROY(upstream_list);
      DICT_DESTROY(dict);
      DICT_DESTROY(response);
    }
    END_TEST

    START_TEST (getdns_context_set_upstream_recursive_servers_11)
    {
     /*
      *  create context
      *  Call getdns_list_create() to create a list
      *  Call getdns_dict_create() to create a list
      *  Create bindata containing “IPv4” 
      */

      struct getdns_context *context = NULL;
      struct getdns_list    *upstream_list = NULL;
      struct getdns_dict *dict = NULL;
      struct getdns_dict *response = NULL;
      struct getdns_bindata address_type = { 5, (void *)"IPv4" };
      struct getdns_bindata address_data = { 4, (void *)"\x0A\xAA\x0C\x38" };
      struct getdns_bindata port = { 3, (void *)"53" };
      size_t index = 0;

      CONTEXT_CREATE(TRUE);
      LIST_CREATE(upstream_list);
      DICT_CREATE(dict);

      ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");

      ASSERT_RC(getdns_dict_set_bindata(dict, "address_data", &address_data),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");

      ASSERT_RC(getdns_dict_set_bindata(dict, "53", &port),
         GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");

      ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
        "Return code from getdns_list_set_dict()"); 


      ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
        GETDNS_RETURN_GOOD, "Return code from getdns_context_set_upstream_recursive_servers()");

      ASSERT_RC(getdns_general_sync(context, "google.com", GETDNS_RRTYPE_A, NULL, &response), 
         GETDNS_RETURN_GOOD, "Return code from getdns_general_sync()");


      EXTRACT_RESPONSE;
      printf("the resp is %s\n", getdns_pretty_print_dict(response));


       assert_noerror(&ex_response);
       assert_address_in_answer(&ex_response, TRUE, FALSE);

      CONTEXT_DESTROY;  
      LIST_DESTROY(upstream_list);
      DICT_DESTROY(dict);
      DICT_DESTROY(response);
    }
    END_TEST

    
    
    
    Suite *
    getdns_context_set_upstream_recursive_servers_suite (void)
    {
      Suite *s = suite_create ("getdns_context_set_upstream_recursive_servers()");
    
      /* Negative test caseis */
      TCase *tc_neg = tcase_create("Negative");
      tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_1);
      tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_2);
      tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_3);
      tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_4);
      tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_5);
      tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_6);
      tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_7);
      tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_8);

      suite_add_tcase(s, tc_neg);
    
      /* Positive test cases */
       TCase *tc_pos = tcase_create("Positive");
       tcase_add_test(tc_pos, getdns_context_set_upstream_recursive_servers_9);
       tcase_add_test(tc_pos, getdns_context_set_upstream_recursive_servers_10);
       tcase_add_test(tc_pos, getdns_context_set_upstream_recursive_servers_11);
      
       suite_add_tcase(s, tc_pos);

       return s;

    }

#endif
