| /* |
| * Copyright 2011 Google Inc. All Rights Reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <stdio.h> |
| |
| #include "gtest/gtest.h" |
| #include "sfntly/data/memory_byte_array.h" |
| #include "sfntly/data/growable_memory_byte_array.h" |
| #include "sfntly/port/file_input_stream.h" |
| #include "test/test_font_utils.h" |
| |
| namespace sfntly { |
| |
| void BuilderForFontFile(const char* font_path, FontFactory* factory, |
| FontBuilderArray* builders) { |
| assert(factory); |
| FileInputStream is; |
| is.Open(font_path); |
| factory->LoadFontsForBuilding(&is, builders); |
| EXPECT_GT(builders->size(), static_cast<size_t>(0)); |
| } |
| |
| void SerializeFont(const char* font_path, FontFactory* factory, Font* font) { |
| assert(font_path); |
| assert(factory); |
| assert(font); |
| MemoryOutputStream output_stream; |
| factory->SerializeFont(font, &output_stream); |
| SerializeToFile(&output_stream, font_path); |
| } |
| |
| void LoadFont(const char* font_path, FontFactory* factory, FontArray* fonts) { |
| FileInputStream is; |
| is.Open(font_path); |
| factory->LoadFonts(&is, fonts); |
| is.Close(); |
| } |
| |
| void LoadFontUsingByteVector(const char* font_path, |
| bool fingerprint, |
| FontArray* fonts) { |
| ByteVector bv; |
| LoadFile(font_path, &bv); |
| FontFactoryPtr factory; |
| factory.Attach(FontFactory::GetInstance()); |
| factory->FingerprintFont(fingerprint); |
| factory->LoadFonts(&bv, fonts); |
| } |
| |
| void LoadFile(const char* input_file_path, ByteVector* input_buffer) { |
| assert(input_file_path); |
| assert(input_buffer); |
| |
| FILE* input_file = NULL; |
| #if defined WIN32 |
| fopen_s(&input_file, input_file_path, "rb"); |
| #else |
| input_file = fopen(input_file_path, "rb"); |
| #endif |
| EXPECT_NE(input_file, reinterpret_cast<FILE*>(NULL)); |
| fseek(input_file, 0, SEEK_END); |
| size_t file_size = ftell(input_file); |
| fseek(input_file, 0, SEEK_SET); |
| input_buffer->resize(file_size); |
| size_t bytes_read = fread(&((*input_buffer)[0]), 1, file_size, input_file); |
| EXPECT_EQ(bytes_read, file_size); |
| fclose(input_file); |
| } |
| |
| void SerializeToFile(MemoryOutputStream* output_stream, const char* file_path) { |
| assert(file_path); |
| assert(output_stream); |
| |
| FILE* output_file = NULL; |
| #if defined WIN32 |
| fopen_s(&output_file, file_path, "wb"); |
| #else |
| output_file = fopen(file_path, "wb"); |
| #endif |
| EXPECT_NE(output_file, reinterpret_cast<FILE*>(NULL)); |
| fwrite(output_stream->Get(), 1, output_stream->Size(), output_file); |
| fflush(output_file); |
| fclose(output_file); |
| } |
| |
| void HexDump(const unsigned char* byte_data, size_t length) { |
| if (byte_data == NULL || length == 0) { |
| fprintf(stderr, "<NULL>\n"); |
| return; |
| } |
| |
| fprintf(stderr, "data length = %ld (%lx)\n", length, length); |
| for (size_t i = 0; i < length; ++i) { |
| fprintf(stderr, "%02x ", byte_data[i]); |
| if ((i & 0xf) == 0xf) { |
| fprintf(stderr, "\n"); |
| } |
| } |
| fprintf(stderr, "\n"); |
| } |
| |
| } // namespace sfntly |