Hi, I've written some unit tests for pdf_uuid_generate and pdf_uuid_string, cheking both generation and ascii structure for UUIDs. Please find attached the patch.
Cheers! Albert 2011/3/24 Jose E. Marchesi <[email protected]>: > > Hi Albert. > > Ok, issues fixed and some improvements added (now a pdf_char_t is > returned by pdf_uuid_string to allow inline calls; added a check for > the appropriate buffer size; improved pdf_uuid_generate & > pdf_uuid_compare code; updated gnupdf.texi) > > Applied. Thanks for the patch. > > By definition it is not easy to predict what a newly generated uuid will > be, but may be useful to have some simple tests running the generation > function and checking the structure of the printed representation. > > -- > Jose E. Marchesi [email protected] > GNU Project http://www.gnu.org >
# Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: [email protected]\ # 5y80i4y2ctwxrxdk # target_branch: bzr://bzr.sv.gnu.org/pdf/libgnupdf/trunk/ # testament_sha1: cfeee9833f9aaec447adcada689dfccd4f36e923 # timestamp: 2011-04-21 13:16:15 +0200 # base_revision_id: [email protected] # # Begin patch === modified file 'ChangeLog' --- ChangeLog 2011-04-18 18:36:00 +0000 +++ ChangeLog 2011-04-21 11:13:24 +0000 @@ -1,3 +1,10 @@ +2011-04-21 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 + 2011-04-18 Aleksander Morgado <[email protected]> base,types: Refactored pdf buffer type === modified file 'torture/unit/Makefile.am' --- torture/unit/Makefile.am 2011-03-29 21:12:24 +0000 +++ torture/unit/Makefile.am 2011-04-21 11:13:24 +0000 @@ -163,7 +163,8 @@ # 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 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-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-04-21 11:13:24 +0000 @@ -0,0 +1,91 @@ +/* -*- 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 conditions: + * 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 */ + uuid_time = pdf_uuid_generate (PDF_UUID_TIME); + fail_if(uuid_time.uuid == NULL); + + /* Create a random-based UUID */ + uuid_random = pdf_uuid_generate (PDF_UUID_RANDOM); + fail_if(uuid_random.uuid == NULL); + +} +END_TEST + + +/* + * 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 + +/* + * 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_test(tc, pdf_uuid_generate_002); + + 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-04-21 11:13:24 +0000 @@ -0,0 +1,300 @@ +/* -*- 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 conditions: + * 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 */ + uuid = pdf_uuid_generate (PDF_UUID_RANDOM); + fail_if(uuid.uuid == NULL); + + /* 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 conditions: + * 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 */ + uuid = pdf_uuid_generate (PDF_UUID_RANDOM); + fail_if(uuid.uuid == NULL); + + /* 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. + * **FAIL** 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 */ + uuid = pdf_uuid_generate (PDF_UUID_RANDOM); + fail_if(uuid.uuid == NULL); + + /* 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 */ + uuid = pdf_uuid_generate (PDF_UUID_RANDOM); + fail_if(uuid.uuid == NULL); + + /* 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 */ + uuid = pdf_uuid_generate (PDF_UUID_RANDOM); + fail_if(uuid.uuid == NULL); + + /* 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 */ + uuid = pdf_uuid_generate (PDF_UUID_RANDOM); + fail_if(uuid.uuid == NULL); + + /* 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-04-21 11:13:24 +0000 @@ -27,6 +27,9 @@ #include <check.h> #include <pdf-test-common.h> +extern TCase *test_pdf_uuid_generate (void); +extern TCase *test_pdf_uuid_string (void); + Suite * tsuite_types () { @@ -34,6 +37,9 @@ s = suite_create("types"); + suite_add_tcase (s, test_pdf_uuid_generate ()); + suite_add_tcase (s, test_pdf_uuid_string ()); + return s; } # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWcUZK5YACYN/jE5wACB4//// f+ferr////ogAAgAYBG9vtaFsMUdmlU+m0AA3pydHrrk666AS6BoAADyCgDQ9QlNUU/UeigZGmTQ 09EyepozUAaA0ANAAAAkiCZGgIENGppqntKZ6iMh6CeoeieoGjQAfqIHNGjQ0wgGmBNNAGQ0MQBo xGhgjIAJEhKabUyj1HiaQMTanqYTaCDEGARkGmmRkwIoiTVP1PUh6R5CNA9Rk0MTTT1BpiMg0AAM mmBUkQTQQaANE0NBMhiZUzCNR6npqeoepmoaZGheV9ILIowYJBKuto+PBvnN69wliQI7AGKZnFCr Azh95ppGdXdmP6eva77R32+GEvhzEZeoLOMLiyhbesvS6WsYwKKiVctJZKpZKckoTbRJB6i0Ygv8 t0xBXqApnNV+jL6Czjv2nj8eOdl/s1SciS7qf+GDBQ4nUeSKVVVGnfY7rt0h4mMfkz7u8DtEbqCD andcUG9BOGXGMU8ny3GQmjAdySqfzpJZSGKd5ctE9NSWSTDVROoutQUqBVJCpQqojk7ZUqvlwLPC n/ShreZGz0jAySqVrRSkgyo2uNhXlSj9U+4YZI2xLHnfc1t6SfGOR4jDMzAzeqO1f7LC6PDpB00G 7mhPdKPaQlGJJYDPDpFFYYZ9CdUoM2hXTnLaRgYuX0It+QWrSYrwQhrYVChVj/R4OrH+ni4TCpDr bmw6VMIop+iZWSkUlPF+LiTJi73UJ+DRyvc/mm1oaSWdKyPVvKWP+06GMU6u3RV7FfFp+re1ubNm qTSp62K0d2b0uHkYz2MUqLV2c+06Fo4Fc4nE4rgkQTqxA6EjO5D/dZK6hwOLolaZKxUqWdAFETYY Pn3OaWPDaNSOj2RhgYJiLTHH3h8ac2MzDMi66zI0GI+SNktTQKkrqwGfByJia292rbY3uuNsJhaH DOqvdL3qqqqZmaKDWwGmBY4pE1BDAWFrUhTW4p1jGGRnZRx6LQL0yL52LsmHESImRYMxGcVBjgVF mQSvBz5jN1S4JaFR6FRYiiJmZmaFAmWwioa5SIR7BNp3Ld1JKGKy0ji4ifYYkoXRZMeaMTT7TkqR /iofCHpMIjsio7O20XiqLy5YuKSjqFJaFHFy/s5flx9eNcz4trlX+f9JlSK+zMWVDCfqLs2YZjkj wR7wiEBfal9n157jDTPft0H2oqIUFCopRKiKUnro+047cCokYVB4w/q+LinT2NqWS0XLdDMd7rPf YsMdYOHv/WsPJevzZs/Yut4M0TL4jNaERajlSTTW9vddJgvNM8TM1ug3W+r9uB1I1OMeqNRyXZ8c 4/mlD6yQd01oes0NNDbfgFG4ph3dxy4AzD7V3M3WrexDpH9Q1705MvCJHvJ4SlIlK+So5GzLt1xe buJW1meq61ZQu54+mth78GTQlctLIaSnatlNVrHEOCAdnFI3qWjCSaMr8i9k8Ywxd7CXxyXvTXxX SLt0VNI+iONeUpsi1hsZ8eWi9rKSpabbO96cbY6qvd6g/DES6IjorQVARaI5eYTTZuzY2ehC4egq B8lrhx3t2OwmBSs6Zjyd3etUM1FhQzhDxx0kRKVvLsOt0crt1OTM3bCrBr/N2DE9qW8+LSVA7jr0 Ie5uYaB9HoDM4UW/REaSiPOlnHNDs8+vQqs77b5EjNicBHc4fBABTKqZCVRBaV6b7KdtVxxepfRE ojlRJtw1N1cRqq50czxXKCCOOFjwDP4BLoQG3GnTSYTWBpe2zLKEHd3CGBuh6WiSfn8oNjS665TE qxvi30RjEYn3PBt9kbIavQlw7aqEqS7FIqcjEmfVqXm77prVNqzCTb67JZFiQX51gIK5y4NEgnJA 1TIpoGpAxJDihCWle0zOvMwvDQzR3iTaXloJQ28BRPTCSOZ1OY56l5qdOEtby8Ozbjx1uMTiJaRU 2cuhREcuTDSbDV85+EIdbPdPSPonsaljE5OluDRl1Ezfga7TJd658b+oo0Y7uQROd9xFX7bRNtks bjaZM1zMhyRE/IGJtfNgv5PDVmdGJID0iU4zDHAcJlJK3E1NLD3D01pr0RoQmdXdgO+47Dib8MmL 4KZ2btpKpsUmMlkbHT5eFxdY4NlmjHF1Ka3Hwm6e8d5zpRXvFPW6cuK05dliuCEnag81HV5YFOEn U5isIKsh7irE7zEdjJsa1haknJa0DnjPu570jowxFn4u5PbFKofxkop/gJYG7r0LVSmziil6upVJ YA7OodHKysBTWANYcBwHw4V/RBU4DjOMtArrwYc8ISIIPmb9T0F5/S4cVitAG8TiWZKFfcwFn+f8 nFr4hg00bIN1fxfw2lhuWkKVEn6MT+SDf9i9+h1upqKE58VKEgI3eaUYHdycslqBYcPMCICc1S5Z HAtzLjtHqzXRi0fnJg3N197EmHczWQ7hWWkTEM2XBcZsTILc82L2c1M188RnEfjiNaDHtXE3trMT QVHko0yckXfPXFtS7O/t3ti9uXnve973Oc51nAkhJCEw2gzVqMACAq3nGJN8fUhST4LrR+KXSMPj jFj98BIEjV3fJReFLhhIViCUgCxFyi2raRgoYFS9SyJNThJNRPwdiZs+l04OtY6z75FA92WfgC34 27DocLgN4gKnznuIib8p4CZHj5jC/Z+7NGqOZ9Qx++wMmO8WfQkiY0mNhOMJS7SuvCSXfoYKdkSm THBDU9yU/OKJTN0ZPrWataiVQqqpOWpHrUjR6GXJmoB1ogZEbcUYBXYwNYJxMUGyjVIXEpJUSXWU i2x0WU0zT0PN1IdrFTWY/iMuZgao80juiIGRj1pQaLRIB5IFwBBsOmPtE3hIDyKMkwLSXRYsep2h 2PnfSrnrnYPe7/Jk9jkPEmVtkZmw4wwKB2HYlWx4wwKiII70svkbOfLz+7uScnuWbDvjCT6Q4vGp VNdNkPP52Y2KNVOjasuNTXo5nUk2xGMPEoqWtLKj0bMELqTNwdbzbezTT0s1mnkYtcmkm54L97Y0 aQa3EtEksik2ZmbizZruUnLDa8jnjDRVJzvMTyqgTiUmbDNK2KZj1pKO5qmIZzLr8PZO1f4RgS7R ZZfdYw6TWqMU+eowNBiVGGqDNeR77MmuLMC7FqW6jNpJiyY7GC0wMlrZyNSzXTPDWXMLIkiYU8T1 9D2dp2kyUrqxaQTganj6ufbuNS8uMFslsyGR3om1jWURbhhhFURAil34nGyGoWk6FMMJLPx2MjrU xaWZU4LPa6lntDRaQ4DHpiRa0Ya1NYdVBGWK5RMiqNOiiWf4QEpnGWc40DJUSolFbW1HQnHIyloj yQ7lTkcF+e1k5kJhqwPAP2La06UPRujdYNSo+Q8MAxk7Nn2NiP7BYWRejQ6E1Icrasxc6w3pvhhI 7mv73sdiJTe/BVolQLxNxPc7vc62D1YvK+asV3t4S3tYNhNBKEqIOlBo6foel4ocqaie0O1745zs jbHvSdBusOuQtAoSiWNy8qoCjcxzYUBTGcYh0VQpuSbXwLJs3tSPFOZsTr8ivY6zGF/MTF9l4Nl1 Sg9KiopOm+MxMlsX24vrpNRgsyRZ4Go2bXe1YEw70coal0nd2PIH5LHsTLvwF2Hd2RF+ssRwpOEi ogtTBp0TGB3Da1rDlDvQYJP3KjtXYaJoP7Q+odOySH19nhhqd6pFKhRQpKhkN81yfOlcz3jmLuoo qMk3u1TZkPIOGLpfqZSE2+X49/FsdhSVcpaPmtySMJZbgY94udPHakxTarmebA40xsXgU3PyZhnI xSZqkumPIn3L/FdbFwsTVTYTY0XZMOSFL8qpKpX7a2/bn3tKtjUzj2h4XYsOGU9cakuqYZpmzXZr 08mDCMMFULKlqus42OPNGS6pPvlRaoVSaRf5MtUOZZYWSyZCitEJmlmKlEpSJhPm/gZpGIZTN65e Fkk1VJqcceIwmLB42/9eE+PlDgjceySe67cdVMYP3Hne7JkntO/M7p68amrxnRBx0TcqSXHsptNQ YQu33+dTawfBY6vSpMxslTL0DCWackxFcTsx8782DOHwMHMl2Hl6Fm95nhy8bm9VRUlOyZB73T+V aTIiRUkE2kdoPWaBlI0GNkmJkokxsbGxsbEUk3lCu4BtoFBeRcWYrFteLWNFI14pzZ3eAwWPOfSb OB4NcyUmi0tRubrLqVDIqF5JcWT2J7+ndTYuxSeNJVJRSGtO41rL2NarrFrGyrPOzlNjW5ZZ5ocj OJdJr5JFpHanzJZ0e+yeOY5dW85+C0kOUZT6mZzsdScmAaXWdc/De1sJNUUswBjYoUxKZJXcNKkN 3/OlQuUCCLEGH6ZxJMF875x2Ncj2KxYWkVNJtFsNiaw6s4ZLilKKkLudhI7MXOsnwtHEzRylqVJv wjCpFKkVRG6PmpeatcaoobVTbRIxqsRUms0RaVsNb13QwkzPcbV1KaYHxnnZxN3E4nEzTGTerBk7 2RjTGFMFxyr2b9LBQXLDHRDGLjsRUupeR5XWjkbFE1QNyoa1JrpLMVkwbFnLmzcWY6GHl22tbAub FI7LLJJSlNfLW3LGnO2MZHeqShqhqzN8ij+nNOVhJItUWFw4ML2rGSXl5M0uo6jialEQOmAeAvap iVjVtnYLU0cUajdzGqeCSkfCz706nykvvcIf3PokiNbypEnsnSnGwhotLHM595vkbuExv3PkGyaC 8jF/vxsFFyZQ9CdgpLprIq1WSFWpVaGmMX808HBwmClLDUZiR1CRqhzxloZxIthk/4mqQDRZTELi 1JMIm50udk4K5G13rtiTUfkk0nunDmNJDcZrjuUHQY3MN/gBOUNEqcwu5IpwoSGKMlcs
