1#!/usr/bin/env python
2
3#
4# ldns_resolver testing script.
5#
6# Do not use constructs that differ between Python 2 and 3.
7# Use write on stdout or stderr.
8#
9
10
11import ldns
12import sys
13import os
14import inspect
15
16
17class_name = "ldns_resolver"
18method_name = None
19error_detected = False
20temp_fname = "tmp_resolver.txt"
21
22
23def set_error():
24    """
25        Writes an error message and sets error flag.
26    """
27    global class_name
28    global method_name
29    global error_detected
30    error_detected = True
31    sys.stderr.write("(line %d): malfunctioning method %s.\n" % \
32       (inspect.currentframe().f_back.f_lineno, method_name))
33
34
35#if not error_detected:
36if True:
37    method_name = class_name + ".axfr_complete()"
38    sys.stderr.write("%s not tested.\n" % (method_name))
39
40
41#if not error_detected:
42if True:
43    method_name = class_name + ".axfr_last_pkt()"
44    sys.stderr.write("%s not tested.\n" % (method_name))
45
46
47#if not error_detected:
48if True:
49    method_name = class_name + ".axfr_next()"
50    sys.stderr.write("%s not tested.\n" % (method_name))
51
52
53#if not error_detected:
54if True:
55    method_name = class_name + ".axfr_start()"
56    sys.stderr.write("%s not tested.\n" % (method_name))
57
58
59#if not error_detected:
60if True:
61    method_name = class_name + ".debug()"
62    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
63    resolver.set_debug(False)
64    try:
65        ret = resolver.debug()
66        if not isinstance(ret, bool):
67            set_error()
68        if ret != False:
69            set_error()
70    except:
71        set_error()
72    resolver.set_debug(True)
73    try:
74        ret = resolver.debug()
75        if not isinstance(ret, bool):
76            set_error()
77        if ret != True:
78            set_error()
79    except:
80        set_error()
81
82
83#if not error_detected:
84if True:
85    method_name = class_name + ".dec_nameserver_count()"
86    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
87    cnt = resolver.nameserver_count()
88    try:
89        resolver.dec_nameserver_count()
90    except:
91        set_error()
92    if cnt != (resolver.nameserver_count() + 1):
93        set_error()
94
95
96#if not error_detected:
97if True:
98    method_name = class_name + ".defnames()"
99    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
100    resolver.set_defnames(False)
101    try:
102        ret = resolver.defnames()
103        if not isinstance(ret, bool):
104            set_error()
105        if ret != False:
106            set_error()
107    except:
108        set_error()
109    resolver.set_defnames(True)
110    try:
111        ret = resolver.defnames()
112        if not isinstance(ret, bool):
113            set_error()
114        if ret != True:
115            set_error()
116    except:
117        set_error()
118
119
120#if not error_detected:
121if True:
122    method_name = class_name + ".dnsrch()"
123    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
124    resolver.set_dnsrch(False)
125    try:
126        ret = resolver.dnsrch()
127        if not isinstance(ret, bool):
128            set_error()
129        if ret != False:
130            set_error()
131    except:
132        set_error()
133    resolver.set_dnsrch(True)
134    try:
135        ret = resolver.dnsrch()
136        if not isinstance(ret, bool):
137            set_error()
138        if ret != True:
139            set_error()
140    except:
141        set_error()
142
143
144#if not error_detected:
145if True:
146    method_name = class_name + ".dnssec()"
147    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
148    resolver.set_dnssec(False)
149    try:
150        ret = resolver.dnssec()
151        if not isinstance(ret, bool):
152            set_error()
153        if ret != False:
154            set_error()
155    except:
156        set_error()
157    resolver.set_dnssec(True)
158    try:
159        ret = resolver.dnssec()
160        if not isinstance(ret, bool):
161            set_error()
162        if ret != True:
163            set_error()
164    except:
165        set_error()
166
167
168#if not error_detected:
169if True:
170    method_name = class_name + ".dnssec_anchors()"
171    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
172    rrl = ldns.ldns_rr_list.new()
173    try:
174        ret = resolver.dnssec_anchors()
175        if ret != None:
176            set_error()
177    except:
178        set_error()
179    resolver.set_dnssec_anchors(rrl)
180    try:
181        ret = resolver.dnssec_anchors()
182        if not isinstance(ret, ldns.ldns_rr_list):
183            set_error()
184    except:
185        set_error()
186
187
188#if not error_detected:
189if True:
190    method_name = class_name + ".dnssec_cd()"
191    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
192    resolver.set_dnssec_cd(False)
193    try:
194        ret = resolver.dnssec_cd()
195        if not isinstance(ret, bool):
196            set_error()
197        if ret != False:
198            set_error()
199    except:
200        set_error()
201    resolver.set_dnssec_cd(True)
202    try:
203        ret = resolver.dnssec_cd()
204        if not isinstance(ret, bool):
205            set_error()
206        if ret != True:
207            set_error()
208    except:
209        set_error()
210
211
212#if not error_detected:
213if True:
214    method_name = class_name + ".domain()"
215    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
216    resolver.set_domain(None)
217    try:
218        ret = resolver.domain()
219        if ret != None:
220            set_error()
221    except:
222        set_error()
223    dname = ldns.ldns_dname("example.com.")
224    resolver.set_domain(dname)
225    try:
226        ret = resolver.domain()
227        if not isinstance(ret, ldns.ldns_dname):
228            set_error()
229        if ret != dname:
230            set_error()
231    except:
232        set_error()
233
234
235#if not error_detected:
236if True:
237    method_name = class_name + ".edns_udp_size()"
238    try:
239        resolver = ldns.ldns_resolver.new()
240        if not isinstance(resolver, ldns.ldns_resolver):
241            set_error()
242    except:
243        set_error()
244
245
246
247#if not error_detected:
248if True:
249    method_name = class_name + ".edns_udp_size()"
250    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
251    resolver.set_edns_udp_size(4096)
252    try:
253        ret = resolver.edns_udp_size()
254        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
255            set_error()
256        if ret != 4096:
257            set_error()
258    except:
259        set_error()
260
261
262#if not error_detected:
263if True:
264    method_name = class_name + ".fail()"
265    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
266    resolver.set_fail(False)
267    try:
268        ret = resolver.fail()
269        if not isinstance(ret, bool):
270            set_error()
271        if ret != False:
272            set_error()
273    except:
274        set_error()
275    resolver.set_fail(True)
276    try:
277        ret = resolver.fail()
278        if not isinstance(ret, bool):
279            set_error()
280        if ret != True:
281            set_error()
282    except:
283        set_error()
284
285
286#if not error_detected:
287if True:
288    method_name = class_name + ".fallback()"
289    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
290    resolver.set_fallback(False)
291    try:
292        ret = resolver.fallback()
293        if not isinstance(ret, bool):
294            set_error()
295        if ret != False:
296            set_error()
297    except:
298        set_error()
299    resolver.set_fallback(True)
300    try:
301        ret = resolver.fallback()
302        if not isinstance(ret, bool):
303            set_error()
304        if ret != True:
305            set_error()
306    except:
307        set_error()
308
309
310#if not error_detected:
311if True:
312    method_name = class_name + ".get_addr_by_name()"
313    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
314    try:
315        ret = resolver.get_addr_by_name("www.google.com", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
316        if not isinstance(ret, ldns.ldns_rr_list):
317            set_error()
318    except:
319        set_error()
320    try:
321        ret = resolver.get_addr_by_name(1, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
322        set_error()
323    except TypeError as e:
324        pass
325    except:
326        set_error()
327    try:
328        ret = resolver.get_addr_by_name("www.google.com", "bad argument", ldns.LDNS_RD)
329        set_error()
330    except TypeError as e:
331        pass
332    except:
333        set_error()
334    try:
335        ret = resolver.get_addr_by_name("www.google.com", ldns.LDNS_RR_CLASS_IN, "bad argument")
336        set_error()
337    except TypeError as e:
338        pass
339    except:
340        set_error()
341
342
343#if not error_detected:
344if True:
345    method_name = class_name + ".get_name_by_addr()"
346    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
347    try:
348        addr = resolver.get_name_by_addr("8.8.8.8", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
349        if not isinstance(addr, ldns.ldns_rr_list):
350            set_error()
351    except:
352        set_error()
353    try:
354        addr = resolver.get_name_by_addr(1, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
355        set_error()
356    except TypeError as e:
357        pass
358    except:
359        set_error()
360    try:
361        addr = resolver.get_name_by_addr("8.8.8.8", "bad argument", ldns.LDNS_RD)
362        set_error()
363    except TypeError as e:
364        pass
365    except:
366        set_error()
367    try:
368        addr = resolver.get_name_by_addr("8.8.8.8", ldns.LDNS_RR_CLASS_IN, "bad argument")
369        set_error()
370    except TypeError as e:
371        pass
372    except:
373        set_error()
374
375
376
377#if not error_detected:
378if True:
379    method_name = class_name + ".igntc()"
380    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
381    resolver.set_igntc(False)
382    try:
383        ret = resolver.igntc()
384        if not isinstance(ret, bool):
385            set_error()
386        if ret != False:
387            set_error()
388    except:
389        set_error()
390    resolver.set_igntc(True)
391    try:
392        ret = resolver.igntc()
393        if not isinstance(ret, bool):
394            set_error()
395        if ret != True:
396            set_error()
397    except:
398        set_error()
399
400
401#if not error_detected:
402if True:
403    method_name = class_name + ".incr_nameserver_count()"
404    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
405    cnt = resolver.nameserver_count()
406    try:
407        resolver.incr_nameserver_count()
408    except:
409        set_error()
410    if (cnt + 1) != resolver.nameserver_count():
411        set_error()
412
413
414#if not error_detected:
415if True:
416    method_name = class_name + ".ip6()"
417    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
418    resolver.set_ip6(0)
419    try:
420        ret = resolver.ip6()
421        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
422            set_error()
423        if ret != 0:
424            set_error()
425    except:
426        set_error()
427
428
429#if not error_detected:
430if True:
431    method_name = class_name + ".nameserver_count()"
432    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
433    resolver.set_nameserver_count(1)
434    try:
435        ret = resolver.nameserver_count()
436        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
437            set_error()
438        if ret != 1:
439            set_error()
440    except:
441        set_error()
442
443
444#if not error_detected:
445if True:
446    method_name = class_name + ".nameserver_rtt()"
447    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
448    num = resolver.nameserver_count()
449    for i in range(0, num):
450        resolver.set_nameserver_rtt(i, i + 1)
451    try:
452        for i in range(0, num):
453            ret = resolver.nameserver_rtt(i)
454            if (not isinstance(ret, int)) and (not isinstance(ret, long)):
455                set_error()
456            if (i + 1) != ret:
457                set_error()
458    except:
459        set_error()
460    try:
461        ret = resolver.nameserver_rtt("bad argument")
462        set_error()
463    except TypeError as e:
464        pass
465    except:
466        set_error()
467
468
469#if not error_detected:
470if True:
471    method_name = class_name + ".nameservers()"
472    sys.stderr.write("%s not tested.\n" % (method_name))
473
474
475#if not error_detected:
476if True:
477    method_name = class_name + ".nameservers_randomize()"
478    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
479    try:
480        resolver.nameservers_randomize()
481    except:
482        set_error()
483
484
485#if not error_detected:
486if True:
487    method_name = class_name + ".new_frm_file()"
488    try:
489        ret = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf", raiseException=True)
490        if not isinstance(ret, ldns.ldns_resolver):
491            set_error()
492    except:
493        set_error()
494    try:
495        ret = ldns.ldns_resolver.new_frm_file(1, raiseException=True)
496        set_error()
497    except TypeError as e:
498        pass
499    except:
500        set_error()
501
502
503#if not error_detected:
504if True:
505    method_name = class_name + ".new_frm_fp()"
506    fi = open("/etc/resolv.conf")
507    try:
508        ret = ldns.ldns_resolver.new_frm_fp(fi, raiseException=True)
509        if not isinstance(ret, ldns.ldns_resolver):
510            set_error()
511    except:
512        set_error()
513    fi.close()
514    try:
515        ret = ldns.ldns_resolver.new_frm_fp(1, raiseException=True)
516        set_error()
517    except TypeError as e:
518        pass
519    except:
520        set_error()
521
522
523#if not error_detected:
524if True:
525    method_name = class_name + ".new_frm_fp_l()"
526    fi = open("/etc/resolv.conf")
527    try:
528        ret, line = ldns.ldns_resolver.new_frm_fp_l(fi, raiseException=True)
529        if not isinstance(ret, ldns.ldns_resolver):
530            set_error()
531        if (not isinstance(line, int)) and (not isinstance(line, long)):
532            set_error()
533    except:
534        set_error()
535    fi.close()
536    try:
537        ret, line = ldns.ldns_resolver.new_frm_fp_l(1, raiseException=True)
538        set_error()
539    except TypeError as e:
540        pass
541    except:
542        set_error()
543
544
545#if not error_detected:
546if True:
547    method_name = class_name + ".pop_nameserver()"
548    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
549    cnt = resolver.nameserver_count()
550    try:
551        for i in range(0, cnt):
552            ret = resolver.pop_nameserver()
553            if not isinstance(ret, ldns.ldns_rdf):
554                set_error()
555    except:
556        set_error()
557    try:
558        ret = resolver.pop_nameserver()
559        if ret != None:
560            set_error()
561    except:
562        set_error()
563
564
565#if not error_detected:
566if True:
567    method_name = class_name + ".port()"
568    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
569    resolver.set_port(12345)
570    try:
571        ret = resolver.port()
572        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
573            set_error()
574        if ret != 12345:
575            set_error()
576    except:
577        set_error()
578
579
580#if not error_detected:
581if True:
582    method_name = class_name + ".prepare_query_pkt()"
583    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
584    try:
585        ret = resolver.prepare_query_pkt("example.com.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD, raiseException=True)
586        if not isinstance(ret, ldns.ldns_pkt):
587            set_error()
588    except:
589        set_error()
590    try:
591        ret = resolver.prepare_query_pkt(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD, raiseException=True)
592        set_error()
593    except TypeError as e:
594        pass
595    except:
596        set_error()
597    try:
598        ret = resolver.prepare_query_pkt("example.com.", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD, raiseException=True)
599        set_error()
600    except TypeError as e:
601        pass
602    except:
603        set_error()
604    try:
605        ret = resolver.prepare_query_pkt("example.com.", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD, raiseException=True)
606        set_error()
607    except TypeError as e:
608        pass
609    except:
610        set_error()
611    try:
612        ret = resolver.prepare_query_pkt("example.com.", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument", raiseException=True)
613        set_error()
614    except TypeError as e:
615        pass
616    except:
617        set_error()
618
619
620#if not error_detected:
621if True:
622    method_name = class_name + ".push_dnssec_anchor()"
623    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
624    key = ldns.ldns_key.new_frm_algorithm(ldns.LDNS_SIGN_DSA, 512)
625    domain = ldns.ldns_dname("example.")
626    key.set_pubkey_owner(domain)
627    pubkey = key.key_to_rr()
628    ds = ldns.ldns_key_rr2ds(pubkey, ldns.LDNS_SHA1)
629    try:
630        ret = resolver.push_dnssec_anchor(ds)
631        if ret != ldns.LDNS_STATUS_OK:
632            set_error()
633    except:
634        set_error()
635    rr = ldns.ldns_rr.new_frm_str("test1 600 IN A 0.0.0.0")
636    try:
637        ret = resolver.push_dnssec_anchor(rr)
638        if ret == ldns.LDNS_STATUS_OK:
639            set_error()
640    except:
641        set_error()
642    try:
643        ret = resolver.push_dnssec_anchor("bad argument")
644        set_error()
645    except TypeError as e:
646        pass
647    except:
648        set_error()
649
650
651#if not error_detected:
652if True:
653    method_name = class_name + ".push_nameserver()"
654    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
655    rdf = ldns.ldns_rdf.new_frm_str("127.0.0.1", ldns.LDNS_RDF_TYPE_A)
656    try:
657        ret = resolver.push_nameserver(rdf)
658        if ret != ldns.LDNS_STATUS_OK:
659            set_error()
660    except:
661        set_error()
662    rdf = ldns.ldns_rdf.new_frm_str("::1", ldns.LDNS_RDF_TYPE_AAAA)
663    try:
664        ret = resolver.push_nameserver(rdf)
665        if ret != ldns.LDNS_STATUS_OK:
666            set_error()
667    except:
668        set_error()
669    rdf = ldns.ldns_rdf.new_frm_str("example.com.", ldns.LDNS_RDF_TYPE_DNAME)
670    try:
671        ret = resolver.push_nameserver(rdf)
672        if ret == ldns.LDNS_STATUS_OK:
673            set_error()
674    except:
675        set_error()
676    try:
677        ret = resolver.push_nameserver("bad argument")
678        set_error()
679    except TypeError as e:
680        pass
681    except:
682        set_error()
683
684#if not error_detected:
685if True:
686    method_name = class_name + ".push_nameserver_rr()"
687    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
688    rr = ldns.ldns_rr.new_frm_str("test 600 IN A 127.0.0.1")
689    try:
690        ret = resolver.push_nameserver_rr(rr)
691        if ret != ldns.LDNS_STATUS_OK:
692            set_error()
693    except:
694        set_error()
695    rr = ldns.ldns_rr.new_frm_str("test 600 IN AAAA ::1")
696    try:
697        ret = resolver.push_nameserver_rr(rr)
698        if ret != ldns.LDNS_STATUS_OK:
699            set_error()
700    except:
701        set_error()
702    rr = ldns.ldns_rr.new_frm_str("test 600 IN NS 8.8.8.8")
703    try:
704        ret = resolver.push_nameserver_rr(rr)
705        if ret == ldns.LDNS_STATUS_OK:
706            set_error()
707    except:
708        set_error()
709    try:
710        ret = resolver.push_nameserver_rr("bad argument")
711        set_error()
712    except TypeError as e:
713        pass
714    except:
715        set_error()
716
717
718#if not error_detected:
719if True:
720    method_name = class_name + ".push_nameserver_rr_list()"
721    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
722    rrl = ldns.ldns_rr_list.new()
723    rr = ldns.ldns_rr.new_frm_str("test 600 IN A 127.0.0.1")
724    rrl.push_rr(rr)
725    try:
726        ret = resolver.push_nameserver_rr_list(rrl)
727        if ret != ldns.LDNS_STATUS_OK:
728            set_error()
729    except:
730        set_error()
731    rrl = ldns.ldns_rr_list.new()
732    rr = ldns.ldns_rr.new_frm_str("test 600 IN AAAA ::1")
733    rrl.push_rr(rr)
734    try:
735        ret = resolver.push_nameserver_rr_list(rrl)
736        if ret != ldns.LDNS_STATUS_OK:
737            set_error()
738    except:
739        set_error()
740    rrl = ldns.ldns_rr_list.new()
741    rr = ldns.ldns_rr.new_frm_str("test 600 IN NS 8.8.8.8")
742    rrl.push_rr(rr)
743    try:
744        ret = resolver.push_nameserver_rr_list(rrl)
745        if ret == ldns.LDNS_STATUS_OK:
746            set_error()
747    except:
748        set_error()
749    try:
750        ret = resolver.push_nameserver_rr_list("bad argument")
751        set_error()
752    except TypeError as e:
753        pass
754    except:
755        set_error()
756
757
758#if not error_detected:
759if True:
760    method_name = class_name + ".push_searchlist()"
761    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
762    resolver.push_searchlist("example.com.")
763    try:
764        resolver.push_searchlist("example.com.")
765    except:
766        set_error()
767    try:
768        resolver.push_searchlist(1)
769        set_error()
770    except TypeError as e:
771        pass
772    except:
773        set_error()
774
775
776#if not error_detected:
777if True:
778    method_name = class_name + ".query()"
779    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
780    try:
781        ret = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
782        if not isinstance(ret, ldns.ldns_pkt):
783            set_error()
784    except:
785        set_error()
786    try:
787        ret = resolver.query(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
788        set_error()
789    except TypeError as e:
790        pass
791    except:
792        set_error()
793    try:
794        ret = resolver.query("www.nic.cz", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
795        set_error()
796    except TypeError as e:
797        pass
798    except:
799        set_error()
800    try:
801        ret = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD)
802        set_error()
803    except TypeError as e:
804        pass
805    except:
806        set_error()
807    try:
808        ret = resolver.query("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument")
809        set_error()
810    except TypeError as e:
811        pass
812    except:
813        set_error()
814
815
816#if not error_detected:
817if True:
818    method_name = class_name + ".random()"
819    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
820    resolver.set_random(False)
821    try:
822        ret = resolver.random()
823        if not isinstance(ret, bool):
824            set_error()
825        if ret != False:
826            set_error()
827    except:
828        set_error()
829    resolver.set_random(True)
830    try:
831        ret = resolver.random()
832        if not isinstance(ret, bool):
833            set_error()
834        if ret != True:
835            set_error()
836    except:
837        set_error()
838
839
840#if not error_detected:
841if True:
842    method_name = class_name + ".recursive()"
843    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
844    resolver.set_recursive(False)
845    try:
846        ret = resolver.recursive()
847        if not isinstance(ret, bool):
848            set_error()
849        if ret != False:
850            set_error()
851    except:
852        set_error()
853    resolver.set_recursive(True)
854    try:
855        ret = resolver.recursive()
856        if not isinstance(ret, bool):
857            set_error()
858        if ret != True:
859            set_error()
860    except:
861        set_error()
862
863
864#if not error_detected:
865if True:
866    method_name = class_name + ".retrans()"
867    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
868    resolver.set_retrans(127)
869    try:
870        ret = resolver.retrans()
871        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
872            set_error()
873        if ret != 127:
874            set_error()
875    except:
876        set_error()
877
878
879#if not error_detected:
880if True:
881    method_name = class_name + ".retry()"
882    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
883    resolver.set_retry(4)
884    try:
885        ret = resolver.retry()
886        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
887            set_error()
888        if ret != 4:
889            set_error()
890    except:
891        set_error()
892
893
894#if not error_detected:
895if True:
896    method_name = class_name + ".rtt()"
897    sys.stderr.write("%s not tested.\n" % (method_name))
898
899
900#if not error_detected:
901if True:
902    method_name = class_name + ".search()"
903    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
904    try:
905        ret = resolver.search("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
906        if not isinstance(ret, ldns.ldns_pkt):
907            set_error()
908    except:
909        set_error()
910    try:
911        ret = resolver.search(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
912        set_error()
913    except TypeError as e:
914        pass
915    except:
916        set_error()
917    try:
918        ret = resolver.search("www.nic.cz", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
919        set_error()
920    except TypeError as e:
921        pass
922    except:
923        set_error()
924    try:
925        ret = resolver.search("www.nic.cz", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD)
926        set_error()
927    except TypeError as e:
928        pass
929    except:
930        set_error()
931    try:
932        ret = resolver.search("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument")
933        set_error()
934    except TypeError as e:
935        pass
936    except:
937        set_error()
938
939
940#if not error_detected:
941if True:
942    method_name = class_name + ".searchlist()"
943    sys.stderr.write("%s not tested.\n" % (method_name))
944
945
946#if not error_detected:
947if True:
948    method_name = class_name + ".searchlist_count()"
949    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
950    try:
951        ret = resolver.searchlist_count()
952        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
953            set_error()
954        if ret != 0:
955            set_error()
956    except:
957        set_error()
958
959
960#if not error_detected:
961if True:
962    method_name = class_name + ".send()"
963    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
964    try:
965        ret = resolver.send("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
966        if not isinstance(ret, ldns.ldns_pkt):
967            set_error()
968    except:
969        set_error()
970    try:
971        ret = resolver.send(1, ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
972        set_error()
973    except TypeError as e:
974        pass
975    except:
976        set_error()
977    try:
978        ret = resolver.send("www.nic.cz", "bad argument", ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD)
979        set_error()
980    except TypeError as e:
981        pass
982    except:
983        set_error()
984    try:
985        ret = resolver.send("www.nic.cz", ldns.LDNS_RR_TYPE_A, "bad argument", ldns.LDNS_RD)
986        set_error()
987    except TypeError as e:
988        pass
989    except:
990        set_error()
991    try:
992        ret = resolver.send("www.nic.cz", ldns.LDNS_RR_TYPE_A, ldns.LDNS_RR_CLASS_IN, "bad argument")
993        set_error()
994    except TypeError as e:
995        pass
996    except:
997        set_error()
998
999
1000#if not error_detected:
1001if True:
1002    method_name = class_name + ".send_pkt()"
1003    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1004    pkt = ldns.ldns_pkt.new_query_frm_str("test.nic.cz",ldns.LDNS_RR_TYPE_ANY, ldns.LDNS_RR_CLASS_IN, ldns.LDNS_RD | ldns.LDNS_AD)
1005    try:
1006        status, ret = resolver.send_pkt(pkt)
1007        if status != ldns.LDNS_STATUS_OK:
1008            ste_error()
1009        if not isinstance(ret, ldns.ldns_pkt):
1010            set_error()
1011    except:
1012        set_error()
1013    try:
1014        status, ret = resolver.send_pkt("bad argument")
1015        set_error()
1016    except TypeError as e:
1017        pass
1018    except:
1019        set_error()
1020
1021
1022#if not error_detected:
1023if True:
1024    method_name = class_name + ".set_debug()"
1025    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1026    try:
1027        resolver.set_debug(False)
1028        ret = resolver.debug()
1029        if not isinstance(ret, bool):
1030            set_error()
1031        if ret != False:
1032            set_error()
1033    except:
1034        set_error()
1035    try:
1036        resolver.set_debug(True)
1037        ret = resolver.debug()
1038        if not isinstance(ret, bool):
1039            set_error()
1040        if ret != True:
1041            set_error()
1042    except:
1043        set_error()
1044
1045
1046#if not error_detected:
1047if True:
1048    method_name = class_name + ".set_defnames()"
1049    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1050    try:
1051        resolver.set_defnames(False)
1052        ret = resolver.defnames()
1053        if not isinstance(ret, bool):
1054            set_error()
1055        if ret != False:
1056            set_error()
1057    except:
1058        set_error()
1059    try:
1060        resolver.set_defnames(True)
1061        ret = resolver.defnames()
1062        if not isinstance(ret, bool):
1063            set_error()
1064        if ret != True:
1065            set_error()
1066    except:
1067        set_error()
1068
1069
1070#if not error_detected:
1071if True:
1072    method_name = class_name + ".set_dnsrch()"
1073    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1074    try:
1075        resolver.set_dnsrch(False)
1076        ret = resolver.dnsrch()
1077        if not isinstance(ret, bool):
1078            set_error()
1079        if ret != False:
1080            set_error()
1081    except:
1082        set_error()
1083    try:
1084        resolver.set_dnsrch(True)
1085        ret = resolver.dnsrch()
1086        if not isinstance(ret, bool):
1087            set_error()
1088        if ret != True:
1089            set_error()
1090    except:
1091        set_error()
1092
1093
1094#if not error_detected:
1095if True:
1096    method_name = class_name + ".set_dnssec()"
1097    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1098    try:
1099        resolver.set_dnssec(False)
1100        ret = resolver.dnssec()
1101        if not isinstance(ret, bool):
1102            set_error()
1103        if ret != False:
1104            set_error()
1105    except:
1106        set_error()
1107    try:
1108        resolver.set_dnssec(True)
1109        ret = resolver.dnssec()
1110        if not isinstance(ret, bool):
1111            set_error()
1112        if ret != True:
1113            set_error()
1114    except:
1115        set_error()
1116
1117
1118#if not error_detected:
1119if True:
1120    method_name = class_name + ".set_dnssec_anchors()"
1121    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1122    rrl = ldns.ldns_rr_list.new()
1123    try:
1124        resolver.set_dnssec_anchors(rrl)
1125        ret = resolver.dnssec_anchors()
1126        if not isinstance(ret, ldns.ldns_rr_list):
1127            set_error()
1128    except:
1129        set_error()
1130    try:
1131        resolver.set_dnssec_anchors("bad argument")
1132        set_error()
1133    except TypeError as e:
1134        pass
1135    except:
1136        set_error()
1137
1138
1139#if not error_detected:
1140if True:
1141    method_name = class_name + ".set_dnssec_cd()"
1142    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1143    try:
1144        resolver.set_dnssec_cd(False)
1145        ret = resolver.dnssec_cd()
1146        if not isinstance(ret, bool):
1147            set_error()
1148        if ret != False:
1149            set_error()
1150    except:
1151        set_error()
1152    try:
1153        resolver.set_dnssec_cd(True)
1154        ret = resolver.dnssec_cd()
1155        if not isinstance(ret, bool):
1156            set_error()
1157        if ret != True:
1158            set_error()
1159    except:
1160        set_error()
1161
1162
1163#if not error_detected:
1164if True:
1165    method_name = class_name + ".set_domain()"
1166    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1167    try:
1168        resolver.set_domain(None)
1169        ret = resolver.domain()
1170        if ret != None:
1171            set_error()
1172    except:
1173        set_error()
1174    dname = ldns.ldns_dname("example.com.")
1175    try:
1176        resolver.set_domain(dname)
1177        ret = resolver.domain()
1178        if not isinstance(ret, ldns.ldns_dname):
1179            set_error()
1180        if ret != dname:
1181            set_error()
1182    except:
1183        set_error()
1184    rdf = ldns.ldns_rdf.new_frm_str("example.com.", ldns.LDNS_RDF_TYPE_DNAME)
1185    try:
1186        resolver.set_domain(rdf)
1187        ret = resolver.domain()
1188        if not isinstance(ret, ldns.ldns_rdf):
1189            set_error()
1190        if ret != dname:
1191            set_error()
1192    except:
1193        set_error()
1194    resolver.set_domain("example.com.")
1195    try:
1196        resolver.set_domain("example.com.")
1197        ret = resolver.domain()
1198        if not isinstance(ret, ldns.ldns_dname):
1199            set_error()
1200        if ret != dname:
1201            set_error()
1202    except:
1203        set_error()
1204    rdf = ldns.ldns_rdf.new_frm_str("127.0.0.1", ldns.LDNS_RDF_TYPE_A)
1205    try:
1206        resolver.set_domain(rdf)
1207        set_error()
1208    except Exception as e:
1209        pass
1210    except:
1211        set_error()
1212    try:
1213        resolver.set_domain(1)
1214        set_error()
1215    except TypeError as e:
1216        pass
1217    except:
1218        set_error()
1219
1220
1221#if not error_detected:
1222if True:
1223    method_name = class_name + ".set_edns_udp_size()"
1224    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1225    try:
1226        resolver.set_edns_udp_size(4096)
1227        ret = resolver.edns_udp_size()
1228        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
1229            set_error()
1230        if ret != 4096:
1231            set_error()
1232    except:
1233        set_error()
1234    try:
1235        resolver.set_edns_udp_size("bad argument")
1236        set_error()
1237    except TypeError as e:
1238        pass
1239    except:
1240        ste_error()
1241
1242
1243#if not error_detected:
1244if True:
1245    method_name = class_name + ".set_fail()"
1246    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1247    try:
1248        resolver.set_fail(False)
1249        ret = resolver.fail()
1250        if not isinstance(ret, bool):
1251            set_error()
1252        if ret != False:
1253            set_error()
1254    except:
1255        set_error()
1256    try:
1257        resolver.set_fail(True)
1258        ret = resolver.fail()
1259        if not isinstance(ret, bool):
1260            set_error()
1261        if ret != True:
1262            set_error()
1263    except:
1264        set_error()
1265
1266
1267#if not error_detected:
1268if True:
1269    method_name = class_name + ".set_fallback()"
1270    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1271    try:
1272        resolver.set_fallback(False)
1273        ret = resolver.fallback()
1274        if not isinstance(ret, bool):
1275            set_error()
1276        if ret != False:
1277            set_error()
1278    except:
1279        set_error()
1280    try:
1281        resolver.set_fallback(True)
1282        ret = resolver.fallback()
1283        if not isinstance(ret, bool):
1284            set_error()
1285        if ret != True:
1286            set_error()
1287    except:
1288        set_error()
1289
1290
1291#if not error_detected:
1292if True:
1293    method_name = class_name + ".set_igntc()"
1294    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1295    try:
1296        resolver.set_igntc(False)
1297        ret = resolver.igntc()
1298        if not isinstance(ret, bool):
1299            set_error()
1300        if ret != False:
1301            set_error()
1302    except:
1303        set_error()
1304    try:
1305        resolver.set_igntc(True)
1306        ret = resolver.igntc()
1307        if not isinstance(ret, bool):
1308            set_error()
1309        if ret != True:
1310            set_error()
1311    except:
1312        set_error()
1313
1314
1315#if not error_detected:
1316if True:
1317    method_name = class_name + ".set_ip6()"
1318    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1319    try:
1320        resolver.set_ip6(1)
1321        ret = resolver.ip6()
1322        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
1323            set_error()
1324        if ret != 1:
1325            set_error()
1326    except:
1327        set_error()
1328    try:
1329        resolver.set_ip6("bad argument")
1330        set_error()
1331    except TypeError as e:
1332        pass
1333    except:
1334        ste_error()
1335
1336
1337#if not error_detected:
1338if True:
1339    method_name = class_name + ".set_nameserver_count()"
1340    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1341    try:
1342        resolver.set_nameserver_count(2)
1343        ret = resolver.nameserver_count()
1344        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
1345            set_error()
1346        if ret != 2:
1347            set_error()
1348    except:
1349        set_error()
1350    try:
1351        resolver.set_nameserver_count("bad argument")
1352        set_error()
1353    except TypeError as e:
1354        pass
1355    except:
1356        set_error()
1357
1358
1359#if not error_detected:
1360if True:
1361    method_name = class_name + ".set_nameserver_rtt()"
1362    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1363    num = resolver.nameserver_count()
1364    try:
1365        for i in range(0, num):
1366            resolver.set_nameserver_rtt(i, i + 1)
1367            ret = resolver.nameserver_rtt(i)
1368            if (not isinstance(ret, int)) and (not isinstance(ret, long)):
1369                set_error()
1370            if (i + 1) != ret:
1371                set_error()
1372    except:
1373        set_error()
1374    try:
1375        ret = resolver.set_nameserver_rtt("bad argument", 0)
1376        set_error()
1377    except TypeError as e:
1378        pass
1379    except:
1380        set_error()
1381    try:
1382        ret = resolver.set_nameserver_rtt(0, "bad argument")
1383        set_error()
1384    except TypeError as e:
1385        pass
1386    except:
1387        set_error()
1388
1389
1390#if not error_detected:
1391if True:
1392    method_name = class_name + ".set_nameservers()"
1393    sys.stderr.write("%s not tested.\n" % (method_name))
1394
1395
1396#if not error_detected:
1397if True:
1398    method_name = class_name + ".set_port()"
1399    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1400    try:
1401        resolver.set_port(12345)
1402        ret = resolver.port()
1403        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
1404            set_error()
1405        if ret != 12345:
1406            set_error()
1407    except:
1408        set_error()
1409    try:
1410        resolver.set_port("bad argument")
1411        set_error()
1412    except TypeError as e:
1413        pass
1414    except:
1415        set_error()
1416
1417
1418#if not error_detected:
1419if True:
1420    method_name = class_name + ".set_random()"
1421    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1422    try:
1423        resolver.set_random(False)
1424        ret = resolver.random()
1425        if not isinstance(ret, bool):
1426            set_error()
1427        if ret != False:
1428            set_error()
1429    except:
1430        set_error()
1431    try:
1432        resolver.set_random(True)
1433        ret = resolver.random()
1434        if not isinstance(ret, bool):
1435            set_error()
1436        if ret != True:
1437            set_error()
1438    except:
1439        set_error()
1440
1441
1442#if not error_detected:
1443if True:
1444    method_name = class_name + ".set_recursive()"
1445    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1446    try:
1447        resolver.set_recursive(False)
1448        ret = resolver.recursive()
1449        if not isinstance(ret, bool):
1450            set_error()
1451        if ret != False:
1452            set_error()
1453    except:
1454        set_error()
1455    try:
1456        resolver.set_recursive(True)
1457        ret = resolver.recursive()
1458        if not isinstance(ret, bool):
1459            set_error()
1460        if ret != True:
1461            set_error()
1462    except:
1463        set_error()
1464
1465
1466#if not error_detected:
1467if True:
1468    method_name = class_name + ".set_retrans()"
1469    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1470    try:
1471        resolver.set_retrans(127)
1472        ret = resolver.retrans()
1473        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
1474            set_error()
1475        if ret != 127:
1476            set_error()
1477    except:
1478        set_error()
1479    try:
1480        resolver.set_retrans("bad argument")
1481        set_error()
1482    except TypeError as e:
1483        pass
1484    except:
1485        set_error()
1486
1487
1488#if not error_detected:
1489if True:
1490    method_name = class_name + ".set_retry()"
1491    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1492    try:
1493        resolver.set_retry(4)
1494        ret = resolver.retry()
1495        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
1496            set_error()
1497        if ret != 4:
1498            set_error()
1499    except:
1500        set_error()
1501    try:
1502        resolver.set_retry("bad argument")
1503        set_error()
1504    except TypeError as e:
1505        pass
1506    except:
1507        set_error()
1508
1509
1510#if not error_detected:
1511if True:
1512    method_name = class_name + ".set_rtt()"
1513    sys.stderr.write("%s not tested.\n" % (method_name))
1514
1515
1516#if not error_detected:
1517if True:
1518    method_name = class_name + ".set_timeout()"
1519    sys.stderr.write("%s not tested.\n" % (method_name))
1520
1521
1522#if not error_detected:
1523if True:
1524    method_name = class_name + ".set_tsig_algorithm()"
1525    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1526    tsigstr = "hmac-md5.sig-alg.reg.int."
1527    try:
1528        resolver.set_tsig_algorithm(tsigstr)
1529        ret = resolver.tsig_algorithm()
1530        if not isinstance(ret, str):
1531            set_error()
1532        if ret != tsigstr:
1533            set_error()
1534    except:
1535        set_error()
1536    try:
1537        resolver.set_tsig_algorithm(1)
1538        set_error()
1539    except TypeError as e:
1540        pass
1541    except:
1542        set_error()
1543
1544
1545#if not error_detected:
1546if True:
1547    method_name = class_name + ".set_tsig_keydata()"
1548    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1549    tkdstr = "Humpty Dumpty sat on a wall, Humpty Dumpty had a great fall, All the King's horses and all the King's men, Couldn't put Humpty together again."
1550    try:
1551        resolver.set_tsig_keydata(tkdstr)
1552        ret = resolver.tsig_keydata()
1553        if not isinstance(ret, str):
1554            set_error()
1555        if ret != tkdstr:
1556            set_error()
1557    except:
1558        set_error()
1559    try:
1560        resolver.set_tsig_keydata(1)
1561        set_error()
1562    except TypeError as e:
1563        pass
1564    except:
1565        set_error()
1566
1567
1568#if not error_detected:
1569if True:
1570    method_name = class_name + ".set_tsig_keyname()"
1571    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1572    tknstr = "key 1"
1573    try:
1574        resolver.set_tsig_keyname(tknstr)
1575        ret = resolver.tsig_keyname()
1576        if not isinstance(ret, str):
1577            set_error()
1578        if ret != tknstr:
1579            set_error()
1580    except:
1581        set_error()
1582    try:
1583        resolver.set_tsig_keyname(1)
1584        set_error()
1585    except TypeError as e:
1586        pass
1587    except:
1588        set_error()
1589
1590
1591#if not error_detected:
1592if True:
1593    method_name = class_name + ".set_usevc()"
1594    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1595    try:
1596        resolver.set_usevc(False)
1597        ret = resolver.usevc()
1598        if not isinstance(ret, bool):
1599            set_error()
1600        if ret != False:
1601            set_error()
1602    except:
1603        set_error()
1604    try:
1605        resolver.set_usevc(True)
1606        ret = resolver.usevc()
1607        if not isinstance(ret, bool):
1608            set_error()
1609        if ret != True:
1610            set_error()
1611    except:
1612        set_error()
1613
1614
1615#if not error_detected:
1616if True:
1617    method_name = class_name + ".timeout()"
1618    sys.stderr.write("%s not tested.\n" % (method_name))
1619
1620
1621#if not error_detected:
1622if True:
1623    method_name = class_name + ".trusted_key()"
1624    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1625    key = ldns.ldns_key.new_frm_algorithm(ldns.LDNS_SIGN_DSA, 512)
1626    domain = ldns.ldns_dname("example.")
1627    key.set_pubkey_owner(domain)
1628    pubkey = key.key_to_rr()
1629    ds = ldns.ldns_key_rr2ds(pubkey, ldns.LDNS_SHA1)
1630    resolver.push_dnssec_anchor(ds)
1631    rrl = ldns.ldns_rr_list.new()
1632    try:
1633        ret = resolver.trusted_key(rrl)
1634        if ret != None:
1635            set_error()
1636    except:
1637        set_error()
1638    rrl.push_rr(ds)
1639    ret = resolver.trusted_key(rrl)
1640    try:
1641        ret = resolver.trusted_key(rrl)
1642        if not isinstance(ret, ldns.ldns_rr_list):
1643            set_error()
1644        if ret.rr_count() != 1:
1645            set_error()
1646    except:
1647        set_error()
1648    try:
1649        ret = resolver.trusted_key("bad argument")
1650        set_error()
1651    except TypeError as e:
1652        pass
1653    except:
1654        set_error()
1655
1656
1657#if not error_detected:
1658if True:
1659    method_name = class_name + ".tsig_algorithm()"
1660    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1661    try:
1662        ret = resolver.tsig_algorithm()
1663        if ret != None:
1664            set_error()
1665    except:
1666        set_error()
1667    tsigstr = "hmac-md5.sig-alg.reg.int."
1668    resolver.set_tsig_algorithm(tsigstr)
1669    try:
1670        ret = resolver.tsig_algorithm()
1671        if not isinstance(ret, str):
1672            set_error()
1673        if ret != tsigstr:
1674            set_error()
1675    except:
1676        set_error()
1677
1678
1679#if not error_detected:
1680if True:
1681    method_name = class_name + ".tsig_keydata()"
1682    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1683    try:
1684        ret = resolver.tsig_keydata()
1685        if ret != None:
1686            set_error()
1687    except:
1688        set_error()
1689    tkdstr = "Twas brillig, and the slithy toves Did gyre and gimble in the wabe; All mimsy were the borogoves, And the mome raths outgrabe."
1690    resolver.set_tsig_keydata(tkdstr)
1691    try:
1692        ret = resolver.tsig_keydata()
1693        if not isinstance(ret, str):
1694            set_error()
1695        if ret != tkdstr:
1696            set_error()
1697    except:
1698        set_error()
1699
1700
1701#if not error_detected:
1702if True:
1703    method_name = class_name + ".tsig_keyname()"
1704    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1705    try:
1706        ret = resolver.tsig_keyname()
1707        if ret != None:
1708            set_error()
1709    except:
1710        set_error()
1711    tknstr = "key 2"
1712    resolver.set_tsig_keyname(tknstr)
1713    try:
1714        ret = resolver.tsig_keyname()
1715        if not isinstance(ret, str):
1716            set_error()
1717        if ret != tknstr:
1718            set_error()
1719    except:
1720        set_error()
1721
1722
1723#if not error_detected:
1724if True:
1725    method_name = class_name + ".usevc()"
1726    resolver = ldns.ldns_resolver.new_frm_file("/etc/resolv.conf")
1727    resolver.set_usevc(False)
1728    try:
1729        ret = resolver.usevc()
1730        if not isinstance(ret, bool):
1731            set_error()
1732        if ret != False:
1733            set_error()
1734    except:
1735        set_error()
1736    resolver.set_usevc(True)
1737    try:
1738        ret = resolver.usevc()
1739        if not isinstance(ret, bool):
1740            set_error()
1741        if ret != True:
1742            set_error()
1743    except:
1744        set_error()
1745
1746
1747if not error_detected:
1748    sys.stdout.write("%s: passed.\n" % (os.path.basename(__file__)))
1749else:
1750    sys.stdout.write("%s: errors detected.\n" % (os.path.basename(__file__)))
1751    sys.exit(1)
1752