drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
android_frameworks_base/cmds/idmap2/tests/IdmapTests.cpp
Mårten Kongstad 0275123eef idmap2: initial code drop 
idmap2 is a reboot of the idmap project. The project aims to

  - use modern C++
  - greatly improve test and debug support
  - interface towards AssetManager2 (instead of AssetManager)
  - provide a solid foundation to add support for new features

To make it easier to verify correctness, this first version of idmap2 is
feature equivalent to idmap. Later versions will add support for new
features such as <overlayable>.

Bug: 78815803
Test: make idmap2_tests
Change-Id: I1d806dc875a493e730ab55d2fdb027618e586d16
2018-10-30 04:37:41 -07:00

396 lines
15 KiB
C++
Raw Blame History

/*
* Copyright (C) 2018 The Android Open Source Project
*
* 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 <cstdio> // fclose
#include <fstream>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "android-base/macros.h"
#include "androidfw/ApkAssets.h"
#include "idmap2/BinaryStreamVisitor.h"
#include "idmap2/CommandLineOptions.h"
#include "idmap2/Idmap.h"
#include "TestHelpers.h"
using ::testing::IsNull;
using ::testing::NotNull;
namespace android {
namespace idmap2 {
TEST(IdmapTests, TestCanonicalIdmapPathFor) {
ASSERT_EQ(Idmap::CanonicalIdmapPathFor("/foo", "/vendor/overlay/bar.apk"),
"/foo/vendor@overlay@bar.apk@idmap");
}
TEST(IdmapTests, CreateIdmapHeaderFromBinaryStream) {
std::string raw(reinterpret_cast<const char*>(idmap_raw_data), idmap_raw_data_len);
std::istringstream stream(raw);
std::unique_ptr<const IdmapHeader> header = IdmapHeader::FromBinaryStream(stream);
ASSERT_THAT(header, NotNull());
ASSERT_EQ(header->GetMagic(), 0x504d4449u);
ASSERT_EQ(header->GetVersion(), 0x01u);
ASSERT_EQ(header->GetTargetCrc(), 0x1234u);
ASSERT_EQ(header->GetOverlayCrc(), 0x5678u);
ASSERT_EQ(header->GetTargetPath().to_string(), "target.apk");
ASSERT_EQ(header->GetOverlayPath().to_string(), "overlay.apk");
}
TEST(IdmapTests, FailToCreateIdmapHeaderFromBinaryStreamIfPathTooLong) {
std::string raw(reinterpret_cast<const char*>(idmap_raw_data), idmap_raw_data_len);
// overwrite the target path string, including the terminating null, with '.'
for (size_t i = 0x10; i < 0x110; i++) {
raw[i] = '.';
}
std::istringstream stream(raw);
std::unique_ptr<const IdmapHeader> header = IdmapHeader::FromBinaryStream(stream);
ASSERT_THAT(header, IsNull());
}
TEST(IdmapTests, CreateIdmapDataHeaderFromBinaryStream) {
const size_t offset = 0x210;
std::string raw(reinterpret_cast<const char*>(idmap_raw_data + offset),
idmap_raw_data_len - offset);
std::istringstream stream(raw);
std::unique_ptr<const IdmapData::Header> header = IdmapData::Header::FromBinaryStream(stream);
ASSERT_THAT(header, NotNull());
ASSERT_EQ(header->GetTargetPackageId(), 0x7fu);
ASSERT_EQ(header->GetTypeCount(), 2u);
}
TEST(IdmapTests, CreateIdmapDataResourceTypeFromBinaryStream) {
const size_t offset = 0x214;
std::string raw(reinterpret_cast<const char*>(idmap_raw_data + offset),
idmap_raw_data_len - offset);
std::istringstream stream(raw);
std::unique_ptr<const IdmapData::TypeEntry> data = IdmapData::TypeEntry::FromBinaryStream(stream);
ASSERT_THAT(data, NotNull());
ASSERT_EQ(data->GetTargetTypeId(), 0x02u);
ASSERT_EQ(data->GetOverlayTypeId(), 0x02u);
ASSERT_EQ(data->GetEntryCount(), 1u);
ASSERT_EQ(data->GetEntryOffset(), 0u);
ASSERT_EQ(data->GetEntry(0), 0u);
}
TEST(IdmapTests, CreateIdmapDataFromBinaryStream) {
const size_t offset = 0x210;
std::string raw(reinterpret_cast<const char*>(idmap_raw_data + offset),
idmap_raw_data_len - offset);
std::istringstream stream(raw);
std::unique_ptr<const IdmapData> data = IdmapData::FromBinaryStream(stream);
ASSERT_THAT(data, NotNull());
ASSERT_EQ(data->GetHeader()->GetTargetPackageId(), 0x7fu);
ASSERT_EQ(data->GetHeader()->GetTypeCount(), 2u);
const std::vector<std::unique_ptr<const IdmapData::TypeEntry>>& types = data->GetTypeEntries();
ASSERT_EQ(types.size(), 2u);
ASSERT_EQ(types[0]->GetTargetTypeId(), 0x02u);
ASSERT_EQ(types[0]->GetOverlayTypeId(), 0x02u);
ASSERT_EQ(types[0]->GetEntryCount(), 1u);
ASSERT_EQ(types[0]->GetEntryOffset(), 0u);
ASSERT_EQ(types[0]->GetEntry(0), 0x0000u);
ASSERT_EQ(types[1]->GetTargetTypeId(), 0x03u);
ASSERT_EQ(types[1]->GetOverlayTypeId(), 0x03u);
ASSERT_EQ(types[1]->GetEntryCount(), 3u);
ASSERT_EQ(types[1]->GetEntryOffset(), 3u);
ASSERT_EQ(types[1]->GetEntry(0), 0x0000u);
ASSERT_EQ(types[1]->GetEntry(1), kNoEntry);
ASSERT_EQ(types[1]->GetEntry(2), 0x0001u);
}
TEST(IdmapTests, CreateIdmapFromBinaryStream) {
std::string raw(reinterpret_cast<const char*>(idmap_raw_data), idmap_raw_data_len);
std::istringstream stream(raw);
std::stringstream error;
std::unique_ptr<const Idmap> idmap = Idmap::FromBinaryStream(stream, error);
ASSERT_THAT(idmap, NotNull());
ASSERT_THAT(idmap->GetHeader(), NotNull());
ASSERT_EQ(idmap->GetHeader()->GetMagic(), 0x504d4449u);
ASSERT_EQ(idmap->GetHeader()->GetVersion(), 0x01u);
ASSERT_EQ(idmap->GetHeader()->GetTargetCrc(), 0x1234u);
ASSERT_EQ(idmap->GetHeader()->GetOverlayCrc(), 0x5678u);
ASSERT_EQ(idmap->GetHeader()->GetTargetPath().to_string(), "target.apk");
ASSERT_EQ(idmap->GetHeader()->GetOverlayPath().to_string(), "overlay.apk");
const std::vector<std::unique_ptr<const IdmapData>>& dataBlocks = idmap->GetData();
ASSERT_EQ(dataBlocks.size(), 1u);
const std::unique_ptr<const IdmapData>& data = dataBlocks[0];
ASSERT_EQ(data->GetHeader()->GetTargetPackageId(), 0x7fu);
ASSERT_EQ(data->GetHeader()->GetTypeCount(), 2u);
const std::vector<std::unique_ptr<const IdmapData::TypeEntry>>& types = data->GetTypeEntries();
ASSERT_EQ(types.size(), 2u);
ASSERT_EQ(types[0]->GetTargetTypeId(), 0x02u);
ASSERT_EQ(types[0]->GetOverlayTypeId(), 0x02u);
ASSERT_EQ(types[0]->GetEntryCount(), 1u);
ASSERT_EQ(types[0]->GetEntryOffset(), 0u);
ASSERT_EQ(types[0]->GetEntry(0), 0x0000u);
ASSERT_EQ(types[1]->GetTargetTypeId(), 0x03u);
ASSERT_EQ(types[1]->GetOverlayTypeId(), 0x03u);
ASSERT_EQ(types[1]->GetEntryCount(), 3u);
ASSERT_EQ(types[1]->GetEntryOffset(), 3u);
ASSERT_EQ(types[1]->GetEntry(0), 0x0000u);
ASSERT_EQ(types[1]->GetEntry(1), kNoEntry);
ASSERT_EQ(types[1]->GetEntry(2), 0x0001u);
}
TEST(IdmapTests, GracefullyFailToCreateIdmapFromCorruptBinaryStream) {
std::string raw(reinterpret_cast<const char*>(idmap_raw_data),
10); // data too small
std::istringstream stream(raw);
std::stringstream error;
std::unique_ptr<const Idmap> idmap = Idmap::FromBinaryStream(stream, error);
ASSERT_THAT(idmap, IsNull());
}
TEST(IdmapTests, CreateIdmapFromApkAssets) {
const std::string target_apk_path(GetTestDataPath() + "/target/target.apk");
std::unique_ptr<const ApkAssets> target_apk = ApkAssets::Load(target_apk_path);
ASSERT_THAT(target_apk, NotNull());
const std::string overlay_apk_path(GetTestDataPath() + "/overlay/overlay.apk");
std::unique_ptr<const ApkAssets> overlay_apk = ApkAssets::Load(overlay_apk_path);
ASSERT_THAT(overlay_apk, NotNull());
std::stringstream error;
std::unique_ptr<const Idmap> idmap =
Idmap::FromApkAssets(target_apk_path, *target_apk, overlay_apk_path, *overlay_apk, error);
ASSERT_THAT(idmap, NotNull());
ASSERT_THAT(idmap->GetHeader(), NotNull());
ASSERT_EQ(idmap->GetHeader()->GetMagic(), 0x504d4449u);
ASSERT_EQ(idmap->GetHeader()->GetVersion(), 0x01u);
ASSERT_EQ(idmap->GetHeader()->GetTargetCrc(), 0xf5ad1d1d);
ASSERT_EQ(idmap->GetHeader()->GetOverlayCrc(), 0xd470336b);
ASSERT_EQ(idmap->GetHeader()->GetTargetPath().to_string(), target_apk_path);
ASSERT_EQ(idmap->GetHeader()->GetOverlayPath(), overlay_apk_path);
ASSERT_EQ(idmap->GetHeader()->GetOverlayPath(), overlay_apk_path);
const std::vector<std::unique_ptr<const IdmapData>>& dataBlocks = idmap->GetData();
ASSERT_EQ(dataBlocks.size(), 1u);
const std::unique_ptr<const IdmapData>& data = dataBlocks[0];
ASSERT_EQ(data->GetHeader()->GetTargetPackageId(), 0x7fu);
ASSERT_EQ(data->GetHeader()->GetTypeCount(), 2u);
const std::vector<std::unique_ptr<const IdmapData::TypeEntry>>& types = data->GetTypeEntries();
ASSERT_EQ(types.size(), 2u);
ASSERT_EQ(types[0]->GetTargetTypeId(), 0x01u);
ASSERT_EQ(types[0]->GetOverlayTypeId(), 0x01u);
ASSERT_EQ(types[0]->GetEntryCount(), 1u);
ASSERT_EQ(types[0]->GetEntryOffset(), 0u);
ASSERT_EQ(types[0]->GetEntry(0), 0x0000u);
ASSERT_EQ(types[1]->GetTargetTypeId(), 0x02u);
ASSERT_EQ(types[1]->GetOverlayTypeId(), 0x02u);
ASSERT_EQ(types[1]->GetEntryCount(), 4u);
ASSERT_EQ(types[1]->GetEntryOffset(), 3u);
ASSERT_EQ(types[1]->GetEntry(0), 0x0000u);
ASSERT_EQ(types[1]->GetEntry(1), kNoEntry);
ASSERT_EQ(types[1]->GetEntry(2), 0x0001u);
ASSERT_EQ(types[1]->GetEntry(3), 0x0002u);
}
TEST(IdmapTests, FailToCreateIdmapFromApkAssetsIfPathTooLong) {
std::string target_apk_path(GetTestDataPath());
for (int i = 0; i < 32; i++) {
target_apk_path += "/target/../";
}
target_apk_path += "/target/target.apk";
ASSERT_GT(target_apk_path.size(), kIdmapStringLength);
std::unique_ptr<const ApkAssets> target_apk = ApkAssets::Load(target_apk_path);
ASSERT_THAT(target_apk, NotNull());
const std::string overlay_apk_path(GetTestDataPath() + "/overlay/overlay.apk");
std::unique_ptr<const ApkAssets> overlay_apk = ApkAssets::Load(overlay_apk_path);
ASSERT_THAT(overlay_apk, NotNull());
std::stringstream error;
std::unique_ptr<const Idmap> idmap =
Idmap::FromApkAssets(target_apk_path, *target_apk, overlay_apk_path, *overlay_apk, error);
ASSERT_THAT(idmap, IsNull());
}
TEST(IdmapTests, IdmapHeaderIsUpToDate) {
fclose(stderr); // silence expected warnings from libandroidfw
const std::string target_apk_path(GetTestDataPath() + "/target/target.apk");
std::unique_ptr<const ApkAssets> target_apk = ApkAssets::Load(target_apk_path);
ASSERT_THAT(target_apk, NotNull());
const std::string overlay_apk_path(GetTestDataPath() + "/overlay/overlay.apk");
std::unique_ptr<const ApkAssets> overlay_apk = ApkAssets::Load(overlay_apk_path);
ASSERT_THAT(overlay_apk, NotNull());
std::stringstream error;
std::unique_ptr<const Idmap> idmap =
Idmap::FromApkAssets(target_apk_path, *target_apk, overlay_apk_path, *overlay_apk, error);
ASSERT_THAT(idmap, NotNull());
std::stringstream stream;
BinaryStreamVisitor visitor(stream);
idmap->accept(&visitor);
std::unique_ptr<const IdmapHeader> header = IdmapHeader::FromBinaryStream(stream);
ASSERT_THAT(header, NotNull());
ASSERT_TRUE(header->IsUpToDate(error)) << error.str();
// magic: bytes (0x0, 0x03)
std::string bad_magic_string(stream.str());
bad_magic_string[0x0] = '.';
bad_magic_string[0x1] = '.';
bad_magic_string[0x2] = '.';
bad_magic_string[0x3] = '.';
std::stringstream bad_magic_stream(bad_magic_string);
std::unique_ptr<const IdmapHeader> bad_magic_header =
IdmapHeader::FromBinaryStream(bad_magic_stream);
ASSERT_THAT(bad_magic_header, NotNull());
ASSERT_NE(header->GetMagic(), bad_magic_header->GetMagic());
ASSERT_FALSE(bad_magic_header->IsUpToDate(error));
// version: bytes (0x4, 0x07)
std::string bad_version_string(stream.str());
bad_version_string[0x4] = '.';
bad_version_string[0x5] = '.';
bad_version_string[0x6] = '.';
bad_version_string[0x7] = '.';
std::stringstream bad_version_stream(bad_version_string);
std::unique_ptr<const IdmapHeader> bad_version_header =
IdmapHeader::FromBinaryStream(bad_version_stream);
ASSERT_THAT(bad_version_header, NotNull());
ASSERT_NE(header->GetVersion(), bad_version_header->GetVersion());
ASSERT_FALSE(bad_version_header->IsUpToDate(error));
// target crc: bytes (0x8, 0xb)
std::string bad_target_crc_string(stream.str());
bad_target_crc_string[0x8] = '.';
bad_target_crc_string[0x9] = '.';
bad_target_crc_string[0xa] = '.';
bad_target_crc_string[0xb] = '.';
std::stringstream bad_target_crc_stream(bad_target_crc_string);
std::unique_ptr<const IdmapHeader> bad_target_crc_header =
IdmapHeader::FromBinaryStream(bad_target_crc_stream);
ASSERT_THAT(bad_target_crc_header, NotNull());
ASSERT_NE(header->GetTargetCrc(), bad_target_crc_header->GetTargetCrc());
ASSERT_FALSE(bad_target_crc_header->IsUpToDate(error));
// overlay crc: bytes (0xc, 0xf)
std::string bad_overlay_crc_string(stream.str());
bad_overlay_crc_string[0xc] = '.';
bad_overlay_crc_string[0xd] = '.';
bad_overlay_crc_string[0xe] = '.';
bad_overlay_crc_string[0xf] = '.';
std::stringstream bad_overlay_crc_stream(bad_overlay_crc_string);
std::unique_ptr<const IdmapHeader> bad_overlay_crc_header =
IdmapHeader::FromBinaryStream(bad_overlay_crc_stream);
ASSERT_THAT(bad_overlay_crc_header, NotNull());
ASSERT_NE(header->GetOverlayCrc(), bad_overlay_crc_header->GetOverlayCrc());
ASSERT_FALSE(bad_overlay_crc_header->IsUpToDate(error));
// target path: bytes (0x10, 0x10f)
std::string bad_target_path_string(stream.str());
bad_target_path_string[0x10] = '\0';
std::stringstream bad_target_path_stream(bad_target_path_string);
std::unique_ptr<const IdmapHeader> bad_target_path_header =
IdmapHeader::FromBinaryStream(bad_target_path_stream);
ASSERT_THAT(bad_target_path_header, NotNull());
ASSERT_NE(header->GetTargetPath(), bad_target_path_header->GetTargetPath());
ASSERT_FALSE(bad_target_path_header->IsUpToDate(error));
// overlay path: bytes (0x110, 0x20f)
std::string bad_overlay_path_string(stream.str());
bad_overlay_path_string[0x110] = '\0';
std::stringstream bad_overlay_path_stream(bad_overlay_path_string);
std::unique_ptr<const IdmapHeader> bad_overlay_path_header =
IdmapHeader::FromBinaryStream(bad_overlay_path_stream);
ASSERT_THAT(bad_overlay_path_header, NotNull());
ASSERT_NE(header->GetOverlayPath(), bad_overlay_path_header->GetOverlayPath());
ASSERT_FALSE(bad_overlay_path_header->IsUpToDate(error));
}
class TestVisitor : public Visitor {
public:
explicit TestVisitor(std::ostream& stream) : stream_(stream) {
}
void visit(const Idmap& idmap ATTRIBUTE_UNUSED) {
stream_ << "TestVisitor::visit(Idmap)" << std::endl;
}
void visit(const IdmapHeader& idmap ATTRIBUTE_UNUSED) {
stream_ << "TestVisitor::visit(IdmapHeader)" << std::endl;
}
void visit(const IdmapData& idmap ATTRIBUTE_UNUSED) {
stream_ << "TestVisitor::visit(IdmapData)" << std::endl;
}
void visit(const IdmapData::Header& idmap ATTRIBUTE_UNUSED) {
stream_ << "TestVisitor::visit(IdmapData::Header)" << std::endl;
}
void visit(const IdmapData::TypeEntry& idmap ATTRIBUTE_UNUSED) {
stream_ << "TestVisitor::visit(IdmapData::TypeEntry)" << std::endl;
}
private:
std::ostream& stream_;
};
TEST(IdmapTests, TestVisitor) {
std::string raw(reinterpret_cast<const char*>(idmap_raw_data), idmap_raw_data_len);
std::istringstream stream(raw);
std::stringstream error;
std::unique_ptr<const Idmap> idmap = Idmap::FromBinaryStream(stream, error);
ASSERT_THAT(idmap, NotNull());
std::stringstream test_stream;
TestVisitor visitor(test_stream);
idmap->accept(&visitor);
ASSERT_EQ(test_stream.str(),
"TestVisitor::visit(Idmap)\n"
"TestVisitor::visit(IdmapHeader)\n"
"TestVisitor::visit(IdmapData)\n"
"TestVisitor::visit(IdmapData::Header)\n"
"TestVisitor::visit(IdmapData::TypeEntry)\n"
"TestVisitor::visit(IdmapData::TypeEntry)\n");
}
} // namespace idmap2
} // namespace android
Reference in New Issue View Git Blame Copy Permalink