Hi, Please find attached a new patch implementing UUID test cases. In addition, the API and implementation of pdf_uuid_generate have been changed, improving parameter filtering.
Cheers, Albert 2011/4/22 Jose E. Marchesi <[email protected]>: > > Hi Albert. > > +/* > + * Test: pdf_uuid_generate_002 > + * Description: > + * Generate a UUID of a non supported type. > + * Success conditions: > + * Generated UUID should be ok. > + */ > +START_TEST (pdf_uuid_generate_002) > +{ > + > + pdf_uuid_t uuid_unknown; > + > + /* Create a UUID from an unkown type */ > + uuid_unknown = pdf_uuid_generate (1111111222222222333333333); > + fail_if(uuid_unknown.uuid == NULL); > + > +} > +END_TEST > > What kind of UUID is the library generating in that case? It is not > documented in the reference manual. I would expect the call to return > an error. > > +/* > + * Test: pdf_uuid_string_003 > + * Description: > + * Generate an UUID ascii representation, buffer size less than > + * required. > + * **FAIL** conditions: The buffer to store the UUID string is too > + * short. The ascii generation should fail. > + */ > > I don't think that build-aux/generate-tsd.pl.in will be happy with that > **FAIL** conditions entry. > > -- > Jose E. Marchesi [email protected] > GNU Project http://www.gnu.org >
# Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: [email protected]\ # e16jdoext3vk18ot # target_branch: bzr://bzr.sv.gnu.org/pdf/libgnupdf/trunk/ # testament_sha1: 7b63be3b05291863d8118539d4dcadcd87009f8e # timestamp: 2011-05-17 13:11:13 +0200 # base_revision_id: [email protected] # # Begin patch === modified file 'ChangeLog' --- ChangeLog 2011-05-10 18:40:38 +0000 +++ ChangeLog 2011-05-17 11:09:51 +0000 @@ -1,3 +1,14 @@ +2011-05-17 Albert Meroño Peñuela <[email protected]> + torture: Unit tests for the UUID module. + * torture/unit/Makefile.am + * torture/unit/base/types/tsuite-types.c + * torture/unit/base/types/pdf-types-uuid-generate.c + * torture/unit/base/types/pdf-types-uuid-string.c + * torture/unit/base/types/pdf-types-uuid-equal-p.c + + base/types: Fix UUID generation API. + * src/base/pdf-types-uuid.[h|c] + 2011-05-10 Jose E. Marchesi <[email protected]> lib: avoid name clash with PDF_OBJ_IS_NULL and provide a quick === modified file 'src/base/pdf-types-uuid.c' --- src/base/pdf-types-uuid.c 2011-03-24 17:58:36 +0000 +++ src/base/pdf-types-uuid.c 2011-05-17 11:09:51 +0000 @@ -27,24 +27,26 @@ #include <pdf-types-uuid.h> -pdf_uuid_t -pdf_uuid_generate (enum pdf_uuid_type_e type) +void +pdf_uuid_generate (pdf_uuid_t * uuid, enum pdf_uuid_type_e type) { - pdf_uuid_t new_uuid; - + + /* Do nothing if requested type is invalid */ + PDF_ASSERT_RETURN (type == PDF_UUID_TIME || type == PDF_UUID_RANDOM); + + /* Generate the requested UUID through uuid.h API */ switch (type) { case PDF_UUID_TIME: - uuid_generate_time (new_uuid.uuid); + uuid_generate_time (uuid->uuid); break; case PDF_UUID_RANDOM: - uuid_generate_random (new_uuid.uuid); + uuid_generate_random (uuid->uuid); break; default: - uuid_generate (new_uuid.uuid); + uuid_clear(uuid->uuid); } - return new_uuid; } pdf_char_t * === modified file 'src/base/pdf-types-uuid.h' --- src/base/pdf-types-uuid.h 2011-03-24 17:58:36 +0000 +++ src/base/pdf-types-uuid.h 2011-05-17 11:09:51 +0000 @@ -35,6 +35,7 @@ /* END PUBLIC */ #include <pdf-types.h> +#include <pdf-error.h> #define PDF_UUID_SIZE 46 @@ -58,7 +59,7 @@ typedef struct pdf_uuid_s pdf_uuid_t; /* UUID creation */ -pdf_uuid_t pdf_uuid_generate (enum pdf_uuid_type_e type); +void pdf_uuid_generate (pdf_uuid_t * uuid, enum pdf_uuid_type_e type); /* Printed ASCII representation of an UUID */ pdf_char_t * pdf_uuid_string (pdf_uuid_t uuid, === modified file 'torture/unit/Makefile.am' --- torture/unit/Makefile.am 2011-03-29 21:12:24 +0000 +++ torture/unit/Makefile.am 2011-05-17 11:09:51 +0000 @@ -163,7 +163,9 @@ # Unit tests for the Types Module test suite -TEST_SUITE_TYPES = +TEST_SUITE_TYPES = base/types/pdf-types-uuid-generate.c \ + base/types/pdf-types-uuid-string.c \ + base/types/pdf-types-uuid-equal-p.c TEST_SUITE_TIME = base/time/pdf-time-test-common.h \ base/time/pdf-time-testdata.c \ === added file 'torture/unit/base/types/pdf-types-uuid-equal-p.c' --- torture/unit/base/types/pdf-types-uuid-equal-p.c 1970-01-01 00:00:00 +0000 +++ torture/unit/base/types/pdf-types-uuid-equal-p.c 2011-05-17 11:09:51 +0000 @@ -0,0 +1,91 @@ +/* -*- mode: C -*- + * + * File: pdf-types-uuid-equal-p.c + * Date: Tue May 17 11:49:23 2011 + * + * GNU PDF Library - Unit tests for pdf_uuid_equal_p + * + */ + +/* Copyright (C) 2011 Free Software Foundation, Inc. */ + +/* This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <config.h> + +#include <check.h> +#include <pdf.h> +#include <pdf-test-common.h> +/* + * Test: pdf_uuid_equal_p_001 + * Description: + * Checks if two time-based UUIDs are equal. + * Success condition: + * Both time-based UUIDs are different. + */ +START_TEST (pdf_uuid_equal_p_001) +{ + + pdf_uuid_t uuid1; + pdf_uuid_t uuid2; + + /* Generate two time-based UUIDs */ + pdf_uuid_generate (&uuid1, PDF_UUID_TIME); + pdf_uuid_generate (&uuid2, PDF_UUID_TIME); + + fail_if(pdf_uuid_equal_p (uuid1, uuid2) == PDF_TRUE); + +} +END_TEST + +/* + * Test: pdf_uuid_equal_p_002 + * Description: + * Checks if two random-based UUIDs are equal. + * Success condition: + * Both random-based UUIDs are different. + */ +START_TEST (pdf_uuid_equal_p_002) +{ + + pdf_uuid_t uuid1; + pdf_uuid_t uuid2; + + /* Generate two time-based UUIDs */ + pdf_uuid_generate (&uuid1, PDF_UUID_RANDOM); + pdf_uuid_generate (&uuid2, PDF_UUID_RANDOM); + + fail_if(pdf_uuid_equal_p (uuid1, uuid2) == PDF_TRUE); + +} +END_TEST + +/* + * Test case creation function + */ +TCase * +test_pdf_uuid_equal_p (void) +{ + TCase *tc = tcase_create ("pdf_uuid_equal_p"); + + tcase_add_test(tc, pdf_uuid_equal_p_001); + tcase_add_test(tc, pdf_uuid_equal_p_002); + + tcase_add_checked_fixture (tc, + pdf_test_setup, + pdf_test_teardown); + + return tc; +} === added file 'torture/unit/base/types/pdf-types-uuid-generate.c' --- torture/unit/base/types/pdf-types-uuid-generate.c 1970-01-01 00:00:00 +0000 +++ torture/unit/base/types/pdf-types-uuid-generate.c 2011-05-17 11:09:51 +0000 @@ -0,0 +1,68 @@ +/* -*- mode: C -*- + * + * File: pdf-types-uuid-generate.c + * Date: Wed Apr 20 10:31:51 2011 + * + * GNU PDF Library - Unit tests for pdf_uuid_generate + * + */ + +/* Copyright (C) 2011 Free Software Foundation, Inc. */ + +/* This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <config.h> + +#include <check.h> +#include <pdf.h> +#include <pdf-test-common.h> +/* + * Test: pdf_uuid_generate_001 + * Description: + * Generate some UUIDs of supported types. + * Success condition: + * Generated UUIDs should be ok. + */ +START_TEST (pdf_uuid_generate_001) +{ + + pdf_uuid_t uuid_time; + pdf_uuid_t uuid_random; + + /* Create a time-based UUID */ + pdf_uuid_generate (&uuid_time, PDF_UUID_TIME); + + /* Create a random-based UUID */ + pdf_uuid_generate (&uuid_random, PDF_UUID_RANDOM); + +} +END_TEST + +/* + * Test case creation function + */ +TCase * +test_pdf_uuid_generate (void) +{ + TCase *tc = tcase_create ("pdf_uuid_generate"); + + tcase_add_test(tc, pdf_uuid_generate_001); + + tcase_add_checked_fixture (tc, + pdf_test_setup, + pdf_test_teardown); + + return tc; +} === added file 'torture/unit/base/types/pdf-types-uuid-string.c' --- torture/unit/base/types/pdf-types-uuid-string.c 1970-01-01 00:00:00 +0000 +++ torture/unit/base/types/pdf-types-uuid-string.c 2011-05-17 11:09:51 +0000 @@ -0,0 +1,294 @@ +/* -*- mode: C -*- + * + * File: pdf-types-uuid-string.c + * Date: Thu Apr 21 08:50:40 2011 + * + * GNU PDF Library - Unit tests for pdf_uuid_string + * + */ + +/* Copyright (C) 2011 Free Software Foundation, Inc. */ + +/* This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include <config.h> + +#include <check.h> +#include <string.h> +#include <pdf.h> +#include <pdf-test-common.h> +/* + * Test: pdf_uuid_string_001 + * Description: + * Generate an UUID ascii representation in heap. + * Success condition: + * Generated UUID ascii should be ok. + */ +START_TEST (pdf_uuid_string_001) +{ + + pdf_uuid_t uuid; + pdf_char_t *buf; + pdf_char_t *ret_buf; + pdf_size_t buf_size; + + /* Crate a dynamically allocated buffer */ + buf_size = 46; + + buf = pdf_alloc (buf_size); + fail_if(buf == NULL); + + /* Generate a new UUID */ + pdf_uuid_generate (&uuid, PDF_UUID_RANDOM); + + /* Get ascii representation of uuid */ + ret_buf = pdf_uuid_string (uuid, buf, buf_size); + fail_if(ret_buf == NULL); + + /* Free resources */ + pdf_dealloc (buf); + +} +END_TEST + +/* + * Test: pdf_uuid_string_002 + * Description: + * Generate an UUID ascii representation in stack. + * Success condition: + * Generated UUID ascii should be ok. + */ +START_TEST (pdf_uuid_string_002) +{ + + pdf_uuid_t uuid; + pdf_char_t *ret_buf; + pdf_size_t buf_size; + + /* Crate a statically allocated buffer */ + buf_size = 46; + + pdf_char_t buf[buf_size]; + + /* Generate a new UUID */ + pdf_uuid_generate (&uuid, PDF_UUID_RANDOM); + + /* Get ascii representation of uuid */ + ret_buf = pdf_uuid_string (uuid, buf, buf_size); + fail_if(ret_buf == NULL); + +} +END_TEST + +/* + * Test: pdf_uuid_string_003 + * Description: + * Generate an UUID ascii representation, buffer size less than + * required. + * Success conditions: The buffer to store the UUID string is too + * short. The ascii generation should fail. + */ +START_TEST (pdf_uuid_string_003) +{ + + pdf_uuid_t uuid; + pdf_char_t *buf; + pdf_char_t *ret_buf; + pdf_size_t buf_size; + + /* Crate the buffer */ + buf_size = 11; + + buf = pdf_alloc (buf_size); + fail_if(buf == NULL); + + /* Generate a new UUID */ + pdf_uuid_generate (&uuid, PDF_UUID_RANDOM); + + /* Get ascii representation of uuid */ + ret_buf = pdf_uuid_string (uuid, buf, buf_size); + fail_if(ret_buf == NULL); + + /* Free resources */ + pdf_dealloc (buf); + +} +END_TEST + +/* + * Test: pdf_uuid_string_004 + * Description: + * Generate an UUID ascii representation, buffer size more than + * required. + * Success conditions: The buffer to store the UUID string is long + * enough. The conversion should pass. + */ +START_TEST (pdf_uuid_string_004) +{ + + pdf_uuid_t uuid; + pdf_char_t *buf; + pdf_char_t *ret_buf; + pdf_size_t buf_size; + + /* Crate the buffer */ + buf_size = 1001; + + buf = pdf_alloc (buf_size); + fail_if(buf == NULL); + + /* Generate a new UUID */ + pdf_uuid_generate (&uuid, PDF_UUID_RANDOM); + + /* Get ascii representation of uuid */ + ret_buf = pdf_uuid_string (uuid, buf, buf_size); + fail_if(ret_buf == NULL); + + /* Free resources */ + pdf_dealloc (buf); + +} +END_TEST + +/* + * Test: pdf_uuid_string_005 + * Description: + * Generate an UUID ascii representation, buffer has just the + * required size. + * Success conditions: The buffer to store the UUID string is long + * enough. The conversion should pass. + */ +START_TEST (pdf_uuid_string_005) +{ + + pdf_uuid_t uuid; + pdf_char_t *buf; + pdf_char_t *ret_buf; + pdf_size_t buf_size; + + /* Crate the buffer */ + buf_size = 46; + + buf = pdf_alloc (buf_size); + fail_if(buf == NULL); + + /* Generate a new UUID */ + pdf_uuid_generate (&uuid, PDF_UUID_RANDOM); + + /* Get ascii representation of uuid */ + ret_buf = pdf_uuid_string (uuid, buf, buf_size); + fail_if(ret_buf == NULL); + + /* Free resources */ + //pdf_dealloc (buf); + +} +END_TEST + + +/* + * Test: pdf_uuid_string_006 + * Description: + * Cheks for appropriate structure of UUID ascii. + * Success conditions: The ascii structure is + * 00000000-0000-0000-0000-000000000000, where 0s match + * hexadecimal digits. + */ +START_TEST (pdf_uuid_string_006) +{ + + pdf_uuid_t uuid; + pdf_char_t *buf; + pdf_char_t *ret_buf; + pdf_size_t buf_size; + pdf_char_t *hex_digits = "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x41\x42\x43\x44\x45\x46\x61\x62\x63\x64\x65\x66"; + pdf_char_t *oc; + pdf_size_t chunk_size; + + /* Crate the buffer */ + buf_size = 46; + + buf = pdf_alloc (buf_size); + fail_if(buf == NULL); + + /* Generate a new UUID */ + pdf_uuid_generate (&uuid, PDF_UUID_RANDOM); + + /* Get ascii representation of uuid */ + ret_buf = pdf_uuid_string (uuid, buf, buf_size); + fail_if(ret_buf == NULL); + + /* Check if characters are valid hex digits */ + /* Check if hex chunks have correct size */ + /* Check if scores are in correct positions */ + + chunk_size = strspn(buf, hex_digits); + fail_if(chunk_size != 8); + + oc = strchr(buf, '-'); + fail_if(oc == NULL); + fail_if(oc-buf != 8); + + chunk_size = strspn(oc+1, hex_digits); + fail_if(chunk_size != 4); + + oc = strchr(oc+1, '-'); + fail_if(oc == NULL); + fail_if(oc-buf != 13); + + chunk_size = strspn(oc+1, hex_digits); + fail_if(chunk_size != 4); + + oc = strchr(oc+1, '-'); + fail_if(oc == NULL); + fail_if(oc-buf != 18); + + chunk_size = strspn(oc+1, hex_digits); + fail_if(chunk_size != 4); + + oc = strchr(oc+1, '-'); + fail_if(oc == NULL); + fail_if(oc-buf != 23); + + chunk_size = strspn(oc+1, hex_digits); + fail_if(chunk_size != 12); + + /* Free resources */ + pdf_dealloc (buf); + +} +END_TEST + +/* + * Test case creation function + */ +TCase * +test_pdf_uuid_string (void) +{ + TCase *tc = tcase_create ("pdf_uuid_string"); + + tcase_add_test(tc, pdf_uuid_string_001); + tcase_add_test(tc, pdf_uuid_string_002); + tcase_add_test(tc, pdf_uuid_string_003); + tcase_add_test(tc, pdf_uuid_string_004); + tcase_add_test(tc, pdf_uuid_string_005); + tcase_add_test(tc, pdf_uuid_string_006); + + tcase_add_checked_fixture (tc, + pdf_test_setup, + pdf_test_teardown); + + return tc; +} === modified file 'torture/unit/base/types/tsuite-types.c' --- torture/unit/base/types/tsuite-types.c 2011-02-24 22:52:23 +0000 +++ torture/unit/base/types/tsuite-types.c 2011-05-17 11:09:51 +0000 @@ -27,6 +27,10 @@ #include <check.h> #include <pdf-test-common.h> +extern TCase *test_pdf_uuid_generate (void); +extern TCase *test_pdf_uuid_string (void); +extern TCase *test_pdf_uuid_equal_p (void); + Suite * tsuite_types () { @@ -34,6 +38,10 @@ s = suite_create("types"); + suite_add_tcase (s, test_pdf_uuid_generate ()); + suite_add_tcase (s, test_pdf_uuid_string ()); + suite_add_tcase (s, test_pdf_uuid_equal_p ()); + return s; } # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWQsnixYADJT/jF7wACB5//// f+ferr////4gAAgAYBT+pXyHvYcGXncmx3IyigKCjA0i61KrZWKkVIaDVRUqgSUOzAoOmEkUyT1J gU09MmUyemp4FPBT1PU2p6gaA9QNA0AABJICMgamIQQgPSaABoAaaAAGgDQDMp+kymQANABoPUAA AAAAAAADgaDTIaaNDCBkNDBGhpk0aAZBiAANBEogQEMJqeSnhGTTalPTJP0mkbJ6jUzU9R6m1NA0 ZP1TQEUQgEmJoyDTUZT000qbwp6amSbT1NQ2iMIwQGjym8DkBkWYzHAO48B9r8bN9fZ7d6nVFA70 IhcrynAk4v4r+MaE9J+SahM9FMM3R9ZNlyE3XdzPUi+feQyy58o5rCIsNDQ3QqNKBcIQgwIjKhRY BCFChBkoMaeaUCQieZwdo/35/baWkVPUMMIge6f5Fv6K1U4btyxCDUV8FvoK4gmXC942NjEM7sHD mWjJCJTky1GrltsjWlmeTn1lMPShxBrUAyhXTjlGWPIlm8w9FoxpHlWb7b667FLT/LLc537QdTf3 QsKP/XIkRowqw4IUHsqNVaRaIBZwQXS1jGkAIQRkRGMQkV3cjGT6fkCivi8NPG5HpE0daFoHvvGm /E0rSUzKxgCmMg8D7tRbNvjGge0YQqN4OCNw9b7XQ8aAfsA1J4gkJCJIiEgiiXIQlg1xgdqgiN8Q SoFHEZgiYxyAocEooiHYJlKJagnZQgNNypV0mmrle+5sYBN8JzhdGLDQe+6ZGPiLIDdB+PUpxhVI 0UgaCp8XqfPq2835UN7zNGIm5ztmQdDG1IMfwQg3jGMGO9/i8SFzazoNivvcTiq4kJHS9p/pC1xD jQo6WgO/hCFB/2OstSG3vxJVZPocX+HS43UXN4nkLGUs9z2chqHtLDCTHDdk9DKcBvkZGRvCxRlz aPc2d16Tu0QwPS9MoV0s20cCC4wc6iNALoYT/znlzdnhz1xba50TPNzPhGBRujAlpT4jFzDudbbW 1l63mdhDX3Ac47Xu2hk3ZSw+btGrk7ntZ0A3HWmaDXjfETQG1a1sNKRERDMzNEFua4grebbJZrmk O1onIZBogfgn0kT6kxhoWqHKOeS4BxTIrPFZ3JwKKgs1ijQAfshpDqcUNZRchiXa6tespFXLFMcC Pv20I0ZYCiUYFUYRGiKgoQVtbFZUy99hBtz6eJZdTdlmmd4U+liRd06pMwUqwHBagR1Vm2T1Lwlr 3nVhkI50wL1C0B3hYC50icvVRKpIFWoUGqkGCuQMggwFceVi3Po0jHtrvp5ktFD0/F22kwH5pYZM 0XuyVFjjf3lgtNqNVsWHQR2I+4Ig8Uo6FSunBpzGofqBgqRAiEGMVijGA/VGJDaMAQ8QnM9rldWx xjn6bdNaWDcNw0KhNFUUHGrSierKqqZWwcXo3KfCsPJUdnr6wt3JoRdnkONNywcCLHeKj0PJjDwR gPOJ1sKByXlFZAw1wYKwIkHNg0hl0BiezIJiChZJcBaAwfFDBRVDr9p/frNvCtCSumparzFsp6np b4XB0UdmUiSaxNawVJKmIDiA/mbBV9u92FI3N4D2IfmA9KI+dXpYxFjO1gHC34cugDisTMzhbxt3 2JWVRq607cgnPHpiB07aXCb2k/NCsKwQ+owFuQhFNhZKL4pNT1FfIgoVXQLitIJMBlyoNQvGBHUW MSSUvNRQoZNShRMyBvGmrI6wqiQZaqaSEEJLSx6nPgRLgwMTtChAMne4duAvHsrZaPTPVyvTtnuF twdKDavgPZs4g+8DCdBfkukYGJwBGG+EDeISBSAQrAJPrL3v9mbbriQ5yBQoIzkOTRuvd0DbCwoM JtnRgc7QfCduZmfoasPEMuzLpsX51LHA6iIQBHN3QXCFljQVxPpLvA0nXnILzszBHGN6cpaGoEcp ZECJM6eXjsqlkUenlxc4kwKDzhfcjwkfKgoVDi1xO3a4F1Xo3503ZGFDqZ6OskO1GkJr22KEyNcB xmcMsQhcJ2dTlGKRMdPZxgw4zOA8xHHQdJzP7DXO8rJbmrRjqOHmL1lk+cZWc5jsHzr4aBvkSOca K1Rc5DtZXGZgYUWBYnB5vEhUaMjUhCcQdkUL5ETcWQTrMc07UMsMzG8kOJjvBU7on4Fnh3QRpLRz mv0Y4loxTZb7BskXcpjXExZtxdxc7qrcpV4Er2eVvxLgjmONGkXEPJDI4lbF0jOxBckEK8eYxEY3 S14G0c4unHRwmtmxA6ayK4glRJYEbwgNrHUVoQHnXKQTDVyT2C2ebpXnLO8yOBmci4vMyhkbBdGU c5PWTOHEjAV5QwLSNSPGDXEeD6Gmz62iYTDXlYuoazi0O4baQkWK8HCHhZlkWUwRscpKkCbxiDTN BiUhmEJ53ImsNxw55qVduRIgwxRb8nnDUkYlh5fE4FQ1cI1WJGtxmZFxJUwORXXWTZSTImu6I7As JZeYgaEkXpTm/QyNScB4waKvNPqcNtsCWE8qOtpYXUGC6eBx4lRgoCO0DwhTccmbR+6gceRyhGeR qOSp0sCMy8kFw4YrqUv2JDi8uJlS95DqDvCWCHMk40I9LdkycdXj1Sjmuq1ZLY67pfwJRCllRJdK oXqXXz6HIM9EE/lLiDkMZQSkRJEHSl/NqrBOe0vLqCVfteQDxgRkU/ssCH1qFAHDZiWhIQybQJWM JVIkg2qHl7Xg9FIwSLXsekB3loXv2PuE/JjVPse9725D1W+iGwNEgkT4PrsT7nK9zjQ12oFVTQE/ 1EkSEID+bUSQP1v7yP9nXnrQq1yycqhdnp8XKMQMzRRjEA+DY4EcyKetoFNb/N2OAxWx0MVqro7x LAq8+ujxbBNCGpkf/QbKy7hLuZ2una3qnrwL2gtmjxEq6OlNsQ2GsIVJ6m9iWsCHYhF+IhYQwb+t ohe2G4QncGbQJeeTKjg0thCGCD+JaDUyIpbtbFc/E53EqYxYDywcl7etVm8rlflx9jvbNuvb29sp SlKUYxjHlwedu6O47jDMyFfwCauiUQiECpWC3K60+cQgvpCrRPYMlAEr9UFAIT5iMqQjKE1Pn8qq fcmIxIrIUAgFqr6hb1orYxCwa0MIUAEk7kd5vMhDtOkpgdZPZxMLjiOn39xrOJU48+7YfQr1YYGo 4XqagzUcn6j7SyEfYodvkfI6kIBTvIfce7iTSnObSOQ7M4xjmQ7ji8JemDdL0kjVho5x+qaq7gl/ aNhh4qEN7dVQxPzIR9ykVgF5iufsaGGNgDJIOmC/iYAxPNu2VvZAnzZYcg41PtzAfeHqPWenlJ8D EKJiMBZUxj4iRKyWzpmUyDPWMZ92uszdF8CmQHEeXKaOcR1FPIDs2uQMadinSkg0GfelRqtUgP6R W4Y/M/qA9wnciQOtgXIWK6UwJwHDQrwCw8ZkLBaLw5cOC4Ruk5SCQ5lzv44G44jU2sYrcdpwnIhD ppxGZxK6U5kMtlAr6fDuF1/FluDklV/GAab4YhyhL8xevvcEM2Exg8v3mDRqhiZ5O494agLAHqYS AmQkmRgUIIAswHh1GPEqdRAcYKGw1G/VbuMom4zCTAr0FypzsF4WIgUBgZS0YKOiuy43C9xyeCXa GZm0g4PeKaiFVYFpRCpgzAZkY3ofeCQeZwbQG9u6PQG5+dKiFHB5alWyDZqHEwCxTOWDgDpuGUxx VxaKfklvXkBLUaGNzkU9rg3ZAXEtr2rLVecvacq3GKmmb6AgsSUSTVaEkIAshgnA7DK+DwBKHw7+ +74c0aHoiu04HRLYk9BgQyniOwqanI43SGVdcAgGnLBvhTRbY62MB3mQFlK2WPqOvRIuq6AZBDay kn+eZcwM5GFr1UbodDQ8zrKPmAcTQX63dmO3flOR1TKmN6/G3PFrNGvLPk/Ch1m47A2vvQqIRWAx hqNSvBTYpcyJUhTyCTzR4FU9KEsO552nCZOlRa2M7D3gP1mlNQHaI+GxOaQHFgD8qHfUAsh26fNz B+8BlCVadZKZCdQ4iHQ6mWxwZU6R6UPcCWQO90/yKuoRbfNyYcQwwsTiFBCqiRmFDKXybRqnNETU UE98XeB8SxcVMzQHIBgBhFS/E4KNnhkT7TIvQctiGYMHee8B7H5AfiDsA1gext8Qopw6iXrQ3iYt qvScz78lDCO4ksNBsxLAhiHCYUg1KFD2BKZG5uDAH1Duc0PXPentlpJIsp4iFT50QM6MBCJ5kBCQ TVW1tGFzLXutPXBrgMcYVbxKuASx5G6oPp+zuUNoBgeJx7DvAf2Mj7kLuVQaNeXVTkGUSjCIDywe VAiilIWOLjG0R5hdHIJA3AHJRqCf4MAdrRriJiJ1//C/WpsyieeIvsv5fDd1hkehiMIDEgsQiYIf KPIbHGJlQmx9KmwavIkGDcvG8rG1M0DWBktdu1uFHLv5X5QTjDg5EsY+WaATQpVoz3ByU6tlbEn0 jchzMb2B+iwbQLToQ2CNotDO/wKgOCFoEIDgxTHYXaEO5oaNGbnlIOMGoHQxKJc1yFgptgbyJghh jP534hyMo6ArfC4Ae0B30Lir2XB7BxAowLL0L29qXtYFWqVqyAUY0qxxuhLHkwh+hhVtiBT8j3hl YXnZZUlCS9CBmNRcBo2kIjGCNj2e9L1C0BuC85RokgJhAmDsHwQoVCxAWe+n4H5tuTD5XB4APETm D2K/jobB6oPMEuBPtHxffeXoesT0XvJxHDxDgiGjADKHzhzTMBqlDopyYM2r8mR6PJgC16mYQ3+K Hjc0MthchH5VOphD7ieV/k/teaxkh8Bs70o8G496+T4+Ydhv3Nw9W+AIEg4uID8Q7D/T3TMTExMQ UblCkKfoMxeMhdWsJBa+ilCylkKwYVpWEhISEhJCC3VkkkkzIa3cwJBE5Rq7E1tDD5DsN/0nuUzu Q6cOI1fFCzIyOfgYCPpPrLmg4khMDqdUtCCAfQFKUSVZUlD4IenwGdmZq2iHkgyDAgJwGrKmQOcI 0bZHRhKEhMjDscCHRzMmX6FOdvyIEKgGW1SVO0faMu/ulD6vEwQyx5x6e5tRUOdCX+hePS2wQoA4 SdHXU+by6HMqJikEwAxELLRl4d1bJ9JMBOXahc7rklljGDyw72iEE+b5o6VRIO6miQcJWFmDsghH EqAc5CJNQYxgwQKupsU3WutoO2NAOBvE0pSME1WJZFIRSRUzPZFqGNL0pQTKQGkArSIgyUlchxEl jMMj10EKremZLBGFBNDqbldNRqdTeNl2MVbnsLktDYGGrihVCGkuxxkBgBolQOcE+kLIX5iGAFAb AEBRgopyeAOx0YVwRDmYB0IXKGWCzBjDZnVqq7cXF14odDXlzTMzM1GiaiADqzoxQBJZlljOkaXF UjoM2yPgYhgUWMImHgHAOEWJ79TobEBpF0wJSB1VE8/OIr1vU73aYDR8EOYMmOuHUZh1K0gvNQGA mnOOQcRSFPhJ4In+KHB+SFdp2i/P6zA/uVE0e9FQo9i7GqGROshoPQ9O5NymuO1+QDmYAUFwfu1t WBoP6n8B4jQh7RcSkyVKlQkgD8O5QIKUookzJYW4NBIVifCF9XlBQTDJ0jwgjxGUrCuERZlvQwR6 WQ+wKvayGq8/AT7SAfYFFoPebQ3B7B9EhcAmLse59Lw8icnnfNoWNR8n1cBvQG9xt+VV42KkmfPc O0H4aMlQf/BuMD/4u5IpwoSAWTxYsA==
