Sourcecode and documentation for libtasn1-2 version 0.2.10-3sarge1
show bar | Show file versions
Search packages:
| Sourcecode archive home

Test_tree.c

00001 /*
00002  *      Copyright (C) 2002 Fabio Fiorina
00003  *
00004  * This file is part of LIBASN1.
00005  *
00006  * LIBASN1 is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * LIBASN1 is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this program; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
00019  */
00020 
00021 
00022 /*****************************************************/
00023 /* File: Test_tree.c                                 */
00024 /* Description: Test sequences for these functions:  */
00025 /*     asn1_visit_tree,                              */   
00026 /*     asn1_create_structure,                        */   
00027 /*     asn1_delete_structure,                        */
00028 /*     asn1_write_value,                             */   
00029 /*     asn1_read_value,                              */   
00030 /*****************************************************/
00031 
00032 #include <stdio.h>
00033 #include <string.h>
00034 #include <stdlib.h>
00035 #include "libtasn1.h"
00036 
00037 #include "Test_tree_asn1_tab.c"
00038 
00039 #define ACT_NULL       0
00040 #define ACT_CREATE     1
00041 #define ACT_DELETE     2
00042 #define ACT_WRITE      3
00043 #define ACT_READ       4
00044 #define ACT_VISIT      5
00045 #define ACT_ENCODING   6
00046 #define ACT_DECODING   7
00047 #define ACT_PRINT_DER  8
00048 #define ACT_EXPAND_ANY 9
00049 #define ACT_DECODING_ELEMENT   10
00050 #define ACT_EXPAND_OCTET       11
00051 #define ACT_NUMBER_OF_ELEMENTS 12
00052 #define ACT_DECODING_START_END 13
00053 #define ACT_READ_DEFINITIONS   14
00054 #define ACT_READ_TAG_CLASS     15
00055 #define ACT_OID_2_STRUCTURE    16
00056 #define ACT_READ_LENGTH        17
00057 #define ACT_ENCODING_LENGTH    18
00058 #define ACT_READ_BIT           19
00059 #define ACT_SET_DER            20
00060 #define ACT_DELETE_ELEMENT     21
00061 
00062 
00063 typedef struct{
00064   int action;
00065   char *par1;
00066   unsigned char *par2;
00067   int par3;
00068   int  errorNumber;
00069 } test_type;
00070 
00071 
00072 test_type test_array[]={
00073 
00074   {ACT_DELETE,"","",0,ASN1_ELEMENT_NOT_FOUND},
00075 
00076   /* Test: APPLICATION 30 */
00077   {ACT_CREATE,"TEST_TREE.KrbError",0,0,ASN1_SUCCESS},
00078   {ACT_WRITE,"pvno","5",0,ASN1_SUCCESS},
00079   {ACT_ENCODING_LENGTH,"",0,5,ASN1_MEM_ERROR},
00080   {ACT_ENCODING,"",0,4,ASN1_MEM_ERROR},
00081   {ACT_ENCODING,"",0,5,ASN1_SUCCESS},
00082   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00083   {ACT_CREATE,"TEST_TREE.KrbError",0,0,ASN1_SUCCESS},
00084   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
00085   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00086   {ACT_DELETE_ELEMENT,"pvno","",0,ASN1_SUCCESS},
00087   {ACT_DELETE_ELEMENT,"pvno","",0,ASN1_ELEMENT_NOT_FOUND},
00088   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00089 
00090   /* Test: CHOICE */
00091   {ACT_CREATE,"TEST_TREE.CertTemplate",0,0,ASN1_SUCCESS},
00092   {ACT_WRITE,"version",0,0,ASN1_SUCCESS},
00093   {ACT_WRITE,"validity",0,0,ASN1_SUCCESS},
00094   {ACT_WRITE,"issuer","rdnSequence",0,ASN1_SUCCESS},
00095   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
00096   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.3",0,ASN1_SUCCESS},
00097   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x18\x71\x75\x61\x73\x61\x72\x2e\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",26,ASN1_SUCCESS},
00098   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
00099   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.7",0,ASN1_SUCCESS},
00100   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x08\x43\x61\x6d\x70\x69\x6e\x61\x73",10,ASN1_SUCCESS},
00101   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
00102   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.6",0,ASN1_SUCCESS},
00103   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x13\x06\x42\x72\x61\x73\x69\x6c",8,ASN1_SUCCESS},
00104   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
00105   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.10",0,ASN1_SUCCESS},
00106   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x02\x49\x43",4,ASN1_SUCCESS},
00107   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
00108   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.11",0,ASN1_SUCCESS},
00109   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x03\x4c\x41\x53",5,ASN1_SUCCESS},
00110   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
00111   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","2.5.4.8",0,ASN1_SUCCESS},
00112   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x0c\x09\x53\x61\x6f\x20\x50\x61\x75\x6c\x6f",11,ASN1_SUCCESS},
00113   {ACT_WRITE,"issuer.rdnSequence","NEW",0,ASN1_SUCCESS},
00114   {ACT_WRITE,"issuer.rdnSequence.?LAST.type","1.2.840.113549.1.9.1",0,ASN1_SUCCESS},
00115   {ACT_WRITE,"issuer.rdnSequence.?LAST.value","\x16\x19\x65\x64\x75\x61\x72\x64\x6f\x40\x6c\x61\x73\x2e\x69\x63\x2e\x75\x6e\x69\x63\x61\x6d\x70\x2e\x62\x72",27,ASN1_SUCCESS},
00116   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00117   {ACT_ENCODING_LENGTH,"",0,152,ASN1_MEM_ERROR},
00118   {ACT_ENCODING,"",0,151,ASN1_MEM_ERROR},
00119   {ACT_ENCODING,"",0,152,ASN1_SUCCESS},
00120   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00121   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00122   {ACT_CREATE,"TEST_TREE.CertTemplate",0,0,ASN1_SUCCESS},
00123   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
00124   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00125   {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?1","",0,ASN1_SUCCESS},
00126   {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?1","",0,ASN1_ELEMENT_NOT_FOUND},
00127   {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?3","",0,ASN1_SUCCESS},
00128   {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?5","",0,ASN1_SUCCESS},
00129   {ACT_DELETE_ELEMENT,"issuer.rdnSequence.?7","",0,ASN1_SUCCESS},
00130   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00131   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00132 
00133   /* Test: Empty sequnces */
00134   {ACT_CREATE,"TEST_TREE.sequenceEmpty",0,0,ASN1_SUCCESS},
00135   {ACT_WRITE,"int1","1",0,ASN1_SUCCESS},
00136   {ACT_WRITE,"seq1.int",NULL,0,ASN1_SUCCESS},
00137   {ACT_ENCODING_LENGTH,"",0,11,ASN1_MEM_ERROR},
00138   {ACT_ENCODING,"",0,10,ASN1_MEM_ERROR},
00139   {ACT_ENCODING,"",0,11,ASN1_SUCCESS},
00140   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00141   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00142   {ACT_CREATE,"TEST_TREE.sequenceEmpty",0,0,ASN1_SUCCESS},
00143   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
00144   {ACT_DECODING_START_END,"seq1","START",5,ASN1_SUCCESS},
00145   {ACT_DECODING_START_END,"seq1","END",6,ASN1_SUCCESS},
00146   {ACT_DECODING_START_END,"set1","START",7,ASN1_SUCCESS},
00147   {ACT_DECODING_START_END,"set1","END",10,ASN1_SUCCESS},
00148   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00149   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00150 
00151   /* Test: Indefinite Length */
00152   {ACT_CREATE,"TEST_TREE.IndefiniteLengthTest",0,0,ASN1_SUCCESS},
00153   {ACT_WRITE,"int1","1",0,ASN1_SUCCESS},
00154   {ACT_WRITE,"seq1.int","2",0,ASN1_SUCCESS},
00155   {ACT_WRITE,"set1","NEW",0,ASN1_SUCCESS},
00156   {ACT_WRITE,"set1.?LAST","1.2.3.4",0,ASN1_SUCCESS},
00157   {ACT_WRITE,"set1","NEW",0,ASN1_SUCCESS},
00158   {ACT_WRITE,"set1.?LAST","1.2.5.6",0,ASN1_SUCCESS},
00159   {ACT_ENCODING,"",0,255,ASN1_SUCCESS},
00160   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00161   {ACT_SET_DER,"\x30\x18\xa1\x80\x02\x01\x02\x00\x00\x31\x80\x06\x03\x2a\x03\x04\x06\x03\x2a\x05\x06\x00\x00\x02\x01\x01",
00162    0,26,ASN1_SUCCESS},
00163   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00164   {ACT_CREATE,"TEST_TREE.IndefiniteLengthTest",0,0,ASN1_SUCCESS},
00165   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
00166   {ACT_DECODING_START_END,"seq1","START",2,ASN1_SUCCESS},
00167   {ACT_DECODING_START_END,"seq1","END",8,ASN1_SUCCESS},
00168   {ACT_DECODING_START_END,"set1","START",9,ASN1_SUCCESS},
00169   {ACT_DECODING_START_END,"set1","END",22,ASN1_SUCCESS},
00170   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00171   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00172 
00173   /* Test: OID */
00174   {ACT_CREATE,"TEST_TREE.OidTest",0,0,ASN1_SUCCESS},
00175   {ACT_READ_LENGTH,"oid",NULL,9,ASN1_MEM_ERROR},
00176   {ACT_READ,"oid","2.5.29.2",9,ASN1_SUCCESS},
00177   {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
00178   {ACT_WRITE,"oid2","2.5.29.1",0,ASN1_SUCCESS},
00179   {ACT_WRITE,"oid3","1.2.29.2",0,ASN1_SUCCESS},
00180   {ACT_ENCODING_LENGTH,"",0,7,ASN1_MEM_ERROR},
00181   {ACT_ENCODING,"",0,6,ASN1_MEM_ERROR},
00182   {ACT_ENCODING,"",0,7,ASN1_SUCCESS},
00183   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00184   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00185   {ACT_CREATE,"TEST_TREE.OidTest",0,0,ASN1_SUCCESS},
00186   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
00187   {ACT_DECODING_START_END,"oid","START",2,ASN1_SUCCESS},
00188   {ACT_DECODING_START_END,"oid","END",6,ASN1_SUCCESS},
00189   {ACT_DECODING_START_END,"","START",0,ASN1_SUCCESS},
00190   {ACT_DECODING_START_END,"","END",6,ASN1_SUCCESS},
00191   {ACT_READ,"oid2","2.5.29.1",9,ASN1_SUCCESS},
00192   {ACT_READ,"oid3","1.2.29.2",9,ASN1_SUCCESS},
00193   {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
00194   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00195   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00196 
00197   /* Test: ENCODING_LENGTH and READ_LEN */
00198   {ACT_CREATE,"TEST_TREE.OidAndTimeTest",0,0,ASN1_SUCCESS},
00199   {ACT_WRITE,"oid","1.2.3.4",0,ASN1_SUCCESS},
00200   {ACT_WRITE,"time1","9801011200Z",1,ASN1_SUCCESS},
00201   {ACT_WRITE,"time2","2001010112001.12-0700",1,ASN1_SUCCESS},
00202   {ACT_WRITE,"oct","ABCD",4,ASN1_SUCCESS},
00203   {ACT_WRITE,"bol","TRUE",1,ASN1_SUCCESS},
00204   {ACT_WRITE,"enum","2",0,ASN1_SUCCESS},
00205   {ACT_WRITE,"bit","1\xC0",10,ASN1_SUCCESS},
00206   {ACT_WRITE,"any","\x30\x01\x01",3,ASN1_SUCCESS},
00207   {ACT_WRITE,"set","NEW",0,ASN1_SUCCESS},
00208   {ACT_WRITE,"set.?LAST","10",0,ASN1_SUCCESS},
00209   {ACT_WRITE,"set","NEW",0,ASN1_SUCCESS},
00210   {ACT_WRITE,"set.?LAST","1",0,ASN1_SUCCESS},
00211   {ACT_WRITE,"gen","Prova",5,ASN1_SUCCESS},
00212   {ACT_READ_LENGTH,"oid",NULL,8,ASN1_MEM_ERROR},
00213   {ACT_READ_LENGTH,"time1",NULL,12,ASN1_MEM_ERROR},
00214   {ACT_READ_LENGTH,"time2",NULL,22,ASN1_MEM_ERROR},
00215   {ACT_READ_LENGTH,"oct",NULL,4,ASN1_MEM_ERROR},
00216   {ACT_READ_LENGTH,"bol",NULL,5,ASN1_MEM_ERROR},
00217   {ACT_READ_LENGTH,"enum",NULL,1,ASN1_MEM_ERROR},
00218   {ACT_READ_LENGTH,"any",NULL,3,ASN1_MEM_ERROR},
00219   {ACT_READ_LENGTH,"gen",NULL,5,ASN1_MEM_ERROR},
00220   {ACT_READ_LENGTH,"bit",NULL,10,ASN1_MEM_ERROR},
00221   {ACT_READ_BIT,"bit","1\xC0",10,ASN1_SUCCESS},
00222   {ACT_ENCODING_LENGTH,"",0,79,ASN1_MEM_ERROR},
00223   {ACT_ENCODING,"",0,78,ASN1_MEM_ERROR},
00224   {ACT_ENCODING,"",0,79,ASN1_SUCCESS},
00225   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00226   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00227   {ACT_CREATE,"TEST_TREE.OidAndTimeTest",0,0,ASN1_SUCCESS},
00228   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
00229   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00230   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00231 
00232   /* Test: OID to STRUCTURE */
00233   {ACT_OID_2_STRUCTURE,"2.5.29.3","",0,ASN1_ELEMENT_NOT_FOUND},
00234   {ACT_OID_2_STRUCTURE,"1.2.29.2","",0,ASN1_ELEMENT_NOT_FOUND},
00235   {ACT_OID_2_STRUCTURE,"2.5.29.2","anyTest2",0,ASN1_SUCCESS},
00236 
00237   /* Test: READ TAG and CLASS */
00238   {ACT_CREATE,"TEST_TREE.SequenceTestTag",0,0,ASN1_SUCCESS},
00239   {ACT_READ_TAG_CLASS,"int","",0,ASN1_ELEMENT_NOT_FOUND},
00240   {ACT_READ_TAG_CLASS,"int1","TAG",ASN1_TAG_INTEGER,ASN1_SUCCESS},
00241   {ACT_READ_TAG_CLASS,"int1","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
00242   {ACT_READ_TAG_CLASS,"int2","TAG",3,ASN1_SUCCESS},
00243   {ACT_READ_TAG_CLASS,"int2","CLASS",ASN1_CLASS_CONTEXT_SPECIFIC,ASN1_SUCCESS},
00244   {ACT_READ_TAG_CLASS,"str1","TAG",1,ASN1_SUCCESS},
00245   {ACT_READ_TAG_CLASS,"str1","CLASS",ASN1_CLASS_CONTEXT_SPECIFIC,ASN1_SUCCESS},
00246   {ACT_READ_TAG_CLASS,"str2","TAG",28,ASN1_SUCCESS},
00247   {ACT_READ_TAG_CLASS,"str2","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
00248   {ACT_READ_TAG_CLASS,"str3","TAG",28,ASN1_SUCCESS},
00249   {ACT_READ_TAG_CLASS,"str3","CLASS",ASN1_CLASS_UNIVERSAL,ASN1_SUCCESS},
00250   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00251   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00252 
00253   /* Test: OBJECT IDENTIFIER  elements */
00254   {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
00255   {ACT_WRITE,"int1","v2",0,ASN1_SUCCESS},
00256   {ACT_READ,"int1","\x01",1,ASN1_SUCCESS},
00257   {ACT_WRITE,"int2","0",0,ASN1_SUCCESS},
00258   {ACT_WRITE,"oct","\x02\x01\x0a",3,ASN1_SUCCESS},
00259   {ACT_WRITE,"id","1 2 3 4 5",0,ASN1_VALUE_NOT_VALID},
00260   {ACT_WRITE,"id","2.5.29.2",0,ASN1_SUCCESS},
00261   {ACT_READ,"id","2.5.29.2",9,ASN1_SUCCESS},
00262   {ACT_READ_LENGTH,"id",NULL,9,ASN1_MEM_ERROR},
00263   {ACT_WRITE,"any1","\x02\x01\x05",3,ASN1_SUCCESS},
00264   {ACT_READ_DEFINITIONS,"TEST_TREE.id-anyTest","2.5.29.1",9,ASN1_SUCCESS},
00265   {ACT_ENCODING_LENGTH,"",0,20,ASN1_MEM_ERROR},
00266   {ACT_ENCODING,"",0,19,ASN1_MEM_ERROR},
00267   {ACT_ENCODING,"",0,200,ASN1_SUCCESS},
00268   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00269   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00270   {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
00271   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
00272   {ACT_DECODING_START_END,"id","START",7,ASN1_SUCCESS},
00273   {ACT_READ,"id","2.5.29.2",9,ASN1_SUCCESS},
00274   {ACT_EXPAND_ANY,"",NULL,0,ASN1_SUCCESS},
00275   {ACT_EXPAND_OCTET,"oct","id",0,ASN1_SUCCESS},
00276   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00277   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00278 
00279   /* Test: CHOICE elements */
00280   {ACT_CREATE,"TEST_TREE.X520LocalityName",0,0,ASN1_SUCCESS},
00281   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00282   {ACT_WRITE,"","teletexString",0,ASN1_SUCCESS},
00283   {ACT_WRITE,"teletexString","PROVA",5,ASN1_SUCCESS},
00284   {ACT_ENCODING_LENGTH,"",0,7,ASN1_MEM_ERROR},
00285   {ACT_ENCODING,"",0,6,ASN1_MEM_ERROR},
00286   {ACT_ENCODING,"",0,7,ASN1_SUCCESS},
00287   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00288   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00289   {ACT_CREATE,"TEST_TREE.X520LocalityName",0,0,ASN1_SUCCESS},
00290   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
00291   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00292   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00293   
00294   /* Test: OPTIONAL elements */
00295   {ACT_CREATE,"TEST_TREE.DHParameter",0,0,ASN1_SUCCESS},
00296   {ACT_WRITE,"prime","1",0,ASN1_SUCCESS},
00297   {ACT_WRITE,"base","2",0,ASN1_SUCCESS},
00298   {ACT_WRITE,"privateValueLength",NULL,0,ASN1_SUCCESS},
00299   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00300   {ACT_ENCODING_LENGTH,"",0,8,ASN1_MEM_ERROR},
00301   {ACT_ENCODING,"",0,7,ASN1_MEM_ERROR},
00302   {ACT_ENCODING,"",0,8,ASN1_SUCCESS},
00303   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00304   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00305   {ACT_CREATE,"TEST_TREE.DHParameter",0,0,ASN1_SUCCESS},
00306   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
00307   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00308   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00309   
00310   /* Test: Integer */
00311   {ACT_CREATE,"TEST_TREE.AnyTest2",0,0,ASN1_SUCCESS},
00312   {ACT_WRITE,"","int",0,ASN1_SUCCESS},
00313   {ACT_WRITE,"int","0",0,ASN1_SUCCESS},
00314   {ACT_ENCODING_LENGTH,"",0,3,ASN1_MEM_ERROR},
00315   {ACT_ENCODING,"",0,2,ASN1_MEM_ERROR},
00316   {ACT_ENCODING,"",0,3,ASN1_SUCCESS},
00317   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00318   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00319   {ACT_WRITE,"int","-1",0,ASN1_SUCCESS},
00320   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
00321   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00322   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00323   {ACT_WRITE,"int","1",0,ASN1_SUCCESS},
00324   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
00325   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00326   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00327   {ACT_WRITE,"int","2000000000",0,ASN1_SUCCESS},
00328   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
00329   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00330   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00331   {ACT_WRITE,"int","-2000000000",0,ASN1_SUCCESS},
00332   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
00333   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00334   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00335   {ACT_WRITE,"int","-20000000000",0,ASN1_SUCCESS},
00336   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
00337   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00338   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00339   {ACT_WRITE,"int","20000000000",0,ASN1_SUCCESS},
00340   {ACT_ENCODING,"",0,1024,ASN1_SUCCESS},
00341   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00342   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00343   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00344   
00345   /* Test: elements without names */
00346   {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
00347   {ACT_WRITE,"int2","10",0,ASN1_SUCCESS},
00348   {ACT_WRITE,"seq","NEW",1,ASN1_SUCCESS},
00349   {ACT_WRITE,"seq.?LAST","1",0,ASN1_SUCCESS},
00350   {ACT_WRITE,"seq","NEW",1,ASN1_SUCCESS},
00351   {ACT_WRITE,"seq.?LAST","2",0,ASN1_SUCCESS},
00352   {ACT_WRITE,"any1",NULL,0,ASN1_SUCCESS},
00353   {ACT_NUMBER_OF_ELEMENTS,"seq","",2,ASN1_SUCCESS},
00354   {ACT_WRITE,"id","1.2.3.4",0,ASN1_SUCCESS},
00355   {ACT_WRITE,"oct","\x30\x03\x02\x01\x15",5,ASN1_SUCCESS},
00356   {ACT_ENCODING,"int2",0,1024,ASN1_SUCCESS},
00357   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00358   {ACT_ENCODING,"seq.?2",0,2,ASN1_MEM_ERROR},
00359   {ACT_ENCODING,"seq.?2",0,3,ASN1_SUCCESS},
00360   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00361   {ACT_ENCODING_LENGTH,"",0,25,ASN1_MEM_ERROR},
00362   {ACT_ENCODING,"",0,24,ASN1_MEM_ERROR},
00363   {ACT_ENCODING,"",0,25,ASN1_SUCCESS},
00364   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00365   {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
00366   {ACT_DECODING_ELEMENT,"int2",0,0,ASN1_SUCCESS},
00367   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00368   {ACT_READ,"int2","\x0a",1,ASN1_SUCCESS},
00369   {ACT_READ_LENGTH,"int2",NULL,1,ASN1_MEM_ERROR},
00370   {ACT_CREATE,"TEST_TREE.Sequence1",0,0,ASN1_SUCCESS},
00371   {ACT_DECODING,0,0,0,ASN1_SUCCESS},
00372   {ACT_DECODING_START_END,"seq.?2","START",10,ASN1_SUCCESS},
00373   {ACT_EXPAND_OCTET,"oct","id",0,ASN1_SUCCESS},
00374   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00375   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00376   
00377   /* Test GeneralString */
00378   {ACT_CREATE,"TEST_TREE.Test3",0,0,ASN1_SUCCESS},
00379   {ACT_WRITE,"a","1234",0,ASN1_SUCCESS},
00380   {ACT_WRITE,"b","prova",5,ASN1_SUCCESS},
00381   {ACT_ENCODING_LENGTH,"",0,17,ASN1_MEM_ERROR},
00382   {ACT_ENCODING,"",0,16,ASN1_MEM_ERROR},
00383   {ACT_ENCODING,"",0,17,ASN1_SUCCESS},
00384   {ACT_PRINT_DER,0,0,0,ASN1_SUCCESS},
00385   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00386   {ACT_CREATE,"TEST_TREE.Test3",0,0,ASN1_SUCCESS},
00387   {ACT_DECODING,0,0,0,ASN1_SUCCESS}, 
00388   {ACT_DECODING_ELEMENT,"b",0,0,ASN1_SUCCESS},
00389   {ACT_READ,"b","prova",5,ASN1_SUCCESS},
00390   {ACT_READ_LENGTH,"b",NULL,5,ASN1_MEM_ERROR},
00391   {ACT_VISIT,"","",ASN1_PRINT_ALL,ASN1_SUCCESS},
00392   {ACT_DELETE,"","",0,ASN1_SUCCESS},
00393   
00394 
00395 
00396   /* end */
00397   {ACT_NULL}
00398 
00399 };
00400 
00401 
00402 int 
00403 main(int argc,char *argv[])
00404 {
00405   asn1_retCode result;
00406   ASN1_TYPE definitions=ASN1_TYPE_EMPTY;
00407   ASN1_TYPE asn1_element=ASN1_TYPE_EMPTY;
00408   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
00409   FILE *out;
00410   test_type *test;
00411   int errorCounter=0,testCounter=0,der_len;
00412   unsigned char value[1024],der[1024];
00413   int valueLen,tag=0,class=0;
00414   int k;
00415   int start,end;
00416   const char *str_p=NULL;
00417 
00418   printf("\n\n/****************************************/\n");
00419   printf(    "/*     Test sequence : Test_tree        */\n");
00420   printf(    "/****************************************/\n\n");
00421 
00422   /* Check version */
00423   if(asn1_check_version("0.2.6")==NULL)
00424     printf("\nLibrary version check ERROR:\n actual version: %s\n\n",asn1_check_version(NULL));
00425 
00426   if(1)
00427     result=asn1_parser2tree("Test_tree.asn",&definitions,errorDescription);
00428   else
00429     result=asn1_array2tree(Test_tree_asn1_tab,&definitions,errorDescription);
00430 
00431   if(result!=ASN1_SUCCESS){
00432     libtasn1_perror(result);
00433     printf("ErrorDescription = %s\n\n",errorDescription);
00434     exit(1);
00435   }
00436 
00437   if(1)
00438     out=stdout;
00439   else
00440     out=fopen("Test_tree.out","w");
00441 
00442   if(out==NULL){
00443     printf("Output file ERROR\n");
00444     exit(1);
00445   }
00446 
00447   if(0){
00448     asn1_print_structure(out,definitions,"TEST_TREE",ASN1_PRINT_ALL);
00449     fprintf(out,"\n");
00450   }
00451 
00452   test=test_array;
00453 
00454   while(test->action != ACT_NULL){
00455     testCounter++;
00456 
00457     switch(test->action){
00458     case ACT_CREATE:
00459       result=asn1_create_element(definitions,test->par1,&asn1_element);
00460       break;
00461     case ACT_DELETE:
00462       result=asn1_delete_structure(&asn1_element);
00463       break;
00464     case ACT_DELETE_ELEMENT:
00465       result=asn1_delete_element(asn1_element,test->par1);
00466       break;
00467     case ACT_WRITE:
00468       if((test->par2) && (!strcmp("DER",test->par2)))
00469       result=asn1_write_value(asn1_element,test->par1,der,der_len);
00470       else
00471       result=asn1_write_value(asn1_element,test->par1,test->par2,test->par3);
00472       break;
00473     case ACT_READ:
00474     case ACT_READ_BIT:
00475       valueLen=test->par3;
00476       result=asn1_read_value(asn1_element,test->par1,value,&valueLen);
00477       break;
00478     case ACT_READ_LENGTH:
00479       valueLen=0;
00480       result=asn1_read_value(asn1_element,test->par1,NULL,&valueLen);
00481       break;
00482     case ACT_READ_DEFINITIONS:
00483       valueLen=1024;
00484       result=asn1_read_value(definitions,test->par1,value,&valueLen);
00485       break;
00486     case ACT_READ_TAG_CLASS:
00487       result=asn1_read_tag(asn1_element,test->par1,&tag,&class);
00488       break;
00489     case ACT_ENCODING:
00490       der_len=test->par3;
00491       result=asn1_der_coding(asn1_element,test->par1,der,&der_len,
00492                        errorDescription);
00493       break;
00494     case ACT_ENCODING_LENGTH:
00495       der_len=0;
00496       result=asn1_der_coding(asn1_element,test->par1,NULL,&der_len,
00497                        errorDescription);
00498       break;
00499     case ACT_DECODING:
00500       result=asn1_der_decoding(&asn1_element,der,der_len,
00501                        errorDescription);
00502       break;
00503     case ACT_DECODING_ELEMENT:
00504       result=asn1_der_decoding_element(&asn1_element,test->par1,der,der_len,
00505                        errorDescription);
00506       break;
00507     case ACT_DECODING_START_END:
00508       result=asn1_der_decoding_startEnd(asn1_element,der,der_len,test->par1,
00509                               &start,&end);
00510       break;
00511     case ACT_EXPAND_ANY:
00512       result=asn1_expand_any_defined_by(definitions,&asn1_element);
00513       break;
00514     case ACT_EXPAND_OCTET:
00515       result=asn1_expand_octet_string(definitions,&asn1_element,test->par1,
00516                                       test->par2);
00517       break;
00518     case ACT_OID_2_STRUCTURE:
00519       str_p=asn1_find_structure_from_oid(definitions,test->par1);
00520       break;
00521     case ACT_VISIT:
00522       asn1_print_structure(out,asn1_element,test->par1,test->par3);
00523       fprintf(out,"\n");
00524       result=ASN1_SUCCESS;
00525       break;
00526     case ACT_PRINT_DER:
00527       printf("DER encoding len:%i\n",der_len);
00528       printf("DER encoding: ");
00529       for(k=0;k<der_len;k++)
00530       printf("%02x ",der[k]);
00531       printf("\n\n");
00532       result=ASN1_SUCCESS;
00533       break;
00534     case ACT_SET_DER:
00535       der_len=test->par3;
00536       memcpy(der,test->par1,der_len);
00537       result=ASN1_SUCCESS;
00538       break;
00539     case ACT_NUMBER_OF_ELEMENTS:
00540       result=asn1_number_of_elements(asn1_element,test->par1,&valueLen);
00541       break;
00542     default:
00543       break;
00544     }
00545 
00546 
00547     switch(test->action){
00548     case ACT_CREATE:
00549     case ACT_DELETE:
00550     case ACT_DELETE_ELEMENT:
00551     case ACT_WRITE:
00552     case ACT_VISIT:
00553     case ACT_ENCODING:
00554     case ACT_DECODING:
00555     case ACT_PRINT_DER:
00556     case ACT_EXPAND_ANY:
00557     case ACT_EXPAND_OCTET:
00558     case ACT_SET_DER:
00559       if(result != test->errorNumber){
00560       errorCounter++;
00561       printf("ERROR N. %d:\n",errorCounter);
00562       printf("  Action %d - %s - %s - %d\n",test->action,test->par1,
00563              test->par2,test->par3);
00564       printf("  Error expected: %s\n",libtasn1_strerror(test->errorNumber));
00565       printf("  Error detected: %s\n\n",libtasn1_strerror(result));
00566       }
00567       break;
00568     case ACT_DECODING_ELEMENT:
00569       if(result != test->errorNumber){
00570       errorCounter++;
00571       printf("ERROR N. %d:\n",errorCounter);
00572       printf("  Action %d - %s - %s - %d\n",test->action,test->par1,
00573              test->par2,test->par3);
00574       printf("  Error expected: %s\n",libtasn1_strerror(test->errorNumber));
00575       printf("  Error detected: %s\n",libtasn1_strerror(result));
00576       printf("  Error description : %s\n\n",errorDescription);
00577       }
00578       break;
00579     case ACT_NUMBER_OF_ELEMENTS:
00580     case ACT_READ_LENGTH:
00581       if((result != test->errorNumber) ||
00582        (valueLen != test->par3)){
00583       errorCounter++;
00584       printf("ERROR N. %d:\n",errorCounter);
00585       printf("  Action %d - %s\n",test->action,test->par1);
00586       printf("  Error expected: %s - %d\n",libtasn1_strerror(test->errorNumber),
00587                                              test->par3);
00588       printf("  Error detected: %s - %d\n\n",libtasn1_strerror(result),
00589                                           valueLen);
00590       }
00591       break;
00592     case ACT_ENCODING_LENGTH:
00593       if((result != test->errorNumber) ||
00594        (der_len != test->par3)){
00595       errorCounter++;
00596       printf("ERROR N. %d:\n",errorCounter);
00597       printf("  Action %d - %s\n",test->action,test->par1);
00598       printf("  Error expected: %s - %d\n",libtasn1_strerror(test->errorNumber),
00599                                              test->par3);
00600       printf("  Error detected: %s - %d\n\n",libtasn1_strerror(result),
00601                                           der_len);
00602       }
00603       break;
00604     case ACT_OID_2_STRUCTURE:
00605       if(((test->errorNumber!=ASN1_SUCCESS) && (str_p!=NULL)) ||
00606        ((test->errorNumber==ASN1_SUCCESS) && (str_p==NULL)) ||
00607        ((test->errorNumber==ASN1_SUCCESS) && (strcmp(str_p,test->par2)))){
00608       errorCounter++;
00609       printf("ERROR N. %d:\n",errorCounter);
00610       printf("  Action %d - %s\n",test->action,test->par1);
00611       printf("  Error expected: %s - %s\n",libtasn1_strerror(test->errorNumber),test->par2);
00612       printf("  Value detected: %s\n\n",str_p);
00613       }
00614       break;
00615     case ACT_DECODING_START_END:
00616       if((result != test->errorNumber) ||
00617        ((!strcmp(test->par2,"START")) && (start != test->par3)) ||
00618        ((!strcmp(test->par2,"END")) && (end != test->par3)) ){
00619       errorCounter++;
00620       printf("ERROR N. %d:\n",errorCounter);
00621       printf("  Action %d - %s - %d\n",test->action,test->par1,
00622                                        test->par3);
00623       printf("  Error expected: %s - %s - %d\n",libtasn1_strerror(test->errorNumber),
00624                                              test->par2,test->par3);
00625       printf("  Error detected: %s - %d - %d\n\n",libtasn1_strerror(result),
00626                                           start,end);
00627       }
00628       break;
00629 
00630     case ACT_READ_TAG_CLASS:
00631       if((result != test->errorNumber) || 
00632        ((!strcmp(test->par2,"TAG")) && (tag != test->par3)) ||      
00633        ((!strcmp(test->par2,"CLASS")) && (class != test->par3))){
00634       errorCounter++;
00635       printf("ERROR N. %d:\n",errorCounter);
00636       printf("  Action %d - %s - %d\n",test->action,test->par1,
00637                                        test->par3);
00638       printf("  Error expected: %s - %s - %d\n",libtasn1_strerror(test->errorNumber),
00639                                              test->par2,test->par3);
00640       printf("  Error detected: %s - %d - %d\n\n",libtasn1_strerror(result),
00641                                           tag,class);
00642       }
00643 
00644       break;
00645 
00646     case ACT_READ:
00647     case ACT_READ_DEFINITIONS:
00648     case ACT_READ_BIT:
00649       if(test->action==ACT_READ_BIT){
00650       if((valueLen-(valueLen/8.0))==0) tag=valueLen/8;
00651       else tag=(valueLen/8)+1;
00652       if((test->par3-(test->par3/8.0))==0) class=test->par3/8;
00653       else class=(test->par3/8)+1;
00654       }
00655 
00656       for(k=0;k<class;k++) 
00657       if(test->par2[k] != value[k]){
00658         k=-1;
00659         break;
00660       }
00661 
00662       if((result != test->errorNumber) ||
00663        (valueLen != test->par3) ||
00664        (k == -1)){
00665       errorCounter++;
00666       printf("ERROR N. %d:\n",errorCounter);
00667       printf("  Action %d - %s\n",test->action,test->par1);
00668       printf("  Error expected: %s - %d - ",libtasn1_strerror(test->errorNumber),
00669                                              test->par3);
00670       for(k=0;k<test->par3;k++)
00671         printf("%02x",test->par2[k]); 
00672       printf("\n  Error detected: %s - %d - ",libtasn1_strerror(result),
00673                                           valueLen);
00674       for(k=0;k<valueLen;k++)
00675         printf("%02x",value[k]);
00676       printf("\n\n");
00677 
00678       }
00679 
00680       break;
00681     default:
00682       break;
00683     }
00684 
00685     test++;
00686   }
00687 
00688 
00689   printf("Total tests : %d\n",testCounter);
00690   printf("Total errors: %d\n",errorCounter);
00691 
00692 
00693   /* Clear the definition structures */
00694   asn1_delete_structure(&definitions);
00695 
00696 
00697   if(out != stdout) fclose(out);
00698 
00699   exit(0);
00700 }
00701 
00702 
00703 
00704 
00705 
00706 
00707 
00708 
00709 

Generated by  Doxygen 1.5.1