1#!/usr/bin/env python
2
3#
4# ldns_rdf 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_rdf"
18method_name = None
19error_detected = False
20temp_fname = "tmp_rdf.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 + ".__init__()"
38    try:
39        # Should raise an Exception
40        rdf = ldns.ldns_rdf()
41        set_error()
42    except Exception as e:
43        pass
44
45
46#if not error_detected:
47if True:
48    method_name = class_name + ".[comparison operators]"
49    rdf1 = ldns.ldns_rdf.new_frm_str("0.0.0.0", ldns.LDNS_RDF_TYPE_A)
50    rdf2 = ldns.ldns_rdf.new_frm_str("1.1.1.1", ldns.LDNS_RDF_TYPE_A)
51    try:
52        ret = rdf1 < rdf2
53        if not isinstance(ret, bool):
54            set_error()
55        if ret != True:
56            set_error()
57    except:
58        set_error()
59    try:
60        ret = rdf2 < rdf1
61        if not isinstance(ret, bool):
62            set_error()
63        if ret != False:
64            set_error()
65    except:
66        set_error()
67    try:
68        ret = rdf1 <= rdf2
69        if not isinstance(ret, bool):
70            set_error()
71        if ret != True:
72            set_error()
73    except:
74        set_error()
75    try:
76        ret = rdf2 <= rdf1
77        if not isinstance(ret, bool):
78            set_error()
79        if ret != False:
80            set_error()
81    except:
82        set_error()
83    try:
84        ret = rdf1 == rdf2
85        if not isinstance(ret, bool):
86            set_error()
87        if ret != False:
88            set_error()
89    except:
90        set_error()
91    try:
92        ret = rdf1 == rdf1
93        if not isinstance(ret, bool):
94            set_error()
95        if ret != True:
96            set_error()
97    except:
98        set_error()
99    try:
100        ret = rdf1 != rdf2
101        if not isinstance(ret, bool):
102            set_error()
103        if ret != True:
104            set_error()
105    except:
106        set_error()
107    try:
108        ret = rdf1 != rdf1
109        if not isinstance(ret, bool):
110            set_error()
111        if ret != False:
112            set_error()
113    except:
114        set_error()
115    try:
116        ret = rdf1 > rdf2
117        if not isinstance(ret, bool):
118            set_error()
119        if ret != False:
120            set_error()
121    except:
122        set_error()
123    try:
124        ret = rdf2 > rdf1
125        if not isinstance(ret, bool):
126            set_error()
127        if ret != True:
128            set_error()
129    except:
130        set_error()
131    try:
132        ret = rdf1 >= rdf2
133        if not isinstance(ret, bool):
134            set_error()
135        if ret != False:
136            set_error()
137    except:
138        set_error()
139    try:
140        ret = rdf2 >= rdf1
141        if not isinstance(ret, bool):
142            set_error()
143        if ret != True:
144            set_error()
145    except:
146        set_error()
147
148
149#if not error_detected:
150if True:
151    method_name = "ldns_rdf_new()"
152    sys.stderr.write("%s not tested.\n" % (method_name))
153
154
155#if not error_detected:
156if True:
157    method_name = "ldns_rdf_new_frm_data()"
158    sys.stderr.write("%s not tested.\n" % (method_name))
159
160
161#if not error_detected:
162if True:
163    method_name = "ldns_rdf_new_frm_str()"
164    try:
165        rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz")
166    except:
167        set_error()
168    try:
169        rdf = ldns.ldns_rdf_new_frm_str("", "www.nic.cz")
170        et_error()
171    except TypeError:
172        pass
173    except:
174        set_error()
175    try:
176        rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, 1)
177    except TypeError:
178        pass
179    except:
180        set_error()
181
182
183#if not error_detected:
184if True:
185    method_name = "ldns_rdf_new_frm_fp()"
186    f = open(temp_fname, "w")
187    f.write("217.31.205.50")
188    f.close()
189    f = open(temp_fname, "r")
190    try:
191        status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_A, f)
192        if status != ldns.LDNS_STATUS_OK:
193            set_error()
194        if rdf == None:
195            set_error()
196    except:
197        set_error()
198    try:
199        # Reading past file end.
200        status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, f)
201        if status == ldns.LDNS_STATUS_OK:
202            set_error()
203        if rdf != None:
204            set_error()
205    except:
206        set_error()
207    f.close()
208    f = open(temp_fname, "r")
209    try:
210        status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, f)
211        if status != ldns.LDNS_STATUS_OK:
212            set_error()
213        if rdf != None:
214            set_error()
215    except:
216        set_error()
217    f.close()
218    os.remove(temp_fname)
219    try:
220        status, rdf = ldns.ldns_rdf_new_frm_fp("", f)
221    except TypeError:
222        pass
223    except:
224        set_error()
225    try:
226        status, rdf = ldns.ldns_rdf_new_frm_fp(ldns.LDNS_RDF_TYPE_AAAA, "")
227    except TypeError:
228        pass
229    except:
230        set_error()
231
232
233#if not error_detected:
234if True:
235    method_name = "ldns_rdf_new_frm_fp_l()"
236    f = open(temp_fname, "w")
237    f.write("217.31.205.50\n194.0.12.1")
238    f.close()
239    f = open(temp_fname, "r")
240    try:
241        status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f)
242        if status != ldns.LDNS_STATUS_OK:
243            set_error()
244        if rdf == None:
245            set_error()
246    except:
247        set_error()
248    try:
249        status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f)
250        if status != ldns.LDNS_STATUS_OK:
251            set_error()
252        if rdf == None:
253            set_error()
254    except:
255        set_error()
256    try:
257        # Reading past file end.
258        status, rdf, line = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_A, f)
259        if status == ldns.LDNS_STATUS_OK:
260            set_error()
261        if rdf != None:
262            set_error()
263    except:
264        set_error()
265    f.close()
266    os.remove(temp_fname)
267    try:
268        status, rdf = ldns.ldns_rdf_new_frm_fp_l("", f)
269    except TypeError:
270        pass
271    except:
272        set_error()
273    try:
274        status, rdf = ldns.ldns_rdf_new_frm_fp_l(ldns.LDNS_RDF_TYPE_AAAA, "")
275    except TypeError:
276        pass
277    except:
278        set_error()
279
280
281#if not error_detected:
282if True:
283    method_name = "ldns_drf.absolute()"
284    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
285    try:
286        ret = rdf.absolute()
287        if not isinstance(ret, bool):
288            set_error()
289        if not ret:
290            set_error()
291    except:
292        set_error()
293
294
295#if not error_detected:
296if True:
297    method_name = "ldns_rdf.address_reverse()"
298    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
299    try:
300        ret = rdf.address_reverse()
301        if ret == None:
302            set_error()
303    except:
304        set_error()
305    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_AAAA, "::1")
306    try:
307        ret = rdf.address_reverse()
308        if ret == None:
309            set_error()
310    except:
311        set_error()
312    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
313    try:
314        ret = rdf.address_reverse()
315        if ret != None:
316            set_error()
317    except:
318        set_error()
319
320
321#if not error_detected:
322if True:
323    method_name = "ldns_rdf.cat()"
324    rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic")
325    rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "cz.")
326    try:
327        ret = rdf1.cat(rdf2)
328        if ret != ldns.LDNS_STATUS_OK:
329            set_error()
330    except:
331        set_error()
332    rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.")
333    rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
334    try:
335        ret = rdf1.cat(rdf2)
336        if ret == ldns.LDNS_STATUS_OK:
337            set_error()
338    except:
339        set_error()
340    try:
341        ret = rdf2.cat(rdf1)
342        if ret == ldns.LDNS_STATUS_OK:
343            set_error()
344    except:
345        set_error()
346    try:
347        ret = rdf2.cat("")
348        set_error()
349    except TypeError:
350        pass
351    except:
352        set_error()
353
354
355#if not error_detected:
356if True:
357    method_name = "ldns_rdf.cat_clone()"
358    rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic")
359    rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "cz.")
360    try:
361        ret = rdf1.cat_clone(rdf2)
362        if ret == None:
363            set_error()
364    except:
365        set_error()
366    rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.")
367    rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
368    try:
369        ret = rdf1.cat_clone(rdf2)
370        if ret != None:
371            set_error()
372    except:
373        set_error()
374    try:
375        ret = rdf2.cat_clone(rdf1)
376        if ret != None:
377            set_error()
378    except:
379        set_error()
380    try:
381        ret = rdf2.cat_clone("")
382        set_error()
383    except TypeError:
384        pass
385    except:
386        set_error()
387
388
389#if not error_detected:
390if True:
391    method_name = "ldns_rdf.clone()"
392    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
393    try:
394        ret = rdf.clone()
395    except:
396        set_error()
397
398
399#if not error_detected:
400if True:
401    method_name = "ldns_rdf.data()"
402    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
403    try:
404        ret = rdf.data()
405    except:
406        set_error()
407
408
409#if not error_detected:
410if True:
411    method_name = "ldns_rdf.data_as_bytearray()"
412    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
413    try:
414        ret = rdf.data_as_bytearray()
415        if not isinstance(ret, bytearray):
416            set_error()
417        if len(ret) != 12:
418            set_error()
419    except:
420        set_error()
421
422
423#if not error_detected:
424if True:
425    method_name = "ldns_rdf.dname_compare()"
426    rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
427    rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "nic.cz.")
428    try:
429        ret = rdf1.dname_compare(rdf2)
430        if ret != 1:
431            set_error()
432    except:
433        set_error()
434    try:
435        ret = rdf2.dname_compare(rdf1)
436        if ret != -1:
437            set_error()
438    except:
439        set_error()
440    try:
441        ret = rdf1.dname_compare(rdf1)
442        if ret != 0:
443            set_error()
444    except:
445        set_error()
446    rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
447    rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
448    try:
449        ret = rdf1.dname_compare(rdf2)
450        set_error()
451    except Exception:
452        pass
453    except:
454        set_error()
455
456
457#if not error_detected:
458if True:
459    method_name = "ldns_rdf.dname_new_frm_str()"
460    try:
461        rdf = ldns.ldns_rdf.dname_new_frm_str("www.nic.cz.")
462        if rdf == None:
463            set_error()
464    except:
465        set_error()
466    try:
467        rdf = ldns.ldns_rdf.dname_new_frm_str("")
468        if rdf != None:
469            set_error()
470    except:
471        set_error()
472    try:
473        rdf = ldns.ldns_rdf.dname_new_frm_str(1)
474        set_error()
475    except TypeError:
476        pass
477    except:
478        set_error()
479
480
481#if not error_detected:
482if True:
483    method_name = "ldns_rdf.get_type()"
484    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
485    try:
486        ret = rdf.get_type()
487        if not isinstance(ret, int):
488            set_error()
489        if ret != ldns.LDNS_RDF_TYPE_DNAME:
490            set_error()
491    except:
492        set_error()
493
494
495#if not error_detected:
496if True:
497    method_name = "ldns_rdf.get_type_str()"
498    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
499    try:
500        ret = rdf.get_type_str()
501        if not isinstance(ret, str):
502            set_error()
503    except:
504        set_error()
505
506
507#if not error_detected:
508if True:
509    method_name = "ldns_rdf.interval()"
510    rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "a.ns.nic.cz.")
511    rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "b.ns.nic.cz.")
512    rdf3 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "c.ns.nic.cz.")
513    try:
514        ret = rdf1.interval(rdf2, rdf3)
515        if ret != -1:
516            set_error()
517    except:
518        set_error()
519    try:
520        ret = rdf2.interval(rdf1, rdf3)
521        if ret != 1:
522            set_error()
523    except:
524        set_error()
525    rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
526    rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "b.ns.nic.cz.")
527    rdf3 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "c.ns.nic.cz.")
528    try:
529        ret = rdf1.interval(rdf2, rdf3)
530        set_error()
531    except Exception:
532        pass
533    except:
534        set_error()
535    try:
536        ret = rdf2.interval("", rdf3)
537        set_error()
538    except TypeError:
539        pass
540    except:
541        set_error()
542
543#if not error_detected:
544if True:
545    method_name = "ldns_rdf.is_subdomain()"
546    rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "nic.cz.")
547    rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
548    try:
549        ret = rdf1.is_subdomain(rdf2)
550        if not isinstance(ret, bool):
551            set_error()
552        if ret == True:
553            set_error()
554        ret = rdf2.is_subdomain(rdf1)
555        if ret != True:
556            set_error()
557    except:
558        set_error()
559    rdf1 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "194.0.12.1")
560    rdf2 = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
561    try:
562        ret = rdf1.is_subdomain(rdf2)
563        if ret != False:
564            set_error()
565    except:
566        set_error()
567    try:
568        ret = rdf2.is_subdomain(rdf1)
569        if ret != False:
570            set_error()
571    except:
572        set_error()
573    try:
574        ret = rdf2.is_subdomain("")
575        set_error()
576    except TypeError:
577        pass
578    except:
579        set_error()
580
581
582#if not error_detected:
583if True:
584    method_name = "ldns_rdf.label()"
585    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
586    try:
587        ret = rdf.label(0)
588        if not isinstance(ret, ldns.ldns_rdf):
589            set_error()
590    except:
591        set_error()
592    try:
593        ret = rdf.label(10)
594        if ret != None:
595            set_error()
596    except:
597        set_error()
598    try:
599        ret = rdf.label("")
600    except TypeError:
601        pass
602    except:
603        set_error()
604    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
605    try:
606        ret = rdf.label(0)
607        if ret != None:
608            set_error()
609    except:
610        set_error()
611
612
613#if not error_detected:
614if True:
615    method_name = "ldns_rdf.label_count()"
616    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
617    try:
618        ret = rdf.label_count()
619        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
620            set_error()
621        if ret != 3:
622            set_error()
623    except:
624        set_error()
625    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
626    try:
627        ret = rdf.label_count()
628        if (not isinstance(ret, int)) and (not isinstance(ret, long)):
629            set_error()
630        if ret != 0:
631            set_error()
632    except:
633        set_error()
634
635
636#if not error_detected:
637if True:
638    method_name = "ldns_rdf.left_chop()"
639    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
640    try:
641        ret = rdf.left_chop()
642        if not isinstance(ret, ldns.ldns_rdf):
643            set_error()
644    except:
645        set_error()
646    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
647    try:
648        ret = rdf.left_chop()
649        if ret != None:
650            set_error()
651    except:
652        set_error()
653
654
655#if not error_detected:
656if True:
657    method_name = "ldns_rdf.make_canonical()"
658    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "WWW.NIC.CZ.")
659    try:
660        rdf.make_canonical()
661        if rdf.__str__() != "www.nic.cz.":
662            set_error()
663    except:
664        set_error()
665    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
666    try:
667        rdf.make_canonical()
668    except:
669        set_error()
670
671
672#if not error_detected:
673if True:
674    method_name = "ldns_rdf.new_frm_str()"
675    try:
676        rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_DNAME)
677    except:
678        set_error()
679    try:
680        rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_AAAA)
681        set_error()
682    except Exception:
683        pass
684    except:
685        set_error()
686    try:
687        rdf = ldns.ldns_rdf.new_frm_str("www.nic.cz.", ldns.LDNS_RDF_TYPE_AAAA, raiseException = False)
688        if rdf != None:
689            set_error()
690    except:
691        set_error()
692    try:
693        rdf = ldns.ldns_rdf.new_frm_str("", "www.nic.cz")
694        et_error()
695    except TypeError:
696        pass
697    except:
698        set_error()
699    try:
700        rdf = ldns.ldns_rdf.new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, 1)
701    except TypeError:
702        pass
703    except:
704        set_error()
705
706
707#if not error_detected:
708if True:
709    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
710    f = open(temp_fname, "w")
711    try:
712        rdf.print_to_file(f)
713    except:
714        set_error()
715    f.close()
716    f = open(temp_fname, "r")
717    if f.read() != "127.0.0.1":
718        set_error()
719    f.close()
720    os.remove(temp_fname)
721
722
723#if not error_detected:
724if True:
725    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
726    try:
727        ret = rdf.reverse()
728        if not isinstance(ret, ldns.ldns_rdf):
729            set_error()
730        if ret.__str__() != "cz.nic.www.":
731            set_error()
732    except:
733        set_error()
734    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_A, "127.0.0.1")
735    try:
736        ret = rdf.reverse()
737        set_error()
738    except Exception:
739        pass
740    except:
741        set_error()
742
743
744#if not error_detected:
745if True:
746    method_name = "ldns_rdf.set_data()"
747    sys.stderr.write("%s not tested.\n" % (method_name))
748
749
750#if not error_detected:
751if True:
752    method_name = "ldns_rdf.set_size()"
753    sys.stderr.write("%s not tested.\n" % (method_name))
754
755
756#if not error_detected:
757if True:
758    method_name = "ldns_rdf.set_type()"
759    sys.stderr.write("%s not tested.\n" % (method_name))
760
761
762#if not error_detected:
763if True:
764    method_name = "ldns_rdf.size()"
765    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
766    try:
767        ret = rdf.size()
768        if ret != 12:
769            set_error()
770    except:
771        set_error()
772
773
774#if not error_detected:
775if True:
776    method_name = "ldns_rdf.write_to_buffer()"
777    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "www.nic.cz.")
778    buf = ldns.ldns_buffer(1024)
779    try:
780        ret = rdf.write_to_buffer(buf)
781        if ret != ldns.LDNS_STATUS_OK:
782            set_error()
783        if buf.position() != 12:
784            set_error()
785    except:
786        set_error()
787    try:
788        ret = rdf.write_to_buffer("")
789    except TypeError:
790        pass
791    except:
792        set_error()
793
794
795#if not error_detected:
796if True:
797    method_name = "ldns_rdf.write_to_buffer_canonical()"
798    rdf = ldns.ldns_rdf_new_frm_str(ldns.LDNS_RDF_TYPE_DNAME, "WWW.NIC.CZ.")
799    buf = ldns.ldns_buffer(1024)
800    try:
801        ret = rdf.write_to_buffer_canonical(buf)
802        if ret != ldns.LDNS_STATUS_OK:
803            set_error()
804        if buf.position() != 12:
805            set_error()
806    except:
807        set_error()
808    try:
809        ret = rdf.write_to_buffer_canonical("")
810    except TypeError:
811        pass
812    except:
813        set_error()
814
815
816if not error_detected:
817    sys.stdout.write("%s: passed.\n" % (os.path.basename(__file__)))
818else:
819    sys.stdout.write("%s: errors detected.\n" % (os.path.basename(__file__)))
820    sys.exit(1)
821