TEST_FIXTURE(page_blob_test_base, existing_page_blob_write_stream) { CHECK_THROW(m_blob.open_write(azure::storage::access_condition(), azure::storage::blob_request_options(), m_context), azure::storage::storage_exception); azure::storage::blob_request_options options; options.set_store_blob_content_md5(true); std::vector<uint8_t> buffer; buffer.resize(16 * 1024); fill_buffer_and_get_md5(buffer); m_blob.upload_from_stream(concurrency::streams::bytestream::open_istream(buffer), 0, azure::storage::access_condition(), options, m_context); CHECK_THROW(m_blob.open_write(azure::storage::access_condition(), options, m_context), std::logic_error); options.set_store_blob_content_md5(false); auto stream = m_blob.open_write(azure::storage::access_condition(), options, m_context); stream.seek(512); stream.streambuf().putn_nocopy(buffer.data(), 512).wait(); stream.close().wait(); concurrency::streams::container_buffer<std::vector<uint8_t>> downloaded_blob; CHECK_THROW(m_blob.download_to_stream(downloaded_blob.create_ostream(), azure::storage::access_condition(), options, m_context), azure::storage::storage_exception); downloaded_blob.seekpos(0, std::ios_base::out); options.set_disable_content_md5_validation(true); m_blob.download_to_stream(downloaded_blob.create_ostream(), azure::storage::access_condition(), options, m_context); CHECK_ARRAY_EQUAL(buffer.data(), downloaded_blob.collection().data(), 512); CHECK_ARRAY_EQUAL(buffer.data(), downloaded_blob.collection().data() + 512, 512); CHECK_ARRAY_EQUAL(buffer.data() + 1024, downloaded_blob.collection().data() + 1024, (int)(buffer.size()) - 1024); }
TEST_FIXTURE(ConstructorFixture, BlockingSendAccumulatesOverMultipleCalls) { uint8_t expected[20] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 }; spark_protocol.blocking_send(expected, 20); CHECK_ARRAY_EQUAL(expected, sent_buf_0, 20); }
TEST_FIXTURE(ConstructorFixture, HandshakeSendsExpectedHello) { const uint8_t expected[18] = { 0x00, 0x10, 0xde, 0x89, 0x60, 0x27, 0xba, 0x11, 0x1a, 0x95, 0xbe, 0x39, 0x6f, 0x4d, 0xfc, 0x30, 0x9b, 0x6b }; spark_protocol.handshake(); CHECK_ARRAY_EQUAL(expected, sent_buf_1, 18); }
TEST_FIXTURE(StrModFixture, CopyENTerminateTest) { char *cc = fslc_strncpy_e(testString,"Hello, World!", 5); strncpy(expectedString,"Hello, World!", 5); CHECK_EQUAL((uintptr_t)testString+5, (uintptr_t)cc); CHECK_ARRAY_EQUAL(expectedString, testString, MAXLEN); }
TEST_FIXTURE(StrModFixture, Copy0TerminateTest) { char *cc = fslc_strncpy(testString,"Hello, World!", 30); strncpy(expectedString,"Hello, World!", 30); CHECK_EQUAL((uintptr_t)testString, (uintptr_t)cc); CHECK_ARRAY_EQUAL(expectedString, testString, strlen(expectedString)+1); }
TEST_FIXTURE(ConstructorFixture, BlockingReceiveAccumulatesOverMultipleCalls) { uint8_t expected[20] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 }; uint8_t receive_buf[20]; memcpy(message_to_receive, expected, 20); spark_protocol.blocking_receive(receive_buf, 20); CHECK_ARRAY_EQUAL(expected, receive_buf, 20); }
TEST_FIXTURE(HandshakeFixture, HMACMatchesOpenSSLExample) { uint8_t hmac[20]; uint8_t hmac_key[40]; decipher_aes_credentials(private_key, encrypted_aes_credentials, hmac_key); calculate_ciphertext_hmac(encrypted_aes_credentials, hmac_key, hmac); CHECK_ARRAY_EQUAL(expected_hmac, hmac, 20); }
TEST_FIXTURE(CoAPFixture, VariableValueDoubleMatchesOpenSSL) { uint8_t expected[16] = { 0x00, 0x06, 0x3d, 0xb5, 0xcc, 0xda, 0xf9, 0xce, 0x81, 0x26, 0x01, 0x97, 0xbb, 0x64, 0x8d, 0x97 }; unsigned char buf[16]; memset(buf, 0, 16); init(); spark_protocol.variable_value(buf, 0x5d, 0xab, 0xce,-104.858); CHECK_ARRAY_EQUAL(expected, buf, 16); }
TEST_FIXTURE(CoAPFixture, ChunkReceivedMatchesOpenSSL) { uint8_t expected[16] = { 0x26, 0x03, 0x6a, 0x64, 0x8b, 0xba, 0xc7, 0x42, 0xc9, 0xfa, 0x78, 0x7b, 0xf9, 0x25, 0x51, 0x01 }; unsigned char buf[16]; memset(buf, 0, 16); init(); spark_protocol.chunk_received(buf, 0x01, ChunkReceivedCode::OK); CHECK_ARRAY_EQUAL(expected, buf, 16); }
TEST_FIXTURE(CoAPFixture, UpdateReadyMatchesOpenSSL) { uint8_t expected[16] = { 0xf8, 0xe2, 0xf5, 0xc5, 0x50, 0xa3, 0x12, 0x03, 0xd0, 0xa0, 0xf9, 0x98, 0xe5, 0x48, 0x58, 0x71 }; unsigned char buf[16]; memset(buf, 0, 16); init(); spark_protocol.update_ready(buf, 0x10); CHECK_ARRAY_EQUAL(expected, buf, 16); }
TEST_FIXTURE(CoAPFixture, VariableValueBoolMatchesOpenSSL) { uint8_t expected[16] = { 0xae, 0x35, 0x85, 0xd5, 0x6b, 0xc0, 0x6d, 0xd0, 0xd6, 0x25, 0x75, 0xb9, 0xd2, 0x9c, 0x36, 0x42 }; unsigned char buf[16]; memset(buf, 0, 16); init(); spark_protocol.variable_value(buf, 0x5f, 0xf6, 0x49, false); CHECK_ARRAY_EQUAL(expected, buf, 16); }
TEST_FIXTURE(CoAPFixture, VariableValueIntMatchesOpenSSL) { uint8_t expected[16] = { 0xbe, 0x47, 0x34, 0x62, 0x85, 0xc0, 0x7b, 0x92, 0x21, 0xc8, 0x9a, 0xc4, 0x91, 0x96, 0xf5, 0xf6 }; unsigned char buf[16]; memset(buf, 0, 16); init(); spark_protocol.variable_value(buf, 0x88, 0x97, 0xb2, -98765); CHECK_ARRAY_EQUAL(expected, buf, 16); }
TEST_FIXTURE(CoAPFixture, FunctionReturnIntMatchesOpenSSL) { uint8_t expected[16] = { 0x73, 0x9b, 0xa0, 0xad, 0xa9, 0xff, 0x01, 0x3d, 0xcd, 0xc3, 0x18, 0xe4, 0x3e, 0x5a, 0x92, 0xe6 }; unsigned char buf[16]; memset(buf, 0, 16); init(); spark_protocol.function_return(buf, 0xc3, 42); CHECK_ARRAY_EQUAL(expected, buf, 16); }
TEST_FIXTURE(CoAPFixture, KeyChangedMatchesOpenSSL) { uint8_t expected[16] = { 0x67, 0x64, 0x33, 0xa9, 0x58, 0x12, 0xca, 0x37, 0x5f, 0x12, 0x59, 0x3b, 0x3e, 0x32, 0x64, 0xd3 }; unsigned char buf[16]; memset(buf, 0, 16); init(); spark_protocol.key_changed(buf, 0x99); CHECK_ARRAY_EQUAL(expected, buf, 16); }
TEST_FIXTURE(CoAPFixture, HelloMatchesOpenSSL) { uint8_t expected[16] = { 0x3d, 0xc4, 0xa4, 0x21, 0xb8, 0x30, 0x9b, 0x9d, 0xc8, 0x4b, 0x70, 0x07, 0x33, 0xc1, 0xff, 0x3e }; unsigned char buf[16]; memset(buf, 0, 16); init(); spark_protocol.hello(buf, false); CHECK_ARRAY_EQUAL(expected, buf, 16); }
TEST_FIXTURE(CoAPFixture, VariableValueStringMatchesOpenSSL) { uint8_t expected[16] = { 0x89, 0x21, 0x18, 0xc6, 0x35, 0x2f, 0xe7, 0xa0, 0xeb, 0x6f, 0x7b, 0x0b, 0xb6, 0x31, 0xa2, 0x12 }; unsigned char buf[16]; memset(buf, 0, 16); init(); spark_protocol.variable_value(buf, 0x5c, 0xf6, 0x49, "woot", 4); CHECK_ARRAY_EQUAL(expected, buf, 16); }
TEST_FIXTURE(CoAPFixture, PresenceAnnouncementMatchesExpected) { uint8_t expected[19] = { 0x50, 0x02, 0x00, 0x00, 0xb1, 'h', 0xff, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; const char id[12] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; unsigned char buf[19]; memset(buf, 0, 19); init(); spark_protocol.presence_announcement(buf, id); CHECK_ARRAY_EQUAL(expected, buf, 19); }
TEST_FIXTURE(page_blob_test_base, page_blob_write_stream_seek_without_md5) { std::vector<uint8_t> buffer; std::vector<uint8_t> final_blob_contents; final_blob_contents.resize(16 * 1024); azure::storage::blob_request_options options; options.set_store_blob_content_md5(false); auto stream = m_blob.open_write(final_blob_contents.size(), 0, azure::storage::access_condition(), options, m_context); CHECK(stream.can_seek()); // Because container create and blob create are also in the request results, // number of requests should start with 2. size_t attempts = 2; buffer.resize(1024); fill_buffer_and_get_md5(buffer); stream.streambuf().putn_nocopy(buffer.data(), buffer.size()).wait(); std::copy(buffer.begin(), buffer.end(), final_blob_contents.begin()); stream.seek(5 * 1024); attempts++; fill_buffer_and_get_md5(buffer); stream.streambuf().putn_nocopy(buffer.data(), buffer.size()).wait(); std::copy(buffer.begin(), buffer.end(), final_blob_contents.begin() + 5 * 1024); fill_buffer_and_get_md5(buffer); stream.streambuf().putn_nocopy(buffer.data(), buffer.size()).wait(); std::copy(buffer.begin(), buffer.end(), final_blob_contents.begin() + 6 * 1024); stream.seek(512); attempts++; fill_buffer_and_get_md5(buffer); stream.streambuf().putn_nocopy(buffer.data(), buffer.size()).wait(); std::copy(buffer.begin(), buffer.end(), final_blob_contents.begin() + 512); stream.close().wait(); attempts++; CHECK_EQUAL(attempts, m_context.request_results().size()); concurrency::streams::container_buffer<std::vector<uint8_t>> downloaded_blob; m_blob.download_to_stream(downloaded_blob.create_ostream(), azure::storage::access_condition(), options, m_context); CHECK_ARRAY_EQUAL(final_blob_contents, downloaded_blob.collection(), (int)final_blob_contents.size()); }
TEST_FIXTURE(HandshakeFixture, RSADecryptionMatchesOpenSSLExample) { uint8_t expected[41] = "\x3E\x78\xEB\x7A\x0B\xB2\x1D\xFB\xF2\xB1\x53\x4B\x06\xE5\x66\x12" "\x14\x5A\x01\xF1\x07\x0E\x40\xA1\x11\x88\xF7\x84\xC4\x9B\xC6\x53" "\xC5\x76\x94\xFC\x1F\x3B\x7D\x72"; uint8_t aes_credentials[40]; decipher_aes_credentials(private_key, encrypted_aes_credentials, aes_credentials); CHECK_ARRAY_EQUAL(expected, aes_credentials, 40); }
TEST_FIXTURE(AESFixture, SuccessfullyDecryptsOpenSSLExample) { unsigned char buf[32]; memcpy(buf, ciphertext, 32); unsigned char iv[16]; memcpy(iv, credentials + 16, 16); aes_context ctx; aes_setkey_dec(&ctx, credentials, 128); aes_crypt_cbc(&ctx, AES_DECRYPT, 32, iv, buf, buf); CHECK_ARRAY_EQUAL(plaintext, buf, 32); }
TEST_FIXTURE(AESFixture, EncryptsSameAsOpenSSL) { uint8_t buf[32]; memcpy(buf, plaintext, 32); unsigned char iv[16]; memcpy(iv, credentials + 16, 16); aes_context ctx; aes_setkey_enc(&ctx, credentials, 128); /* Note length 21, without PKCS #7 padding */ aes_crypt_cbc(&ctx, AES_ENCRYPT, 21, iv, buf, buf); CHECK_ARRAY_EQUAL(ciphertext, buf, 32); }
TEST_FIXTURE(CoAPFixture, DescriptionMatchesOpenSSL) { uint8_t expected[48] = { 0xac, 0xc9, 0x8f, 0x76, 0x26, 0x76, 0xc9, 0x53, 0xf5, 0xc2, 0x2a, 0x20, 0x70, 0xe6, 0x60, 0x28, 0x5a, 0xa0, 0x95, 0x15, 0x1c, 0x4a, 0xdc, 0x53, 0x19, 0xbf, 0x95, 0x44, 0x6c, 0xe5, 0x50, 0x59, 0xf9, 0x26, 0xd4, 0x04, 0x36, 0x9b, 0x97, 0xef, 0x4d, 0xe7, 0x45, 0xc6, 0xce, 0x13, 0xb3, 0x5d }; unsigned char buf[48]; memset(buf, 0, 48); init(); spark_protocol.description(buf, 0x66, 0xf6, 0x49); CHECK_ARRAY_EQUAL(expected, buf, 48); }
TEST_FIXTURE(EnchantDictionarySuggest_TestFixture, EnchantDictionarySuggest_LenSpecified) { size_t cSuggestions; _suggestions = enchant_dict_suggest(_dict, "helodisregard me", 4, &cSuggestions); CHECK(_suggestions); CHECK_EQUAL(std::string("helo"), suggestWord); CHECK_EQUAL(4, cSuggestions); std::vector<std::string> suggestions; if(_suggestions != NULL){ suggestions.insert(suggestions.begin(), _suggestions, _suggestions+cSuggestions); } CHECK_ARRAY_EQUAL(GetExpectedSuggestions("helo"), suggestions, std::min((size_t)4,cSuggestions)); }
TEST_FIXTURE(EnchantDictionarySuggest_TestFixture, EnchantDictionarySuggest_DuplicateSuggestionsFromPersonal_notIncluded) { size_t cSuggestions; enchant_dict_add(_dict, "aelo", -1); _suggestions = enchant_dict_suggest(_dict, "helo", -1, &cSuggestions); CHECK(_suggestions); CHECK_EQUAL(4, cSuggestions); std::vector<std::string> suggestions; if(_suggestions != NULL){ suggestions.insert(suggestions.begin(), _suggestions, _suggestions+cSuggestions); } CHECK_ARRAY_EQUAL(GetExpectedSuggestions("helo"), suggestions, std::min((size_t)4,cSuggestions)); }
TEST_FIXTURE(ConstructorFixture, EventLoopRespondsToFunctionCallWithACK) { uint8_t function_call[34] = { 0x00, 0x20, 0xc6, 0xf4, 0xcb, 0x28, 0x85, 0xd8, 0x1e, 0xdd, 0x23, 0x1c, 0x56, 0xb8, 0xd8, 0x03, 0x28, 0x94, 0xce, 0x89, 0xab, 0x42, 0x48, 0x86, 0x78, 0x76, 0xa0, 0x14, 0x07, 0x23, 0xb5, 0xa9, 0xfe, 0x75 }; memcpy(message_to_receive, function_call, 34); const uint8_t expected[18] = { 0x00, 0x10, 0x80, 0xef, 0x08, 0x49, 0xd1, 0xbe, 0xe3, 0x20, 0xf5, 0x06, 0xf9, 0x7d, 0xf1, 0xce, 0x25, 0x36 }; spark_protocol.handshake(); bytes_received[0] = bytes_sent[0] = 0; spark_protocol.event_loop(); CHECK_ARRAY_EQUAL(expected, sent_buf_0, 18); }
TEST_FIXTURE(ConstructorFixture, EventLoopCallsOnlyHandlerOnPrefixMatchedEvent) { const char *event_name = "teapot"; uint8_t event[34] = { 0x00, 0x20, 0x36, 0x0b, 0xed, 0xd1, 0x5a, 0x7b, 0x9b, 0xf0, 0xe5, 0x44, 0xd2, 0xce, 0x49, 0x6f, 0x6b, 0xc1, 0x27, 0xa7, 0x88, 0x9a, 0xa8, 0x72, 0xd3, 0x5a, 0x8f, 0xce, 0x2a, 0x94, 0xbd, 0x49, 0x26, 0xdc }; memcpy(message_to_receive, event, 34); spark_protocol.handshake(); bytes_received[0] = bytes_sent[0] = 0; event_handlers_called_with[0].event_name[0] = 0; spark_protocol.add_event_handler(event_name, mock_event_handler_0); spark_protocol.event_loop(); CHECK_ARRAY_EQUAL(event_name, event_handlers_called_with[0].event_name, strlen(event_name)); }
TEST_FIXTURE(page_blob_test_base, page_blob_file_upload) { azure::storage::blob_request_options options; options.set_store_blob_content_md5(true); utility::string_t md5_header; m_context.set_sending_request([&md5_header] (web::http::http_request& request, azure::storage::operation_context) { if (!request.headers().match(U("x-ms-blob-content-md5"), md5_header)) { md5_header.clear(); } }); temp_file invalid_file(1000); CHECK_THROW(m_blob.upload_from_file(invalid_file.path(), 0, azure::storage::access_condition(), options, m_context), azure::storage::storage_exception); temp_file file(1024); m_blob.upload_from_file(file.path(), 0, azure::storage::access_condition(), options, m_context); CHECK_UTF8_EQUAL(file.content_md5(), md5_header); m_context.set_sending_request(std::function<void(web::http::http_request &, azure::storage::operation_context)>()); temp_file file2(0); m_blob.download_to_file(file2.path(), azure::storage::access_condition(), options, m_context); concurrency::streams::container_buffer<std::vector<uint8_t>> original_file_buffer; auto original_file = concurrency::streams::file_stream<uint8_t>::open_istream(file.path()).get(); original_file.read_to_end(original_file_buffer).wait(); original_file.close().wait(); concurrency::streams::container_buffer<std::vector<uint8_t>> downloaded_file_buffer; auto downloaded_file = concurrency::streams::file_stream<uint8_t>::open_istream(file2.path()).get(); downloaded_file.read_to_end(downloaded_file_buffer).wait(); downloaded_file.close().wait(); CHECK_EQUAL(original_file_buffer.collection().size(), downloaded_file_buffer.collection().size()); CHECK_ARRAY_EQUAL(original_file_buffer.collection(), downloaded_file_buffer.collection(), (int)downloaded_file_buffer.collection().size()); m_blob.properties().set_content_md5(dummy_md5); m_blob.upload_properties(); options.set_retry_policy(azure::storage::no_retry_policy()); CHECK_THROW(m_blob.download_to_file(file2.path(), azure::storage::access_condition(), options, m_context), azure::storage::storage_exception); }
TEST_FIXTURE(EnchantDictionarySuggest_TestFixture, EnchantDictionarySuggest_SuggestionListWithInvalidUtf8_InvalidSuggestionIgnored_FreeCalled) { suggestBehavior = returnFourOneInvalidUtf8; size_t cSuggestions; _suggestions = enchant_dict_suggest(_dict, "helo", -1, &cSuggestions); CHECK(_suggestions); CHECK(dictSuggestCalled); CHECK(providerFreeStringListCalled); CHECK_EQUAL(3, cSuggestions); std::vector<std::string> suggestions; if(_suggestions != NULL){ suggestions.insert(suggestions.begin(), _suggestions, _suggestions+cSuggestions); } CHECK_ARRAY_EQUAL(GetExpectedSuggestions("helo",1), suggestions, std::min((size_t)3,cSuggestions)); }
TEST_FIXTURE(EnchantDictionarySuggest_TestFixture, EnchantDictionarySuggest_SuggestionsFromPersonal_addedToEnd) { size_t cSuggestions; enchant_dict_add(_dict, "hello", -1); _suggestions = enchant_dict_suggest(_dict, "helo", -1, &cSuggestions); CHECK(_suggestions); CHECK_EQUAL(5, cSuggestions); std::vector<std::string> suggestions; if(_suggestions != NULL){ suggestions.insert(suggestions.begin(), _suggestions, _suggestions+cSuggestions); } std::vector<std::string> expected = GetExpectedSuggestions("helo"); expected.push_back("hello"); CHECK_ARRAY_EQUAL(expected, suggestions, std::min((size_t)5,cSuggestions)); }
size_t seek_read_and_compare(concurrency::streams::istream stream, std::vector<uint8_t> buffer_to_compare, utility::size64_t offset, size_t count, size_t expected_read_count) { std::vector<uint8_t> buffer; buffer.resize(count); stream.seek(offset); auto read_count = stream.streambuf().getn(buffer.data(), count).get(); CHECK_EQUAL(expected_read_count, read_count); CHECK_ARRAY_EQUAL(buffer_to_compare.data() + offset, buffer.data(), (int)read_count); return read_count; }