javacommons/security/tsrc/src/testcertchains.cpp
changeset 80 d6dafc5d983f
parent 21 2a9601315dfc
equal deleted inserted replaced
78:71ad690e91f5 80:d6dafc5d983f
   108         js->open();
   108         js->open();
   109         js->write(MIDP_PACKAGE_TABLE, entry);
   109         js->write(MIDP_PACKAGE_TABLE, entry);
   110 
   110 
   111         certEntry = createEntry(suite1Uid.toString(),
   111         certEntry = createEntry(suite1Uid.toString(),
   112                                 L"MIDlet-Certificate-1-1",
   112                                 L"MIDlet-Certificate-1-1",
   113                                 L"abc123");
   113                                 L"YWJjMTIz");
   114 
   114 
   115         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   115         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   116 
   116 
   117         JavaStorageApplicationEntry_t foolEntry;
   117         JavaStorageApplicationEntry_t foolEntry;
   118         attr.setEntry(ID, suite1Uid.toString());
   118         attr.setEntry(ID, suite1Uid.toString());
   125         foolEntry.insert(attr);
   125         foolEntry.insert(attr);
   126 
   126 
   127         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
   127         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
   128 
   128 
   129         authMod->getCertChains(suite1Uid, chains);
   129         authMod->getCertChains(suite1Uid, chains);
       
   130         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   131         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   132         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
       
   133         
   130         CHECK(chains.size() == 1);
   134         CHECK(chains.size() == 1);
   131 
   135         string refString("YWJjMTIz");
   132         string refString("abc123");
   136         CHECK(JavaCommonUtils::base64encode(chains.front()) == refString);
   133         CHECK(chains.front() == refString);
       
   134 
       
   135         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   136         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   137         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
       
   138     }
   137     }
   139     catch (JavaStorageException& aJse)
   138     catch (JavaStorageException& aJse)
   140     {
   139     {
   141         string es = "UnExp2: " + aJse.toString();
   140         string es = "UnExp2: " + aJse.toString();
   142         FAIL(es.c_str());
   141         FAIL(es.c_str());
   156         js->open();
   155         js->open();
   157         js->write(MIDP_PACKAGE_TABLE, entry);
   156         js->write(MIDP_PACKAGE_TABLE, entry);
   158 
   157 
   159         certEntry = createEntry(suite1Uid.toString(),
   158         certEntry = createEntry(suite1Uid.toString(),
   160                                 L"MIDlet-Certificate-1-1",
   159                                 L"MIDlet-Certificate-1-1",
   161                                 L"abc123");
   160                                 L"YWJjMTIz");
   162 
   161 
   163         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   162         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   164 
   163 
   165         JavaStorageApplicationEntry_t certEntry2;
   164         JavaStorageApplicationEntry_t certEntry2;
   166         certEntry2 = createEntry(suite1Uid.toString(),
   165         certEntry2 = createEntry(suite1Uid.toString(),
   167                                  L"MIDlet-Certificate-3-1",
   166                                  L"MIDlet-Certificate-3-1",
   168                                  L"def456");
   167                                  L"ZGVmNDU2");
   169 
   168 
   170         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   169         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   171 
   170 
   172         authMod->getCertChains(suite1Uid, chains);
   171         authMod->getCertChains(suite1Uid, chains);
       
   172         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   173         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   174         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   173 
   175 
   174         CHECK(chains.size() == 2);
   176         CHECK(chains.size() == 2);
   175 
   177 
   176         list<string>::const_iterator iter = chains.begin();
   178         list<string>::const_iterator iter = chains.begin();
   177 
   179 
   178         string cert1Ref("abc123");
   180         string cert1Ref("YWJjMTIz");
   179         CHECK((*iter++) == cert1Ref);
   181         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert1Ref);
   180         string cert2Ref("def456");
   182         string cert2Ref("ZGVmNDU2");
   181         CHECK((*iter) == cert2Ref);
   183         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert2Ref);
   182 
       
   183         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   184         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   185         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
       
   186     }
   184     }
   187     catch (JavaStorageException& aJse)
   185     catch (JavaStorageException& aJse)
   188     {
   186     {
   189         string es = "UnExp3: " + aJse.toString();
   187         string es = "UnExp3: " + aJse.toString();
   190         FAIL(es.c_str());
   188         FAIL(es.c_str());
   204         js->open();
   202         js->open();
   205         js->write(MIDP_PACKAGE_TABLE, entry);
   203         js->write(MIDP_PACKAGE_TABLE, entry);
   206 
   204 
   207         certEntry = createEntry(suite1Uid.toString(),
   205         certEntry = createEntry(suite1Uid.toString(),
   208                                 L"MIDlet-Certificate-1-1",
   206                                 L"MIDlet-Certificate-1-1",
   209                                 L"abc123");
   207                                 L"YWJjMTIz");
   210 
   208 
   211         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   209         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   212 
   210 
   213         JavaStorageApplicationEntry_t certEntry2;
   211         JavaStorageApplicationEntry_t certEntry2;
   214         certEntry2 = createEntry(suite1Uid.toString(),
   212         certEntry2 = createEntry(suite1Uid.toString(),
   215                                  L"MIDlet-Certificate-3-1",
   213                                  L"MIDlet-Certificate-3-1",
   216                                  L"def456");
   214                                  L"ZGVmNDU2");
   217 
   215 
   218         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   216         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   219 
   217 
   220         JavaStorageApplicationEntry_t certEntry3;
   218         JavaStorageApplicationEntry_t certEntry3;
   221         certEntry3 = createEntry(suite1Uid.toString(),
   219         certEntry3 = createEntry(suite1Uid.toString(),
   222                                  L"MIDlet-Certificate-4-1",
   220                                  L"MIDlet-Certificate-4-1",
   223                                  L"fooBar");
   221                                  L"Zm9vQmFy");
   224 
   222 
   225         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   223         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   226 
   224 
   227         JavaStorageApplicationEntry_t certEntry4;
   225         JavaStorageApplicationEntry_t certEntry4;
   228         certEntry4 = createEntry(suite1Uid.toString(),
   226         certEntry4 = createEntry(suite1Uid.toString(),
   229                                  L"MIDlet-Certificate-5-1",
   227                                  L"MIDlet-Certificate-5-1",
   230                                  L"HelloWorld");
   228                                  L"SGVsbG9Xb3JsZA==");
   231 
   229 
   232         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry4);
   230         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry4);
   233 
   231 
   234         authMod->getCertChains(suite1Uid, chains);
   232         authMod->getCertChains(suite1Uid, chains);
   235 
       
   236         CHECK(chains.size() == 4);
       
   237 
       
   238         list<string>::const_iterator iter = chains.begin();
       
   239 
       
   240         string cert1Ref("abc123");
       
   241         CHECK((*iter++) == cert1Ref);
       
   242         string cert2Ref("def456");
       
   243         CHECK((*iter++) == cert2Ref);
       
   244         string cert3Ref("fooBar");
       
   245         CHECK((*iter++) == cert3Ref);
       
   246         string cert4Ref("HelloWorld");
       
   247         CHECK((*iter) == cert4Ref);
       
   248 
       
   249         js->remove(MIDP_PACKAGE_TABLE, entry);
   233         js->remove(MIDP_PACKAGE_TABLE, entry);
   250         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   234         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   251         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   235         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   252         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   236         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   253         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry4);
   237         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry4);
       
   238 
       
   239         CHECK(chains.size() == 4);
       
   240 
       
   241         list<string>::const_iterator iter = chains.begin();
       
   242 
       
   243         string cert1Ref("YWJjMTIz");
       
   244         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert1Ref);
       
   245         string cert2Ref("ZGVmNDU2");
       
   246         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert2Ref);
       
   247         string cert3Ref("Zm9vQmFy");
       
   248         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert3Ref);
       
   249         string cert4Ref("SGVsbG9Xb3JsZA==");
       
   250         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert4Ref);
   254     }
   251     }
   255     catch (JavaStorageException& aJse)
   252     catch (JavaStorageException& aJse)
   256     {
   253     {
   257         string es = "UnExp4: " + aJse.toString();
   254         string es = "UnExp4: " + aJse.toString();
   258         FAIL(es.c_str());
   255         FAIL(es.c_str());
   272         js->open();
   269         js->open();
   273         js->write(MIDP_PACKAGE_TABLE, entry);
   270         js->write(MIDP_PACKAGE_TABLE, entry);
   274 
   271 
   275         certEntry = createEntry(suite1Uid.toString(),
   272         certEntry = createEntry(suite1Uid.toString(),
   276                                 L"MIDlet-Certificate-1-1",
   273                                 L"MIDlet-Certificate-1-1",
   277                                 L"abc123");
   274                                 L"YWJjMTIz");
   278 
   275 
   279         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   276         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   280 
   277 
   281         JavaStorageApplicationEntry_t certEntry2;
   278         JavaStorageApplicationEntry_t certEntry2;
   282         certEntry2 = createEntry(suite1Uid.toString(),
   279         certEntry2 = createEntry(suite1Uid.toString(),
   283                                  L"MIDlet-Certificate-2-1",
   280                                  L"MIDlet-Certificate-2-1",
   284                                  L"def456");
   281                                  L"ZGVmNDU2");
   285 
   282 
   286         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   283         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   287 
   284 
   288         authMod->getCertChains(suite1Uid, chains);
   285         authMod->getCertChains(suite1Uid, chains);
       
   286         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   287         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   288         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   289 
   289 
   290         CHECK(chains.size() == 2);
   290         CHECK(chains.size() == 2);
   291 
   291 
   292         list<string>::const_iterator iter = chains.begin();
   292         list<string>::const_iterator iter = chains.begin();
   293 
   293 
   294         string cert1Ref("abc123");
   294         string cert1Ref("YWJjMTIz");
   295         CHECK((*iter++) == cert1Ref);
   295         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert1Ref);
   296         string cert2Ref("def456");
   296         string cert2Ref("ZGVmNDU2");
   297         CHECK((*iter) == cert2Ref);
   297         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert2Ref);
   298 
       
   299         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   300         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   301         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
       
   302     }
   298     }
   303     catch (JavaStorageException& aJse)
   299     catch (JavaStorageException& aJse)
   304     {
   300     {
   305         string es = "UnExp5: " + aJse.toString();
   301         string es = "UnExp5: " + aJse.toString();
   306         FAIL(es.c_str());
   302         FAIL(es.c_str());
   320         js->open();
   316         js->open();
   321         js->write(MIDP_PACKAGE_TABLE, entry);
   317         js->write(MIDP_PACKAGE_TABLE, entry);
   322 
   318 
   323         certEntry = createEntry(suite1Uid.toString(),
   319         certEntry = createEntry(suite1Uid.toString(),
   324                                 L"MIDlet-Certificate-1-1",
   320                                 L"MIDlet-Certificate-1-1",
   325                                 L"abc123");
   321                                 L"YWJjMTIz");
   326 
   322 
   327         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   323         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   328 
   324 
   329         JavaStorageApplicationEntry_t certEntry2;
   325         JavaStorageApplicationEntry_t certEntry2;
   330         certEntry2 = createEntry(suite1Uid.toString(),
   326         certEntry2 = createEntry(suite1Uid.toString(),
   331                                  L"MIDlet-Certificate-2-1",
   327                                  L"MIDlet-Certificate-2-1",
   332                                  L"def456");
   328                                  L"ZGVmNDU2");
   333 
   329 
   334         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   330         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   335 
   331 
   336         authMod->getCertChains(suite1Uid, chains);
   332         authMod->getCertChains(suite1Uid, chains);
       
   333         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   334         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   335         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   337 
   336 
   338         CHECK(chains.size() == 2);
   337         CHECK(chains.size() == 2);
   339 
   338 
   340         list<string>::const_iterator iter = chains.begin();
   339         list<string>::const_iterator iter = chains.begin();
   341 
   340 
   342         string cert1Ref("abc123");
   341         string cert1Ref("YWJjMTIz");
   343         CHECK((*iter++) == cert1Ref);
   342         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert1Ref);
   344         string cert2Ref("def456");
   343         string cert2Ref("ZGVmNDU2");
   345         CHECK((*iter) == cert2Ref);
   344         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert2Ref);
   346 
       
   347         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   348         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   349         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
       
   350     }
   345     }
   351     catch (JavaStorageException& aJse)
   346     catch (JavaStorageException& aJse)
   352     {
   347     {
   353         string es = "UnExp6: " + aJse.toString();
   348         string es = "UnExp6: " + aJse.toString();
   354         FAIL(es.c_str());
   349         FAIL(es.c_str());
   368         js->open();
   363         js->open();
   369         js->write(MIDP_PACKAGE_TABLE, entry);
   364         js->write(MIDP_PACKAGE_TABLE, entry);
   370 
   365 
   371         certEntry = createEntry(suite1Uid.toString(),
   366         certEntry = createEntry(suite1Uid.toString(),
   372                                 L"MIDlet-Certificate-1-1",
   367                                 L"MIDlet-Certificate-1-1",
   373                                 L"abc123");
   368                                 L"YWJjMTIz");
   374 
   369 
   375         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   370         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   376 
   371 
   377         JavaStorageApplicationEntry_t certEntry2;
   372         JavaStorageApplicationEntry_t certEntry2;
   378         certEntry2 = createEntry(suite1Uid.toString(),
   373         certEntry2 = createEntry(suite1Uid.toString(),
   379                                  L"MIDlet-Certificate-2-1",
   374                                  L"MIDlet-Certificate-2-1",
   380                                  L"def456");
   375                                  L"ZGVmNDU2");
   381 
   376 
   382         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   377         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   383 
   378 
   384         JavaStorageApplicationEntry_t certEntry3;
   379         JavaStorageApplicationEntry_t certEntry3;
   385         certEntry3 = createEntry(suite1Uid.toString(),
   380         certEntry3 = createEntry(suite1Uid.toString(),
   386                                  L"MIDlet-Certificate-3-1",
   381                                  L"MIDlet-Certificate-3-1",
   387                                  L"fooBar");
   382                                  L"Zm9vQmFy");
   388 
   383 
   389         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   384         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   390 
   385 
   391         authMod->getCertChains(suite1Uid, chains);
   386         authMod->getCertChains(suite1Uid, chains);
       
   387         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   388         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   389         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
       
   390         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   392 
   391 
   393         CHECK(chains.size() == 3);
   392         CHECK(chains.size() == 3);
   394 
   393 
   395         list<string>::const_iterator iter = chains.begin();
   394         list<string>::const_iterator iter = chains.begin();
   396 
   395 
   397         string cert1Ref("abc123");
   396         string cert1Ref("YWJjMTIz");
   398         CHECK((*iter++) == cert1Ref);
   397         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert1Ref);
   399         string cert2Ref("def456");
   398         string cert2Ref("ZGVmNDU2");
   400         CHECK((*iter++) == cert2Ref);
   399         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert2Ref);
   401         string cert3Ref("fooBar");
   400         string cert3Ref("Zm9vQmFy");
   402         CHECK((*iter) == cert3Ref);
   401         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert3Ref);
   403 
       
   404         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   405         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   406         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
       
   407         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
       
   408     }
   402     }
   409     catch (JavaStorageException& aJse)
   403     catch (JavaStorageException& aJse)
   410     {
   404     {
   411         string es = "UnExp7: " + aJse.toString();
   405         string es = "UnExp7: " + aJse.toString();
   412         FAIL(es.c_str());
   406         FAIL(es.c_str());
   426         js->open();
   420         js->open();
   427         js->write(MIDP_PACKAGE_TABLE, entry);
   421         js->write(MIDP_PACKAGE_TABLE, entry);
   428 
   422 
   429         certEntry = createEntry(suite1Uid.toString(),
   423         certEntry = createEntry(suite1Uid.toString(),
   430                                 L"MIDlet-Certificate-1-1",
   424                                 L"MIDlet-Certificate-1-1",
   431                                 L"abc123");
   425                                 L"YWJjMTIz");
   432 
   426 
   433         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   427         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   434 
   428 
   435         JavaStorageApplicationEntry_t certEntry2;
   429         JavaStorageApplicationEntry_t certEntry2;
   436         certEntry2 = createEntry(suite1Uid.toString(),
   430         certEntry2 = createEntry(suite1Uid.toString(),
   437                                  L"MIDlet-Certificate-2-1",
   431                                  L"MIDlet-Certificate-2-1",
   438                                  L"def456");
   432                                  L"ZGVmNDU2");
   439 
   433 
   440         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   434         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   441 
   435 
   442         authMod->getCertChains(suite1Uid, chains);
   436         authMod->getCertChains(suite1Uid, chains);
       
   437         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   438         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   439         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   443 
   440 
   444         CHECK(chains.size() == 2);
   441         CHECK(chains.size() == 2);
   445 
   442 
   446         list<string>::const_iterator iter = chains.begin();
   443         list<string>::const_iterator iter = chains.begin();
   447 
   444 
   448         string cert1Ref("abc123");
   445         string cert1Ref("YWJjMTIz");
   449         CHECK((*iter++) == cert1Ref);
   446         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert1Ref);
   450         string cert2Ref("def456");
   447         string cert2Ref("ZGVmNDU2");
   451         CHECK((*iter) == cert2Ref);
   448         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert2Ref);
   452 
       
   453         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   454         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   455         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
       
   456     }
   449     }
   457     catch (JavaStorageException& aJse)
   450     catch (JavaStorageException& aJse)
   458     {
   451     {
   459         string es = "UnExp8: " + aJse.toString();
   452         string es = "UnExp8: " + aJse.toString();
   460         FAIL(es.c_str());
   453         FAIL(es.c_str());
   474         js->open();
   467         js->open();
   475         js->write(MIDP_PACKAGE_TABLE, entry);
   468         js->write(MIDP_PACKAGE_TABLE, entry);
   476 
   469 
   477         certEntry = createEntry(suite1Uid.toString(),
   470         certEntry = createEntry(suite1Uid.toString(),
   478                                 L"MIDlet-Certificate-1-1",
   471                                 L"MIDlet-Certificate-1-1",
   479                                 L"abc123");
   472                                 L"YWJjMTIz");
   480 
   473 
   481         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   474         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   482 
   475 
   483         JavaStorageApplicationEntry_t certEntry2;
   476         JavaStorageApplicationEntry_t certEntry2;
   484         certEntry2 = createEntry(suite1Uid.toString(),
   477         certEntry2 = createEntry(suite1Uid.toString(),
   485                                  L"MIDlet-Certificate-2-1",
   478                                  L"MIDlet-Certificate-2-1",
   486                                  L"def456");
   479                                  L"ZGVmNDU2");
   487 
   480 
   488         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   481         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   489 
   482 
   490         authMod->getCertChains(suite1Uid, chains);
   483         authMod->getCertChains(suite1Uid, chains);
       
   484         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   485         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   486         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   491 
   487 
   492         CHECK(chains.size() == 2);
   488         CHECK(chains.size() == 2);
   493 
   489 
   494         list<string>::const_iterator iter = chains.begin();
   490         list<string>::const_iterator iter = chains.begin();
   495 
   491 
   496         string cert1Ref("abc123");
   492         string cert1Ref("YWJjMTIz");
   497         CHECK((*iter++) == cert1Ref);
   493         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert1Ref);
   498         string cert2Ref("def456");
   494         string cert2Ref("ZGVmNDU2");
   499         CHECK((*iter) == cert2Ref);
   495         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert2Ref);
   500 
       
   501         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   502         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   503         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
       
   504     }
   496     }
   505     catch (JavaStorageException& aJse)
   497     catch (JavaStorageException& aJse)
   506     {
   498     {
   507         string es = "UnExp9: " + aJse.toString();
   499         string es = "UnExp9: " + aJse.toString();
   508         FAIL(es.c_str());
   500         FAIL(es.c_str());
   521         js->open();
   513         js->open();
   522         js->write(MIDP_PACKAGE_TABLE, entry);
   514         js->write(MIDP_PACKAGE_TABLE, entry);
   523 
   515 
   524         certEntry = createEntry(suite1Uid.toString(),
   516         certEntry = createEntry(suite1Uid.toString(),
   525                                 L"MIDlet-Certificate-1-1",
   517                                 L"MIDlet-Certificate-1-1",
   526                                 L"abc123");
   518                                 L"YWJjMTIz");
   527 
   519 
   528         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   520         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   529 
   521 
   530         JavaStorageApplicationEntry_t certEntry2;
   522         JavaStorageApplicationEntry_t certEntry2;
   531         certEntry2 = createEntry(suite1Uid.toString(),
   523         certEntry2 = createEntry(suite1Uid.toString(),
   532                                  L"MIDlet-Certificate-1-2",
   524                                  L"MIDlet-Certificate-1-2",
   533                                  L"fib8");
   525                                  L"ZmliOA==");
   534 
   526 
   535         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   527         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   536 
   528 
   537         JavaStorageApplicationEntry_t certEntry3;
   529         JavaStorageApplicationEntry_t certEntry3;
   538         certEntry3 = createEntry(suite1Uid.toString(),
   530         certEntry3 = createEntry(suite1Uid.toString(),
   539                                  L"MIDlet-Certificate-1-3",
   531                                  L"MIDlet-Certificate-1-3",
   540                                  L"D");
   532                                  L"RA==");
   541 
   533 
   542         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   534         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   543 
   535 
   544         authMod->getCertChains(suite1Uid, chains);
   536         authMod->getCertChains(suite1Uid, chains);
       
   537         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   538         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   539         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
       
   540         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
       
   541 
   545         CHECK(chains.size() == 1);
   542         CHECK(chains.size() == 1);
   546 
   543         string refString("YWJjMTIzZmliOEQ=");
   547         string refString("abc123fib8D");
   544         CHECK(JavaCommonUtils::base64encode(chains.front()) == refString);
   548         CHECK(chains.front() == refString);
       
   549 
       
   550         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   551         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   552         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
       
   553         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
       
   554     }
   545     }
   555     catch (JavaStorageException& aJse)
   546     catch (JavaStorageException& aJse)
   556     {
   547     {
   557         string es = "UnExp10: " + aJse.toString();
   548         string es = "UnExp10: " + aJse.toString();
   558         FAIL(es.c_str());
   549         FAIL(es.c_str());
   571         js->open();
   562         js->open();
   572         js->write(MIDP_PACKAGE_TABLE, entry);
   563         js->write(MIDP_PACKAGE_TABLE, entry);
   573 
   564 
   574         certEntry = createEntry(suite1Uid.toString(),
   565         certEntry = createEntry(suite1Uid.toString(),
   575                                 L"MIDlet-Certificate-1-1",
   566                                 L"MIDlet-Certificate-1-1",
   576                                 L"See");
   567                                 L"U2Vl");
   577 
   568 
   578         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   569         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   579 
   570 
   580         JavaStorageApplicationEntry_t certEntry2;
   571         JavaStorageApplicationEntry_t certEntry2;
   581         certEntry2 = createEntry(suite1Uid.toString(),
   572         certEntry2 = createEntry(suite1Uid.toString(),
   582                                  L"MIDlet-Certificate-1-2",
   573                                  L"MIDlet-Certificate-1-2",
   583                                  L"No");
   574                                  L"Tm8=");
   584 
   575 
   585         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   576         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   586 
   577 
   587         JavaStorageApplicationEntry_t certEntry3;
   578         JavaStorageApplicationEntry_t certEntry3;
   588         certEntry3 = createEntry(suite1Uid.toString(),
   579         certEntry3 = createEntry(suite1Uid.toString(),
   589                                  L"MIDlet-Certificate-1-3",
   580                                  L"MIDlet-Certificate-1-3",
   590                                  L"More");
   581                                  L"TW9yZQ==");
   591 
   582 
   592         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   583         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   593 
   584 
   594         JavaStorageApplicationEntry_t certEntry4;
   585         JavaStorageApplicationEntry_t certEntry4;
   595 
   586 
   612                                  L"My");
   603                                  L"My");
   613 
   604 
   614         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry6);
   605         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry6);
   615 
   606 
   616         authMod->getCertChains(suite1Uid, chains);
   607         authMod->getCertChains(suite1Uid, chains);
   617 
       
   618         CHECK(chains.size() == 2);
       
   619 
       
   620         list<string>::const_iterator iter = chains.begin();
       
   621 
       
   622         string cert1Ref("SeeNoMore");
       
   623         CHECK((*iter++) == cert1Ref);
       
   624         string cert2Ref("MeAndMy");
       
   625         CHECK((*iter) == cert2Ref);
       
   626 
       
   627         js->remove(MIDP_PACKAGE_TABLE, entry);
   608         js->remove(MIDP_PACKAGE_TABLE, entry);
   628         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   609         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   629         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   610         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry2);
   630         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   611         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry3);
   631         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry4);
   612         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry4);
   632         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry5);
   613         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry5);
   633         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry6);
   614         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry6);
       
   615 
       
   616         CHECK(chains.size() == 1);
       
   617 
       
   618         list<string>::const_iterator iter = chains.begin();
       
   619 
       
   620         string cert1Ref("U2VlTm9Nb3Jl");
       
   621         CHECK(JavaCommonUtils::base64encode((*iter++)) == cert1Ref);
   634     }
   622     }
   635     catch (JavaStorageException& aJse)
   623     catch (JavaStorageException& aJse)
   636     {
   624     {
   637         string es = "UnExp11: " + aJse.toString();
   625         string es = "UnExp11: " + aJse.toString();
   638         FAIL(es.c_str());
   626         FAIL(es.c_str());
   651         js->open();
   639         js->open();
   652         js->write(MIDP_PACKAGE_TABLE, entry);
   640         js->write(MIDP_PACKAGE_TABLE, entry);
   653 
   641 
   654         certEntry = createEntry(suite1Uid.toString(),
   642         certEntry = createEntry(suite1Uid.toString(),
   655                                 L"MIDlet-Certificate-1-1",
   643                                 L"MIDlet-Certificate-1-1",
   656                                 L"abc123");
   644                                 L"YWJjMTIz");
   657 
   645 
   658         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   646         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   659 
   647 
   660         JavaStorageApplicationEntry_t foolEntry;
   648         JavaStorageApplicationEntry_t foolEntry;
   661         attr.setEntry(ID, suite1Uid.toString());
   649         attr.setEntry(ID, suite1Uid.toString());
   668         foolEntry.insert(attr);
   656         foolEntry.insert(attr);
   669 
   657 
   670         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
   658         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
   671 
   659 
   672         authMod->getCertChains(suite1Uid, chains);
   660         authMod->getCertChains(suite1Uid, chains);
       
   661         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   662         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   663         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
       
   664 
   673         CHECK(chains.size() == 1);
   665         CHECK(chains.size() == 1);
   674 
   666 
   675         string refString("abc123");
   667         string refString("YWJjMTIz");
   676         CHECK(chains.front() == refString);
   668         CHECK(JavaCommonUtils::base64encode(chains.front()) == refString);
   677 
       
   678         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   679         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   680         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
       
   681     }
   669     }
   682     catch (JavaStorageException& aJse)
   670     catch (JavaStorageException& aJse)
   683     {
   671     {
   684         string es = "UnExp2: " + aJse.toString();
   672         string es = "UnExp2: " + aJse.toString();
   685         FAIL(es.c_str());
   673         FAIL(es.c_str());
   696         js->open();
   684         js->open();
   697         js->write(MIDP_PACKAGE_TABLE, entry);
   685         js->write(MIDP_PACKAGE_TABLE, entry);
   698 
   686 
   699         certEntry = createEntry(suite1Uid.toString(),
   687         certEntry = createEntry(suite1Uid.toString(),
   700                                 L"MIDlet-Certificate-1-1",
   688                                 L"MIDlet-Certificate-1-1",
   701                                 L"abc123");
   689                                 L"YWJjMTIz");
   702 
   690 
   703         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   691         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
   704 
   692 
   705         JavaStorageApplicationEntry_t foolEntry;
   693         JavaStorageApplicationEntry_t foolEntry;
   706         attr.setEntry(ID, suite1Uid.toString());
   694         attr.setEntry(ID, suite1Uid.toString());
   713         foolEntry.insert(attr);
   701         foolEntry.insert(attr);
   714 
   702 
   715         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
   703         js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
   716 
   704 
   717         authMod->getCertChains(suite1Uid, chains);
   705         authMod->getCertChains(suite1Uid, chains);
       
   706         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   707         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   708         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
       
   709 
   718         CHECK(chains.size() == 1);
   710         CHECK(chains.size() == 1);
   719 
   711 
   720         string refString("abc123");
   712         string refString("YWJjMTIz");
   721         CHECK(chains.front() == refString);
   713         CHECK(JavaCommonUtils::base64encode(chains.front()) == refString);
   722 
       
   723         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   724         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, certEntry);
       
   725         js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, foolEntry);
       
   726     }
   714     }
   727     catch (JavaStorageException& aJse)
   715     catch (JavaStorageException& aJse)
   728     {
   716     {
   729         string es = "UnExp13: " + aJse.toString();
   717         string es = "UnExp13: " + aJse.toString();
   730         FAIL(es.c_str());
   718         FAIL(es.c_str());
   742 
   730 
   743         js->open();
   731         js->open();
   744         js->write(MIDP_PACKAGE_TABLE, entry);
   732         js->write(MIDP_PACKAGE_TABLE, entry);
   745 
   733 
   746         authMod->getCertChains(suite1Uid, chains);
   734         authMod->getCertChains(suite1Uid, chains);
       
   735         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   736 
   747         CHECK(chains.size() == 0);
   737         CHECK(chains.size() == 0);
   748 
       
   749         js->remove(MIDP_PACKAGE_TABLE, entry);
       
   750     }
   738     }
   751     catch (JavaStorageException& aJse)
   739     catch (JavaStorageException& aJse)
   752     {
   740     {
   753         string es = "UnExp14: " + aJse.toString();
   741         string es = "UnExp14: " + aJse.toString();
   754         FAIL(es.c_str());
   742         FAIL(es.c_str());